DE102015121646B4 - Fehlerkorrektur - Google Patents

Abstract

Verfahren zur Korrektur eines Fehlers in einem Fehlermuster,- bei dem die Korrektur des Fehlers unter Verwendung eines modifizierten Fehlersyndroms durchgeführt wird,- wobei das modifizierte Fehlersyndrom unter Verwendung des Fehlermusters bestimmt ist,- wobei die Korrektur mittels eines Fehlercodes mit einem Codeabstand 2(t + 1) für K Fehlermuster aus jeweils M Bits durchgeführt wird und bei dem K · M = t + 1, t ≥ 2, K ≥ 1 und M ≥ 2 gelten.

Description

• Es ist bekannt, dass in elektronischen Schaltungen und in Speichern permanente bzw. transiente Fehler auftreten können. Derartige Fehler können zu Bitfehlern in binären Wörtern führen. Ein binäres Wort umfasst hierbei mehrere Bits, z.B. 8 Bits, 16 Bits, oder allgemein eine Vielzahl von Bits.
• Aus [C. Badack, T. Kern, M. Gössel: Modified DEC BCH codes for parallel correction of 3-bit errors comprising a pair of adjacent errors, IEEE 20th International On-Line Testing Symposium (IOLTS), 2014, Seiten 116 bis 121] ist ein Verfahren zur Korrektur eines Fehlermusters bekannt.
• Die Aufgabe der Erfindung besteht darin, eine Möglichkeit für eine effiziente Fehlererkennung und/oder Fehlerkorrektur bereitzustellen.
• Diese Aufgabe wird gemäß den Merkmalen der unabhängigen Ansprüche gelöst. Bevorzugte Ausführungsformen sind insbesondere den abhängigen Ansprüchen entnehmbar.
• Zur Lösung der Aufgabe wird ein Verfahren vorgeschlagen zur Korrektur eines Fehlers in einem Fehlermuster,
• - bei dem die Korrektur des Fehlers unter Verwendung eines modifizierten Fehlersyndroms durchgeführt wird,
• - wobei das modifizierte Fehlersyndrom unter Verwendung des Fehlermusters bestimmt ist,
• - wobei die Korrektur mittels eines Fehlercodes mit einem Codeabstand 2(t + 1) für K Fehlermuster aus jeweils M Bits durchgeführt wird, wobei K · M = t + 1, t ≥ 2, K ≥ 1 und M ≥ 2 gelten.
• Die Korrektur des Fehlers kann dabei eine Korrektur mindestens eines fehlerhaften Bits, mindestens einer fehlerhaften Position oder mindestens eines fehlerhaften Werts in dem Fehlermuster umfassen.
• Das modifizierte Fehlersyndrom kann unter Verwendung eines unmodifizierten Fehlersyndroms (eines Fehlercodes) bestimmt sein.
• Insbesondere kann das modifizierte Fehlersyndrom als ein Fehlersyndrom eines K-Bitfehler korrigierenden Codes zur Fehlerkorrektur jeweils eines Bits der K Fehlermuster bestimmt sein.
• Weiterhin kann das modifizierte Fehlersyndrom so gebildet sein, dass es ein Fehlersyndrom eines K-Bitfehler korrigierenden Codes zur Fehlerkorrektur jeweils eines ersten Bits der K Fehlermuster ist.
• Es ist eine Weiterbildung, dass das modifizierte Fehlersyndrom und ein unmodifiziertes Fehlersyndrom Teilsyndrome aufweisen und ein Teilsyndrom des modifizierten Fehlersyndroms aus einem entsprechenden Teilsyndrom des unmodifizierten Fehlersyndroms unter Verwendung des Fehlermusters bestimmt ist.
• Es ist eine Weiterbildung, dass ein Teilsyndrom des modifizierten Fehlersyndroms aus einem entsprechenden Teilsyndrom des unmodifizierten Fehlersyndroms durch Multiplikation mit einer Konstanten bestimmt ist.
• Insbesondere kann die Multiplikation mit der Konstanten in einem entsprechenden Galoisfeld durchgeführt werden.
• Es ist eine Weiterbildung, dass das Fehlermuster benachbarte Bits aufweist.
• Es ist eine Weiterbildung, dass das Fehlermuster mindestens zwei Bits oder mindestens zwei Bitpositionen aufweist.
• Es ist eine Weiterbildung, dass das Fehlermuster eine Anzahl von M Bits aufweist, wobei jedes weitere Bit des Fehlermusters durch einen Abstand von einem ersten Bit des Fehlermusters bestimmt ist.
• Es ist eine Weiterbildung, dass dann, wenn mindestens ein Bit des Fehlermusters fehlerhaft ist, ein erstes Bit des Fehlermusters aus dem modifizierten Fehlersyndrom bestimmt ist.
• Es ist eine Weiterbildung, dass die Korrektur basierend auf einer Anzahl der Fehlermuster durchgeführt wird.
• Es ist eine Weiterbildung, dass eine Anzahl von K zu korrigierende erste Bits der K gleichen Fehlermuster unter Verwendung des modifizierten Fehlersyndroms bestimmt sind.
• Es ist eine Weiterbildung, dass die K Fehlermuster jeweils M Bits umfassen, die den Wert 1 aufweisen.
• Es ist eine Weiterbildung, dass
• - der Fehlercode mit dem Codeabstand 2(t + 1) ein t-Bitfehler korrigierender BCH-Code über einem Galoisfeld GF(2^m) mit einbezogener Gesamtparität und einer H-Matrix $$H=\left(\begin{array}{l}{H}_1\hfill \\ H_3\hfill \\ ⋮\hfill \\ H_{2t-1}\hfill \\ P\hfill \end{array}\right)$$
  
  ist,
• - Teilsyndrome $s_1^{mod},s_3^{mod},\dots ,s_{2K-1}^{mod}$
  
  des modifizierten Fehlersyndroms aus den unmodifizierten Teilsyndromen s₁, s₃,..., s_2K-1 des Fehlersyndroms des BCH-Codes gemäß $$\begin{array}{c}{s}_1^{mod}=s_1\cdot {\beta }_1^{-1}\\ s_3^{mod}=s_3\cdot {\beta }_3^{-1}\\ ⋮\\ s_{2K-1}^{mod}=s_{2K-1}\cdot {\beta }_{2K-1}^{-1},\end{array}$$
  
  bestimmt sind, wobei
  • - s_i ein Teilsyndrom des Fehlersyndroms,
  • - $s_i^{mod}$
    
    ein Teilsyndrom des modifizierten Fehlersyndroms,
  • - β_i eine Konstante und
  • - i = 1,..., (2K - 1) eine Laufvariable
  bezeichnen.
• Hierbei sei angemerkt, dass vorzugsweise 1 ≤ K < t gilt, wobei die Konstanten β₁, β₃,..., β_2K-1 durch jeweils m Komponenten einer komponentenweisen XOR-Summe von M-Spalten der H-Matrix bestimmt sind, die einem Fehlermuster entsprechen. Weiterhin gelten insbesondere: t ≥ 2, m ≥ 3 und K · M = t + 1. Vorzugsweise ist für i = 1, 3, 5, ... , 2K - 1 die Konstante β_i gleich der komponentenweise XOR-Summe der M-Spalten der Matrix H_i, die den Komponenten der normierten Fehlervektoren des Fehlermusters entsprechen, die gleich 1 sind.
• Es ist eine Weiterbildung, dass zusätzlich eine Korrektur von beliebigen τ-Bitfehlern mit 1 ≤ τ ≤ t erfolgt, wobei im Falle eines τ-Bitfehlers mit 1 ≤ τ ≤ t die zu korrigierenden τ Bitpositionen durch die Teilsyndrome s₁, s₃, ... , s_2t-1 bestimmt sind.
• Es ist eine Weiterbildung, dass gilt: $$\begin{array}{c}{H}_1=\left({\alpha }^{i_1},{\alpha }^{i_1+d},\dots ,{\alpha }^{i_1+\left(n-1\right)-d}\right)\\ H_3=\left({\alpha }^{3-i_1},{\alpha }^{3-\left(i_1+d\right)},\dots ,{\alpha }^{3-\left(i_1+\left(n-1\right)-d\right)}\right)\\ ⋮\\ H_{2i-1}=\left({\alpha }^{\left(2t-1\right)i_1},{\alpha }^{\left(2t-1\right)\left(i_1+d\right)},\dots ,{\alpha }^{\left(2t-1\right)\left(i_1+\left(n-1\right)-d\right)}\right)\\ P=\underset{n}{\underbrace{\left(\mathrm{1,1,}\dots \mathrm{,1}\right)}}\end{array}$$

  
• - wobei die Operationen in den Exponenten der Elemente der H-Matrix modulo 2^m - 1 auszuführen sind,
• - wobei a ein erzeugendes Element des Galoisfelds GF(2^m) ist und
• - wobei die Elemente α^j der H-Matrix Elemente des Galoisfelds GF(2^m) in ihrer Vektordarstellung als m-dimensionale binäre Spaltenvektoren sind.
• Es ist eine Weiterbildung, dass gilt: $$\begin{array}{c}{i}_1=0\\ d=0\\ H_1=\left({\alpha }^0,{\alpha }^1,\dots ,{\alpha }^{n-1}\right)\\ H_3=\left({\alpha }^0,{\alpha }^3,\dots ,{\alpha }^{\left(n-1\right)-3}\right)\\ ⋮\\ H_{2t-1}=\left({\alpha }^0,{\alpha }^{2t-r},\dots ,{\alpha }^{\left(n-1\right)\cdot \left(2t-1\right)}\right).\end{array}$$

  
• Es ist eine Weiterbildung, dass die Konstanten β₁, β₃, ..., β_2t-1 so bestimmt sind, dass für einen Fehler, der K gleiche Fehlermuster F_m mit dem normierten Fehlervektor $e_{Fm}^{norm}$

  

  aufweist, gilt: $$\begin{array}{l}{\beta }_1\cdot {\alpha }^{i_1}=H_1\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ {\beta }_3\cdot {\alpha }^{3\cdot i_1}=H_3\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}\cdot {\alpha }^{\left(2t-1\right)\cdot i_1}=H_{2t-1}\cdot {\left[e_{Fm}^{norm}\right]}^T.\hfill \end{array}$$

  
• Hierbei sei angemerkt, dass ${\left[e_{Fm}^{norm}\right]}^T$

  

  ein transponierter n-dimensionaler Spaltenvektor des n-dimensionalen Zeilenvektors $e_{Fm}^{norm}$

  

  ist. Insbesondere gilt für die obige Beziehung auch K ≥ 1.
• Es ist eine Weiterbildung, dass die Konstanten β₁, β₃, ..., β_2t-1 so bestimmt sind, dass für einen Fehler, der K gleiche Fehlermuster F_m mit dem normierten Fehlervektor $e_{Fm}^{norm}$

  

  aufweist, gilt: $$\begin{array}{l}{\beta }_1=H_1\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ {\beta }_3=H_3\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}=H_{2t-1}\cdot {\left[e_{Fm}^{norm}\right]}^T.\hfill \end{array}$$

  
• Es ist eine Weiterbildung, dass für das Fehlermuster F_m = [M, D₁,... ,D_M-1] gilt: $$\begin{array}{l}{H}_1\cdot e_{Fm}^{norm}={\alpha }^{i_1}\cdot \left(1+{\alpha }^{\left(D_1+D_2\right)\cdot d}+\dots +{\alpha }^{\left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}\right)\hfill \\ H_3\cdot e_{Fm}^{norm}={\alpha }^{3\cdot i_1}\cdot \left(1+{\alpha }^{3\cdot }{}^{\left(D_1+D_2\right)\cdot d}+\dots +{\alpha }^{3\cdot }{}^{\left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}\right)\hfill \\ ⋮\hfill \\ \begin{array}{c}{H}_{2t-1}\cdot e_{Fm}^{norm}={\alpha }^{\left(2t-1\right)i_1}\cdot (1+{\alpha }^{\left(2t-1\right)\cdot D_1\cdot d\cdot \left(D_1+D_2\right)\cdot d}+\dots +\\ +{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}).\end{array}\hfill \end{array}$$

  
• Es ist eine Weiterbildung, dass für das Fehlermuster F_m = [M, D₁,... ,D_M-1] gilt: $$\begin{array}{l}{H}_1\cdot e_{Fm}^{norm}=1+{\alpha }^{D_1}+{\alpha }^{\left(D_1+D_2\right)}+\dots +{\alpha }^{\left(D_1+D_2+\dots +D_{M-1}\right)}\hfill \\ H_3\cdot e_{Fm}^{norm}=1+{\alpha }^{3\cdot D_1}+{\alpha }^{3\cdot }{}^{\left(D_1+D_2\right)}+\dots +{\alpha }^{3\cdot }{}^{\left(D_1+D_2+\dots +D_{M-1}\right)}\hfill \\ ⋮\hfill \\ H_{2t-1}\cdot e_{Fm}^{norm}=1+{\alpha }^{\left(2t-1\right)\cdot D_1}+{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2\right)}+\dots +{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2+\dots +D_{M-1}\right)}.\hfill \end{array}$$

  
• Es ist eine Weiterbildung, dass die Korrektur eines Fehlers eine Korrektur eines Fehlervektors umfasst, wobei der Fehlervektor mindestens ein Fehlermuster umfasst.
• Es ist eine Weiterbildung, dass das erste Bit des Fehlermusters nur vorgegebene Bitpositionen des Fehlervektors annehmen kann.
• Es ist eine Weiterbildung, dass das Fehlermuster aus zwei Bits besteht und der Fehlervektor eines 4-Bitfehlers aus zwei 2-Bitfehlern besteht.
• Das Fehlermuster kann insbesondere zwei benachbarte Bits umfassen; beispielsweise kann das Fehlermuster aus zwei Bits mit einem festen Abstand bestehen. Auch eine Permutation der Bits oder Positionen (der Bits) ist möglich.
• Es ist eine Weiterbildung, dass das Fehlermuster aus zwei Bits besteht und der Fehlervektor eines 6-Bitfehlers aus drei 2-Bitfehlern besteht.
• Es ist eine Weiterbildung, dass das Fehlermuster aus drei Bits besteht und der Fehlervektor eines 6-Bitfehlers aus zwei 3-Bitfehlern besteht.
• Es ist eine Weiterbildung, dass das Verfahren wenigstens teilweise durch eine Schaltungsanordnung in Hardware und/oder wenigstens teilweise mittels Software implementiert ist.
• Es ist eine Weiterbildung, dass ein einer Anzahl der Fehler entsprechendes Lokatorpolynom iterativ nach dem Berlekamp-Massey-Algorithmus bestimmt wird.
• Insbesondere ist es eine Option, dass unter Verwendung von zusätzlichen Prüfbits (t + 1)-Bitfehler mit einem Fehlervektor, der K gleiche Fehlermuster aus M Bits aufweist, von (t + 1)-Bitfehlern mit einem Fehlervektor, der nicht K gleiche Fehlermuster aus M-Bits, die gleich 1 sind, aufweist, unterschieden werden.
• Auch wird zur Lösung der oben genannten Aufgabe eine Vorrichtung zur Korrektur eines Fehlers vorgeschlagen, wobei die Vorrichtung eine Verarbeitungseinheit aufweist, die derart eingerichtet ist, dass
• - die Korrektur des Fehlers mittels modifizierter Fehlersyndrome durchführbar ist,
• - wobei der Fehler auf mindestens einem Fehlermuster basiert,
• - wobei die Korrektur mittels eines Fehlercodes mit einem Codeabstand 2(t + 1) für K Fehlermuster aus jeweils M Bits durchgeführt wird, wobei K · M = t + 1, t ≥ 2, K ≥ 1 und M ≥ 2 gelten.
• 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, Ein-/Ausgabe-Schnittstellen, Ein-Ausgabe-Geräte, etc.) sein oder umfassen.
• Die vorstehenden Erläuterungen betreffend das Verfahren gelten für die Vorrichtung entsprechend. Die Vorrichtung kann in einer Komponente oder verteilt in mehreren Komponenten ausgeführt sein.
• Auch wird die oben genannte Aufgabe gelöst mittels eines Systems umfassend mindestens eine der hier beschriebenen Vorrichtungen.
• Weiterhin wird zur Lösung der Aufgabe ein Computerprogrammprodukt angegeben, das direkt in einen Speicher eines digitalen Computers ladbar ist, umfassend Programmcodeteile, die dazu geeignet sind, Schritte des hier beschriebenen Verfahrens durchzuführen.
• Auch wird zur Lösung der Aufgabe ein computerlesbares Speichermedium angegeben, umfassend von einem Computer ausführbare Anweisungen, 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.
• Es zeigen:
• 1 eine Tabelle, die unterschiedliche Darstellungsformen von Elementen eines Galoisfelds GF(2^m) mit m = 5 veranschaulicht;
• 2 eine beispielhafte Schaltungsanordnung, die unter Verwendung eines BCH-Codes zur Korrektur beliebiger 3-Bitfehler zusätzlich eine Korrektur spezieller 4-Bitfehler erlaubt, die sich aus zwei benachbarten 2-Bitfehlern zusammensetzen;
• 3 eine beispielhafte Schaltungsanordnung, die unter Verwendung eines BCH-Codes zur Korrektur beliebiger 3-Bitfehler zusätzlich eine Korrektur spezieller 4-Bitfehler erlaubt, die sich aus zwei benachbarten 2-Bitfehlern in ungeraden Bitpositionen zusammensetzen;
• 4 eine beispielhafte Schaltungsanordnung, die unter Verwendung eines BCH-Codes zur Korrektur beliebiger 5-Bitfehler zusätzlich eine Korrektur spezieller 6-Bitfehler erlaubt, die sich aus drei benachbarten 2-Bitfehlern zusammensetzen;
• 5 eine beispielhafte Schaltungsanordnung, die unter Verwendung eines BCH-Codes zur Korrektur beliebiger 5-Bitfehler zusätzlich eine Korrektur spezieller 6-Bitfehler erlaubt, die sich aus zwei benachbarten 3-Bitfehlern zusammensetzen;
• 6 eine beispielhafte Schaltungsanordnung, die unter Verwendung eines BCH-Codes zur Korrektur beliebiger 2-Bitfehler und beliebiger 1-Bitfehler zusätzlich eine Korrektur benachbarter 3-Bitfehler erlaubt;
• 7 eine beispielhafte Schaltungsanordnung, die unter Verwendung eines BCH-Codes zur Korrektur beliebiger 3-Bitfehler und 2-Bitfehler zusätzlich eine Korrektur spezieller 4-Bitfehler erlaubt, die sich aus zwei benachbarten 2-Bitfehlern zusammensetzen;
• 8 eine mögliche Implementierung einer Teilschaltung zur Erkennung von 1-Bit-, 2-Bit-, 3-Bit- und 4-Bitfehlern.
• Es ist möglich, Bitfehler in Binärwörtern durch fehlererkennende und/oder fehlerkorrigierenden Codes zu erkennen und/oder zu korrigieren. Derartige Codes werden nachfolgend auch als Fehlercodes bezeichnet. Ein Fehlercode kann eine bestimmte Anzahl von Fehlern erkennen und/oder eine bestimmte (ggf. andere) Anzahl von Fehlern korrigieren. Häufig erfolgt die Fehlererkennung und/oder Fehlerkorrektur mittels bekannter Blockcodes, bei denen jeweils Blöcke von n Bits betrachtet werden. Die Zahl n wird auch als die Anzahl der Bits eines Blocks oder als Länge des Codes bezeichnet.
• Beispielsweise können lineare Blockcodes verwendet werden, die durch eine Generatormatrix G und durch eine H-Matrix H beschrieben werden.
• Ist die Länge des Codes gleich n und werden k Datenbits (auch bezeichnet als Informationsbits) $$u=u_0,\dots ,u_{k-1}$$

  

  als ein Codewort $$v=v_0,\dots ,v_{n-1}$$

  

  codiert, dann gilt für den linearen Code $$v=v_0,\dots ,v_{n-1}=\left(u_0,\dots ,u_{k-1}\right)\cdot G=u\cdot G$$

  
• Es ist möglich, dass Datenbits eines Codeworts Bits der Leseadresse oder Bits der Schreibadresse oder aus Bits der Leseadresse oder aus Bits der Schreibadresse abgeleitete Bits sind oder enthalten. Dies gilt insbesondere in dem Fall, dass ein Teil der Datenbits in einem adressierbaren Speicher gespeichert ist. Eine andere Option besteht darin, dass Datenbits auch mindestens ein Invertierungsbit umfassen können, das angibt, ob ein Bit oder eine Gruppe von Bits invertiert gespeichert werden/wurden.
• Die Generatormatrix G ist eine (k, n) -Matrix und die entsprechende H-Matrix H ist eine (m, n)-Matrix mit m = n - k. Die Bitkombination v = v₀, ..., v_n-1 ist genau dann ein Codewort des Codes C, wenn $$H\cdot v^T=H\cdot {\left(v_0,\dots ,v_{n-1}\right)}^T=0$$

  

  gilt, wobei v^T den transponierten Spaltenvektor des Zeilenvektors v bezeichnet. Ist $$v\text{'}=v_0^{\text{'}},\dots ,v_{n-1}^{\text{'}}=v+e=v_0+e_0,\dots ,v_{n-1}+e_{n-1}$$

  

  ein durch Bitfehler aus v entstandenes Wort, dann gilt für das Fehlersyndrom s^T $$s^T=H\cdot {\left(v\text{'}\right)}^T=H\cdot {\left(v+e\right)}^T=H\cdot e^T.$$

  
• Dabei heißt $$e=e_0,\dots ,e_{n-1}$$

  
• Fehlervektor, und das i-te Bit $v_i^{\text{'}}$

  

  von v' ist
• - fehlerhaft, wenn e_i = 1 ist und
• - korrekt, wenn e_i = 0 ist.
• Das Fehlersyndrom s^T ist ein (n - k)-dimensionaler transponierter Spaltenvektor des Zeilenvektors s, wobei hier beispielhaft s^T bzw. s das unmodifizierte Fehlersyndrom bezeichnen.
• Ein Hamming-Abstand d(v¹,v²) zwischen zwei Wörtern $$v^1=v_0^1,\dots ,v_{n-1}^1$$

  

  und $$v^2=v_0^2,\dots ,v_{n-1}^2$$

  

  ist durch die Anzahl ihrer Komponenten bestimmt, in denen sie sich unterscheiden. Somit gilt: $$d\left(v^1,v^2\right)={\displaystyle \sum _{i=0}^{n-1}{v}_i^1\oplus }{v}_i^2,$$

  

  wobei ⊕ die Addition modulo 2 (auch: Exklusiv-Oder-Verknüpfung, XOR-Verknüpfung) bezeichnet.
• Der Codeabstand d_C eines Codes C ist der minimale Abstand zwischen zwei Codewörtern des Codes C, so dass $$d_C=min\left[d\left(v^i,v^j\right){\text{ und v}}^i,v^j\in C,v^i\ne v^j\right]$$

  

  gilt.
• Bei der Fehlerkorrektur eines fehlerhaften Wortes v' kann das Wort v' in das Codewort vⁱ korrigiert werden, das von dem Wort v' den kleinsten Hamming-Abstand aufweist.
• Beispielsweise ist für einen bekannten 3-Bitfehler korrigierenden und 4-Bitfehler erkennenden BCH-Code mit einbezogener Parität der Codeabstand d_C = 8. Zwei beliebige Codewörter dieses Codes unterscheiden sich dann mindestens in den Werten von 8 Komponenten. Sind v¹ und v² Codewörter dieses Codes, für die d(v¹, v²) = 8 gilt, und wird das Codewort v¹ in einem Bit in das fehlerhafte Wort v^1' gestört, dann gilt d (v¹, v^1') = 1 und d(v², v^1') ≥ 7.
• In diesem Fall wird das fehlerhafte Wort v^1' in das Codewort v¹ korrigiert, d.h. in das Codewort, das von dem fehlerhaften Wort v^1' den kleinsten Abstand hat.
• Wird das Codewort v¹ in zwei Bits gestört, so dass sich das fehlerhafte Wort v^1' ergibt, gilt d(v¹, v^1') = 2 und d (v², v^1') ≥ 6. In diesem Fall wird das fehlerhafte Wort v^1' in das Codewort v¹ korrigiert.
• Werden drei Bits des Codeworts v¹ gestört, so dass sich das fehlerhafte Wort v^1' ergibt, gilt d(v¹, v^1') = 3 und d (v², v^1') ≥ 5. In diesem Fall wird das fehlerhafte Wort v^1' in das Codewort v¹ korrigiert.
• Werden vier Bits des Codeworts v¹ gestört, so dass sich das fehlerhafte Wort v^1' ergibt, d(v¹, v^1') = 4 und d(v², v^1') ≥ 4. In diesem Fall ist es möglich, dass sich das fehlerhafte Codewort v^1' sowohl von dem Codewort v¹ als auch von dem Codewort v² jeweils in 4 Bits unterscheidet. Somit kann das in 4 Bits fehlerhafte Wort v^1' nicht mehr eindeutig in v¹ oder v² korrigiert werden.
• Nach diesem Beispiel kann somit ein 4-Bitfehler erkannt und es kann ein 1-Bitfehler, ein 2-Bitfehler oder ein 3-Bitfehler korrigiert werden.
• Allgemein gilt somit: Im Falle eines t-Bitfehler korrigierenden und (t+1)-Bitfehler erkennenden Codes wird ein Wort v', das durch τ Bitfehler mit 1 ≤ τ ≤ t aus einem Codewort v entstanden ist, in das Codewort v korrigiert, wobei d_C(v,v') = τ ≤ t ist. Ist ein Wort durch einen (t + 1)-Bitfehler aus einem Codewort entstanden, dann wird der (t + 1)-Bitfehler bislang nicht korrigiert und als (t + 1)-Bitfehler erkannt.
• Fehlermuster
• Der hier vorgeschlagene Ansatz ermöglicht es, ein fehlerhaftes Wort v', das durch einen (t + 1)-Bitfehler aus dem Codewort v entstanden ist, unter Verwendung eines t-Bitfehler korrigierenden und (t + 1)-Bit erkennenden Codes mit einem Codeabstand d_C = 2(t + 1) eindeutig in das Codewort v zu korrigieren, wenn der (t + 1)-Bitfehler ein bestimmtes Fehlermuster aufweist. Ein solches Fehlermuster kann beispielsweise in Speichern auftreten, deren Speicherzellen mehr als zwei Werte speichern können.
• Nachfolgend werden beispielhaft Fehlermuster beschrieben, die in Kombination mit der hier erläuterten Lösung verwendet werden können.
• Ein Fehlermuster F_m wird beispielhaft beschrieben durch
• - eine Anzahl M fehlerhafter Bits und
• - Abstände D₁, ... , D_M-1 aufeinanderfolgender M - 1 fehlerhafter Bitpositionen.
• Sind M fehlerhafte Bits in dem Fehlermuster vorhanden, wird das Fehlermuster durch ein Tupel $$\left[M;D_1,\dots ,D_{M-1}\right]$$

  

  beschrieben.
• Besteht ein Fehlermuster $F_m^1$

  

  aus M = 2 aufeinanderfolgenden Bits, wird es durch $F_m^1=\left[\mathrm{2,1}\right]$

  

  beschrieben. Das zweite der fehlerhaften Bits hat dann den Abstand 1 von dem ersten fehlerhaften Bit.
• Besteht ein Fehlermuster $F_m^2$

  

  aus M = 3 aufeinanderfolgenden Bits, wird es durch $F_m^2=\left[3;\mathrm{1,1}\right]$

  

  beschrieben. Das zweite der fehlerhaften Bits hat dann den Abstand 1 von dem ersten fehlerhaften Bit und das dritte der fehlerhaften Bits hat den Abstand 1 von dem zweiten fehlerhaften Bit.
• Das Fehlermuster $F_m^3=\left[4;\mathrm{2,1,2}\right]$

  

  beschreibt ein Fehlermuster mit M = 4 fehlerhaften Bits. Der Abstand des zweiten fehlerhaften Bits von dem ersten fehlerhaften Bit ist 2, der Abstand des dritten fehlerhaften Bits von dem zweiten fehlerhaften Bit ist 1 und der Abstand des vierten fehlerhaften Bits von dem dritten fehlerhaften Bit ist 2.
• Den Fehlermustern $F_m^i$

  

  (mit i = 1,2,3) kann jeweils die folgende Binärfolge fehlerhafter Bits zugeordnet werden:
• - $F_m^1=\left[2;1\right]:$
  
  Binärfolge 1,1,
• - $F_m^2=\left[3;\mathrm{1,1}\right]:$
  
  Binärfolge 1,1,1 und
• - $F_m^3=\left[4;\mathrm{2,1,2}\right]:$
  
  Binärfolge 1,0,1,1,0,1.
• Es ist möglich, die Bitpositionen eines Fehlermusters in unterschiedlicher Reihenfolge zu betrachten. Die Abstände aufeinander folgender fehlerhafter Bits D₁,..., D_M-1 können beispielsweise auch negativ sein. So beschreiben beispielsweise [2,1] und [2, -1] die gleichen Tupel. In der ersten Beschreibung [2,1] folgt dem ersten fehlerhaften Bit nach rechts im Abstand 1 das zweite fehlerhafte Bit. Das erste fehlerhafte Bit des Paars fehlerhafter Bits ist das linke Bit. In der zweiten Beschreibung [2, -1] ist das erste fehlerhafte Bit das rechte Bit und das zweite fehlerhafte Bit folgt dem ersten fehlerhaften Bit nach links im Abstand -1.
• Im Folgenden werden die verwendeten Fehlermuster beispielhaft mit positiven Abständen D₁,..., D_M-1 verwendet.
• Das erste Bit eines Fehlermusters kann in einem Fehlervektor an unterschiedlichen Bitpositionen positioniert sein.
• Ein Fehlervektor $$e^1=e_0^1,\dots ,e_9^1=\left(\mathrm{0,0,1,1,0,0,0,0,0,0}\right)$$

  

  der Länge n = 10 enthält das Fehlermuster $F_m^1=\left[2;1\right].$

  

  Das erste Bit des Fehlermusters ist das Bit $e_2^1$

  

  des Fehlervektors, da $e_2^1=e_3^1=1\text{ und }{e}_0^1=e_1^1=e_4^1=\dots =e_9^1=0$

  

  gilt.
• Entsprechend enthalten die Fehlervektoren $$e^2=e_0^2,\dots ,e_9^2=\left(\mathrm{0,0,0,0,1,1,0,0,0,0}\right)$$

  

  und $$e^3=e_0^3,\dots ,e_9^3=\left(\mathrm{0,0,0,0,0,0,0,0,1,1}\right)$$

  

  jeweils das Fehlermuster [2; 1]. $e_4^2$

  

  ist das erste Bit des Fehlermusters [2; 1] in dem Fehlervektor e²; entsprechend ist $e_8^3$

  

  das erste Bit des Fehlermusters [2; 1] in dem Fehlervektor e³.
• Handelt es sich bei dem betrachteten Code um einen zyklischen Code der Länge n, können für ein Fehlermuster $$\left[M;D_1,\dots ,D_{M-1}\right]$$

  

  die Abstände D₁,... , D_M-1 zyklisch modulo n interpretiert werden.
• Beispiel: Der zyklische Code hat eine Länge n = 7 und den Fehlervektor $$e^4=\left(e_0^4,\dots ,e_6^4\right).$$

  
• Ist das erste Bit des Fehlermusters $F_m^2=\left[3;\mathrm{1,1}\right]$

  

  das Bit $e_6^4,$

  

  ergibt sich aufgrund der modulo 7-Interpretation der Fehlervektor zu $$e^4=\left(\mathrm{1,1,0,0,0,0,1}\right).$$

  
• Mit dem Abstand D₁ = 1 ist dem zweiten Bit des Fehlermusters das Bit $e_7^4$

  

  zugeordnet. Entsprechend ist mit dem Abstand D₂ = 1 dem dritten Bit des Fehlermusters das Bit $e_8^4$

  

  zugeordnet. Da die Indizes modulo 7 zu interpretieren sind, gelten: $$e_0^4=e_{\left(7modulo7\right)}^4$$

  

  und $$e_1^4=e_{\left(8modulo7\right)}^4$$

  
• Ist das erste Bit eines Fehlermusters F_m in der ersten Bitposition eines Fehlervektors positioniert, wird der Fehlervektor $e_{F_m}^{norm}$

  

  als normierter Fehlervektor des Fehlermusters F_m bezeichnet.
• Beispielsweise sind für eine Länge von n = 12 die normierten Fehlervektoren der Fehlermuster $F_m^1=\left[2;1\right],F_m^2=\left[3;\mathrm{1,1}\right]\text{ und }{F}_m^3=\left[4;\mathrm{2,1,2}\right]:$

  

  $$e_{\left[2;1\right]}^{norm}=\left(\mathrm{1,1,0,0,0,0,0,0,0,0,0,0}\right),$$

  

  $$e_{\left[3;\mathrm{1,1}\right]}^{norm}=\left(\mathrm{1,1,1,0,0,0,0,0,0,0,0,0}\right),$$

  

  $$e_{\left[4;\mathrm{2,1,2}\right]}^{norm}=\left(\mathrm{1,0,1,1,0,1,0,0,0,0,0,0}\right).$$

  
• Es ist möglich, dass ein Fehlermuster F_m in einem Fehlervektor mehrmals enthalten ist:
• - Der Fehlervektor $e^5=e_0^5,\dots ,e_9^5=\left(\mathrm{0,1,1,0,0,0,1,1,0,0}\right)$
  
  enthält das Fehlermuster $F_m^1=\left[2;1\right]$
  
  zweimal, ein erstes Mal beginnend in der Bitposition $e_1^5=1$
  
  und ein zweites Mal beginnend in der Bitposition $e_6^5=1.$
  
• - Der Fehlervektor $e^6=e_0^6,\dots ,e_9^6=\left(\mathrm{0,1,1,1,1,0,1,1,0,0}\right)$
  
  enthält das Fehlermuster $F_m^1=\left[2;1\right]$
  
  dreimal, ein erstes Mal beginnend in der Bitposition $e_1^6=\mathrm{1,}$
  
  ein zweites Mal beginnend in der Bitposition $e_3^6=1$
  
  und ein drittes Mal beginnend in der Bitposition $e_6^6=1.$
  
• - Der Fehlervektor $e^7=e_0^7,\dots ,e_9^7=\left(\mathrm{1,0,1,1,1,1,1,1,0,1}\right)$
  
  enthält das Fehlermuster $F_m^3=\left[4;\mathrm{2,1,2}\right]$
  
  zweimal, ein erstes Mal beginnend in der Bitposition $e_0^7=\mathrm{1,}$
  
  ein zweites Mal beginnend in der Bitposition $e_4^7=1.$
  
• Enthält ein Fehlervektor ein Fehlermuster mehrfach, nimmt für eine Bitposition des Fehlervektors, für die eines der Fehlermuster den Wert 1 annimmt, kein weiteres Fehlermuster den Wert 1 an.
• Damit gilt, dass die Anzahl der 1-Komponenten eines Fehlervektors e, der K-Mal ein Fehlermuster [M;D₁,... ,D_M-1] annimmt, gleich K · M ist. Durch den Fehlervektor e wird dann ein (K-M)-Bitfehler beschrieben.
• So ist beispielsweise das Fehlermuster $F_m^1=\left[2;1\right]$

  

  in dem Fehlervektor e⁵ zweimal (K = 2) enthalten, der Fehlervektor e⁵ weist K · M = 2 · 2 = 4 Einsen auf und beschreibt einen 4-Bitfehler .
• Das Fehlermuster $F_m^1=\left[2;1\right]$

  

  ist in dem Fehlervektor e⁶ dreimal (K = 3) enthalten, der Fehlervektor e⁶ weist K · M = 3 · 2 = 6 Einsen auf und beschreibt einen 6-Bitfehler.
• Das Fehlermuster $F_m^3=\left[4;\mathrm{2,1,2}\right]$

  

  ist in dem Fehlervektor e⁷ zweimal (K = 2) enthalten, der Fehlervektor e⁷ weist K · M = 2 · 4 = 8 Einsen auf und beschreibt einen 8-Bitfehler.
• BCH-Codes
• Zur Fehlerkorrektur zufällig verteilter Mehrbitfehler können BCH-Codes verwendet werden. Dies ist beispielsweise in [Lin, S., Costello, D.: „Error Control Coding", Prentice Hall, 1983, vgl. z.B. Seiten 143 bis 160] beschrieben.
• Ein BCH-Code ist ein linearer Code, der durch eine Paritätsprüfmatrix H und eine Generatormatrix G, die beispielsweise aus der Paritätsprüfmatrix ableitbar ist, beschrieben werden kann. Hat der Code die Länge N und weist er k Informationsbits auf, dann ist die Paritätsprüfmatrix H eine (L,N)-Matrix mit L Zeilen und N Spalten, wobei L = N - k ist. Die Generatormatrix G ist dann eine (k, N)-Matrix mit k Zeilen und N Spalten und der Code hat L Prüfbits.
• Ein t-Bitfehler korrigierender unverkürzter BCH-Code kann durch die H-Matrix $$H=\left(\begin{array}{c}{H}_1\\ H_3\\ ⋮\\ H_{2t-1}\end{array}\right)=\left(h_0,\dots ,h_{N-1}\right)$$

  

  beschrieben werden, wobei die H-Matrix in separierter Form dargestellt ist. Beispielsweise werden H₁, H₃, ..., H_2t-1 als $$\begin{array}{c}{H}_1=\left({\alpha }^0,{\alpha }^1,\dots ,{\alpha }^i,\dots ,{\alpha }^{N-1}\right)=\left(h_0^1,\dots ,h_i^1,\dots ,h_{N-1}^1\right),\\ H_3=\left({\alpha }^0,{\alpha }^3,\dots ,{\alpha }^{3i},\dots ,{\alpha }^{3\left(N-1\right)}\right)=\left(h_0^3,\dots ,h_i^3,\dots ,h_{N-1}^3\right),\\ ⋮\\ H_{12t-}=\left({\alpha }^0,{\alpha }^{2t-1},\dots ,{\alpha }^{\left(2t-t\right)i},\dots ,{\alpha }^{\left(2t-1\right)\left(N-1\right)}\right)=\left(h_0^{2t-1},\dots ,h_i^{2t-1},\dots ,h_{N-1}^{2t-1}\right)\end{array}$$

  

  gewählt, wenn der Code nicht verkürzt ist. Dabei kann α ein primitives Element eines endlichen Körpers GF(2^m) (auch bezeichnet mit GF(2^q)) sein, der auch Galoisfeld genannt wird. In diesem Fall gilt: N = 2^m - 1. Die Exponenten von $${\alpha }^j,{\alpha }^{3j},\dots ,{\alpha }^{\left(2t-1\right)j}$$

  

  sind modulo 2^m - 1 bestimmt. Ist α ein primitives Element des verwendeten Galoisfelds, kann der entsprechende BCH-Code auch als primitiver BCH-Code bezeichnet werden. $$H_1,H_3,\dots ,H_{2t-1}$$

  

  sind allgemein jeweils (m,N)-Matrizen mit m Zeilen und N = 2^m - 1 Spalten. Es ist möglich, dass einige der m Zeilen einer der Matrizen H_i linear abhängig sind. In einem solchen Fall können Zeilen der Matrix H_i weggelassen werden, bis alle Zeilen linear unabhängig sind. Die Anzahl der Zeilen beispielsweise der Matrix H_i kann somit auch kleiner als m sein.
• Die Elemente aⁱ des Galoisfelds GF(2^m) sind hier in ihrer Vektordarstellung m-stellige binäre Spaltenvektoren.
• Werden Q Spalten der H-Matrix des unverkürzten BCH-Codes gestrichen, so ergibt sich eine H-Matrix eines verkürzten BCH-Codes der Länge n = N - Q. Für den verkürzten Code gilt: n = N - Q < 2^m - 1.
• Optional kann die H-Matrix H um eine Zeile aus lauter Einsen ergänzt werden. Einer zusätzlichen Zeile aus Einsen in der H-Matrix entspricht die zusätzliche Berücksichtigung einer Gesamtparität. Bei Berücksichtigung der Gesamtparität kann die H-Matrix die Form $$H=\left(\begin{array}{c}{H}_1\\ H_3\\ ⋮\\ H_{2t-1}\\ P\end{array}\right)$$

  

  haben, wobei P die Zeile aus Einsen darstellt.
• Nachfolgend wird ein verkürzter BCH-Code der Länge n betrachtet, wobei $$n=N-Q<2^m-1$$

  

  gilt. Ein Codewort dieses BCH-Codes v = v₀,..., v_n-1 (auch bezeichnet als Codevektor) besteht aus n Komponenten v₀, v₁,... , v_n-1. Dabei kann ein Codevektor als ein Zeilenvektor oder als ein Spaltenvektor beschrieben sein. Wird eine Matrix von rechts mit einem Vektor multipliziert, dann ist der Vektor als Spaltenvektor zu interpretieren und das Ergebnis ist ein Spaltenvektor. Wird eine Matrix von links mit einem Vektor multipliziert, dann ist der Vektor ein Zeilenvektor und das Resultat der Multiplikation ist ebenfalls ein Zeilenvektor. Es ist dann nicht erforderlich, die entsprechenden Vektoren explizit als Spaltenvektoren oder Zeilenvektoren hervorzuheben, da aus dem Kontext klar ist, ob es sich um einen Spaltenvektor oder einen Zeilenvektor handelt. Weiterhin sei angemerkt, dass ein Vektor w, der als Spaltenvektor dargestellt ist, in der Form w^T notiert sein kann.
• Wird ein Codewort v = v₀, ..., v_n-1 in ein Wort $v\text{'}=v_0^{\text{'}},\dots ,v_{n-1}^{\text{'}}$

  

  gestört, dann kann der Unterschied zwischen dem Codewort v und dem gestörten Wort v' durch einen Fehlervektor e mit $$e=e_0,\dots ,e_{n-1}=v_0\oplus v_0^{\text{'}},\dots ,v_{n-1}\oplus v_{n-1}^{\text{'}}=v+v\text{'}$$

  

  beschrieben werden.
• Eine Komponente e_i des Fehlervektors e ist gleich 1, wenn sich das Codewort v_i und das gestörte Codewort $v_i^{\text{'}}$

  

  unterscheiden und wenn $v_i=v_i^{\text{'}}\oplus 1=\overline{v_i^{\text{'}}}$

  

  gilt. Eine Komponente e_j des Fehlervektors e ist gleich 0, wenn das Codewort v_j und das gestörte Codewort $v_j^{\text{'}}$

  

  gleich sind und wenn $v_j=v_j^{\text{'}}$

  

  gilt.
• Das Symbol „⊕“ bezeichnet die Exklusiv-Oder-Verknüpfung (auch bezeichnet als XOR-Verknüpfung).
• Kann ein Fehler durch eine Fehlerkorrekturschaltung korrigiert werden, dann können die Korrekturwerte, die die Fehlerkorrekturschaltung ausgibt, gleich den Komponenten des Fehlervektors sein, und die Korrekturschaltung gibt in diesem Fall an einem i-ten Ausgang ihrer n Ausgänge den Korrekturwert e_i aus. Der Korrekturwert e_i kann dann mit der zu korrigierenden Komponente $v_j^{\text{'}}$

  

  zu $$v_i^{corr}=v_i^{\text{'}}\oplus e_i.$$

  

  XOR-verknüpft werden. Die Korrekturwerte e_i können auch zu einem Korrekturvektor zusammengefasst werden.
• Der Korrekturvektor ist gleich dem Fehlervektor, wenn der Fehler durch den Code korrigiert werden kann und die Komponenten des Korrekturvektors und des zu korrigierenden Vektors komponentenweise XOR-verknüpft werden.
• Kann ein Fehler durch eine Fehlerkorrekturschaltung korrigiert werden, dann können die Korrekturwerte, die die Fehlerkorrekturschaltung ausgibt, auch gleich den invertierten Komponenten des Fehlervektors sein, und die Korrekturschaltung gibt in diesem Fall an dem i-ten Ausgang ihrer N Ausgänge den invertierten Korrekturwert e _i aus. Der invertierte Korrekturwert e _i kann dann mit der zu korrigierenden Komponente $v_i^{\text{'}}$

  

  zu $$v^{corr}=\overline{v_i^{\text{'}}\oplus \overline{e_i}}$$

  
• XNOR-verknüpft werden. Es ist auch möglich, eine Teilmenge der Korrekturwerte zu invertieren.
• Hierbei sei angemerkt, dass das XNOR-Gatter die Funktion (Exklusiv-Nicht-ODER) wahrnimmt; an dessen Ausgang liegt genau dann eine logische 1 an, wenn an beiden Eingängen 1 oder an beiden Eingängen 0 anliegt. Die XNOR-Verknüpfung wird auch als Äquivalenz bezeichnet.
• Nachfolgend werden beispielhaft nicht-invertierte Korrekturwerte verwendet. Eine Anwendung der hier beschriebenen Lösungen auf invertierte Korrekturwerte ist entsprechend möglich.
• Grundsätzlich ist es nicht notwendig, dass alle n Bits eines eventuell fehlerhaften n-stelligen Binärwortes $v\text{'}=v_0^{\text{'}},\dots ,v_{n-1}^{\text{'}}$

  

  korrigiert werden. Es ist zum Beispiel möglich, T Bits dieser n Bits zu korrigieren, wobei T ≤ n gilt. Erfolgt die Korrektur unter Verwendung eines t-Bitfehler korrigierenden Codes, gilt allgemein T > t. So ist es möglich, nur Datenbits des Binärwortes v unter Verwendung des t-Bitfehler korrigierenden Codes zu korrigieren. Es ist aber auch möglich, dass T = n gilt und alle Bits korrigiert werden. Beispielhaft wird der Fall betrachtet, dass t < T ≤ n gilt.
• Ist der Vektor v ein Codevektor eines separierbaren Codes, bei dem Datenbits und Prüfbits in dem Codevektor v getrennt vorhanden sind, ist es möglich, nur die Datenbits oder nur einen Teil der Datenbits des Vektors v' zu korrigieren.
• Ein Fehlersyndrom s = (s₁, s₃,... ,s_2t-1, s_p) eines gestörten Wortes v' ist für einen t-Bitfehler korrigierenden BCH-Code mit einbezogener Gesamtparität durch $$s=H\cdot v\text{'}$$

  

  bestimmt, wobei $$\begin{array}{l}{s}_1=H_1\cdot v\text{'},\left(2\right)\hfill \\ s_3=H_3\cdot v\text{'},\left(3\right)\hfill \\ ⋮\left(4\right)\hfill \\ \begin{array}{l}{s}_{2t-1}=H_{2t-1}\cdot v\text{'},\left(5\right)\hfill \\ \text{und }\left(6\right)\hfill \\ s_p=P\cdot v\text{'}=\left(\mathrm{1,}\dots \mathrm{,1}\right)\cdot v\text{'}=v_0^{\text{'}}\oplus v_1^{\text{'}}\oplus \dots \oplus v_{n-1}^{\text{'}}\left(7\right)\hfill \end{array}\hfill \end{array}$$

  

  gelten.
• Das Fehlersyndrom eines Codewortes v ist gleich 0, so dass für ein Codewort v gilt: $$s=H\cdot v=0.$$

  
• Entsprechend gilt für ein Nicht-Codewort v' = v ⊕ e: $$s=H\cdot v\text{'}=H=\left(v\oplus e\right)=\left(H\cdot v\right)\oplus \left(H\cdot e\right)=H\cdot e\ne 0.$$

  
• Das Fehlersyndrom s ist durch den Fehlervektor e bestimmt. Das Fehlersyndrom s wird hier als unmodifiziertes Fehlersyndrom bezeichnet. Entsprechend sind s₁, s₃, ..., s_2t-1 Teilsyndrome des unmodifizierten Fehlersyndroms s. Die Teilsyndrome s₁, s₃, ..., s_2t-1 sind ihrerseits Elemente des Galoisfelds GF(2^m) und können in den verschiedenen Darstellungen von Galoisfeld-Elementen wiedergegeben sein. Beispielsweise können diese Elemente in ihrer Vektordarstellung in dem Galoisfeld GF(2^m) jeweils m binäre Komponenten (d.h. Werte in dem Galoisfeld GF(2^m)) aufweisen. Die Teilsyndrome s₁, s₃, ..., s_2t-1 werden auch als Komponenten des Fehlersyndroms s = (s₁, s₃, ..., s_2t-1) bezeichnet, wobei die Komponenten s₁, s₃, ..., s_2t-1 dann Werte des Galoisfelds GF(2^m) annehmen.
• Um aus dem fehlerhaften, gestörten Nicht-Codewort v' das zugehörige korrekte Codewort zu ermitteln, sind diejenigen Komponenten $v_j^{\text{'}}$

  

  zu invertieren, für die e_j = 1 gilt, so dass die eine Komponente e_j des Fehlervektors der entsprechende Korrekturwert ist, den die Fehlerkorrekturschaltung bestimmt.
• Für den betrachteten verkürzten BCH-Code kann der Fehlervektor e aus dem unmodifizierten Fehlersyndrom $$s=\left(s_1\text{,}{s}_3\text{,}\dots s_{2t-1}{\text{,s}}_p\right)$$

  

  mit der H-Matrix $$H=\left(\begin{array}{c}{H}_1\\ H_3\\ ⋮\\ H_{2t-1}\\ P\end{array}\right)$$

  

  bestimmt werden.
• Die Matrizen H₁, H₃, ..., H_2t-1 der H-Matrix können durch ihre jeweiligen Spalten wie folgt angegeben werden: $$\begin{array}{l}{H}_1=\left(h_0^1{\text{,h}}_1^1\text{,}\dots {\text{,h}}_{n-1}^1\right)=\left({\alpha }^{i_0}\text{,}{\alpha }^{i_1}\text{,}\dots \text{,}{\alpha }^{i_{n-1}}\right)\text{, (10)}\hfill \\ {\text{ H}}_3=\left(h_0^3,h_1^3\text{,}\dots {\text{,h}}_{n-1}^3\right)=\left({\alpha }^{\left(2t-1\right)\left(i_0\right)}\text{,}{\alpha }^{\left(2t-1\right)\left(i_1\right)}\text{,}\dots \text{,}{\alpha }^{\left(2t-1\right)\left(i_{n-1}\right)}\right)\text{, (11)}\hfill \\ ⋮\hfill \\ H_{2t-1}=\left(h_0^{2t-1}{\text{,h}}_1^{2t-1}\text{,}\dots {\text{,h}}_{n-1}^{2t-1}\right)=\left({\alpha }^{\left(2t-1\right)\left(i_0\right)}\text{,}{\alpha }^{\left(2t-1\right)\left(i_1\right)}\text{,}\dots \text{,}{\alpha }^{\left(2t-1\right)\left(i_{n-1}\right)}\right),(12)\hfill \\ P=\underset{n}{\underbrace{\left(\mathrm{1,1,}\dots \mathrm{,1}\right)}}.(13)\hfill \end{array}$$

  
• Die Exponenten von α sind modulo 2^m - 1 bestimmt, und die Exponenten i₀, i₁, ..., i_n-i sind paarweise verschieden. Es ist dabei nicht erforderlich, dass i_j = j für j = 0, ..., n - 1 gilt.
• Beispielhaft kann die H-Matrix in der Form $$\begin{array}{l}{H}_1=\left({\alpha }^{i_0},{\alpha }^{i_0+d}\text{,}\dots \text{,}{\alpha }^{i_0+\left(n-1\right)\cdot d}\right)\hfill \\ H_3=\left({\alpha }^{3\cdot i_0}\text{,}{\alpha }^{3\cdot \left(i_0+d\right)}\text{,}\dots \text{,}{\alpha }^{3\cdot \left(i_0+\left(n-1\right)\right)\cdot d}\right)\hfill \\ ⋮\hfill \\ H_{2t-1}=\left({\alpha }^{\left(2t-1\right)i_0},{\alpha }^{\left(2t-1\right)\left(i_0+d\right)}\text{,}\dots \text{,}{\alpha }^{\left(2t-1\right)\left(i_0+\left(n-1\right)\cdot d\right)}\right)\hfill \\ P=\underset{n}{\underbrace{\left(\mathrm{1,1}\dots \mathrm{,1}\right)}}\hfill \end{array}$$

  

  verwendet werden.
• Für ein Fehlermuster F_m = [M, D₁,... ,D_M-1] gilt für diese H-Matrix $$\begin{array}{l}{H}_1\cdot e_{F_m}^{norm}={\alpha }^{i_0}\cdot \left(1+{\alpha }^{D_1\cdot d}+{\alpha }^{\left(D_1+D_2\right)\cdot d}+\dots +{\alpha }^{\left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}\right)\hfill \\ H_3\cdot e_{F_m}^{norm}={\alpha }^{3\cdot i_0}\cdot \left(1+{\alpha }^{3\cdot D_1\cdot d}+{\alpha }^{3\cdot }{}^{\left(D_1+D_2\right)\cdot d}+\dots +{\alpha }^{3\cdot \left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}\right)\hfill \\ ⋮\hfill \\ H_{2t-1}\cdot e_{F_m}^{norm}={\alpha }^{\left(2t-1\right)\cdot i_0}\cdot (1+{\alpha }^{\left(2t-1\right)\cdot D_1\cdot d}+{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2\right)\cdot d}+\dots +\hfill \\ +{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2+\dots +D_{M-1}\right)\cdot d)}\text{,}\hfill \end{array}$$

  

  und Konstanten β₁, ... , β_2t-1 sind durch $$\begin{array}{l}{\beta }_1=\frac{H_1\cdot {\left[e_{Fm}^{norm}\right]}^T}{{\alpha }^{i_0}}\hfill \\ {\beta }_3=\frac{H_3\cdot {\left[e_{Fm}^{norm}\right]}^T}{{\alpha }^{3\cdot i_0}}\hfill \\ {}^{⋮}\hfill \\ {\beta }_{2t-1}=\frac{H_{2t-1}\cdot {\left[e_{Fm}^{norm}\right]}^T}{{\alpha }^{\left(2t-1\right)\cdot i_0}}\hfill \end{array}$$

  

  bestimmt, wobei ${\left[e_{Fm}^{norm}\right]}^T$

  

  der transponierte n-dimensionale Spaltenvektor des n-dimensionalen Zeilenvektors $e_{Fm}^{norm}$

  

  ist. Ferner gilt K ≥ 1.
• Zur Bestimmung von β₁ wird die Teilmatrix H₁ mit dem normierten Fehlervektor $e_{F_m}^{norm}$

  

  des Fehlermusters F_m multipliziert. Dabei werden die Spalten der Teilmatrix H₁ komponentenweise XOR-verknüpft, die den Positionen des normierten Fehlervektors $e_{F_m}^{norm}$

  

  entsprechen, die gleich 1 sind. Das Resultat wird als Element des Galoisfelds durch ${\alpha }^{i_0}$

  

  dividiert oder gleichwertig mit ${\alpha }^{-i_0}$

  

  multipliziert. Ist i₀ = 0 und damit ${\alpha }^{i_0}={\alpha }^0=\mathrm{1,}$

  

  dann ist keine weitere Operation erforderlich.
• Zur Bestimmung von β₃ wird die Teilmatrix H₃ mit dem normierten Fehlervektor $e_{F_M}^{norm}$

  

  des Fehlermusters F_m multipliziert. Dabei werden die Spalten der Teilmatrix H₃ komponentenweise XOR-verknüpft, die den Positionen des normierten Fehlervektors $e_{F_m}^{norm}$

  

  entsprechen, die gleich 1 sind. Das Resultat wird als Element des Galoisfelds durch ${\alpha }^{3\left(i_0\right)}$

  

  dividiert oder gleichwertig mit ${\alpha }^{-3\left(i_0\right)}$

  

  multipliziert. Ist i₀ = 0 und damit ${\alpha }^{3\left(i_0\right)}={\alpha }^0=\mathrm{1,}$

  

  dann ist keine weitere Operation erforderlich.
• Entsprechend werden β₅,..., β_2t-1 bestimmt. $e_{F_m}^{norm}$

  

  ist hier ein n-komponentiger Spaltenvektor, da die Matrizen H₁, H₃, ... von rechts mit $e_{F_m}^{norm}$

  

  multipliziert werden.
• Für den speziellen Fall i₀ = 0 und d = 1 gilt für die H-Matrix: $$\begin{array}{l}{H}_1=\left({\alpha }^0,{\alpha }^1\text{,}\dots \text{,}{\alpha }^{n-1)}\right)\hfill \\ H_3=\left({\alpha }^0\text{,}{\alpha }^3\text{,}\dots \text{,}{\alpha }^{\left(n-1\right)\cdot 3)}\right)\hfill \\ ⋮\hfill \\ H_{2t-1}=\left({\alpha }^0,{\alpha }^{\left(2t-1\right)}\text{,}\dots \text{,}{\alpha }^{\left(n-1\right)\cdot \left(2t-1\right)}\right)\text{.}\hfill \end{array}$$

  
• Für ein Fehlermuster F_m = [M, D₁,... ,D_M-1] gilt $$\begin{array}{l}{H}_1\cdot e_{F_m}^{norm}=\left(1+{\alpha }^{D_1}+{\alpha }^{\left(D_1+D_2\right)}+\dots +{\alpha }^{\left(D_1+D_2+\dots +D_{M-1}\right)}\right)\hfill \\ H_3\cdot e_{F_m}^{norm}=\left(1+{\alpha }^{3\cdot D_1}+{\alpha }^{3\cdot }{}^{\left(D_1+D_2\right)}+\dots +{\alpha }^{3\cdot \left(D_1+D_2+\dots +D_{M-1}\right)}\right)\hfill \\ ⋮\hfill \\ H_{2t-1}\cdot e_{F_m}^{norm}=(1+{\alpha }^{\left(2t-1\right)\cdot D_1}+{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2\right)\cdot d}+\dots ++\alpha {}^{\left(2t-1\right)\cdot \left(D_1+D_2+\dots +D_{M-1}\right)})\hfill \end{array}$$

  

  und weiter mit ${\alpha }^{i_0}={\alpha }^0=1$

  

  $$\begin{array}{l}{\beta }_1=H_1\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ {\beta }_3=H_3\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ {}^{⋮}\hfill \\ {\beta }_{2t-1}=H_{2t-1}\cdot {\left[e_{Fm}^{norm}\right]}^T\text{.}\hfill \end{array}$$

  
• Speziell für ein Fehlermuster F_m = [M;D₁,... ,D_M-1] folgt somit $$\begin{array}{l}{\beta }_1=\left(1+{\alpha }^{D_1}+{\alpha }^{\left(D_1+D_2\right)}+\dots +{\alpha }^{\left(D_1+D_2+\dots +D_{M-1}\right)}\right)\hfill \\ {\beta }_3=\left(1+{\alpha }^{3\cdot D_1}+{\alpha }^{3\cdot }{}^{\left(D_1+D_2\right)}+\dots +{\alpha }^{3\cdot \left(D_1+D_2+\dots +D_{M-1}\right)}\right)\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}=(1+{\alpha }^{\left(2t-1\right)\cdot D_1}+{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2\right)\cdot d}+\dots ++\alpha {}^{\left(2t-1\right)\cdot \left(D_1+D_2+\dots +D_{M-1}\right)})\hfill \end{array}$$

  
• Es wird die Korrektur eines Fehlers betrachtet, der K Mal ein Fehlermuster $$\left[M;D_1\text{,}\dots {\text{,D}}_{M-1}\right]$$

  

  aufweist, wobei $$K\cdot M=t+1$$

  

  gilt. Für k = 1, ... , K ist beispielhaft das erste Bit des k-ten Fehlermusters das j_k-te Bit des Fehlervektors. Für die Teilsyndrome des Fehlersyndroms s ergibt sich $$\begin{array}{l}{s}_1={\alpha }^{j1}\cdot {\beta }_1+{\alpha }^{j2}\cdot {\beta }_1+\dots +{\alpha }^{jK}\cdot {\beta }_1\hfill \\ s_3={\alpha }^{3\cdot j_1}\cdot {\beta }_3+{\alpha }^{3\cdot j_2}\cdot {\beta }_3+\dots +{\alpha }^{3\cdot j_K}\cdot {\beta }_3\hfill \\ ⋮\hfill \\ s_{2t-1}={\alpha }^{\left(2t-1\right)\cdot j_1}\cdot {\beta }_{2t-1}+{\alpha }^{\left(2t-1\right)\cdot j_2}{\beta }_{2t-1}+\dots +{\alpha }^{\left(2t-1\right)\cdot j_K}\cdot {\beta }_{2t-1}\hfill \end{array}$$

  

  mit $$\begin{array}{l}{\beta }_1=1+{\alpha }^{D_1\cdot d}+\dots +{\alpha }^{\left(D_1+\dots +D_{M-1}\right)\cdot d},\hfill \\ {\beta }_3=1+{\alpha }^{3\cdot D_1\cdot d}+\dots +{\alpha }^{3\cdot }{}^{\left(D_1+\dots +D_{M-1}\right)\cdot d}\text{,}\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}=1+{\alpha }^{\left(2t-1\right)\cdot D_1\cdot d}+\dots +{\alpha }^{\left(2t-1\right)\cdot }{}^{\left(D_1+\dots +D_{M-1}\right)\cdot d}\text{.}\hfill \end{array}$$

  
• Aus der Gleichung (14) folgt: $$\begin{array}{l}{s}_1^{mod}=s_1\cdot {\beta }_1^{-1}={\alpha }^{j1}+{\alpha }^{j2}+\dots {\alpha }^{j_K}\hfill \\ s_1^{mod}=s_3\cdot {\beta }_3^{-1}={\alpha }^{j1}+{\alpha }^{j2}+\dots {\alpha }^{j_K}\hfill \\ ⋮\hfill \\ s_{2t-1}^{mod}=s_{{}_{2t--1}}\cdot {\beta }_{2_{t-1}}^{-1}={\alpha }^{\left(2t-1\right)\cdot j_1}+{\alpha }^{\left(2t-1\right)\cdot j_2}+\dots +{\alpha }^{\left(2t-1\right)\cdot j_K}\hfill \end{array}$$

  
• Für die jeweils ersten Bitpositionen j₁, j₂, ... , j_K der K Fehlermuster gelten die Gleichungen für einen K-Bitfehler eines K-Bitfehler korrigierenden BCH-Codes, wenn man das unmodifizierte Fehlersyndrom durch das modifizierte Fehlersyndrom ersetzt. Das unmodifizierte Fehlersyndrom umfasst die Teilsyndrome s₁, ... , s_2t-1 und das modifizierte Fehlersyndrom umfasst die Teilsyndrome $s_1^{mod},\dots ,s_{2K-1}^{mod}\text{.}$

  
• Mit anderen Worten: Das modifizierte Fehlersyndrom $s^{mod}=s_1^{mod}\text{,}\dots {\text{,s}}_{2K-1}^{mod}$

  

  wird so gebildet, dass es als Fehlersyndrom eines K-Bitfehler korrigierenden Codes für jeweils ein erstes Bit der K Fehlermuster dient.
• Das modifizierte Fehlersyndrom $$s^{mod}=s_1^{mod},\dots ,s_{2K-1}^{mod}$$

  

  wird unter Verwendung des unmodifizierten Fehlersyndroms $$s=s_1\text{,}\dots {\text{,s}}_{2t-1}$$

  

  und des Fehlermusters F_m bestimmt, wobei das Fehlermuster F_m beispielsweise durch seinen normierten Fehlervektor $e_{F_{m}0}^{norm}$

  

  beschrieben ist.
• Beispielsweise sind die Konstanten β₁, ... , β_2K-1 zu $$\begin{array}{l}{\beta }_1=\frac{H_1\cdot e_{F_m}^{norm}}{{\alpha }^{i_0}}\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}=\frac{H_{2t-1}\cdot e_{F_m}^{norm}}{{\alpha }^{\left(2t-1\right)i_0}}\hfill \end{array}$$

  

  bestimmt und die Teilsyndrome $s_1^{mod}\text{,}\dots {\text{,s}}_{K-1}^{mod}$

  

  des modifizierten Fehlersyndroms ergeben sich durch Multiplikation der entsprechenden Teilsyndrome s₁,..., s_2k-1 des unmodifizierten Fehlersyndroms mit jeweils einer Konstanten ${\beta }_1^{-1}\text{,}\dots \text{,}{\beta }_{2K-1}^{-1}\text{.}$

  
• Die Korrektur dieses K-Bitfehlers kann unter Verwendung der modifizierten Teilsyndrome $s_1^{mod}{\text{,s}}_3^{mod}\text{,}\dots {\text{,s}}_{2K-1}^{mod}$

  

  erfolgen, wenn bereits bestimmt wurde, dass ein t + 1-Bitfehler vorliegt. Für den t + 1-Bitfehler wird dann angenommen, dass es sich um einen Fehler handelt, dessen Fehlervektor K mindestens ein Fehlermuster [M;D₁,...,D_M-1] aufweist.
• Entsprechend ist es möglich, die Korrektur unter Verwendung aller modifizierten Teilsyndrome $s_1^{mod}{\text{,s}}_3^{mod}\text{,}\dots {\text{,s}}_{2t-1}^{mod}$

  

  vorzunehmen.
• In manchen Anwendungsbeispielen ist es möglich, dass die ersten Bitpositionen der K Fehlermuster nur bestimmte Werte annehmen. Liegt beispielsweise ein Speicher vor, dessen Speicherzellen vier verschiedene Zustände und damit vier verschiedene binär codierte Werte 00, 01, 10, 11 annehmen können, kann eine Anzahl von K benachbarten 2-Bitfehlern auftreten, deren erste Bits die Bits 1, 3, 5, ... sind, sofern der i-ten Speicherzelle die Bits 2i - 1, 2i zugeordnet sind. Wenn die ersten Bitpositionen der Fehlermuster nur bestimmte Werte annehmen können, kann dadurch eine vereinfachte Decodierung und Fehlerkorrektur genutzt werden.
• Für d = 1 und k₁ = 0 gilt $$\begin{array}{l}{\beta }_1=1+{\alpha }^{D_1}+\dots +{\alpha }^{\left(D_1+\dots +D_{M-1}\right)}=H_1\cdot e_{F_m}^{norm}\hfill \\ {\beta }_3=1+{\alpha }^{3\cdot D_1}+\dots +{\alpha }^{3\cdot \left(D_1+\dots +D_{M-1}\right)}=H_3\cdot e_{F_m}^{norm}\text{,}\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}=1+{\alpha }^{\left(2t-1\right)\cdot D_1}+\dots +{\alpha }^{\left(2t-1\right)\cdot \left(D_1+\dots +D_{M-1}\right)}=H_{2t-1}\cdot e_{F_m}^{norm}.\hfill \end{array}$$

  

  mit F_m = [M;D₁,...,D_M-1].
• Nachfolgend wird ein Ausführungsbeispiel für einen 3-Bitfehler korrigierenden und 4-Bitfehler erkennenden BCH-Code mit einem Codeabstand 8 betrachtet. Beliebige 3-Bitfehler und 4-Bitfehler aus zwei benachbarten 2-Bitfehlern können korrigiert werden. Das Fehlermuster ist in diesem Beispiel [2;1].
• Es wird die H-Matrix $$H=\left(\begin{array}{llll}{\alpha }^0\hfill & {\alpha }^1\hfill & {\alpha }^2\hfill & \dots \hfill \\ {\alpha }^0\hfill & {\alpha }^3\hfill & {\alpha }^6\hfill & \dots \hfill \\ {\alpha }^0\hfill & {\alpha }^5\hfill & {\alpha }^{10}\hfill & \dots \hfill \\ 1\hfill & 1\hfill & 1\hfill & \dots \hfill \end{array}\right)$$

  

  verwendet.
• Liegt ein 1-Bitfehler im j-ten Bit vor, dann gilt $$s_1={\alpha }^j\text{,}$$

  

  $$s_3={\alpha }^{3j}\text{,}$$

  

  $$s_5={\alpha }^{5j}\text{,}$$

  

  $$s_p=1$$

  

  und es ist $s_1^3=s_3,s_1^5=s_5\text{.}$

  
• Liegt ein 2-Bitfehler in den Bitpositionen j und l vor, gilt $$s_1={\alpha }^j\oplus {\alpha }^l,$$

  

  $$s_3={\alpha }^{3j}\oplus {\alpha }^{3l},$$

  

  $$s_5={\alpha }^{5j}\otimes {\alpha }^{5l},$$

  

  $$s_p=0$$

  

  und es ist $s_1^3\ne s_3.$

  
• Liegt ein 3-Bitfehler in den Bitpositionen i, j und l vor, gilt $$s_1={\alpha }^i\oplus {\alpha }^j\oplus {\alpha }^l,$$

  

  $$s_3={\alpha }^{3i}\oplus {\alpha }^{3j}\oplus {\alpha }^{3l},$$

  

  $$s_5={\alpha }^{5i}\oplus {\alpha }^{5j}\oplus {\alpha }^{5l},$$

  

  $$s_p=1$$

  

  und es ist $s_1^3\ne s_3.$

  
• Ein 1-Bitfehler, ein 2-Bitfehler oder ein 3-Bitfehler wird unter Verwendung der Teilsyndrome s₁, s₃ und s₅ korrigiert, wie dies bei der Verwendung eines BCH-Codes üblich ist.
• Liegt ein 4-Bitfehler in den Bitpositionen j, j + 1, l und l + 1 vor, ist das Fehlermuster [2, 1] zweimal in dem Fehlervektor e enthalten. Das erste Fehlermuster eines benachbarten 2-Bitfehlers beginnt in der Bitposition j und das zweite Fehlermuster aus zwei benachbarten 2-Bitfehlern beginnt in der Bitposition l. Diese Bitpositionen sollen bestimmt werden.
• Es gelten: $$s_1={\alpha }^j+{\alpha }^{j+1}+{\alpha }^l+{\alpha }^{l+1}={\alpha }^j\left(1+\alpha \right)+{\alpha }^l\left(1+\alpha \right),$$

  

  $$s_3={\alpha }^{3j}+{\alpha }^{3\left(j+1\right)}+{\alpha }^{3l}+{\alpha }^{3\left(l+1\right)}={\alpha }^{3j}\left(1+{\alpha }^3\right)+{\alpha }^{3l}\left(1+{\alpha }^3\right),$$

  

  $$s_5={\alpha }^{5j}+{\alpha }^{5\left(j+1\right)}+{\alpha }^{5l}+{\alpha }^{5\left(l+1\right)}={\alpha }^{5j}\left(1+{\alpha }^5\right)+{\alpha }^{5l}\left(1+{\alpha }^5\right),$$

  

  $$s_p=0.$$

  

  Mit $${\beta }_1=H_1\cdot e_{\left[\mathrm{2,1}\right]}^{norm}=H_1\cdot {\left[\mathrm{1,1,0,}\dots \mathrm{,0}\right]}^T=1+\alpha ,$$

  

  $${\beta }_3=H_3\cdot e_{\left[\mathrm{2,1}\right]}^{norm}=H_3\cdot {\left[\mathrm{1,1,0,}\dots \mathrm{,0}\right]}^T=1+{\alpha }^3,$$

  

  $${\beta }_5=H_2\cdot e_{\left[\mathrm{2,1}\right]}^{norm}=H_5\cdot {\left[\mathrm{1,1,0,}\dots \mathrm{,0}\right]}^T=1+{\alpha }^5,$$

  

  ergibt sich $$s_1^{mod}=s_1\cdot {\beta }_1^{-1}={\alpha }^j+{\alpha }^l,$$

  

  $$s_3^{mod}=s_3\cdot {\beta }_3^{-1}={\alpha }^{3j}+{\alpha }^{3l},$$

  

  $$s_5^{mod}=s_5\cdot {\beta }_5^{-1}={\alpha }^{5j}+{\alpha }^{5l}.$$

  

  und die Bitpositionen j und l sind, wenn schon bekannt ist, dass ein 4-Bitfehler (mit t + 1 = 4) aus 2 benachbarten 2-Bitfehlern vorliegt, wie ein 2-Bitfehler aus den modifizierten Teilyndromen $s_1^{mod}\text{ und }{s}_3^{mod}$

  

  des BCH-Codes bestimmbar.
• Es ist auch möglich, die Teilsyndrome $s_1^{mod},s_3^{mod}\text{ und }{s}_5^{mod}$

  

  zur Bestimmung der Bitpositionen j und l zu verwenden.
• Weiterhin ist es eine Option, anstelle des 4-Bitfehlers aus zwei benachbarten 2-Bitfehlern einen 4-Bitfehler aus vier benachbarten Bitfehlern zu betrachten: Der so modifizierte BCH-Code korrigiert dann beliebige 3-Bitfehler und einen 4-Bit-Burst-Fehler, wobei ein 4-Bit-Burst-Fehler ein beliebiger Fehler innerhalb von 4 aufeinanderfolgenden Bits ist. Das Fehlermuster ist in diesem Fall F_m = [4; 1,1,1] und der Fehlervektor ergibt sich zu $$e_{Fm}^{norm}=\left[\mathrm{1,1,1,1,0,}\dots \mathrm{,0}\right].$$

  
• Für einen 4-Bitfehler mit 4 benachbarten Bitfehlern mit der ersten Bitposition j gilt somit $$s_1={\alpha }^j+{\alpha }^{j+1}+{\alpha }^{j+2}+{\alpha }^{j+3}={\alpha }^j\left(1+\alpha +{\alpha }^2+{\alpha }^3\right),$$

  

  $$s_3={\alpha }^{3j}+{\alpha }^{3\left(j+1\right)}+{\alpha }^{3\left(j+2\right)}+{\alpha }^{3\left(j+3\right)}={\alpha }^{3j}\left(1+{\alpha }^3+{\alpha }^6+{\alpha }^9\right)$$

  

  $$s_5={\alpha }^{5j}+{\alpha }^{5\left(j+1\right)}+{\alpha }^{5\left(j+2\right)}+{\alpha }^{5\left(j+3\right)}={\alpha }^{5j}\left(1+{\alpha }^5\right)+{\alpha }^{10}+{\alpha }^{15})$$

  

  $$s_p=\mathrm{0,}$$

  

  wobei die Position j aus der Gleichung $$s_1^{mod}=s_1\cdot {\beta }_1^{-1}={\alpha }^j$$

  

  mit $${\beta }_1=H_1\cdot {\left[\mathrm{1,1,1,1,0,}\dots \mathrm{,0}\right]}^T=1+\alpha +{\alpha }^2+{\alpha }^3$$

  

  bestimmt werden kann.
• Es ist möglich, den Ort eines Fehlers als Nullstelle eines Lokatorpolynoms zu bestimmen. Liegt ein µ-Bitfehler vor, dann ist es möglich, die Fehlerorte durch die µ Nullstellen eines Lokatorpolynoms µ-ten Grades L_µ (x) mit $$L_{\mu }\left(x\right)=x^{\mu }+{\mathrm{\sigma }}_1^{\mu }{x}^{\mu -1}+{\mathrm{\sigma }}_2^{\mu }{x}^{\mu -2}+\dots +{\mathrm{\sigma }}_{\mu -1}^{\mu }{x}^1+{\mathrm{\sigma }}_{\mu }^{\mu }$$

  

  zu ermitteln. Weiterhin ist es möglich, (µ - 1) Fehlerorte eines (µ - 1)-Bitfehlers durch die Nullstellen des Lokatorpolynoms µ-ten Grades zu bestimmen. Im Falle eines (µ - 1)-Bitfehlers ist eine erste Nullstelle des Lokatorpolynoms µ-ten Grades gleich 0, während die weiteren (µ - 1) Nullstellen den (µ - 1) Fehlerorten entsprechen.
• Es ist bekannt, das der Anzahl der Fehler entsprechende Lokatorpolynom iterativ nach dem Berlekamp-Massey-Algorithmus zu bestimmen (siehe z.B. [Lin, S., Costello, D.: „Error Control Coding", Prentice Hall, 1983, vgl. z.B. Seiten 155 bis 160]).
• Weiterhin können die Koeffizienten der entsprechenden Lokatorpolynome durch Lösen einer linearen Gleichung aus den Teilsyndromen bestimmt werden. Dies wird nachfolgend erläutert.
• Zunächst werden beispielhaft Lokatorpolynome für µ = 1,2,3,4,5 angegeben.
• Für µ = 1 hat das Lokatorpolynom die Form $$L_1\left(x\right)=x+{\mathrm{\sigma }}_1^1,$$

  

  für µ = 2 hat das Lokatorpolynom die Form $$L_2\left(x\right)=x^2+{\mathrm{\sigma }}_1^{2}x+{\mathrm{\sigma }}_2^2,$$

  

  für µ = 3 hat das Lokatorpolynom die Form $$L_3\left(x\right)=x^3+{\mathrm{\sigma }}_1^3{x}^2+{\mathrm{\sigma }}_2^3{x}^1+{\mathrm{\sigma }}_3^3,$$

  

  für µ = 4 hat das Lokatorpolynom die Form $$L_4\left(x\right)=x^4+{\mathrm{\sigma }}_1^4{x}^3+{\mathrm{\sigma }}_2^4{x}^2+{\mathrm{\sigma }}_3^4{x}^1+{\mathrm{\sigma }}_4^4,$$

  

  und für µ = 5 hat das Lokatorpolynom die Form $$L_5\left(x\right)=x^5+{\mathrm{\sigma }}_1^5{x}^4+{\mathrm{\sigma }}_2^5{x}^3+{\mathrm{\sigma }}_3^5{x}^2+{\mathrm{\sigma }}_4^5{x}^1+{\mathrm{\sigma }}_5^5.$$

  
• Liegt ein µ-Bitfehler vor, dann sind die µ Fehlerorte i₁, i₂, i₃, ... , i_µ die Exponenten der Nullstellen ${\alpha }^{i_1},{\alpha }^{i_2},\dots ,{\alpha }^{i_{\mu }}$

  

  des Lokatorpolynoms L_µ(x).
• Wird in dem Lokatorpolynom Lµ(x) die Variable x durch $y^{-1}=\frac{1}{y}$

  

  ersetzt und wird weiter $$L_{\mu }^{*}\left(y\right)=y^{\mu }\cdot L_{\mu }\left(y^{-1}\right),$$

  

  gesetzt, so gilt $$L_{\mu }^{*}\left(y\right)=1+{\mathrm{\sigma }}_1^{\mu }{x}^1+{\mathrm{\sigma }}_2^{\mu }{x}^2+\dots +{\mathrm{\sigma }}_{\mu -1}^{\mu }{x}^{\mu -1}+{\mathrm{\sigma }}_{\mu }^{\mu }{x}^{\mu }.$$

  
• Das Polynom $L_{\mu }^{*}\left(y\right)$

  

  kann ebenfalls als Lokatorpolynom verwendet werden. Die µ Fehlerorte j₁, j₂, j₃, ... , j_µ sind dann die negativen Exponenten der Nullstellen ${\alpha }^{j_1},{\alpha }^{j_2},\dots ,{\alpha }^{j_{\mu }}$

  

  des Lokatorpolynoms $L_{\mu }^{*}\left(y\right),$

  

  wobei die Exponenten jeweils modulo 2^m - 1 zu betrachten sind, wenn das verwendete Galoisfeld GF(2^m) ist.
• Nachfolgend wird beispielhaft das Lokatorpolynom L_µ (x) verwendet.
• Die Koeffizienten der Lokatorpolynome können als Lösungen der folgenden linearen Gleichungssysteme bestimmt werden.
• Für µ = 2 gilt $$M\left(2\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^2\\ {\mathrm{\sigma }}_2^2\end{array}\right)=\left(\begin{array}{cc}1& 0\\ s_2& s_1\end{array}\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^2\\ {\mathrm{\sigma }}_2^2\end{array}\right)=\begin{array}{c}{s}_1\\ s_3\end{array}$$

  

  mit der Lösung $${\mathrm{\sigma }}_1^2=s_1\text{ und }{\mathrm{\sigma }}_2^2=\frac{s_3+s_1^3}{s_1}.$$

  
• Hierbei ist berücksichtigt, dass im Galoisfeld GF(2^m) gilt: $s_2=s_1^2.$

  
• Für µ = 3 gilt $$M\left(3\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^3\\ {\mathrm{\sigma }}_2^3\\ {\mathrm{\sigma }}_3^3\end{array}\right)=\left(\begin{array}{ccc}1& 0& 0\\ s_2& s_1& 0\\ s_4& s_3& s_2\end{array}\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^3\\ {\mathrm{\sigma }}_2^3\\ {\mathrm{\sigma }}_3^3\end{array}\right)=\begin{array}{c}{s}_1\\ s_3\\ s_5\end{array},$$

  

  wobei ${\mathrm{\sigma }}_1^3,{\mathrm{\sigma }}_2^3,{\mathrm{\sigma }}_3^3$

  

  durch Lösen der linearen Gleichung zu $$\begin{array}{c}{\mathrm{\sigma }}_1^3=s_1,\end{array}$$

  

  $${\sigma }_2^3=\frac{s_1^2{s}_3+s_5}{s_1^3+s_3}$$

  

  $${\sigma }_3^3=s_1^3+s_3+s_1\cdot \frac{s_1^2{s}_3+s_5}{s_1^3+s_3}$$

  

  bestimmt sind, wobei in dieser Lösung berücksichtigt ist, dass im Galoisfeld GF(2^m) gilt: $s_2=s_1^2;s_4=s_2^2=s_1^4.$

  
• Für µ = 4 gilt $$M\left(4\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^4\\ {\mathrm{\sigma }}_2^4\\ {\mathrm{\sigma }}_3^4\\ {\mathrm{\sigma }}_4^4\end{array}\right)=\left(\begin{array}{cccc}1& 0& 0& 0\\ s_2& s_1& 1& 0\\ s_4& s_3& s_2& s_1\\ s_6& s_5& s_4& s_3\end{array}\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^4\\ {\mathrm{\sigma }}_2^4\\ {\mathrm{\sigma }}_3^4\\ {\mathrm{\sigma }}_4^4\end{array}\right)=\begin{array}{c}{s}_1\\ s_3\\ s_5\\ s_7\end{array},$$

  

  wobei ${\mathrm{\sigma }}_1^4,{\mathrm{\sigma }}_2^4,{\mathrm{\sigma }}_3^4,{\mathrm{\sigma }}_4^4$

  

  durch Lösen der linearen Gleichung zu $${\mathrm{\sigma }}_1^4=s_1,$$

  

  $${\mathrm{\sigma }}_2^4=\frac{s_1{s}_7+s_3{s}_5+s_1^5\left(s_3+s_1^3\right)}{s_1{s}_5+s_3^2+s_1^3{s}_3+s_1^6}$$

  

  $${\mathrm{\sigma }}_3^4=\frac{s_1^2{s}_7+s_1^4{s}_5+s_3{\left(s_3+s_1^3\right)}^2}{s_1{s}_5+s_3^2+s_1^3{s}_3+s_1^6}$$

  

  $${\mathrm{\sigma }}_4^4=\frac{\left(s_7+s_1^2{s}_5+s_1{s}_3^2+s_1^4{s}_3\right)\left(s_3+s_1^3\right)+{\left(s_5+s_1^5\right)}^2}{s_1{s}_5+s_3^2+s_1^3{s}_3+s_1^6}$$

  

  bestimmt sind, wobei in dieser Lösung berücksichtigt ist, dass im Galoisfeld GF(2^m) gilt: $s_2=s_1^2;s_4=s_2^2=s_1^4;s_6=s_3^2.$

  
• Für µ = 5 gilt $$M\left(5\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^5\\ {\mathrm{\sigma }}_2^5\\ {\mathrm{\sigma }}_3^5\\ {\mathrm{\sigma }}_4^5\end{array}\right)=\left(\begin{array}{lllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ s_2\hfill & s_1\hfill & 1\hfill & 0\hfill & 0\hfill \\ s_4\hfill & s_3\hfill & s_2\hfill & s_1\hfill & 1\hfill \\ s_6\hfill & s_5\hfill & s_4\hfill & s_3\hfill & s_2\hfill \\ s_8\hfill & s_7\hfill & s_6\hfill & s_5\hfill & s_4\hfill \end{array}\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^5\\ {\mathrm{\sigma }}_2^5\\ {\mathrm{\sigma }}_3^5\\ {\mathrm{\sigma }}_4^5\end{array}\right)=\begin{array}{l}{s}_1\hfill \\ s_3\hfill \\ s_5\hfill \\ s_7\hfill \\ s_9\hfill \end{array},$$

  

  wobei die konkreten Werte für ${\mathrm{\sigma }}_1^5,\dots ,{\mathrm{\sigma }}_5^5$

  

  wieder durch Lösen einer linearen Gleichung (24) bestimmt sind und beispielsweise [Wicker, S.: „Error Control Systems for digital Communication and Storage“, Prentice Hall, 1995, Seite 208] angegeben sind.
• Allgemein ist eine Matrix M(t) zu $$M\left(t\right)=\left(\begin{array}{ccccccc}1& 0& 0& 0& 0& \dots & 0\\ s_2& s_1& 1& 0& 0& \dots & 0\\ s_4& s_3& s_2& s_1& 1& \dots & 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& \dots & ⋮\\ s_{2t-2}& s_{2t-3}& s_{2t-4}& s_{2t-5}& s_{2t-6}& \dots & s_{t-1}\end{array}\right)$$

  

  bestimmt und für mehr als fünf Bitfehler (t > 5) gilt: $$\begin{array}{l}M\left(t\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^t\\ {\mathrm{\sigma }}_1^t\\ {\mathrm{\sigma }}_3^5\\ ⋮\\ {\mathrm{\sigma }}_t^t\end{array}\right)=\\ \left(\begin{array}{ccccccc}1& 0& 0& 0& 0& \dots & 0\\ s_2& s_1& 1& 0& 0& \dots & 0\\ s_4& s_3& s_2& s_1& 1& \dots & 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& \dots & ⋮\\ s_{2t-2}& s_{2t-3}& s_{2t-4}& s_{2t-5}& s_{2t-6}& \dots & s_{t-1}\end{array}\right)\cdot \left(\begin{array}{c}{\mathrm{\sigma }}_1^t\\ {\mathrm{\sigma }}_2^t\\ {\mathrm{\sigma }}_3^5\\ ⋮\\ {\mathrm{\sigma }}_t^t\end{array}\right)=\begin{array}{c}{s}_1\\ s_3\\ s_5\\ ⋮\\ s_{2t-1}\end{array}.\end{array}$$

  
• Die Werte für ${\mathrm{\sigma }}_1^t,\dots ,{\mathrm{\sigma }}_t^t$

  

  sind wieder durch Lösen einer linearen Gleichung, hier durch Lösen der linearen Gleichung (25) bestimmt.
• Eine Aufgabe einer Fehlerkorrekturschaltung besteht darin, die Fehlerpositionen eines beliebigen 1-Bitfehlers, eines beliebigen 2-Bitfehlers oder eines beliebigen 3-Bitfehlers, ..., oder eines beliebigen τ-Bitfehlers mit 1 ≤ τ ≤ t aus dem Fehlersyndrom, d.h. aus den Teilsyndromen s₁, s₃, ..., s_2t-1 des BCH-Codes effizient zu bestimmen und in den bestimmten Bitpositionen des Datenwortes durch einen Korrekturwert eine Korrektur des mindestens einen als fehlerhaft erkannten Bits vorzunehmen.
• Der hier vorgeschlagene Ansatz ermöglicht es darüber hinaus, dass ein (t + 1)-Bitfehler korrigiert werden kann, wenn der (t + 1)-Bitfehler ein bestimmtes Fehlermuster einmal oder mehrmals enthält.
• Bei der Fehlerkorrektur kann zunächst die Anzahl der Fehler bestimmt werden.
• Liegt ein τ-Bitfehler mit 1 ≤ τ ≤ t vor, wird der τ-Bitfehler unter Verwendung der Teilsyndrome s₁,..., s_2t-1 des Fehlersyndroms des BCH-Codes korrigiert, wie das bei BCH-Codes üblich ist.
• Liegt ein (t + 1)-Bitfehler vor, der ein bestimmtes Fehlermuster aus M Bits K Mal aufweist, wobei K · M = t + 1 gilt, kann der Fehlervektor unter Verwendung von modifizierten Teilsyndromen $$\begin{array}{l}{s}_1^{mod}=s_1\cdot {\beta }_1^{-1},\hfill \\ s_3^{mod}=s_3\cdot {\beta }_3^{-1},\hfill \\ ⋮\hfill \\ s_{2K-1}^{mod}=s_{2K-1}\cdot {\beta }_{2K-1}^{-1}\hfill \end{array}$$

  

  bestimmt werden, wobei β₁, ... , β_2k-1 konstante Werte des Galoisfelds sind, die durch das Fehlermuster aus M Bits und die Spalten der H-Matrix des betrachteten BCH-Codes bestimmt sind.
• Unter Verwendung der modifizierten Teilsyndrome $s_1^{mod},\dots ,s_{2K-1}^{mod}$

  

  des Fehlersyndroms werden jeweils K erste Bits der K Fehlermuster aus M Bits korrigiert. Der Korrekturwert der weiteren M - 1 Bits der K Fehlermuster ist dann gleich dem Korrekturwert des jeweils ersten korrigierten Bits.
• Besteht beispielsweise ein Fehlermuster aus zwei aufeinanderfolgenden Bits, dann kann das erste Bit des Fehlermusters unter Verwendung der Teilsyndrome des modifizierten Fehlersyndroms korrigiert werden. Weiterhin wird das zweite Bit des Fehlermusters ebenfalls korrigiert, wenn das erste Bit des Fehlermusters korrigiert wird.
• Weist beispielsweise ein Fehlervektor zwei Fehlermuster aus drei aufeinanderfolgenden Bits auf, dann wird beispielsweise das erste Bit der beiden Fehlermuster unter Verwendung der Teilsyndrome des modifizierten Fehlersyndroms korrigiert und die jeweils zweiten Bits der beiden Fehlermuster und die jeweils dritten Bits der beiden Fehlermuster werden ebenfalls korrigiert, wenn das erste Bit der Fehlermuster korrigiert wird.
• Ist bereits bestimmt worden, dass ein (t + 1)-Bitfehler vorliegt, dann ist es möglich, zur Korrektur eines ersten Bits der K Fehlermuster lediglich die modifizierten Teilsyndrome $s_1^{mod},\dots ,s_{2K-1}^{mod}$

  

  des Fehlersyndroms zu verwenden, wobei die Korrektur mittels modifiziertem Fehlersyndrom wie für einen K-Bitfehler korrigierenden BCH-Code erfolgt.
• Bei einem derartigen Vorgehen ist unter Verwendung der nicht modifizierten Teilsyndrome s₁, ... , s_2t-1 zu bestimmen, ob ein (t + 1)-Bitfehler vorliegt oder nicht.
• Wird erkannt, dass ein τ-Bitfehler mit 1 ≤ τ ≤ t vorliegt, dann kann die Fehlerkorrektur mit dem t-Bitfehler korrigierenden BCH-Code unter Verwendung der Syndrome s₁,... , s_2t-1 durchgeführt werden.
• Tritt ein (t +1)-Bitfehler auf, ist es auch möglich zur Dekodierung die modifizierten Teilsyndrome $$s_1^{mod},\dots ,s_{2K-1}^{mod},\dots ,s_{2t-1}^{mod}$$

  

  zur Fehlerkorrektur zu verwenden.
• Eine Möglichkeit zur Bestimmung der Anzahl der aufgetretenen Fehler ist beispielsweise in [Wicker, S.: „Error Control Systems for digital Communication and Storage“, Prentice Hall, 1995, Seite 206] beschrieben.
• Aus $$Det\left(M\left(\tau \right)\right)\ne 0$$

  

  kann gefolgert werden, dass τ-Bitfehler oder (τ- 1)-Bitfehler vorhanden sind. Entsprechend gilt $$Det\left(M\left(\tau \right)\right)=\mathrm{0,}$$

  

  wenn weniger als (τ - 1)-Bitfehler vorhanden sind.
• Sind τ-Bitfehler vorhanden, sind die τ Fehlerorte durch die τ Nullstellen des Lokatorpolynoms L_τ(x) bestimmt.
• Sind (τ- 1)-Bitfehler vorhanden, sind die (τ - 1) Fehlerorte durch die (τ - 1) Nullstellen ≠ 0 des Lokatorpolynoms L_τ(x) bestimmt, wobei in diesem Fall eine weitere Nullstelle gleich 0 vorhanden ist. Das Vorhandensein eines Fehlers wird durch s ≠ 0 angezeigt.
• Wird vorausgesetzt, dass maximal ein t-Bitfehler vorliegt, kann aus $$Det\left(M\left(t\right)\right)\ne 0$$

  

  gefolgert werden, dass entweder ein t-Bitfehler oder ein (t - 1)-Bitfehler vorliegt. Liegt ein t-Bitfehler vor, sind die Fehlerorte durch die t Nullstellen des Lokatorpolynoms L_t(x) t-ten Grades bestimmt. Liegt ein t - 1-Bitfehler vor, sind die t - 1 Fehlerorte durch die t - 1 Nullstellen ≠ 0 des Lokatorpolynoms L_t(x) t-ten Grades bestimmt. Eine weitere Nullstelle des Lokatorpolynoms t-ten Grades ist dann 0.
• Gilt $$Det\left(M\left(t\right)\right)=\mathrm{0,}$$

  

  liegt weder ein t-Bitfehler noch ein (t - 1)-Bitfehler vor. In diesem Fall kann höchstens ein (t - 2)-Bitfehler vorliegen.
• Ist $$Det\left(M\left(t-2\right)\right)\ne \mathrm{0,}$$

  

  kann gefolgert werden, dass entweder ein (t - 2)-Bitfehler oder ein (t - 3)-Bitfehler vorliegt:
• - Liegt ein (t - 2)-Bitfehler vor, sind die Fehlerorte durch die t - 2 Nullstellen des Lokatorpolynoms L_t-2(x) bestimmt, das den Grad t - 2 hat.
• - Liegt ein (t - 3)-Bitfehler vor, sind die t - 3 Fehlerorte durch die t - 3 Nullstellen ≠ 0 des Lokatorpolynoms L_t-2(x) bestimmt, das den Grad t - 2 aufweist. Eine weitere Nullstelle des Lokatorpolynoms (t - 2)-ten Grades ist in diesem Fall 0.
• Ist $$Det\left(M\left(t-2\right)\right)=\mathrm{0,}$$

  

  kann gefolgert werden, dass maximal ein (t - 4)-Bitfehler vorliegt.
• Um die Anzahl der Fehler zu bestimmen, können die Determinanten $$Det\left(M\left(t\right)\right),Det\left(M\left(t-2\right)\right),Det\left(M\left(t-4\right)\right),\dots$$

  

  betrachtet werden, bis eine Determinante ≠ 0 gefunden wird.
• Für einen 4-Bitfehler korrigierenden BCH-Code mit zusätzlicher Gesamtparität soll nachfolgend das Vorgehen erläutert werden:
• Beispielsweise wird s = (s₁, s₃, s₅, s₇, P) ≠ 0 angenommen. Die Determinanten werden jeweils nach den Elementen der ersten Zeile entwickelt und die Determinante der verbliebenen 3×3-Matrizen wird direkt berechnet. Es folgt: $$\begin{array}{l}Det\left(M\left(5\right)\right)=Det\left(\begin{array}{ccccc}1& 0& 0& 0& 0\\ s_2& s_1& 1& 0& 0\\ s_4& s_3& s_2& s_1& 1\\ s_6& s_5& s_4& s_3& s_2\\ s_8& s_7& s_6& s_5& s_4\end{array}\right)=Det\left(\begin{array}{cccc}{s}_1& 1& 0& 0\\ s_3& s_2& s_1& 1\\ s_5& s_4& s_3& s_2\\ s_7& s_6& s_5& s_4\end{array}\right)=\\ =s_3^2{s}_4+s_1{s}_2{s}_7+s_5^2+s_1{s}_4{s}_5+s_2{s}_3{s}_5+s_3{s}_7.\end{array}$$

  
• Der so erhaltene algebraische Ausdruck lässt sich aus den Werten der Teilsyndrome unter Verwendung von bekannten Galoisfeldmultiplizierern von einem Fachmann implementieren und mit Hilfe eines Synthesetools optimieren.
• Gilt Det (M(5)) ≠ 0, dann liegt ein 5-Bitfehler oder ein 4-Bitfehler vor. Ist die Parität P = 1, handelt es sich um einen 5-Bitfehler, ist die Parität P = 0, handelt es sich um einen 4-Bitfehler.
• Gilt Det (M(5)) = 0, dann liegt ein 3-Bitfehler, ein 2- Bitfehler oder ein 1-Bitfehler vor, wenn s = (s₁, s₃, s₅, s₇) ≠ 0 ist. Ist P = 0, dann liegt ein 2-Bitfehler vor. Ist P = 1, dann liegt entweder ein 1-Bit oder ein 3-Bitfehler vor. Weiterhin kann die Determinante Det (M(3)) bestimmt werden. Ist Det (M(3)) = 1, liegt ein 3-Bitfehler vor, ist Det (M(3)) = 0, liegt ein 1-Bitfehler vor.
• Zur Unterscheidung zwischen einem 1-Bitfehler und einem 3-Bitfehler, kann auch geprüft werden, ob $s_1^3=s_3$

  

  s₃ oder ob $s_1^3\ne s_3$

  

  s₃ gilt. Ist $s_1^3=s_3,$

  

  liegt ein 1-Bitfehler vor, ist $s_1^3\ne s_3,$

  

  s₃, liegt ein 3-Bitfehler vor.
• Ein bestimmtes Fehlermuster kann beispielsweise in einem Speicher dadurch verursacht werden, dass eine Speicherzelle, die mehr als ein Bit speichern kann, fehlerhaft ist. Es ist möglich, dass eine Speicherzelle vier unterschiedliche Werte speichern kann, indem sie vier verschiedene Zustände annimmt. Beispielsweise werden die Zustände mit 0, 1, 2, 3 bezeichnet, die binär als 00, 01, 10, 11 bereitgestellt werden können. Wird der interne Zustand 2 (binär 10) der Speicherzelle in den Zustand 1 (binär 01) verfälscht, tritt ein benachbarter 2-Bitfehler auf, da die korrekte binäre Ausgabe 10 in die fehlerhafte Ausgabe 01 verfälscht wird. Wird der interne Zustand 3 in den internen Zustand 0 gestört, tritt ebenfalls ein benachbarter 2-Bitfehler auf, weil anstelle von des binären Werts 11 der binäre Wert 00 ausgegeben wird. Die fehlerhaften Bits sind benachbart. Es ist auch möglich beispielsweise durch eine Vertauschung der Ausgangsleitungen zu erreichen, dass anstelle eines Fehlermusters [2,1] ein Fehlermuster [2,3] oder ein anderes Fehlermuster entsteht.
• Sind zwei Speicherzellen gleichzeitig fehlerhaft, sind die folgenden Bitfehler möglich:
• - Beide Speicherzellen verursachen einen 1-Bitfehler. Es ist dann ein 2-Bitfehler mit beliebigen Bitpositionen zu korrigieren.
• - Eine erste Speicherzelle verursacht einen benachbarten 2-Bitfehler und damit ein Fehlermuster [2; 1]. Die zweite Speicherzelle verursacht einen 1-Bitfehler. Es tritt ein 3-Bitfehler in zwei benachbarten Bits und einer beliebigen Bitposition auf.
• - Beide Speicherzellen verursachen einen benachbarten 2-Bitfehler, jeweils mit dem Fehlermuster [2; 1] und das Fehlermuster [2; 1] ist in dem Fehlervektor zweimal vorhanden.
• Ein Code, der beliebige τ-Bitfehler mit 1 ≤ τ ≤ 3 korrigiert und einen 4-Bitfehler aus K = 2 Fehlermustern aus M = 2 Bits korrigiert, korrigiert alle beschriebenen Fehler.
• Dabei wird beispielhaft angenommen, dass 4-Bitfehler mit jeweils zwei benachbarten 2-Bitfehlern, die durch zwei fehlerhafte Speicherzellen hervorgerufen werden, häufiger auftreten als beliebige 4-Bitfehler, bei denen mindesten 3 Speicherzellen gleichzeitig fehlerhaft sind.
• Beispiel im Galoisfeld GF(2^m) mit m = 5
• Für die Ausführungsbeispiele wird beispielhaft m = 5 gewählt, so dass das zugrundeliegende Galoisfeld GF(2^m) = GF(2⁵) = GF(32) insgesamt 32 Elemente umfasst.
• Elemente des Galoisfelds GF(32) sind in ihren verschiedenen Darstellungsformen in 1 dargestellt. Das Modularpolynom des Galoisfelds GF(32) ist das Polynom $$p\left(x\right)=1+x^2+x^5.$$

  
• Die erste Spalte der in 1 gezeigten Tabelle umfasst die Elemente αⁱ ≠ 0 des GF(2⁵) für i = 0,1,...,30 in Exponentendarstellung (auch bezeichnet als Exponentialdarstellung). Das Nullelement des Körpers besitzt keine Exponentendarstellung. In der zweiten Spalte der Tabelle sind alle Elemente in ihrer Polynomdarstellung für das zugehörige Modularpolynom p(x) aufgelistet. Die dritte Spalte der Tabelle zeigt die Tupel- oder Vektordarstellung der Elemente des GF(2⁵). Die Vektordarstellung eines Elementes kann direkt aus der Polynomdarstellung abgelesen werden. Die fünf Komponenten der Vektordarstellung entsprechen dabei von links nach rechts den Koeffizienten der zugehörigen Potenzen $$x^0,x^1,x^2,x^3,x^4$$

  

  in der Polynomdarstellung.
• Die entsprechende Polynomdarstellung ergibt sich aus der Potenzdarstellung αⁱ, indem [xⁱ modulo (1 +x² +x⁵)] bestimmt wird. Beispielsweise ist die Polynomdarstellung von α⁵ gleich 1 + x², da $$x^{5}modulo\left(1+x^2+x^5\right)=1+x^2$$

  

  gilt.
• Die Multiplikation zweier Elemente des Galoisfelds kann in der Exponentendarstellung oder in der Polynomdarstellung vorgenommen werden. Sind zwei Elemente des Galoisfelds GF(2^m) = GF(2⁵) in der Exponentendarstellung αⁱ und α^j gegeben, ergibt sich deren Produkt zu: $${\alpha }^i\cdot {\alpha }^j={\alpha }^k\text{mit k=}\left(i+j\right)modulo\left(2^m-1\right)=\left(i+j\right)modulo31.$$

  
• Liegen die zu multiplizierenden Elemente des Galoisfelds in ihrer Vektordarstellung oder in ihrer Polynomdarstellung vor, kann ihre Multiplikation mit einem Galoisfeld-Multiplizierer vorgenommen werden. Nachfolgend wird beispielhaft die Multiplikation zweier Elemente in ihrer Polynomdarstellung beschrieben. Um zwei Elemente, die als Elemente des Galoisfelds GF(2^m) = GF(2⁵) in ihrer Polynomdarstellung gegeben sind, miteinander zu multiplizieren, dann sind die Polynome direkt in der üblichen Weise miteinander zu multiplizieren, und das Ergebnis ist modulo des Modularpolynoms zu bestimmen.
• Sind beispielsweise die Polynome 1 + x² + x³ und x + x³ gegeben, so ergibt ihre direkte Multiplikation $$\left(1+x^2+x^3\right)\left(x+x^3\right)=x+x^4+x^5+x^6.$$

  
• Wegen $$x^5=1+x^{2}modulo\left(1+x^2+x^5\right)$$

  

  und $$x^6=x+x^{3}modulo\left(1+x^2+x^5\right)$$

  

  folgt $$x+x^4+x^5+x^6=x+x^4+1+x^2+x+x^3=1+x^2+x^3+x^4$$

  
• Somit gilt im Ergebnis: $$\left(1+x^2+x^3\right)\cdot \left(x+x^3\right)=1+x^2+x^3+x^4.$$

  
• Nachfolgend wird der Fall beschrieben, wonach ein erstes Element a(x) mit $$a\left(x\right)=a_4{x}^4+a_3{x}^3+a_2{x}^2+a_{1}x+a_0$$

  

  und und ein zweites Element b(x) mit $$b\left(x\right)=b_4{x}^4+b_3{x}^3+b_2{x}^2+b_{1}x+b_0$$

  

  in dem Galoisfeld GF(2⁵) mit dem Modularpolynom $$m\left(x\right)=x^5+x^2+1$$

  

  multipliziert werden. Durch direktes Ausmultiplizieren der Polynome a(x) und b(x) ergibt sich zunächst ein Polynom 8-ten Grades. Mit $$x^{5}modulo\left(1+x^2+x^5\right)=1+x^2,$$

  

  $$x^{6}modulo\left(1+x^2+x^5\right)=x+x^3,$$

  

  $$x^{7}modulo\left(1+x^2+x^5\right)=x^2+x^4,$$

  

  $$x^{8}modulo\left(1+x^2+x^5\right)=1+x^2+x^3$$

  

  ergibt sich ein Polynom vierten Grades wie folgt: $$\begin{array}{ccc}& c_4{x}^4+c_3{x}^3+c_2{x}^2+x_1{x}^1+c_0=a\left(x\right)\cdot b\left(x\right)\text{ mod }m\left(x\right)& =\\ =& \left(a_0{b}_4+a_1{b}_3+a_2{b}_2+a_3{b}_1+a_3{b}_4+a_4{b}_0+a_4{b}_3\right)\cdot x^4& +\\ +& \left(a_0{b}_3+a_1{b}_2+a_2{b}_1+a_2{b}_4+a_3{b}_0+a_3{b}_3+a_4{b}_2+a_4{b}_4\right)\cdot x^3& +\\ +& \left(a_0{b}_2+a_1{b}_1+a_1{b}_4+a_2{b}_0+a_2{b}_3+a_3{b}_2+a_3{b}_4+a_4{b}_1+a_4{b}_3+a_4{b}_4\right)\cdot x^2& +\\ +& \left(a_0{b}_1+a_1{b}_0+a_2{b}_4+a_3{b}_3+a_4{b}_2\right)\cdot x^1& +\\ +& \left(a_0{b}_0+a_1{b}_4+a_2{b}_3+a_3{b}_2+a_4{b}_1+a_4{b}_4\right)& \end{array}$$

  
• Diese Beziehung wird durch einen Galoisfeld-Multiplizierer mit fünf ersten binären Eingängen, fünf zweiten binären Eingängen und fünf binären Ausgängen realisiert. Dies wird nachfolgend näher erläutert.
• An den ersten fünf Eingängen des Galoisfeld-Multiplizierers liegen die binären Werte a₀, a₁, a₂, a₃, a₄ und an den zweiten fünf Eingängen liegen die binären Werte b₀, b₁, b₂, b₃, b₄ an, während an den fünf binären Ausgängen die Werte c₀, c₁, c₂, c₃, c₄ mit $$\left(a_0{b}_0+a_1{b}_4+a_2{b}_3+a_3{b}_2+a_4{b}_1+a_4{b}_4\right)=c_0,$$

  

  $$\left(a_0{b}_1+a_1{b}_0+a_2{b}_4+a_3{b}_3+a_4{b}_2\right)=c_1$$

  

  $$\left(a_0{b}_2+a_1{b}_1+a_1{b}_4+a_2{b}_0+a_2{b}_3+a_3{b}_2+a_3{b}_4+a_4{b}_1+a_4{b}_3+a_4{b}_4\right)=c_2$$

  

  $$\left(a_0{b}_3+a_1{b}_2+a_2{b}_1+a_2{b}_4+a_3{b}_0+a_3{b}_3+a_4{b}_2+a_4{b}_4\right)=c_3$$

  

  $$\left(a_0{b}_4+a_1{b}_3+a_2{b}_2+a_3{b}_1+a_3{b}_4+a_4{b}_0+a_4{b}_3\right)=c_4$$

  

  ausgegeben werden. Hierbei bezeichnet das Symbol „+“ die Addition modulo 2 (XOR-Operation).
• Die Implementierung der Gleichungen (27) bis (31) kann mittels eines Galoisfeld-Multiplizierers erfolgen, beispielsweise unter Verwendung von UND-Gattern und XOR-Gatter (Exklusiv-Oder-Gattern). Beispielsweise kann im Rahmen der Implementierung auch ein Synthesetool eingesetzt werden.
• Wird ein Element des Galoisfelds quadriert, ist es mit sich selbst zu multiplizieren. Ist in der Polynomdarstellung ein Element als Polynom $$a\left(x\right)=a_0+a_1{x}^1+a_2{x}^2+a_3{x}^3+a_4{x}^4$$

  

  gegeben, gilt $$\begin{array}{l}{\left(a\left(x\right)\right)}^2\text{mod }m\left(x\right)=\\ =\left[a_0+a_1{x}^2+a_2{x}^4+a_3{x}^6{a}_4{x}^8\right]\text{ mod }\left(1+x^2+x^5\right)=\\ =\left(a_2\right)x^4+\left(a_3+a_4\right)x^3+\left(a_1+a_4\right)x^2+a_3{x}^1+\left(a_0+a_4\right).\end{array}$$

  
• Das Quadrieren eines Elementes im Galoisfeld GF(2⁵) kann entsprechend mit einem Quadrierer mit fünf binären Eingängen und fünf binären Ausgängen realisiert werden. An seinen fünf binären Eingängen werden die binären Werte a₀, a₁, a₂, a₃, a₄ zugeführt und an den fünf binären Ausgängen werden die binären Werte d₀, d₁, d₂, d₃, d₄ bereitgestellt. Es gelten $$a_0+a_4=d_0,$$

  

  $$a_3=d_1,$$

  

  $$a_1+a_4=d_2,$$

  

  $$a_3+a_4=d_3,$$

  

  $$a_2=d_4,$$

  

  wobei das Symbol „+“ wieder die Addition modulo 2 (XOR-Verknüpfung) bezeichnet.
• Zur Realisierung eines Quadrierers in dem Galoisfelds GF(2⁵) mit dem Modularpolynom m(x) = 1 + x²+ x⁵ können die Gleichungen (32) bis (36) beispielsweise mittels XOR-Gattern implementiert werden.
• Am Beispiel des Galoisfelds GF(2⁵) wird beschrieben, wie die dritte Potenz eines Elements bestimmt werden kann, das in seiner Polynomdarstellung angegeben ist.
• Wird die dritte Potenz (a(x))³ eines Polynomes $$a\left(x\right)=a_0+a_1{x}^1+a_2{x}^2+a_3{x}^3+a_4{x}^4$$

  
• Modulo des Modularpolynoms m(x) = 1 + x²+ x⁵ bestimmt, gilt: $$\begin{array}{rrr}\hfill & \hfill {\left(a\left(x\right)\right)}^3\text{mod }m\left(x\right)& \hfill =\\ \hfill =& \hfill \left(a_0{a}_2+a_0{a}_4+a_1{a}_2+a_1{a}_3+a_1{a}_4+a_2{a}_3+a_2{a}_4+a_3+a_3{a}_4\right)\cdot x^4& \hfill +\\ \hfill +& \hfill \left(a_0{a}_4+a_1+a_2+a_2{a}_3+a_2{a}_4+a_3+a_4\right)\cdot x^3& \hfill +\\ \hfill +& \hfill \left(a_0{a}_1+a_0{a}_2+a_0{a}_4+a_1{a}_2+a_2{a}_4+a_3{a}_4+a_4\right)\cdot x^2& \hfill +\\ \hfill +& \hfill \left(a_0{a}_1+a_0{a}_3+a_2+a_3+a_3{a}_4+a_4\right)\cdot x^1& \hfill +\\ \hfill +& \hfill \left(a_0+a_0{a}_4+a_1{a}_2+a_1{a}_3+a_2{a}_3\right)& \hfill \end{array}$$

  
• Das Bilden der dritten Potenz eines Elements im Galoisfeld GF(2⁵) kann entsprechend mit einem Dritte-Potenz-Bildner mit fünf binären Eingängen und fünf binären Ausgängen realisiert werden. Den fünf binären Eingängen werden die binären Werte a₀, a₁, a₂, a₃, a₄ zugeführt und an den fünf binären Ausgängen werden die binären Werte f₀, f₁, f₂, f₃, f₄ bereitgestellt. Es gilt: $$f_0=a_0+a_0{a}_4+a_1{a}_2+a_1{a}_3+a_2{a}_3$$

  

  $$f_1=a_0{a}_1+a_0{a}_3+a_2+a_3+a_3{a}_4+a_4$$

  

  $$f_2=a_0{a}_1+a_0{a}_2+a_0{a}_4+a_1{a}_2+a_2{a}_4+a_3{a}_4+a_4$$

  

  $$f_3=a_0{a}_4+a_1+a_2+a_2{a}_3+a_2{a}_4+a_3+a_4$$

  

  $$f_4=a_0{a}_2+a_0{a}_4+a_1{a}_2+a_1{a}_3+a_1{a}_4+a_2{a}_3+a_2{a}_4+a_3+a_3{a}_4$$

  
• Beispielsweise kann ein Dritte-Potenz-Bildner realisiert werden, im vorliegenden Beispiel in dem Galoisfelds GF(2⁵) mit dem Modularpolynom m(x) = 1 + x²+ x⁵, indem lediglich die Gleichungen (37) bis (41) implementiert werden.
• Alternativ kann ein Dritte-Potenz-Bildner aus einem Quadrierer und einen nachgeschalteten Galoisfeld-Multiplizierer realisiert werden. Auch können höhere Potenzen des Elements a(x) in entsprechender Weise unter Verwendung geeigneter Bausteine realisiert werden.
• Eine Implementierung eines Konstanten-Multiplizierers in dem Galoisfeld GF(2^m) wird nachfolgend beispielhaft für m = 5 dargestellt. Das Modularpolynom ist $$m\left(x\right)=1+x^2+x^5.$$

  
• Es sei a ∈ GF(2⁵) ein beliebiges Element des Galoisfelds mit der folgenden Polynomdarstellung $$a\left(x\right)=a_0+a_{1}x+a_2{x}^2+a_3{x}^3+a_4{x}^4.$$

  
• Als zu multiplizierende Konstante wird beispielhaft α⁹ gewählt, deren Polynomdarstellung gemäß der in 1 gezeigten Tabelle mit $${\alpha }^9\left(x\right)=x+x^3+x^4$$

  

  gegeben ist. Als Multiplikation ergibt sich $$a\left(x\right)\cdot {\alpha }^9\left(x\right)modulo\left(1+x^2+x^5\right)=b_0+b_{1}x+b_2{x}^2+b_3{x}^3+b_4{x}^4$$

  

  mit $$b_0=a_1+a_2.$$

  

  $$b_1=a_0+a_2+a_3,$$

  

  $$b_2=a_2+a_3+a_4,$$

  

  $$b_3=a_0+a_3+a_4,$$

  

  $$b_4=a_0+a_1+a_4.$$

  
• Die Ausgabewerte b₀, ... , b₄ werden aus den Eingabewerten a₀, ..., a₄ entsprechend der in den Gleichungen (45) bis (49) dargestellten Beziehungen abgeleitet, so dass die Ausgabewerte durch XOR-Verknüpfungen aus den Eingabewerten bestimmt sind. Hierbei bezeichnet das Symbol „+“ die Addition modulo 2 (XOR-Operation). Entsprechend kann der Multiplizierer mittels XOR-Gatter realisiert werden.
• Beispiel: Korrektur spezieller 4-Bitfehler, die sich aus zwei benachbarten 2-Bitfehlern zusammensetzen
• Nachfolgend wird gezeigt, wie unter Verwendung eines BCH-Codes zur Korrektur beliebiger 1-Bit-, 2-Bit- und 3-Bitfehler, eine Korrektur spezieller 4-Bitfehler erfolgen kann, die sich aus zwei benachbarten 2-Bitfehlern zusammensetzen. Eine nachfolgende Gleichung (50) stellt beispielhaft eine Prüfmatrix eines 3-Bitfehler korrigierenden BCH-Codes mit einbezogener Gesamtparität für m = 5 und n = 31 dar, wobei der BCH-Code eine minimale Hamming-Distanz d_min = 8 aufweist: $$H=\left[\begin{array}{c}{H}_1\\ H_3\\ H_5\\ P\end{array}\right]=\left[\begin{array}{cccccc}{\alpha }^0& {\alpha }^0& {\alpha }^0& \dots & {\alpha }^0& {\alpha }^0\\ {\alpha }^{3\cdot 0}& {\alpha }^{3\cdot 1}& {\alpha }^{3\cdot 2}& \dots & {\alpha }^{3\cdot \left(29\right)}& {\alpha }^{3\cdot \left(30\right)}\\ {\alpha }^{5\cdot 0}& {\alpha }^{5\cdot 1}& {\alpha }^{5\cdot 2}& \dots & {\alpha }^{5\cdot \left(29\right)}& {\alpha }^{5\cdot \left(30\right)}\\ 1& 1& 1& \dots & 1& 1\end{array}\right]$$

  
• Die Potenzen von αⁱ sind dabei modulo (2⁵ - 1) = 31 zu interpretieren. Die letzte Zeile der H-Matrix (50) besteht aus lauter Einsen. Durch diese Zeile ist die Gesamtparität P bestimmt. In der nachfolgend dargestellten Gleichung (51) sind zur verbesserten Übersichtlichkeit die einzelnen Elemente der Teilmatrizen H₁, H₃ und H₅ nur anhand ihre Potenz dargestellt: $$H_1=\left[\begin{array}{ccccccccccccccccccccccccccccccc}0& 1& 2& 3& 4& 5& 6& 7& 8& 9& 10& 11& 12& 13& 14& 15& 16& 17& 18& 19& 20& 21& 22& 23& 24& 25& 26& 27& 28& 29& 30\end{array}\right]$$

  

  $$H_3=\left[\begin{array}{ccccccccccccccccccccccccccccccc}0& 3& 6& 9& 12& 15& 18& 21& 24& 27& 30& 2& 5& 8& 11& 14& 17& 20& 23& 26& 29& 1& 4& 7& 10& 13& 16& 19& 22& 25& 28\end{array}\right]$$

  

  $$H_5=\left[\begin{array}{ccccccccccccccccccccccccccccccc}0& 5& 10& 15& 20& 25& 30& 4& 9& 14& 19& 24& 29& 3& 8& 13& 18& 23& 28& 2& 7& 12& 17& 22& 27& 1& 6& 11& 16& 21& 26\end{array}\right]$$

  
• Unter Berücksichtigung der in 1 gezeigten Tabelle kann eine binäre Prüfmatrix H aufgestellt werden, indem die in der Gleichung (51) für H₁, H₃ und H₅ gezeigten Potenzen der Elemente durch ihre zugehörige Vektordarstellung als Spaltenvektoren ersetzt werden. Damit ergibt sich eine binäre Prüfmatrix H zu

  
• 2 zeigt eine Schaltungsanordnung bestehend aus einem Syndromgenerator SG 11 mit n = 31 binären Eingängen und 3 · 5 + 1 = 16 binären Ausgängen, einer Fehler- erkennungseinheit FE 12 mit (3·5 + 1) = 16 binären Eingängen und 4 binären Ausgängen, Konstantenmultiplizierern 131, 132, 133 mit jeweils 5 binären Eingängen und 5 binären Ausgängen, Multiplexern 141, 142, 143 mit jeweils (2·5 + 1) = 11 binären Eingängen und 5 binären Ausgängen, einem BCH-Decoder DEC BCH 15 mit (3·5) = 15 binären Eingängen und n = 31 binären Ausgängen, UND-Gattern 161, 162, ..., 1630 mit jeweils 2 binären Eingängen und einem binären Ausgang, ODER-Gattern 171, 172, ..., 1730 mit jeweils 2 binären Eingängen und einem binären Ausgang und XOR-Gattern 181, 182, ..., 1831 mit jeweils 2 binären Eingängen und einem binären Ausgang.
• Der Syndromgenerator SG 11 weist n = 31 binäre Eingänge auf, an denen das möglicherweise fehlerhafte Binärwort $v\text{'}=\left(v_0^{\text{'}},v_1^{\text{'}},\dots ,v_{30}^{\text{'}}\right)$

  

  anliegt. An seinem (3 · 5+ 1)-Bit breiten Ausgang gibt der Syndromgenerator SG 11 ein Fehlersyndrom s = (s₁, s₃, s₅, s_p) der Wortbreite (3·5 + 1) aus. Dabei ist der Syndromgenerator SG 11 so konfiguriert, dass er die Teilsyndrome des Fehlersyndroms s auf Basis der Prüfmatrix H gemäß Gleichung (52) so bestimmt, dass gilt: $$\begin{array}{c}{s}_1^T=H_1\cdot {\left(v\text{'}\right)}^T,\\ s_3^T=H_3\cdot {\left(v\text{'}\right)}^T,\\ s_5^T=H_5\cdot {\left(v\text{'}\right)}^T,\\ s_p=P\cdot {\left(v\text{'}\right)}^T=v_0^{\text{'}}+v_1^{\text{'}}+\cdots +v_{30}^{\text{'}}.\end{array}$$

  
• Für i = 1, 2, 3 sind die i-ten 5 binären Ausgänge des Syndromgenerators SG 11, die das Teilsyndrom s_2i-1 tragen, in die i-ten 5 binären Eingänge der Fehlererkennungseinheit FE 12, in den 5-Bit breiten 0-Eingang des Multiplexers MUX 14i und in den 5-Bit breiten Eingang des Konstantenmultiplizierers 13i geführt.
• Der Konstantenmultiplizierer 13i ist so konfiguriert, dass er ein modifiziertes Teilsyndrom $$s_{2i-1}^{mod}=s_{2i-1}\cdot {\left(1+{\alpha }^{2i-1}\right)}^{-1}$$

  

  an seinen 5 binären Ausgängen erzeugt, die in den 5-Bit breiten 1-Eingang des Multiplexers MUX 14i geführt sind. Der 5-Bit breite Ausgang des Multiplexers MUX 14i ist mit den i-ten 5 binären Eingängen des BCH-Decoders DEC BCH 15 verbunden.
• Der BCH-Decoder DEC BCH 15 erzeugt auf Basis der Syndromkomponenten s₁, s₃ und s₅ einen Korrekturvektor e = (e₀, e₁,...., e₃₀) an seinen 31 binären Ausgängen. Dabei ist der BCH-Decoder DEC BCH 15 so konfiguriert, dass, wenn die an den Eingängen bereitgestellten Teilsyndrome s₁, s₃ und s₅ dem Fehlersyndrom eines i-Bitfehlers in den Bitpositionen b₁, b₂,..., b_i mit 0 ≤ b₁ < b₂ < ... < b_i ≤ 30 entsprechen, ein Korrekturvektor e = (e₀, e₁,..., e₃₀) erzeugt wird, der in den Komponenten e_{b 1} , e_{b 2} ,...,e_{b i} , eine binäre 1 in allen anderen Komponenten eine binäre 0 aufweist. Zeigen die Teilsyndrome keinen Fehler an und gilt s₁ = s₃ = s₅ = 0, so wird ein Korrekturvektor e = (e₀, e₁,..., e₃₀) = (0, 0,..., 0) an den Ausgängen des BCH-Decoders DEC BCH 15 erzeugt.
• Der binäre Ausgang des Syndromgenerators SG 11, der das 1-Bit breite Teilsyndrom s_p trägt, ist mit einem binären Eingang der Fehlererkennungseinheit FE 12 verbunden.
• Die Fehlererkennungseinheit FE 12 ist so konfiguriert, dass in Abhängigkeit von den an ihren Eingängen anliegenden Teilsyndromen s₁, s₃, s₅, s_p vier 1-Bit breite Fehlererkennungssignale det_i für i = 1,2,3,4 an ihren Ausgängen ausgegeben werden, wobei det_i genau dann 1 ist, wenn das binäre Wort v' durch einen i-Bitfehler gestört ist. Die Fehlererkennung kann in diesem Beispiel durch Berechnung der Determinante $$Det\left(M\left(4\right)\right)=Det\left(\begin{array}{cccc}1& 0& 0& 0\\ s_2& s_1& 1& 0\\ s_4& s_3& s_2& s_1\\ s_6& s_5& s_4& s_3\end{array}\right)=Det\left(\begin{array}{ccc}{s}_1& 1& 0\\ s_3& s_2& s_1\\ s_5& s_4& s_3\end{array}\right)$$

  

  erfolgen, wobei s = (s₁, s₃, s₅, s_p) ≠ 0 angenommen wird. Es folgt: $$Det\left(M\left(4\right)\right)=s_1{s}_2{s}_3+s_1{s}_5+s_1^2{s}_4+s_3^2=s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2.$$

  
• Gilt Det $\left(M\left(4\right)\right)\ne 0$

  

  so ist das gestörte (bzw. fehlerhafte) Binärwort v' durch einen 3-Bitfehler oder einen 4-Bitfehler gestört. Ist s_p = 1, handelt es sich um einen 3-Bitfehler; ist s_p = 0, handelt es sich um einen 4-Bitfehler.
• Gilt Det $\left(M\left(4\right)\right)=\mathrm{0,}$

  

  so liegt ein 1-Bitfehler oder ein 2-Bitfehler vor. Ist s_p = 1, handelt es sich um einen 1-Bitfehler; ist s_p = 0, handelt es sich um einen 2-Bitfehler.
• Für die vier Fehlererkennungssignale det_i gilt somit:
• - det₁ = 1 genau dann, wenn $s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2=\mathrm{0,}{s}_p=1$
  
• - det₂ = 1 genau dann, wenn $s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2=\mathrm{0,}{s}_p=0\text{ und }s\ne 0$
  
• - det₃ = 1 genau dann, wenn $s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2\ne \mathrm{0,}{s}_p=1$
  
• - det₄ = 1 genau dann, wenn $s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2\ne \mathrm{0,}{s}_p=0$
  
• Der algebraische Ausdruck $$s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2$$

  

  kann mittels Galoisfeldmultiplizierern, komponentenweiser XOR-Verknüpfungen und/oder Potenzbildnern im Galoisfeld implementiert werden.
• Ein binärer Ausgang der Fehlererkennungseinheit trägt das Signal det₄ zur 4-Bitfehler-Erkennung und wird sowohl mit einem jeweils zweiten 1-Bit breiten Eingang der UND-Gatter 161, 162, ..., 1630 verbunden, als auch in den jeweils 1-Bit breiten Kontrolleingang der Multiplexer MUX 141, 142 und 143 geführt.
• Der erste Ausgang des BCH-Decoders DEC BCH 15 trägt die binäre Komponente e₀ des Korrekturvektors und ist in einen zweiten binären Eingang des XOR-Gatters 181 und in den ersten Eingang des UND-Gatters 161 geführt, wobei der Ausgang des UND-Gatters 161 mit einem ersten Eingang des ODER-Gatters 171 verbunden ist. Die erste binäre Komponente $v_0^{\text{'}}$

  

  des möglicherweise fehlerhaften Wortes v' liegt am ersten Eingang des XOR-Gatters 181 an, an dessen Ausgang die erste Komponente $v_0^{cor}$

  

  des korrigierten Wortes v^cor erzeugt wird.
• Für i = 2,3,..., 30 trägt der i-te Ausgang des BCH-Decoders DEC BCH 15 die binäre Komponente e_i-1 des Korrekturvektors und ist in einen zweiten Eingang des ODER-Gatters 17(i-1) und in den ersten Eingang des UND-Gatters 16_i geführt, wobei der Ausgang des UND-Gatters 16_i mit einem ersten Eingang des ODER-Gatters 17i verbunden ist. Der Ausgang des ODER-Gatters 17(i - 1) ist mit dem zweiten Eingang des XOR-Gatters 18i verbunden, wobei an dessen ersten Eingang die i-te Komponente $v_{i-1}^{\text{'}}$

  

  des Wortes v' anliegt. Die i-te Komponente $v_{i-1}^{cor}$

  

  des korrigierten Wortes wird am binären Ausgang des XOR-Gatters 18i ausgegeben.
• Der letzte Ausgang des BCH-Decoders DEC BCH 15 trägt die binäre Komponente e₃₀ und ist mit dem zweiten Eingang des ODER-Gatters 1730 verbunden. Der Ausgang des ODER-Gatters 1730 ist in einen zweiten Eingang des XOR-Gatters 1831 geführt, an dessen erstem Eingang die binäre Komponente $v_{30}^{\text{'}}$

  

  des Wortes v' anliegt. Der Ausgang des XOR-Gatters 1831 trägt das Signal $v_{30}^{cor}.$

  
• Hierbei sei angemerkt, dass die Notation 16i mit i = 1,... ,30 meint, dass 30 UND-Gatter vorgesehen sind, die die Bezugszeichen $$\mathrm{161,162,163,}\dots \mathrm{,169,1610,1611,}\dots \mathrm{,1629,1630}$$

  

  tragen. Insoweit stellt die Ziffernfolge 16 einen ersten Teil des Bezugszeichen, der mit einem zweiten Teil i des Bezugszeichens verkettet (konkateniert) wird. Dies gilt entsprechend für die ODER-Gatter 17i sowie die XOR-Gatter 18i.
• Liegt ein 1-Bitfehler, 2-Bitfehler oder 3-Bitfehler vor, ist det₄ = 0 und die 0-Eingänge der Multiplexer MUX 141, 142 und 143, die die unveränderten Teilsyndrome s₁, s₃, s₅ tragen, werden an die zugehörigen Eingänge des BCH-Decoders DEC BCH 15 weitergeleitet.
• Liegt ein 4-Bitfehler vor, ist det₄ = 1 und die 1-Eingänge der Multiplexer MUX 141, 142 und 143, die die modifizierten Teilsyndrome $s_1^{mod},s_3^{mod},s_5^{mod}$

  

  tragen, werden an die zugehörigen Eingänge des BCH-Decoders DEC BCH 15 weitergeleitet.
• Im Falle eines 4-Bitfehlers, der sich aus zwei benachbarten 2-Bitfehlern zusammensetzt, ist das binäre Wort v' in vier Bitpositionen i, (i + 1) und j, (j + 1) für i, j ∈ {0,1,..., 29} gestört. Der Syndromgenerator SG 11 erzeugt dann an seinen Ausgängen das Fehlersyndrom $$\begin{array}{l}s=\left(\begin{array}{c}{s}_1\\ s_3\\ s_5\\ s_p\end{array}\right)=\left(\begin{array}{c}{\alpha }^i+{\alpha }^{\left(i+1\right)}+{\alpha }^j+{\alpha }^{\left(j+1\right)}\\ {\alpha }^{3i}+{\alpha }^{3\left(i+1\right)}+{\alpha }^{3j}+{\alpha }^{3\left(j+1\right)}\\ {\alpha }^{5i}+{\alpha }^{5\left(i+1\right)}+{\alpha }^{5j}+{\alpha }^{5\left(j+1\right)}\\ 0\end{array}\right)\\ =\left(\begin{array}{c}{\alpha }^i\cdot \left(1+\alpha \right)+{\alpha }^j\cdot \left(1+\alpha \right)\\ {\alpha }^{3i}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3\right)\\ {\alpha }^{5i}\cdot \left(1+{\alpha }^5\right)+{\alpha }^{5j}\cdot \left(1+{\alpha }^5\right)\\ 0\end{array}\right),\end{array}$$

  

  dessen Teilsyndrome s₁, s₃ und s₅ durch die Konstantenmultiplizierer 131, 132 und 133 modifiziert werden. Die Konstantenmultiplizierer 131, 132 und 133 sind so konfiguriert, dass die unveränderten Teilsyndrome s₁, s₃ und s₅, die dem Fehlersyndrom eines 4-Bitfehlers in den Bitpositionen [i, (i + 1), j, (j + 1)] entsprechen, auf die modifizierten Teilsyndrome $s_1^{mod},s_3^{mod}\text{ und }{s}_5^{mod}$

  

  abgebildet werden, die dem Fehlersyndrom eines 2-Bitfehlers in den Bitpositionen [i, j] entsprechen, wie das in den nachfolgenden Gleichungen gezeigt ist: $$\begin{array}{c}{s}_1^{mod}=s_1\cdot {\left(1+\alpha \right)}^{-1}=\frac{{\alpha }^i\cdot \left(1+\alpha \right)+{\alpha }^j\cdot \left(1+\alpha \right)}{1+\alpha }={\alpha }^i+{\alpha }^j\\ s_3^{mod}=s_3\cdot {\left(1+{\alpha }^3\right)}^{-1}=\frac{{\alpha }^{3i}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3\right)}{1+{\alpha }^3}={\alpha }^{3i}+{\alpha }^{3j}\\ s_5^{mod}=s_5\cdot {\left(1+{\alpha }^5\right)}^{-1}=\frac{{\alpha }^{5i}\cdot \left(1+{\alpha }^5\right)+{\alpha }^{5j}\cdot \left(1+{\alpha }^5\right)}{1+{\alpha }^5}={\alpha }^{5i}+{\alpha }^{5j}\end{array}$$

  
• Beispiel: Korrektur spezieller 4-Bitfehler, die sich aus zwei benachbarten 2-Bitfehlern in ungeraden Bitpositionen zusammensetzen
• In einem weiteren Beispiel wird gezeigt, wie unter Verwendung eines BCH-Codes zur Korrektur beliebiger 1-Bitfehler, 2-Bitfehler und 3-Bitfehler eine Korrektur spezieller 4-Bitfehler erfolgen kann, die sich aus zwei benachbarten 2-Bitfehlern in ungeraden Bitpositionen zusammensetzen.
• 3 zeigt eine schematische Schaltungsanordnung, die weitgehend der in 2 gezeigten Schaltungsanordnung entspricht. Im Unterschied zu 2 entfallen in 3 für j = 2,4,6,...,30 die UND-Gatter 16j und die ODER-Gatter 17j. Der 1-Bit breite Ausgang det₄ der Fehlererkennungseinheit FE 12 ist somit nur mit dem ersten Eingang der UND-Gatter 16(j - 1) verbunden.
• Für i = 1,3,5,...,29 trägt der i-te Ausgang des BCH-Decoders DEC BCH 15 die binäre Komponente e_i-1 des Korrekturvektors und ist in einen zweiten Eingang des XOR-Gatters 18i und in den ersten Eingang des UND-Gatters 16i geführt, wobei der Ausgang des UND-Gatters 16i mit dem ersten Eingang des ODER-Gatters 17i verbunden ist. Während am ersten Eingang des XOR-Gatters 18i die i-te Komponente $v_{i-1}^{\text{'}}$

  

  des gestörten binären Wortes v' anliegt, wird an dessen Ausgang die i-te Komponente $v_{i-1}^{cor}$

  

  des korrigierten Wortes erzeugt.
• Der (i + 1)-te Ausgang des BCH-Decoders DEC BCH 15 trägt die binäre Komponente e_i des Korrekturvektors und ist in den zweiten Eingang des ODER-Gatters 17i geführt.
• Der Ausgang des ODER-Gatters 17i ist mit dem zweiten Eingang des XOR-Gatters 18(i + 1) verbunden, wobei an dessen ersten Eingang die (i +1)-te Komponente $v_i^{\text{'}}$

  

  des Wortes v' anliegt. Die (i + 1)-te Komponente $v_i^{cor}$

  

  des korrigierten Wortes wird am binären Ausgang des XOR-Gatters 18(i + 1) ausgegeben.
• Der letzte Ausgang des BCH-Decoders DEC BCH 15 trägt die binäre Komponente e₃₀ und ist mit dem zweiten Eingang des XOR-Gatters 1831 verbunden, an dessen erstem Eingang die binäre Komponente $v_{30}^{\text{'}}$

  

  des Wortes v' anliegt. Der Ausgang des XOR-Gatters 1831 trägt das Signal $v_{30}^{cor}.$

  
• Durch die vorgenommenen Änderungen an der Schaltungsanordnung von 3 können derartige 4-Bitfehler korrigiert werden, die sich aus zwei benachbarten 2-Bitfehlern zusammensetzen, und das binäre Wort v' in den vier Bitpositionen i, (i + 1), j, (j + 1) für i, j ∈ {0,2,...,28} stören.
• Die Schaltungsanordnung gemäß 3 erfordert einen geringeren Schaltungsaufwand als die in 2 gezeigte Schaltungsanordnung. Die Schaltungsanordnung gemäß 3 setzt voraus, dass benachbarte 2-Bitfehler nur an bestimmten Bitpositionen auftreten. Dies ist beispielsweise dann der Fall, wenn Speicherzellen verwendet werden, bei denen vier verschiedene interne Zustände unterschieden werden können. Ein Fehler des internen Zustandes kann zu einem benachbarten 2-Bitfehler in den beiden Bitpositionen führen, die der fehlerhaften Speicherzelle entsprechen.
• Beispiel: Korrektur spezieller 6-Bitfehler, die aus drei benachbarten 2-Bitfehlern bestehen
• Nachfolgend wird veranschaulicht, wie unter Verwendung eines 5-Bitfehler korrigieren BCH-Codes eine Korrektur spezieller 6-Bitfehler erfolgen kann, die sich aus drei benachbarten 2-Bitfehlern zusammensetzen. In Gleichung (58) ist die Prüfmatrix eines 5-Bitfehler korrigierenden BCH-Codes mit einbezogener Gesamtparität in separierter Form für m = 5 und n = 31 dargestellt, wobei der verwendete BCH-Code eine minimale Hamming-Distanz d_min = 12 aufweist. $$H=\left[\begin{array}{c}{H}_1\\ H_3\\ H_5\\ H_7\\ H_9\\ P\end{array}\right]=\left[\begin{array}{cccccc}{\alpha }^0& {\alpha }^1& {\alpha }^2& \dots & {\alpha }^{29}& {\alpha }^{30}\\ {\alpha }^{3\cdot 0}& {\alpha }^{3\cdot 1}& {\alpha }^{3\cdot 2}& \dots & {\alpha }^{3\cdot \left(29\right)}& {\alpha }^{3\cdot \left(30\right)}\\ {\alpha }^{5\cdot 0}& {\alpha }^{5\cdot 1}& {\alpha }^{5\cdot 2}& \dots & {\alpha }^{5\cdot \left(29\right)}& {\alpha }^{5\cdot \left(30\right)}\\ {\alpha }^{7\cdot 0}& {\alpha }^{7\cdot 1}& {\alpha }^{7\cdot 2}& \dots & {\alpha }^{7\cdot \left(29\right)}& {\alpha }^{7\cdot \left(30\right)}\\ {\alpha }^{9\cdot 0}& {\alpha }^{9\cdot 1}& {\alpha }^{9\cdot 2}& \dots & {\alpha }^{9\cdot \left(29\right)}& {\alpha }^{9\cdot \left(30\right)}\\ 1& 1& 1& \dots & 1& 1\end{array}\right]$$

  
• Die Potenzen von αⁱ sind dabei modulo (2⁵ - 1) = 31 zu interpretieren. Die letzte Zeile der H-Matrix (58) besteht aus lauter Einsen. Durch diese Zeile ist die Gesamtparität P bestimmt.
• Zur besseren Übersichtlichkeit sind die einzelnen Elemente der Teilmatrizen H₁, H₃, H₅, H₇ und H₉ in der nachfolgenden Gleichung (59) durch ihre Potenz dargestellt. $$\begin{array}{c}{H}_1=\left[0\text{ 1 }23456789101112131415161718192021222324252627282930\right]\\ H_3=\left[0369121518212427302581114172023262914710131619222528\right]\\ H_5=\left[0510152025304914192429\text{ 3 }81318232827121722271611162126\right]\\ H_7=\left[0714212841118251815222951219262916233061320273\text{ 10 }1724\right]\\ H_9=\left[0918275142311019286152421120297162531221308172641322\right]\end{array}$$

  
• Unter Verwendung der in 1 gezeigten Tabelle kann die binäre Prüfmatrix H aufgestellt werden, indem die in Gleichung (59) für die Teilmatrizen H₁, H₃, H₅, H₇ und H₉ vorhandenen Potenzen der Elemente durch ihre zugehörige Vektordarstellung als Spaltenvektoren ersetzt werden. Die binäre Prüfmatrix H ergibt sich dann zu

  
• 4 zeigt eine Schaltungsanordnung umfassend einen Syndromgenerator SG 41 mit n = 31 binären Eingängen und (5·5 + 1 = 26) binären Ausgängen, eine Fehlererkennungseinheit FE 42 mit (5·5 + 1 = 26) binären Eingängen und einem binären Ausgang, Konstantenmultiplizierer 431 bis 435 mit jeweils 5 binären Eingängen und 5 binären Ausgängen, Multiplexer MUX 441 bis 445 mit jeweils (2·5 + 1) = 11 binären Eingängen und 5 binären Ausgängen, einen BCH-Decoder DEC BCH 45 mit (5 · 5) = 25 binären Eingängen und n = 31 binären Ausgängen, 30 UND-Gatter 461 bis 4630 mit jeweils 2 binären Eingängen und einem binären Ausgang, 30 ODER-Gatter 471 bis 4730 mit jeweils 2 binären Eingängen und einem binären Ausgang und 31 XOR-Gatter 481 bis 4831 mit jeweils 2 binären Eingängen und einem binären Ausgang.
• Der Syndromgenerator SG 41 weist n = 31 binäre Eingänge auf, in die das möglicherweise fehlerhafte Binärwort $v^{\text{'}}=\left(v_0^{\text{'}},v_1^{\text{'}},\dots ,v_{30}^{\text{'}}\right)$

  

  geführt ist. An seinem 26-Bit breiten Ausgang gibt der Syndromgenerator SG 41 ein Fehlersyndrom $$s=\left(s_1,s_3,s_5,s_9,s_p\right)$$

  

  der Wortbreite (5·5 + 1) aus. Dabei ist der Syndromgenerator SG 41 so konfiguriert, dass er die Komponenten des Fehlersyndroms s auf Basis der Prüfmatrix H gemäß der Gleichung (60) so bestimmt, dass gilt: $$\begin{array}{l}{s}_1^T=H_1\cdot {\left(v\text{'}\right)}^T\hfill \\ s_3^T=H_3\cdot {\left(v\text{'}\right)}^T\hfill \\ ⋮\hfill \\ s_9^T=H_9\cdot {\left(v\text{'}\right)}^T\hfill \\ s_p=P\cdot {\left(v\text{'}\right)}^T=v_0^{\text{'}}+v_1^{\text{'}}+\cdots +v_{30}^{\text{'}}\hfill \end{array}$$

  
• Für i = 1, 2,..., 5 sind die i-ten 5 binären Ausgänge des Syndromgenerators SG 41, die das Teilsyndrom s_2i-1 tragen, in die i-ten 5 binären Eingänge der Fehlererkennungseinheit FE 42, in den 5-Bit breiten 0-Eingang des Multiplexers MUX 44i und in den 5-Bit breiten Eingang des Konstantenmultiplizierers 43i geführt.
• Der Konstantenmultiplizierer 43i ist so konfiguriert, dass er ein modifiziertes Teilsyndrom $$s_{2i-1}^{mod}=s_{2i-1}\cdot {\left(1+{\alpha }^{2i-1}\right)}^{-1}$$

  

  an seinen 5 binären Ausgängen erzeugt, die in den 5-Bit breiten 1-Eingang des Multiplexers MUX 44i geführt sind. Der 5-Bit breite Ausgang des Multiplexers MUX 44i ist mit den i-ten 5 binären Eingängen des BCH-Decoders DEC BCH 45 verbunden.
• Der BCH-Decoder DEC BCH 45 erzeugt auf Basis der Syndromkomponenten s₁, s₃, ..., s₉ einen Korrekturvektor e = (e₀, e₁,...,e₃₀) an seinen 31 binären Ausgängen. Dabei ist der BCH-Decoder DEC BCH 45 so konfiguriert, dass, wenn die an den Eingängen bereitgestellten Teilsyndrome dem Fehlersyndrom eines i-Bitfehlers in den Bitpositionen b₁, b₂,..., b_i mit 0 ≤ b₁ < b₂ < ··· < b_i ≤ 30 entsprechen, ein Korrekturvektor e = (e₀, e₁,...,e₃₀) erzeugt wird, der in den Komponenten e_{b 1} , e_{b 2} ,... ,e_{b i} . eine binäre 1 und in allen anderen Komponenten eine binäre 0 aufweist. Zeigen die Teilsyndrome keinen Fehler an und gilt s₁ = s₃ = ··· = s₉ = 0, so wird ein Korrekturvektor e = (e₀,e_2, ..., e₃₀) = (0, 0,..., 0) an den Ausgängen des BCH-Decoders DEC BCH 45 erzeugt.
• Der binäre Ausgang des Syndromgenerators SG 41, der das 1-Bit breite Teilsyndrom s_p trägt, ist mit einem binären Eingang der Fehlererkennungseinheit FE 42 verbunden.
• Die Fehlererkennungseinheit FE 42 ist so konfiguriert, dass in Abhängigkeit von den Teilsyndromen s₁, s₃, ..., s₉, s_p ein 1-Bit breites Fehlererkennungssignal det₆ an ihrem Ausgang erzeugt wird, wobei det₆ genau dann 1 ist, wenn das binäre Wort v' durch einen 6-Bitfehler gestört ist. Die Fehlererkennung kann in diesem Beispiel durch Berechnung der Determinante $$Det\left(M\left(6\right)\right)=Det\left(\begin{array}{cccccc}1& 0& 0& 0& 0& 0\\ s_2& s_1& 1& 0& 0& 0\\ s_4& s_3& s_2& s_1& 1& 0\\ s_6& s_5& s_4& s_3& s_2& s_1\\ s_8& s_7& s_6& s_5& s_4& s_3\\ s_{10}& s_9& s_8& s_7& s_6& s_5\end{array}\right)=Det\left(\begin{array}{ccccc}{s}_1& 1& 0& 0& 0\\ s_3& s_2& s1& 1& 0\\ s_5& s_4& s_3& s_2& s_1\\ s_7& s_6& s_5& s_4& s_3\\ s_9& s_8& s_7& s_6& s_5\end{array}\right)$$

  

  erfolgen. Gilt Det $\left(M\left(6\right)\right)\ne \mathrm{0,}$

  

  so ist das gestörte Binärwort v' durch einen 5-Bitfehler oder durch einen 6-Bitfehler gestört. Ist s_p = 1, handelt es sich um einen 5-Bitfehler; ist s_p = 0, handelt es sich um einen 6-Bitfehler.
• Für das Fehlererkennungssignal det₆ gilt entsprechend:
• - det₆ = 1 genau dann, wenn Det $\left(M\left(6\right)\right)\ne 0\text{ und }{s}_p=0.$
  
• Der algebraische Ausdruck, der sich durch die Entwicklung der Determinante Det $\left(M\left(6\right)\right)$

  

  ergibt, kann mit Hilfe von Galoisfeldmultiplizierern, komponentenweiser XOR-Verknüpfungen und/oder Potenzbildnern im Galoisfeld implementiert und mit Hilfe von Synthesetools optimiert werden.
• Der Ausgang der Fehlererkennungseinheit FE 42 trägt das Signal det₆ zur 6-Bitfehler-Erkennung und wird sowohl mit einem jeweils zweiten 1-Bit breiten Eingang der UND-Gatter 461, 462, ..., 4630 verbunden, als auch in den jeweils 1-Bit breiten Kontrolleingang der Multiplexer MUX 441, 442, ..., 445 geführt.
• Der erste Ausgang des BCH-Decoders DEC BCH 45 trägt die binäre Komponente e₀ des Korrekturvektors und ist in einen zweiten binären Eingang des XOR-Gatters 481 und in einen ersten Eingang des UND-Gatters 461 geführt, wobei der Ausgang des UND-Gatters 461 mit einem ersten Eingang des ODER-Gatters 471 verbunden ist. Die erste binäre Komponente $v_0^{\text{'}}$

  

  des möglicherweise fehlerhaften Wortes v' liegt an einem ersten Eingang des XOR-Gatters 481 an, an dessen Ausgang die erste Komponente $v_0^{cor}$

  

  des korrigierten Wortes v^cor erzeugt wird.
• Für i = 2,3,..., 30 trägt der i-te Ausgang des BCH-Decoders DEC BCH 45 die binäre Komponente e_i-1 des Korrekturvektors und ist in einen zweiten Eingang des ODER-Gatters 47(i - 1) und in den ersten Eingang des UND-Gatters 46i geführt, wobei der Ausgang des UND-Gatters 46i mit einem ersten Eingang des ODER-Gatters 47i verbunden ist. Der Ausgang des ODER-Gatters 47(i - 1) ist mit einem zweiten Eingang des XOR-Gatters 48i verbunden, wobei an dessen ersten Eingang die i-te Komponente $v_{i-1}^{\text{'}}$

  

  des Wortes v' anliegt. Die i-te Komponente $v_{i-1}^{cor}$

  

  des korrigierten Wortes wird am binären Ausgang des XOR-Gatters 48i ausgegeben.
• Der letzte Ausgang des BCH-Decoders DEC BCH 45 trägt die binäre Komponente e₃₀ und ist mit dem zweiten Eingang des ODER-Gatters 4730 verbunden. Der Ausgang des ODER-Gatters 4730 ist in einen zweiten Eingang des XOR-Gatters 4831 geführt, an dessen erstem Eingang die binäre Komponente $v_{30}^{\text{'}}$

  

  des Wortes v' anliegt. Der Ausgang des XOR-Gatters 4831 trägt das Signal $v_{30}^{cor}.$

  
• Liegt ein 1-Bitfehler, 2-Bitfehler, 3-Bitfehler, 4-Bitfehler oder 5-Bitfehler vor, ist det₆ = 0 und die 0-Eingänge der Multiplexer MUX 441, 442, ..., 445, die die unveränderten Teilsyndrome s₁, s₃, ..., s₉ tragen, werden an die zugehörigen Eingänge des BCH-Decoders DEC BCH 45 weitergeleitet.
• Liegt ein 6-Bitfehler vor, ist det₆ = 1 und die 1-Eingänge der Multiplexer MUX 441, 442, ..., 445, die die modifizierten Teilsyndrome $s_1^{mod},s_3^{mod},\dots ,s_9^{mod}$

  

  tragen, werden an die zugehörigen Eingänge des BCH-Decoders DEC BCH 45 weitergeleitet.
• Im Falle eines 6-Bitfehlers, der sich aus drei benachbarten 2-Bitfehlern zusammensetzt, ist das binäre Wort v' in sechs Bitpositionen $$i,\left(i+1\right),j,\left(j+1\right),k,\left(k+1\right)$$

  

  für i, j, k ∈ {0,1, ... , 29} gestört. Der Syndromgenerator SG 41 erzeugt dann an seinen Ausgängen das Fehlersyndrom $$\begin{array}{l}s=\left(\begin{array}{c}{s}_1\\ s_3\\ s_5\\ s_7\\ s_9\\ s_p\end{array}\right)=\left(\begin{array}{c}{\alpha }^i+{\alpha }^{\left(i+1\right)}+{\alpha }^j+{\alpha }^{\left(j+1\right)}+{\alpha }^k+{\alpha }^{{}_{\left(k+1\right)}}\\ {\alpha }^{3i}+{\alpha }^{3\left(i+1\right)}+{\alpha }^{3j}+{\alpha }^{3\left(j+1\right)}+{\alpha }^{3k}+{\alpha }^{3_{\left(k+1\right)}}\\ {\alpha }^{5i}+{\alpha }^{5\left(i+1\right)}+{\alpha }^{5j}+{\alpha }^{5\left(j+1\right)}+{\alpha }^{5k}+{\alpha }^{{}_{5\left(k+1\right)}}\\ {\alpha }^{7i}+{\alpha }^{7\left(i+1\right)}+{\alpha }^{7j}+{\alpha }^{7\left(j+1\right)}+{\alpha }^{7k}+{\alpha }^{{}_{7\left(k+1\right)}}\\ {\alpha }^{9i}+{\alpha }^{9\left(i+1\right)}+{\alpha }^{9j}+{\alpha }^{9\left(j+1\right)}+{\alpha }^{9k}+{\alpha }^{{}_{9\left(k+1\right)}}\\ 0\end{array}\right)\\ =\left(\begin{array}{c}{\alpha }^i\cdot \left(1+\alpha \right)+{\alpha }^j\cdot \left(1+\alpha \right)+{\alpha }^k\cdot \left(1+\alpha \right)\\ {\alpha }^{3i}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3k}\cdot \left(1+{\alpha }^3\right)\\ {\alpha }^{5i}\cdot \left(1+{\alpha }^5\right)+{\alpha }^{5j}\cdot \left(1+{\alpha }^5\right)+{\alpha }^{5k}\cdot \left(1+{\alpha }^5\right)\\ {\alpha }^{7i}\cdot \left(1+{\alpha }^7\right)+{\alpha }^{7j}\cdot \left(1+{\alpha }^7\right)+{\alpha }^{7k}\cdot \left(1+{\alpha }^7\right)\\ {\alpha }^{9i}\cdot \left(1+{\alpha }^9\right)+{\alpha }^{9j}\cdot \left(1+{\alpha }^9\right)+{\alpha }^{9k}\cdot \left(1+{\alpha }^9\right)\\ 0\end{array}\right),\end{array}$$

  

  dessen Teilsyndrome s₁, s₃, ..., s₉ durch die Konstantenmultiplizierer 431 bis 435 modifiziert werden.
• Die Konstantenmultiplizierer 431, 432, ..., 435 sind so konfiguriert, dass die unveränderten Teilsyndrome s₁, s₃, ..., s₉, die dem Fehlersyndrom eines 6-Bitfehlers in den Bitpositionen [i, (i + 1), j, (j + 1), k, (k + 1)] entsprechen, auf die modifizierten Teilsyndrome $s_1^{mod},s_3^{mod},\dots ,s_9^{mod}$

  

  abgebildet werden, die dem Fehlersyndrom eines 3-Bitfehlers in den Bitpositionen [i, j, k] entsprechen, wie das in den nachfolgenden Gleichungen gezeigt ist: $$\begin{array}{c}{s}_1^{mod}=s_1\cdot {\left(1+\alpha \right)}^{-1}\\ =\left({\alpha }^i\cdot \left(1+\alpha \right)+{\alpha }^j\cdot \left(1+\alpha \right)+{\alpha }^k\cdot \left(1+\alpha \right)\right)\cdot {\left(1+\alpha \right)}^{-1}\\ ={\alpha }^i+{\alpha }^j+{\alpha }^k\\ s_3^{mod}=s_3\cdot {\left(1+{\alpha }^3\right)}^{-1}\\ =\left({\alpha }^{3i}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3k}\cdot \left(1+{\alpha }^3\right)\right)\cdot {\left(1+{\alpha }^3\right)}^{-1}\\ =\alpha 3^i+{\alpha }^{3j}+{\alpha }^{3k}\\ s_5^{mod}=s_5\cdot {\left(1+{\alpha }^5\right)}^{-1}\\ =\left({\alpha }^{5i}\cdot \left(1+{\alpha }^5\right)+{\alpha }^{5j}\cdot \left(1+{\alpha }^5\right)+{\alpha }^{5k}\cdot \left(1+{\alpha }^5\right)\right)\cdot {\left(1+{\alpha }^5\right)}^{-1}\\ =\alpha 5^i+{\alpha }^{5j}+{\alpha }^{5k}\\ s_7^{mod}=s7\cdot {\left(1+{\alpha }^7\right)}^{-1}\\ =\left({\alpha }^{7i}\cdot \left(1+{\alpha }^7\right)+{\alpha }^{7j}\cdot \left(1+{\alpha }^7\right)+{\alpha }^{7k}\cdot \left(1+{\alpha }^7\right)\right)\cdot {\left(1+{\alpha }^7\right)}^{-1}\\ ={\alpha }^{7i}+{\alpha }^{7j}+{\alpha }^{7k}\\ s_9^{mod}=s_9\cdot {\left(1+{\alpha }^9\right)}^{-1}\\ =\left({\alpha }^{9i}\cdot \left(1+{\alpha }^9\right)+{\alpha }^{9j}\cdot \left(1+{\alpha }^9\right)+{\alpha }^{9k}\cdot \left(1+{\alpha }^9\right)\right)\cdot {\left(1+{\alpha }^9\right)}^{-1}\\ ={\alpha }^{9i}+{\alpha }^{9j}+{\alpha }^{9k}\end{array}$$

  
• Beispiel: Korrektur spezieller 6-Bitfehler, die aus zwei benachbarten 3-Bitfehlern bestehen
• In einem weiteren Beispiel wird gezeigt, wie unter Verwendung eines BCH-Codes zur Korrektur beliebiger 1-Bit-, 2-Bit-, ..., 5-Bitfehler, eine Korrektur spezieller 6-Bitfehler erfolgen kann, die sich aus zwei benachbarten 3-Bitfehlern zusammensetzen.
• 5 zeigt eine beispielhafte Schaltungsanordnung, die auf der in 4 dargestellten Schaltungsanordnung basiert. 5 unterscheidet sich von 4 insoweit, dass für i = 1,2,...,5 der Konstantenmultiplizierer 43i durch den Konstantenmultiplizierer 53i ersetzt wurde, wobei die Konstantenmultiplizierer 53i so konfiguriert sind, dass ein modifiziertes Teilsyndrom $$s_{2i-1}^{mod}=s_{2i-1}\cdot {\left(1+{\alpha }^{2i-1}+{\alpha }^{\left(2i-1\right)\cdot 2}\right)}^{-1}$$

  

  an dessen jeweiligen 5 binären Ausgängen erzeugt wird.
• Weiterhin wurden für j = 2,3,..., 30 die ODER-Gatter 47j durch ODER-Gatter 57j mit drei binären Eingängen und einem binären Ausgang ersetzt. Das ODER-Gatter 471 hat unverändert zwei binäre Eingänge.
• Weiterhin weist 5 im Unterschied zu 4 die folgenden Veränderungen auf:
• Der erste Ausgang des BCH-Decoders DEC BCH 45 trägt die binäre Komponente e₀ des Korrekturvektors e und ist in einen zweiten binären Eingang des XOR-Gatters 481 und in den ersten Eingang des UND-Gatters 461 geführt, wobei der Ausgang des UND-Gatters 461 mit einem jeweils ersten Eingang der ODER-Gatter 471 und 572 verbunden ist. Die erste binäre Komponente $v_0^{\text{'}}$
  
  des möglicherweise fehlerhaften Wortes v' liegt an einem ersten Eingang des XOR-Gatters 481 an, an dessen Ausgang die erste Komponente $v_0^{cor}$
  
  des korrigierten Wortes v^cor erzeugt wird.
• Der zweite Ausgang des BCH-Decoders DEC BCH 45 trägt die binäre Komponente e₁ des Korrekturvektors e und ist mit einem zweiten binären Eingang des ODER-Gatters 471 und mit einem ersten Eingang des UND-Gatters 462 verbunden, wobei der Ausgang des UND-Gatters 462 mit einem zweiten Eingang des ODER-Gatters 572 und mit einem ersten Eingang des ODER-Gatters 573 verbunden ist.
• Der Ausgang des ODER-Gatters 471 ist mit einem zweiten Eingang des XOR-Gatters 482 verbunden. Die zweite binäre Komponente $v_1^{\text{'}}$

  

  des möglicherweise fehlerhaften Wortes v' liegt an einem ersten Eingang des XOR-Gatters 482 an, an dessen Ausgang die zweite Komponente $v_1^{cor}$

  

  des korrigierten Wortes v^cor erzeugt wird.
• Für i = 3,...,29 trägt der i-te Ausgang des BCH-Decoders DEC BCH 45 die binäre Komponente e_i-1 des Korrekturvektors e und ist in einen dritten Eingang des ODER-Gatters 57(i - 1) und in einen ersten Eingang des UND-Gatters 46i geführt, wobei der Ausgang des UND-Gatters 46i mit einem zweiten Eingang des ODER-Gatters 57i und mit einem ersten Eingang des ODER-Gatters 57(i + 1) verbunden ist.
• Der Ausgang des ODER-Gatters 57(i - 1) ist mit einem zweiten Eingang des XOR-Gatters 48i verbunden, wobei an dessen ersten Eingang die i-te Komponente $v_{i-1}^{\text{'}}$

  

  des Wortes v' anliegt. Die i-te Komponente $v_{i-1}^{cor}$

  

  des korrigierten Wortes wird am binären Ausgang des XOR-Gatters 48i ausgegeben.
• Der vorletzte Ausgang des BCH-Decoders DEC BCH 45 trägt die binäre Komponente e₂₉ des Korrekturvektors e und ist in einen dritten Eingang des ODER-Gatters 5729 und in einen ersten Eingang des UND-Gatters 4630 geführt, wobei der Ausgang des UND-Gatters 4630 mit einem zweiten Eingang des ODER-Gatters 5730 verbunden ist.
• Der Ausgang des ODER-Gatters 5729 ist mit einem zweiten Eingang des XOR-Gatters 4830 verbunden, wobei an dessen ersten Eingang die 30-te Komponente $v_{29}^{\text{'}}$

  

  des Wortes v' anliegt. Die 30-te Komponente $v_{29}^{cor}$

  

  des korrigierten Wortes wird am binären Ausgang des XOR-Gatters 4830 ausgegeben.
• Der letzte Ausgang des BCH-Decoders DEC BCH 45 trägt die binäre Komponente e₃₀ und ist mit einem dritten Eingang des ODER-Gatters 5730 verbunden. Der Ausgang des ODER-Gatters 5730 ist in einen zweiten Eingang des XOR-Gatters 4831 geführt, an dessen erstem Eingang die binäre Komponente $v_{30}^{\text{'}}$

  

  des Wortes v' anliegt. Der Ausgang des XOR-Gatters 4831 trägt das Signal $v_{30}^{cor}.$

  
• Durch die in 5 gegenüber 4 gezeigten Änderungen können statt drei benachbarten 2-Bitfehlern nun zwei benachbarte 3-Bitfehler korrigiert werden. Im Falle eines 6-Bitfehlers, der sich aus zwei benachbarten 3-Bitfehlern zusammensetzt, ist das gestörte binäre Wort v' an sechs Bitpositionen $$i,\left(i+1\right),\left(i+2\right),j,\left(j+1\right),\left(j+2\right)$$

  

  für i, j ∈ {0,1,...,28} gestört. Der Syndromgenerator SG 41 erzeugt dann an seinen Ausgängen das Fehlersyndrom $$\begin{array}{l}s=\left(\begin{array}{l}{s}_1\hfill \\ s_3\hfill \\ s_5\hfill \\ s_7\hfill \\ s_9\hfill \\ s_p\hfill \end{array}\right)=\left(\begin{array}{c}{\alpha }^i+{\alpha }^{\left(i+1\right)}+{\alpha }^{\left(i+2\right)}+{\alpha }^j+{\alpha }^{\left(j+1\right)}+{\alpha }^{\left(j+2\right)}\\ {\alpha }^{3i}+{\alpha }^{3\left(i+1\right)}+{\alpha }^{3\left(i+2\right)}+{\alpha }^{3j}+{\alpha }^{3\left(j+1\right)}+{\alpha }^{3\left(j+2\right)}\\ {\alpha }^{5i}+{\alpha }^{5\left(i+1\right)}+{\alpha }^{5\left(i+2\right)}+{\alpha }^{5j}+{\alpha }^{5\left(j+1\right)}+{\alpha }^{5\left(j+2\right)}\\ {\alpha }^{7i}+{\alpha }^{7\left(i+1\right)}+{\alpha }^{7\left(i+2\right)}+{\alpha }^{7j}+{\alpha }^{7\left(j+1\right)}+{\alpha }^{7\left(j+2\right)}\\ {\alpha }^{9i}+{\alpha }^{9\left(i+1\right)}+{\alpha }^{9\left(i+2\right)}+{\alpha }^{9j}+{\alpha }^{9\left(j+1\right)}+{\alpha }^{9\left(j+2\right)}\\ 0\end{array}\right)\\ =\left(\begin{array}{c}{\alpha }^i\cdot \left(1+\alpha +{\alpha }^2\right)+{\alpha }^j\cdot \left(1+\alpha +{\alpha }^2\right)\\ {\alpha }^{3i}\cdot \left(1+{\alpha }^3+{\alpha }^{3\cdot 2}\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3+{\alpha }^{3\cdot 2}\right)\\ {\alpha }^{5i}\cdot \left(1+{\alpha }^5+{\alpha }^{5\cdot 2}\right)+{\alpha }^{5j}\cdot \left(1+{\alpha }^5+{\alpha }^{5\cdot 2}\right)\\ {\alpha }^{7i}\cdot \left(1+{\alpha }^7+{\alpha }^{7\cdot 2}\right)+{\alpha }^{7j}\cdot \left(1+{\alpha }^7+{\alpha }^{7\cdot 2}\right)\\ {\alpha }^{9i}\cdot \left(1+{\alpha }^9+{\alpha }^{9\cdot 2}\right)+{\alpha }^{9j}\cdot \left(1+{\alpha }^9+{\alpha }^{9\cdot 2}\right)\\ 0\end{array}\right),\end{array}$$

  

  dessen Teilsyndrome s₁, s₃, ..., s₉ durch die Konstantenmultiplizierer 531 bis 535 modifiziert werden.
• Die Konstantenmultiplizierer 531 bis 535 sind so konfiguriert, dass die unveränderten Teilsyndrome s₁, s₃, ..., s_9, die dem Fehlersyndrom eines 6-Bitfehlers an den Bitpositionen [i, (i + 1), (i + 2), j, (j + 1), (j + 2)] entsprechen, auf die modifizierten Teilsyndrome $s_1^{mod},s_3^{mod},\dots ,s_9^{mod}$

  

  abgebildet werden, die dem Fehlersyndrom eines 2-Bitfehlers in den Bitpositionen [i, j] entsprechen, wie das in den nachfolgenden Gleichungen gezeigt ist: $$\begin{array}{l}\begin{array}{c}{s}_1^{mod}=s_1\cdot {\left(1+\alpha +{\alpha }^2\right)}^{-1}\\ =\left({\alpha }^i\cdot \left(1+\alpha +{\alpha }^2\right)+{\alpha }^j\cdot \left(1+\alpha +{\alpha }^2\right)\right)\cdot {\left(1+\alpha +{\alpha }^2\right)}^{-1}\\ ={\alpha }^i+{\alpha }^j\end{array}\\ \begin{array}{c}{s}_3^{mod}=s_3\cdot {\left(1+{\alpha }^3+{\alpha }^{3\cdot 2}\right)}^{-1}\\ =\left({\alpha }^{3i}\cdot \left(1+{\alpha }^3+{\alpha }^{3\cdot 2}\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3+{\alpha }^{3\cdot 2}\right)\right)\cdot {\left(1+{\alpha }^3+{\alpha }^{3\cdot 2}\right)}^{-1}\\ ={\alpha }^{3i}+{\alpha }^{3j}\end{array}\\ \begin{array}{c}{s}_5^{mod}=s_5\cdot {\left(1+{\alpha }^5+{\alpha }^{5\cdot 2}\right)}^{-1}\\ =\left({\alpha }^{5i}\cdot \left(1+{\alpha }^5+{\alpha }^{5\cdot 2}\right)+{\alpha }^{5j}\cdot \left(1+{\alpha }^5+{\alpha }^{5\cdot 2}\right)\right)\cdot {\left(1+{\alpha }^5+{\alpha }^{5\cdot 2}\right)}^{-1}\\ ={\alpha }^{5i}+{\alpha }^{5j}\end{array}\\ \begin{array}{c}{s}_7^{mod}=s_7\cdot {\left(1+{\alpha }^7+{\alpha }^{7\cdot 2}\right)}^{-1}\\ =\left({\alpha }^{7i}\cdot \left(1+{\alpha }^7+{\alpha }^{7\cdot 2}\right)+{\alpha }^{7j}\cdot \left(1+{\alpha }^7+{\alpha }^{7\cdot 2}\right)\right)\cdot {\left(1+{\alpha }^7+{\alpha }^{7\cdot 2}\right)}^{-1}\\ ={\alpha }^{7i}+{\alpha }^{7j}\end{array}\\ \begin{array}{c}{s}_9^{mod}=s_9\cdot {\left(1+{\alpha }^9+{\alpha }^{9\cdot 2}\right)}^{-1}\\ =\left({\alpha }^{9i}\cdot \left(1+{\alpha }^9+{\alpha }^{9\cdot 2}\right)+{\alpha }^{9j}\cdot \left(1+{\alpha }^9+{\alpha }^{9\cdot 2}\right)\right)\cdot {\left(1+{\alpha }^9+{\alpha }^{9\cdot 2}\right)}^{-1}\\ ={\alpha }^{9i}+{\alpha }^{9j}\end{array}\end{array}$$

  
• Beispiel: Korrektur benachbarter 3-Bitfehler mittels Teilschaltung DEC (H₁)
• Nachfolgend wird gezeigt, wie unter Verwendung eines BCH-Codes zur Korrektur von 1-Bitfehlern und 2-Bitfehlern und durch Nutzung einer Teilschaltung DEC (H₁) eine Korrektur benachbarter 3-Bitfehler erfolgen kann.
• Gemäß der nachfolgend dargestellten Gleichung (67) ist die Prüfmatrix eines 2-Bitfehler korrigierenden BCH-Codes mit einbezogener Gesamtparität in separierter Form für m = 5 und n = 31 dargestellt. Der hier verwendete BCH-Code weist eine minimale Hamming-Distanz d_min = 6 auf. $$H=\left[\begin{array}{l}{H}_1\\ H_3\\ P\end{array}\right]=\left[\begin{array}{cccccc}{\alpha }^0& {\alpha }^1& {\alpha }^2& \cdots & {\alpha }^{29}& {\alpha }^{30}\\ {\alpha }^{3\cdot 0}& {\alpha }^{3\cdot 1}& {\alpha }^{3\cdot 2}& \cdots & {\alpha }^{3\cdot \left(29\right)}& {\alpha }^{3\cdot \left(30\right)}\\ 1& 1& 1& \dots & 1& 1\end{array}\right]$$

  
• Die Potenzen von αⁱ sind dabei modulo (2⁵ - 1) = 31 zu interpretieren. Die letzte Zeile der H-Matrix gemäß Gleichung (67) besteht aus lauter Einsen. Durch diese Zeile ist die Gesamtparität P bestimmt.
• Zur besseren Übersichtlichkeit sind die einzelnen Elemente der Teilmatrizen H₁ und H₃ in der nachfolgenden Gleichung (68) durch ihre Potenz dargestellt. $$\begin{array}{l}{H}_1=\left[\text{0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30}\right]\\ H_3=\left[\text{0 3 6 9 12 15 18 21 24 27 30 2 5 8 11 14 17 20 23 26 29 1 4 7 10 13 16 19 22 25 28}\right]\end{array}$$

  
• Unter Verwendung der in 1 gezeigten Tabelle kann die binäre Prüfmatrix H aufgestellt werden, indem die in Gleichung (68) für die Teilmatrizen H₁ und H₃ aufgelisteten Potenzen der Elemente durch ihre zugehörige Vektordarstellung als Spaltenvektoren ersetzt werden. Die binäre Prüfmatrix H ergibt sich dann zu

  
• 6 zeigt eine Schaltungsanordnung umfassend einen Syndromgenerator SG 61 mit n = 31 binären Eingängen und 2 · 5 + 1 = 11 binären Ausgängen, eine Fehlererkennungseinheit FE 62 mit (2 · 5 + 1) = 11 binären Eingängen und einem binären Ausgang, einen Konstantenmultiplizierer 63 mit 5 binären Eingängen und 5 binären Ausgängen, einen BCH-Decoder DEC BCH 64 mit (2·5) = 10 binären Eingängen und n = 31 binären Ausgängen, eine Teilschaltung DEC (H₁) 65 mit 5 binären Eingängen und n = 31 binären Ausgängen, einen Multiplexer 66 mit (2·31+1) = 63 binären Eingängen und 31 binären Ausgängen, 30 UND-Gatter 671 bis 6730 mit jeweils 2 binären Eingängen und einem binären Ausgang, ein ODER-Gatter 681 mit 2 binären Eingängen und einem binären Ausgang, 29 ODER-Gatter 682 bis 6830 mit jeweils 3 binären Eingängen und einem binären Ausgang und 31 XOR-Gatter 691 bis 6931 mit jeweils 2 binären Eingängen und einem binären Ausgang.
• Der Syndromgenerator SG 61 weist n = 31 binäre Eingänge auf, in die das möglicherweise fehlerhafte Binärwort $v\text{'}=\left(v_0^{\text{'}},v_1^{\text{'}},\dots ,v_{30}^{\text{'}}\right)$

  

  geführt ist. An seinem 11-Bit breiten Ausgang gibt der Syndromgenerator SG 61 ein Fehlersyndrom $$s=\left(s_1,s_3,s_p\right)$$

  

  der Wortbreite (2·5 + 1) aus. Dabei ist der Syndromgenerator SG 61 so konfiguriert, dass er die Komponenten des Fehlersyndroms s auf Basis der Prüfmatrix H (69) so bestimmt, dass gilt: $$\begin{array}{l}{s}_1^T=H_1\cdot {\left(v\text{'}\right)}^T\\ s_3^T=H_3\cdot {\left(v\text{'}\right)}^T\\ s_p=P\cdot {\left(v\text{'}\right)}^T=v_0^{\text{'}}+v_1^{\text{'}}+\cdots +v_{30}^{\text{'}}\end{array}$$

  
• Für i = 1, 2 sind die i-ten 5 binären Ausgänge des Syndromgenerators SG 61, die das Teilsyndrom s_2i-1 tragen, in die i-ten 5 binären Eingänge der Fehlererkennungseinheit FE 62, und in die i-ten 5 binären Eingänge des BCH-Decoder DEC BCH 64 geführt.
• Der BCH-Decoder DEC BCH 64 erzeugt auf Basis der Syndromkomponenten s₁ und s₃ einen Korrekturvektor $e\text{'}=\left(e_0^{\text{'}},e_1^{\text{'}},\dots ,e_{30}^{\text{'}}\right)$

  

  an seinen 31 binären Ausgängen. Dabei ist der BCH-Decoder DEC BCH 64 so konfiguriert, dass wenn die an den Eingängen bereitgestellten Teilsyndrome s₁, und s₃ dem Fehlersyndrom eines i-Bitfehlers in den Bitpositionen b₁, b₂, ..., b_i mit 0 ≤ b₁ < b₂ < ··· < b_i ≤ 30 entsprechen, ein Korrekturvektor e' erzeugt wird, der in den Komponenten $e_{b_1}^{\text{'}},e_{b_2}^{\text{'}},\dots ,e_{b_i}^{\text{'}}$

  

  eine binäre 1 und in allen anderen Komponenten eine binäre 0 aufweist. Zeigen die Teilsyndrome keinen Fehler an und gilt s₁ = s₃ = 0, so wird ein Korrekturvektor $e\text{'}=\left(e_0^{\text{'}},e_1^{\text{'}},\dots ,e_{30}^{\text{'}}\right)=\left(\mathrm{0,0,}\dots \mathrm{,0}\right)$

  

  an den Ausgängen des BCH-Decoders DEC BCH 64 erzeugt.
• Die ersten 5 binären Ausgänge des Syndromgenerators SG 61, die das Teilsyndrom s₁ tragen, sind zusätzlich mit dem 5-Bit breiten Eingang des Konstantenmultiplizierers 63 verbunden. Der Konstantenmultiplizierer 63 ist so konfiguriert, dass er ein modifiziertes Teilsyndrom $$s_1^{mod}=s_1\cdot {\left(1+\alpha +{\alpha }^2\right)}^{-1}$$

  

  an seinen 5 binären Ausgängen erzeugt, die in den 5-Bit breiten Eingang der Teilschaltung DEC (H₁) 65 geführt sind.
• Die Teilschaltung DEC (H₁) 65 basiert auf der Teilmatrix H₁ von Gleichung (69) und erzeugt auf Basis der Syndromkomponente s₁, einen Korrekturvektor $e"=\left(e_0^{"},e_1^{"},\dots ,e_{30}^{"}\right)$

  

  an ihren 31 binären Ausgängen.
• Die Teilschaltung DEC (H₁) 65 ist so konfiguriert, dass, wenn das Teilsyndrom s₁, dem Fehlersyndrom eines 1-Bitfehlers in der Bitposition b mit 0 ≤ b ≤ 30 entspricht, ein Korrekturvektor e'' erzeugt wird, der in der Komponente $e_b^{"}$

  

  eine binäre 1 und in allen anderen Komponenten eine binäre 0 aufweist. Zeigt das Teilsyndrom s₁ keinen Fehler an und gilt s₁ = 0, so wird ein Korrekturvektor $e"=\left(e_0^{"},e_1^{"},\dots ,e_{30}^{"}\right)=\left(\mathrm{0,0,}\dots \mathrm{,0}\right)$

  

  an den Ausgängen der Teilschaltung DEC (H₁) 65 erzeugt.
• Der binäre Ausgang des Syndromgenerators SG 61, der das 1-Bit breite Teilsyndrom s_p trägt, ist mit einem binären Eingang der Fehlererkennungseinheit FE 62 verbunden.
• Die Fehlererkennungseinheit FE 62 ist so konfiguriert, dass in Abhängigkeit von den Teilsyndromen s₁, s₃, s_p ein 1-Bit breites Fehlererkennungssignal det₃ an ihrem Ausgang erzeugt wird, das genau dann gleich 1 ist, wenn das binäre Wort v' durch einen 3-Bitfehler gestört ist. Die Fehlererkennung kann in diesem Beispiel durch Prüfung der Bedingungen $$\begin{array}{ccc}{s}_1^3\ne s_3& \text{und}& s_p=1\end{array}$$

  

  erfolgen.
• Im Falle eines 1-Bitfehler ist $\begin{array}{ccc}{s}_p=1& \text{und}& s_1^3=s_3\end{array},$

  

  
  bei einem 2-Bitfehler gilt $s_p=\mathrm{0,}{s}_1^3\ne s_3$

  

  und bei einem 3-Bitfehler ergibt sich $\begin{array}{ccc}{s}_p=1& \text{und}& s_1^3\ne s_3.\end{array}$

  
• Für das Fehlererkennungssignal gilt also:
• - det₃ = 1 genau dann, wenn $s_1^3\ne s_3$
  
  und s_p = 1
• Der algebraische Ausdruck $s_1^3$

  

  kann mit Hilfe von Galoisfeldmultiplizierern oder Potenzbildnern im Galoisfeld implementiert werden.
• Der 31-Bit breite Ausgang des BCH-Decoders DEC BCH 64, der den Korrekturvektor e' trägt, ist in den 31-Bit breiten 0-Eingang des Multiplexers MUX 66 geführt, während der 31-Bit breite Ausgang der Teilschaltung DEC (H₁) 65, der den Korrekturvektor e'' trägt, mit dem 31-Bit breiten 1-Eingang des Multiplexers MUX 66 verbunden ist.
• Der binäre Ausgang der Fehlererkennungseinheit FE 62 trägt das Signal det₃ zur 3-Bitfehler-Erkennung und wird sowohl mit einem jeweils zweiten 1-Bit breiten Eingang der UND-Gatter 671 bis 6730 verbunden, als auch in den 1-Bit breiten Kontrolleingang des Multiplexers MUX 66 geführt.
• Der erste Ausgang des Multiplexers MUX 66 trägt die binäre Komponente e₀ des Korrekturvektors e und ist in einen zweiten binären Eingang des XOR-Gatters 691 und in einen ersten Eingang des UND-Gatters 671 geführt, wobei der Ausgang des UND-Gatters 671 mit einem jeweils ersten Eingang der ODER-Gatter 681 und 682 verbunden ist. Die erste binäre Komponente $v_0^{\text{'}}$

  

  des möglicherweise fehlerhaften Wortes v' liegt an einem ersten Eingang des XOR-Gatters 691 an, an dessen Ausgang die erste Komponente $v_0^{cor}$

  

  des korrigierten Wortes v^cor erzeugt wird.
• Der zweite Ausgang des Multiplexers MUX 66 trägt die binäre Komponente e₁ des Korrekturvektors e und ist mit einem zweiten binären Eingang des ODER-Gatters 681 und mit einem ersten Eingang des UND-Gatters 672 verbunden, wobei der Ausgang des UND-Gatters 672 mit einem zweiten Eingang des ODER-Gatters 682 und mit einem ersten Eingang des ODER-Gatters 683 verbunden ist.
• Der Ausgang des ODER-Gatters 681 ist mit einem zweiten Eingang des XOR-Gatters 692 verbunden. Die zweite binäre Komponente $v_1^{\text{'}}$

  

  des möglicherweise fehlerhaften Wortes v' liegt an einem ersten Eingang des XOR-Gatters 692 an, an dessen Ausgang die zweite Komponente $v_1^{cor}$

  

  des korrigierten Wortes v^cor erzeugt wird.
• Für i = 3,...,29 trägt der i-te Ausgang des Multiplexers MUX 66 die binäre Komponente e_i-1 des Korrekturvektors e und ist in einen dritten Eingang des ODER-Gatters 68(i-1) und in einen ersten Eingang des UND-Gatters 67i geführt, wobei der Ausgang des UND-Gatters 67i mit einem zweiten Eingang des ODER-Gatters 68i und mit einem ersten Eingang des ODER-Gatters 68(i+1) verbunden ist.
• Der Ausgang des ODER-Gatters 68(i -1) ist mit einem zweiten Eingang des XOR-Gatters 69i verbunden, wobei an dessen ersten Eingang die i-te Komponente $v_{i-1}^{\text{'}}$

  

  des Wortes v' anliegt. Die i-te Komponente $v_{i-1}^{cor}$

  

  des korrigierten Wortes wird an dem binären Ausgang des XOR-Gatters 69i ausgegeben.
• Der vorletzte Ausgang des Multiplexers MUX 66 trägt die binäre Komponente e₂₉ des Korrekturvektors e und ist in einen dritten Eingang des ODER-Gatters 6829 und in einen ersten Eingang des UND-Gatters 6730 geführt, wobei der Ausgang des UND-Gatters 6730 mit einem zweiten Eingang des ODER-Gatters 6830 verbunden ist.
• Der Ausgang des ODER-Gatters 6829 ist mit einem zweiten Eingang des XOR-Gatters 6930 verbunden, wobei an dessen ersten Eingang die 30-te Komponente $v_{29}^{\text{'}}$

  

  des Wortes v' anliegt. Die 30-te Komponente $v_{29}^{cor}$

  

  des korrigierten Wortes wird am binären Ausgang des XOR-Gatters 6930 ausgegeben.
• Der letzte Ausgang des Multiplexers MUX 66 trägt die binäre Komponente e₃₀ und ist mit einem dritten Eingang des ODER-Gatters 6830 verbunden. Der Ausgang des ODER-Gatters 6830 ist in einen zweiten Eingang des XOR-Gatters 6931 geführt, an dessen erstem Eingang die binäre Komponente $v_{30}^{\text{'}}$

  

  des Wortes v' anliegt. Der Ausgang des XOR-Gatters 6931 trägt das Signal $v_{30}^{cor}.$

  
• Liegt ein 1-Bitfehler oder ein 2-Bitfehler vor, ist det₃ = 0 und der 0-Eingang des Multiplexers MUX 66, an dem der Korrekturvektor e' anliegt, ist mit dessen Ausgang verbunden; es gilt: e = e'.
• Liegt ein 3-Bitfehler vor, ist det₃ = 1 und der 1-Eingang des Multiplexers MUX 66, an dem der Korrekturvektor e'' anliegt, ist mit dessen Ausgang verbunden; es gilt: e = e''.
• Im Falle eines benachbarten 3-Bitfehlers ist das gestörte binäre Wort v' in drei Bitpositionen i, (i + 1) und (i + 2) für i ∈ {0,1,..., 28} gestört. Der Syndromgenerator SG 61 erzeugt dann an seinen Ausgängen das Fehlersyndrom $$\begin{array}{l}s=\left(\begin{array}{l}{s}_1\\ s_3\\ p\end{array}\right)=\left(\begin{array}{c}{\alpha }^i+{\alpha }^{\left(i+1\right)}+{\alpha }^{\left(i+2\right)}\\ {\alpha }^{3i}+{\alpha }^{3\left(i+1\right)}+{\alpha }^{3\left(i+2\right)}\\ 1\end{array}\right)\\ =\left(\begin{array}{c}{\alpha }^i\cdot \left(1+\alpha +{\alpha }^2\right)\\ {\alpha }^{3i}\cdot \left(1+{\alpha }^3+{\alpha }^{3\cdot 2}\right)\\ 1\end{array}\right),\end{array}$$

  

  dessen Teilsyndrom s₁ durch den Konstantenmultiplizierer 63 modifiziert wird. Der Konstantenmultiplizierer 63 ist so konfiguriert, dass das Teilsyndrom s₁ des Syndroms s, das dem Fehlersyndrom eines 3-Bitfehlers an den Bitpositionen [i, (i + 1), (i + 2)] entspricht, auf das modifizierte Teilsyndrom $s_1^{mod}$

  

  abgebildet wird, das dem Fehlersyndrom eines 1-Bitfehlers an der Bitposition [i] entspricht, wie das in der nachfolgenden Gleichung gezeigt ist: $$s_1^{mod}=s_1\cdot {\left(1+\alpha +{\alpha }^2\right)}^{-1}=\frac{{\alpha }^i\cdot \left(1+\alpha +{\alpha }^2\right)}{1+\alpha +{\alpha }^2}={\alpha }^i$$

  
• Beispiel: Korrektur von 4-Bitfehlern, die auf benachbarten 2-Bitfehlern basieren mittels Teilschaltung DEC (H₁,H₃)
• Im folgenden Beispiel wird erläutert, wie unter Verwendung eines BCH-Codes zur Korrektur von 1-Bitfehlern, 2-Bitfehlern und 3-Bitfehlern und durch Nutzung einer Teilschaltung DEC (H₁,H₃) eine Korrektur von 4-Bitfehlern, die sich aus zwei benachbarten 2-Bitfehlern zusammensetzen, erfolgen kann.
• Der verwendete BCH-Code basiert dabei auf der binären Prüfmatrix H gemäß der oben eingeführten Gleichung (52).
• 7 zeigt eine Schaltungsanordnung umfassend einen Syndromgenerator SG 71 mit n = 31 binären Eingängen und (3 · 5 + 1) = 16 binären Ausgängen, eine Fehlererkennungseinheit FE 72 mit (3 · 5 + 1) = 16 binären Eingängen und einem binären Ausgang, Konstantenmultiplizierer 731 und 732 mit jeweils 5 binären Eingängen und 5 binären Ausgängen, einen BCH-Decoder DEC BCH 74 mit (3 · 5) = 15 binären Eingängen und n = 31 binären Ausgängen, eine Teilschaltung DEC (H₁, H₃) 75 mit (2·5) = 10 binären Eingängen und n = 31 binären Ausgängen, einen Multiplexer 76 mit (2·31 + 1) = 63 binären Eingängen und 31 binären Ausgängen, 30 UND-Gatter 771 bis 7730 mit jeweils 2 binären Eingängen und einem binären Ausgang, 30 ODER-Gatter 781 bis 7830 mit jeweils 2 binären Eingängen und einem binären Ausgang und 31 XOR-Gatter 791 bis 7931 mit jeweils 2 binären Eingängen und einem binären Ausgang.
• Der Syndromgenerator SG 71 weist n = 31 binäre Eingänge auf, in die das möglicherweise fehlerhafte Binärwort $v\text{'}=\left(v_0^{\text{'}},v_1^{\text{'}},\dots ,v_{30}^{\text{'}}\right)$

  

  geführt ist. An seinem 16-Bit breiten Ausgang gibt der Syndromgenerator SG 71 ein Fehlersyndrom s = (s₁, s₃, s_p) der Wortbreite (3·5 + 1) aus. Dabei ist der Syndromgenerator SG 71 so konfiguriert, dass er die Komponenten des Fehlersyndroms s auf Basis der Prüfmatrix H (52) so bestimmt, dass gilt: $$\begin{array}{l}{s}_1^T=H_1\cdot {\left(v\text{'}\right)}^T\\ s_3^T=H_3\cdot {\left(v\text{'}\right)}^T\\ s_5^T=H_5\cdot {\left(v\text{'}\right)}^T\\ s_p=P\cdot {\left(v\text{'}\right)}^T=v_0^{\text{'}}+v_1^{\text{'}}+\dots +v_{30}^{\text{'}}\end{array}$$

  
• Für i = 1,2,3 sind die i-ten 5 binären Ausgänge des Syndromgenerators SG 71, die das Teilsyndrom s_2i-1 tragen, in die i-ten 5 binären Eingänge der Fehlererkennungseinheit FE 72 und in die i-ten 5 binären Eingänge des BCH-Decoder DEC BCH 74 geführt.
• Der BCH-Decoder DEC BCH 74 erzeugt auf Basis der Syndromkomponenten s₁, s₃ und s₅ einen Korrekturvektor $e\text{'}=\left(e_0^{\text{'}},e_1^{\text{'}},\dots ,e_{30}^{\text{'}}\right)$

  

  an seinen 31 binären Ausgängen. Dabei ist der BCH-Decoder DEC BCH 74 so konfiguriert, dass, wenn die Teilsyndrome dem Fehlersyndrom eines i-Bitfehlers in den Bitpositionen b₁, b₂,..., b_i mit 0 ≤ b₁ < b₂ < ··· < b_i ≤ 30 entsprechen, ein Korrekturvektor e' erzeugt wird, der in den Komponenten $e_{b_1}^{\text{'}},e_{b_2}^{\text{'}},\dots ,e_{b_i}^{\text{'}}$

  

  eine binäre 1 und in allen anderen Komponenten eine binäre 0 aufweist. Zeigen die Teilsyndrome keinen Fehler an und gilt s₁ = s₃ = s₅ = 0, so wird ein Korrekturvektor $e\text{'}=\left(e_0^{\text{'}},e_1^{\text{'}},\dots ,e_{30}^{\text{'}}\right)=\left(\mathrm{0,0,}\dots \mathrm{,0}\right)$

  

  an den Ausgängen des BCH-Decoders DEC BCH 74 erzeugt.
• Die ersten 5 binären Ausgänge des Syndromgenerators SG 71, die das Teilsyndrom s₁ tragen, sind zusätzlich mit dem 5-Bit breiten Eingang des Konstantenmultiplizierers 731 verbunden. Die zweiten 5 binären Ausgänge des Syndromgenerators SG 71, die das Teilsyndrom s₃ tragen, sind zusätzlich mit dem 5-Bit breiten Eingang des Konstantenmultiplizierers 732 verbunden.
• Für i = 1, 2 ist der Konstantenmultiplizierer 73i so konfiguriert, dass er ein modifiziertes Teilsyndrom $$s_{2i-1}^{mod}=s_{2i-1}\cdot {\left(1+{\alpha }^{2i-1}\right)}^{-1}$$

  

  an seinen 5 binären Ausgängen erzeugt, die mit den i-ten 5 binären Eingängen der Teilschaltung DEC (H₁, H₃) 75 verbunden sind.
• Die Teilschaltung DEC (H₁,H₃) 75 basiert auf den Teilmatrizen H₁ und H₃ von Gleichung (52) und erzeugt auf Basis der Syndromkomponenten $s_1^{mod}\text{ und }{s}_3^{mod}$

  

  einen Korrekturvektor $e"=\left(e_0^{"},e_1^{"},\dots ,e_{30}^{"}\right)$

  

  an seinen 31 binären Ausgängen. Die Teilschaltung DEC (H₁,H₃) 75 ist so konfiguriert, dass, wenn die Teilsyndrome $s_1^{mod},s_3^{mod}$

  

  dem Fehlersyndrom eines 2-Bitfehlers in den Bitpositionen b₁ und b₂ mit 0 ≤ b₁ < b₂ ≤ 30 entsprechen, ein Korrekturvektor e'' erzeugt wird, der in den Komponenten $e_{b1}^{"}\text{ und }{e}_{b2}^{"}$

  

  eine binäre 1 und in allen anderen Komponenten eine binäre 0 aufweist.
• Der binäre Ausgang des Syndromgenerators SG 71, der das 1-Bit breite Teilsyndrom s_p trägt, ist mit einem binären Eingang der Fehlererkennungseinheit FE 72 verbunden.
• Die Fehlererkennungseinheit FE 72 ist so konfiguriert, dass in Abhängigkeit von den Teilsyndromen s₁, s₃, s₅, s_p ein 1-Bit breites Fehlererkennungssignal det₄ an ihrem Ausgang erzeugt wird, das genau dann gleich 1 ist, wenn das binäre Wort v' durch einen 4-Bitfehler gestört ist. Die Fehlererkennung kann in diesem Beispiel durch Prüfung der Bedingungen $$s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2\ne 0\text{ und }{s}_p=0$$

  

  erfolgen. Der algebraische Ausdruck $s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2$

  

  kann mit Hilfe von Galoisfeldmultiplizierern, Addierern und Potenzbildnern im Galoisfeld implementiert werden.
• Die 31-Bit breite Ausgang des BCH-Decoders DEC BCH 74, der den Korrekturvektor e' trägt, ist in den 31-Bit breiten 0-Eingang des Multiplexers MUX 76 geführt, während der 31-Bit breite Ausgang der Teilschaltung DEC (H₁,H₃) 75, der den Korrekturvektor e'' trägt, mit dem 31-Bit breiten 1-Eingang des Multiplexers MUX 76 verbunden ist.
• Der binäre Ausgang der Fehlererkennungseinheit FE 72 trägt das Signal det₄ zur 4-Bitfehler-Erkennung und wird sowohl mit einem jeweils zweiten 1-Bit breiten Eingang der UND-Gatter 771 bis 7730 verbunden als auch in einen 1-Bit breiten Kontrolleingang des Multiplexers MUX 76 geführt.
• Der erste Ausgang des Multiplexers MUX 76 trägt die binäre Komponente e₀ des Korrekturvektors und ist in einen zweiten binären Eingang des XOR-Gatters 791 und in einen ersten Eingang des UND-Gatters 771 geführt, wobei der Ausgang des UND-Gatters 771 mit einem ersten Eingang des ODER-Gatters 781 verbunden ist. Die erste binäre Komponente $v_0^{\text{'}}$

  

  des möglicherweise fehlerhaften Wortes v' liegt an einem ersten Eingang des XOR-Gatters 791 an, an dessen Ausgang die erste Komponente $v_0^{cor}$

  

  des korrigierten Wortes v^cor erzeugt wird.
• Für i = 2,3,..., 30 trägt der i-te Ausgang des Multiplexers MUX 76 die binäre Komponente e_i-1 des Korrekturvektors und ist in einen zweiten Eingang des ODER-Gatters 78(i - 1) und in einen ersten Eingang des UND-Gatters 77i geführt, wobei der Ausgang des UND-Gatters 77i mit einem ersten Eingang des ODER-Gatters 78i verbunden ist. Der Ausgang des ODER-Gatters 78(i - 1) ist mit einem zweiten Eingang des XOR-Gatters 79i verbunden, wobei an dessen ersten Eingang die i-te Komponente $v_{i-1}^{\text{'}}$

  

  des Wortes v' anliegt. Die i-te Komponente $v_{i-1}^{cor}$

  

  korrigierten Wortes wird am binären Ausgang des XOR-Gatters 79i ausgegeben.
• Der letzte Ausgang des Multiplexers MUX 76 trägt die binäre Komponente e₃₀ und ist mit einem zweiten Eingang des ODER-Gatters 7830 verbunden. Der Ausgang des ODER-Gatters 7830 ist in einen zweiten Eingang des XOR-Gatters 7931 geführt, an dessen erstem Eingang die binäre Komponente $v_{30}^{\text{'}}$

  

  des Wortes v' anliegt.
• Der Ausgang des XOR-Gatters 7931 trägt das Signal $v_{30}^{cor}.$

  
• Liegt ein 1-Bitfehler, 2-Bitfehler oder 3-Bitfehler vor, ist det₄ = 0 und der 0-Eingang des Multiplexers MUX 76, an dem der Korrekturvektor e' anliegt, ist mit dessen Ausgang verbunden; es gilt: e = e'.
• Liegt ein 4-Bitfehler vor, ist det₄ = 1 und der 1-Eingang des Multiplexers MUX 76, an dem der Korrekturvektor e'' anliegt, ist mit dessen Ausgang verbunden; es gilt: e = e''.
• Im Falle eines 4-Bitfehlers, der sich aus zwei benachbarten 2-Bitfehlern zusammensetzt, ist das gestörte binäre Wort v' in vier Bitpositionen i, (i + 1) und j, (j + 1) für i, j ∈ {0,1,..., 29} gestört. Der Syndromgenerator SG 71 erzeugt dann an seinen Ausgängen das Fehlersyndrom $$\begin{array}{c}s=\left(\begin{array}{l}{s}_1\\ s_3\\ s_5\\ s_P\end{array}\right)=\left(\begin{array}{c}{\alpha }^i+{\alpha }^{\left(i+1\right)}+{\alpha }^j+{\alpha }^{\left(j+1\right)}\\ {\alpha }^{3i}+{\alpha }^{3\left(i+1\right)}+{\alpha }^{3j}+{\alpha }^{3\left(j+1\right)}\\ {\alpha }^{5i}+{\alpha }^{5\left(i+1\right)}+{\alpha }^{5j}+{\alpha }^{5\left(j+1\right)}\\ 0\end{array}\right)\\ =\left(\begin{array}{c}{\alpha }^i\cdot \left(1+\alpha \right)+{\alpha }^j\cdot \left(1+\alpha \right)\\ {\alpha }^{3i}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3\right)\\ {\alpha }^{5i}\cdot \left(1+{\alpha }^5\right)+{\alpha }^{5j}\cdot \left(1+{\alpha }^5\right)\\ 0\end{array}\right),\end{array}$$

  

  dessen Teilsyndrome s₁ und s₃ durch die Konstantenmultiplizierer 731 und 732 modifiziert werden. Die Konstantenmultiplizierer 731 und 732 sind so konfiguriert, dass die unveränderten Teilsyndrome, die dem Fehlersyndrom eines 4-Bitfehlers in den Bitpositionen [i, (i + 1), j, (j + 1)] entsprechen, auf die modifizierten Teilsyndrome $s_1^{mod}\text{ und }{s}_3^{mod}$

  

  abgebildet werden, die dem Fehlersyndrom eines 2-Bitfehlers in den Bitpositionen [i, j] entsprechen, wie das in den nachfolgenden Gleichungen gezeigt ist: $$\begin{array}{l}{s}_1^{mod}=s_1\cdot {\left(1+\alpha \right)}^{-1}=\frac{{\alpha }^i\cdot \left(1+\alpha \right)+{\alpha }^j\cdot \left(1+\alpha \right)}{1+\alpha }={\alpha }^i+{\alpha }^j\\ s_3^{mod}=s_3\cdot {\left(1+{\alpha }^3\right)}^{-1}=\frac{{\alpha }^{3i}\cdot \left(1+{\alpha }^3\right)+{\alpha }^{3j}\cdot \left(1+{\alpha }^3\right)}{1+{\alpha }^3}={\alpha }^{3i}+{\alpha }^{3j}\end{array}$$

  
• Beispielhafte Implementierung einer Fehlererkennungsschaltung
• 8 zeigt eine mögliche Implementierung der Fehlererkennungsschaltung FE 12 aus 2 oder 3. 8 umfasst einen Dritte-Potenzbildner 81 mit 5 binären Eingängen und 5 binären Ausgängen, Galoisfeld-Quadrierer 821 und 822 mit jeweils 5 binären Eingängen und 5 binären Ausgängen, Galoisfeld-Multiplizierer 831 und 832 mit jeweils zwei 5-Bit breiten Eingängen und 5 binären Ausgängen, ODER-Gattern 841, 842, 843 und 844 mit jeweils 5 binären Eingängen und einem binären Ausgang, ein ODER-Gatter 845 mit 3 binären Eingängen und einem binären Ausgang, Galoisfeld-Addierern 851, 852 und 853 mit jeweils zwei 5-Bit breiten Eingängen und 5 binären Ausgängen zur komponentenweisen XOR-Verknüpfung ihrer Eingänge, UND-Gatter 861, 862 und 863 mit jeweils 2 binären Eingängen und einem binären Ausgang und ein UND-Gatter 864 mit 3 binären Eingängen und einem binären Ausgang.
• Die ersten 5 binären Eingänge der Teilschaltung, die das Teilsyndrom s₁ tragen, sind mit den 5 binären Eingängen des Dritte-Potenzbildners 81, mit einem ersten 5-Bit breiten Eingang des Multiplizierers 831 und den 5 binären Eingängen des ODER-Gatters 841 verbunden.
• Die zweiten 5 binären Eingänge der Teilschaltung, die das Teilsyndrom s₃ tragen, sind mit den 5 binären Eingängen des Quadrierers 821, mit einem zweiten 5-Bit breiten Eingang des Multiplizierers 832 und den 5 binären Eingängen des ODER-Gatters 842 verbunden.
• Die dritten 5 binären Eingänge der Teilschaltung, die das Teilsyndrom s₅ tragen, sind mit dem zweiten 5-Bit breiten Eingang des Multiplizierers 831 und den 5 binären Eingängen des ODER-Gatters 843 verbunden.
• Der Ausgang des Dritte-Potenzbildners 81, der das Signal $s_1^3$

  

  trägt, ist in den ersten 5-Bit breiten Eingang des Multiplizierers 832 und die in die 5 binären Eingänge des Quadrierers 822 geführt, dessen Ausgang das Signal $s_1^6$

  

  trägt und mit einem ersten 5-Bit breiten Eingang des Addierers 853 verbunden ist.
• Der Ausgang des Quadrierers 821 trägt das Signal $s_3^2$

  

  und ist in einen ersten 5-Bit breiten Eingang des Addierers 851 geführt, dessen zweiter 5-Bit breiter Eingang mit dem Ausgang des Galoisfeldmultiplizierers 831 verbunden ist.
• Der Ausgang des Addierers 851 ist in einen zweiten 5-Bit breiten Eingang des Addierers 852 geführt. Der erste 5-Bit breite Eingang des Addierers 852 ist mit dem Ausgang des Galoisfeldmultiplizierers 832 verbunden. Der Ausgang des Addierers 852 ist in den zweiten 5-Bit breiten Eingang des Addierers 853 geführt, dessen Ausgang das Signal $s_1^3{s}_3+s_1{s}_5+s_1^6+s_3^2$

  

  trägt und mit den 5 binären Eingängen des ODER-Gatters 844 verbunden ist.
• Für i = 1, 2, 3 ist der Ausgang der 1-Bit breite Ausgang des ODER-Gatters 84i in den i-ten Eingang des ODER-Gatters 845 geführt, dessen Ausgang mit einem dritten binären Eingang des UND-Gatters 864 verbunden ist.
• Der Ausgang des ODER-Gatters 844 ist sowohl in einen jeweils negierten zweiten Eingang der UND-Gatter 861 und 864 geführt, als auch mit einem jeweils zweiten Eingang der UND-Gatter 862 und 863 verbunden.
• Die letzte binäre Eingang der Teilschaltung, der das Teilsyndrom s_p trägt, ist in den jeweils ersten Eingang der UND-Gatter 861 und 862 geführt, als auch mit einem jeweils negierten ersten Eingang der UND-Gatter 863 und 864 verbunden.
• Das Signal det₁ zur 1-Bitfehler-Erkennung wird am Ausgang des UND-Gatters 861 erzeugt, das Signal det₂ zur 2-Bitfehler-Erkennung wird am Ausgang des UND-Gatters 864 erzeugt, das Signal det₃ zur 3-Bitfehler-Erkennung wird am Ausgang des UND-Gatters 862 erzeugt und das Signal det₄ zur 4-Bitfehler-Erkennung wird am Ausgang des UND-Gatters 863 erzeugt.
• Obwohl die Erfindung im Detail durch das mindestens eine gezeigte Ausführungsbeispiel näher illustriert und beschrieben wurde, so ist die Erfindung nicht darauf eingeschränkt und andere Variationen können vom Fachmann hieraus abgeleitet werden, ohne den Schutzumfang der Erfindung zu verlassen.

Claims (28)

1. Verfahren zur Korrektur eines Fehlers in einem Fehlermuster, - bei dem die Korrektur des Fehlers unter Verwendung eines modifizierten Fehlersyndroms durchgeführt wird, - wobei das modifizierte Fehlersyndrom unter Verwendung des Fehlermusters bestimmt ist, - wobei die Korrektur mittels eines Fehlercodes mit einem Codeabstand 2(t + 1) für K Fehlermuster aus jeweils M Bits durchgeführt wird und bei dem K · M = t + 1, t ≥ 2, K ≥ 1 und M ≥ 2 gelten.
2. Verfahren nach Anspruch 1, bei dem das modifizierte Fehlersyndrom und ein unmodifiziertes Fehlersyndrom Teilsyndrome aufweisen und ein Teilsyndrom des modifizierten Fehlersyndroms aus einem entsprechenden Teilsyndrom des unmodifizierten Fehlersyndroms unter Verwendung des Fehlermusters bestimmt ist.
3. Verfahren nach Anspruch 2, bei dem ein Teilsyndrom des modifizierten Fehlersyndroms aus einem entsprechenden Teilsyndrom des unmodifizierten Fehlersyndroms durch Multiplikation mit einer Konstanten bestimmt ist.
4. Verfahren nach einem der vorhergehenden Ansprüche, bei dem das Fehlermuster benachbarte Bits aufweist.
5. Verfahren nach einem der vorhergehenden Ansprüche, bei dem das Fehlermuster mindestens zwei Bits oder mindestens zwei Bitpositionen aufweist.
6. Verfahren nach einem der vorhergehenden Ansprüche, bei dem das Fehlermuster eine Anzahl von M Bits aufweist, wobei jedes weitere Bit des Fehlermusters durch einen Abstand von einem ersten Bit des Fehlermusters bestimmt ist.
7. Verfahren nach einem der vorhergehenden Ansprüche, bei dem dann, wenn mindestens ein Bit des Fehlermusters fehlerhaft ist, ein erstes Bit des Fehlermusters aus dem modifizierten Fehlersyndrom bestimmt ist.
8. Verfahren nach einem der vorhergehenden Ansprüche, bei dem die Korrektur basierend auf einer Anzahl der Fehlermuster durchgeführt wird.
9. Verfahren nach einem der vorhergehenden Ansprüche, bei dem eine Anzahl von K zu korrigierende erste Bits der K gleichen Fehlermuster unter Verwendung des modifizierten Fehlersyndroms bestimmt sind.
10. Verfahren nach Anspruch 9, bei dem die K Fehlermuster jeweils M Bits umfassen, die den Wert 1 aufweisen.
11. Verfahren nach einem der vorhergehenden Ansprüche, - bei dem der Fehlercode mit dem Codeabstand 2(t + 1) ein t-Bitfehler korrigierender BCH-Code über einem Galoisfeld GF(2^m) mit einbezogener Gesamtparität und einer H-Matrix $$H=\left(\begin{array}{c}{H}_1\\ H_3\\ ⋮\\ H_{2t-1}\\ P\end{array}\right)$$

    

    ist, - bei dem Teilsyndrome $s_1^{mod},s_3^{mod},\dots ,s_{2K-1}^{mod}$

    

    des modifizierten Fehlersyndroms aus den unmodifizierten Teilsyndromen s₁, s₃,..., s_2K-1 des Fehlersyndroms des BCH-Codes gemäß $$\begin{array}{l}{s}_1^{mod}=s_1\cdot {\beta }_1^{-1},\hfill \\ s_3^{mod}=s_3\cdot {\beta }_3^{-1},\hfill \\ ⋮\hfill \\ s_{2K-1}^{mod}=s_{2K-1}\cdot {\beta }_{2K-1}^{-1},\hfill \end{array}$$

    

    bestimmt sind, wobei s_i ein Teilsyndrom des Fehlersyndroms, $s_i^{mod}$

    

    ein Teilsyndrom des modifizierten Fehlersyndroms, β_i eine Konstante und i = 1,..., (2K-1) eine Laufvariable bezeichnen.
12. Verfahren nach Anspruch 11, bei dem zusätzlich eine Korrektur von beliebigen τ-Bitfehlern mit 1 ≤ τ ≤ t erfolgt, wobei im Falle eines τ-Bitfehlers mit 1 ≤ τ ≤ t die zu korrigierenden τ Bitpositionen durch die Teilsyndrome s₁, s₃, ... , s_2t-1 bestimmt sind.
13. Verfahren nach einem der Ansprüche 11 oder 12, - mit $$\begin{array}{c}{H}_1=\left({\alpha }^{i_1},{\alpha }^{i_1+d},\dots ,{\alpha }^{i_1+\left(n-1\right)\cdot d}\right)\\ H_3=\left({\alpha }^{3\cdot i_1},{\alpha }^{3\cdot \left(i_1+d\right)},\dots ,{\alpha }^{3\cdot \left(i_1+\left(n-1\right)\cdot d\right)}\right)\\ ⋮\\ H_{2t-1}=\left({\alpha }^{\left(2t-1\right)\cdot i_1},{\alpha }^{\left(2t-1\right)\cdot \left(i_1+d\right)},\dots ,{\alpha }^{\left(2t-1\right)\cdot \left(i_1+\left(n-1\right)\cdot d\right)}\right)\\ P=\underset{n}{\underbrace{\left(\mathrm{1,1,}\dots \mathrm{,1}\right)}},\end{array}$$

    

    - wobei die Operationen in den Exponenten der Elemente der H-Matrix modulo 2^m - 1 auszuführen sind, - wobei α ein erzeugendes Element des Galoisfelds GF(2^m) ist und - wobei die Elemente α^j der H-Matrix Elemente des Galoisfelds GF(2^m) in ihrer Vektordarstellung als m-dimensionale binäre Spaltenvektoren sind.
14. Verfahren nach Anspruch 13, bei dem gelten: $$\begin{array}{c}{i}_1=0\\ d=1\\ H_1=\left({\alpha }^0,{\alpha }^1,\dots ,{\alpha }^{n-1}\right)\\ H_3=\left({\alpha }^0,{\alpha }^3,\dots ,{\alpha }^{\left(n-1\right)\cdot 3}\right)\\ ⋮\\ H_{2t-1}=\left({\alpha }^0,{\alpha }^{\left(2t-1\right)},\dots ,{\alpha }^{\left(n-1\right)\cdot \left(2t-1\right)}\right).\end{array}$$

    
15. Verfahren nach einem der Ansprüche 13 oder 14, bei dem die Konstanten β₁, β₃, ..., β_2t-1 so bestimmt sind, dass für einen Fehler, der K gleiche Fehlermuster F_m mit dem normierten Fehlervektor $e_{Fm}^{norm}$

    

    aufweist, gilt $$\begin{array}{l}{\beta }_1\cdot {\alpha }^{i_1}=H_1\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ {\beta }_3\cdot {\alpha }^{3\cdot i_1}=H_3\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}\cdot {\alpha }^{\left(2t-1\right)\cdot i_1}=H_{2t-1}\cdot {\left[e_{Fm}^{norm}\right]}^T.\hfill \end{array}$$

    
16. Verfahren nach einem der Ansprüche 13 oder 14, bei dem die Konstanten β₁, β₃, ..., β_2t-1 so bestimmt sind, dass für einen Fehler, der K gleiche Fehlermuster F_m mit dem normierten Fehlervektor $e_{Fm}^{norm}$

    

    aufweist, gilt $$\begin{array}{l}{\beta }_1=H_1\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ {\beta }_3=H_3\cdot {\left[e_{Fm}^{norm}\right]}^T\hfill \\ ⋮\hfill \\ {\beta }_{2t-1}=H_{2t-1}\cdot {\left[e_{Fm}^{norm}\right]}^T.\hfill \end{array}$$

    
17. Verfahren nach einem der Ansprüche 13 bis 16, bei dem für das Fehlermuster $$F_m=\left[M,D_1,\dots ,D_{M-1}\right]$$

    

    gilt $$\begin{array}{l}{H}_1\cdot e_{Fm}^{norm}={\alpha }^{i_1}\cdot \left(1+{\alpha }^{D_1\cdot d}+{\alpha }^{\left(D_1+D_2\right)\cdot d}+\dots +{\alpha }^{\left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}\right)\hfill \\ H_3\cdot e_{Fm}^{norm}={\alpha }^{3\cdot i_1}\cdot \left(1+{\alpha }^{3\cdot D_1\cdot d}+{\alpha }^{3\cdot \left(D_1+D_2\right)\cdot d}+\dots +{\alpha }^{3\cdot \left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}\right)\hfill \\ ⋮\hfill \\ \begin{array}{l}{H}_{2t-1}\cdot e_{Fm}^{norm}={\alpha }^{\left(2t-1\right)i_1}\cdot (1+{\alpha }^{\left(2t-1\right)\cdot D_1\cdot d}+{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2\right)\cdot d}+\dots +\hfill \\ +{\alpha }^{\left(2t-1\right)\cdot }{}^{\left(D_1+D_2+\dots +D_{M-1}\right)\cdot d}).\hfill \end{array}\hfill \end{array}$$

    
18. Verfahren nach einem der Ansprüche 13 bis 16, bei dem für das Fehlermuster $$F_m=\left[M,D_1,\dots ,D_{M-1}\right]$$

    

    gilt $$\begin{array}{l}{H}_1\cdot e_{Fm}^{norm}=1+{\alpha }^{D_1}+{\alpha }^{\left(D_1+D_2\right)}+\dots +{\alpha }^{\left(D_1+D_2+\dots +D_{M-1}\right)}\hfill \\ H_3\cdot e_{Fm}^{norm}=1+{\alpha }^{3\cdot D_1}+{\alpha }^{3\cdot \left(D_1+D_2\right)}+\dots +{\alpha }^{3\cdot \left(D_1+D_2+\dots +D_{M-1}\right)}\hfill \\ ⋮\hfill \\ H_{2t-1}\cdot e_{Fm}^{norm}=1+{\alpha }^{\left(2t-1\right)\cdot D_1}+{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2\right)}+\dots +{\alpha }^{\left(2t-1\right)\cdot \left(D_1+D_2+\dots +D_{M-1}\right)}.\hfill \end{array}$$

    
19. Verfahren nach einem der vorhergehenden Ansprüche, bei dem die Korrektur eines Fehlers eine Korrektur eines Fehlervektors umfasst, wobei der Fehlervektor mindestens ein Fehlermuster umfasst.
20. Verfahren nach Anspruch 19, bei dem das erste Bit des Fehlermusters nur vorgegebene Bitpositionen des Fehlervektors annehmen kann.
21. Verfahren nach einem der Ansprüche 19 oder 20, bei dem das Fehlermuster aus zwei Bits besteht und der Fehlervektor eines 4-Bitfehlers aus zwei 2-Bitfehlern besteht.
22. Verfahren nach einem der Ansprüche 19 oder 20, bei dem das Fehlermuster aus zwei Bits besteht und der Fehlervektor eines 6-Bitfehlers aus drei 2-Bitfehlern besteht.
23. Verfahren nach einem der Ansprüche 19 oder 20, bei dem das Fehlermuster aus drei Bits besteht und der Fehlervektor eines 6-Bitfehlers aus zwei 3-Bitfehlern besteht.
24. Verfahren nach einem der vorhergehenden Ansprüche, bei dem das Verfahren wenigstens teilweise durch eine Schaltungsanordnung in Hardware und/oder wenigstens teilweise mittels Software implementiert ist.
25. Verfahren nach einem der vorhergehenden Ansprüche, bei dem ein einer Anzahl der Fehler entsprechendes Lokatorpolynom iterativ nach dem Berlekamp-Massey-Algorithmus bestimmt wird.
26. Vorrichtung zur Korrektur eines Fehlers, wobei die Vorrichtung eine Verarbeitungseinheit aufweist, die derart eingerichtet ist, dass - die Korrektur des Fehlers mittels modifizierter Fehlersyndrome durchführbar ist, - wobei der Fehler auf mindestens einem Fehlermuster basiert, - wobei die Korrektur mittels eines Fehlercodes mit einem Codeabstand 2(t + 1) für K Fehlermuster aus jeweils M Bits durchgeführt wird und bei dem K · M = t + 1, t ≥ 2, K ≥ 1 und M ≥ 2 gelten.
27. 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 25 durchzuführen.
28. Computerlesbares Speichermedium umfassend von einem Computer ausführbare Anweisungen, die dazu geeignet sind, dass der Computer Schritte des Verfahrens nach einem der Ansprüche 1 bis 25 durchführt.

Images