Patent Publication Number: US-2022231704-A1

Title: Correction of bit errors

Description:
REFERENCE TO RELATED APPLICATIONS 
     This Application claims priority to German Application number 10 2021 101 157.4, filed on Jan. 20, 2021 and German Application number 10 2021 133 678.3, filed on Dec. 17, 2021. The contents of the above-referenced Patent Applications are hereby incorporated by reference in their entirety. 
    
    
     TECHNICAL FIELD 
     The correction and/or detection of bit errors in binary data, for example sequences of a plurality of bits, using error codes is known. 
     BACKGROUND 
     An error code can be an error-correcting code, an error-detecting code, or a combination of an error-detecting and error-correcting code. An example of an error code is the Bose—Chaudhuri—Hocquenghem (BCH) code. 
     In the context of a BCH code, bit error positions can be corrected based on the zeros of a locator polynomial of the BCH code. A specific procedure for 2-bit error correction in a Galois field GF(2 m ) can start with an appropriate second order locator polynomial, and this polynomial is transformed such that of the zeros of the transformed polynomial are determinable by a parameter of word width m. This parameter is determined from the syndrome components. Following their determination, the zeros of the transformed polynomial are to be transformed into the zeros of the original locator polynomial. Using a decoder, the bit positions to be corrected can be calculated from the zeros of the original locator polynomial. 
     A disadvantage here is that it takes a relatively long time until the erroneous bit positions can be corrected because the parameter of the transformed locator polynomial is initially determined from the syndrome components. After the zeros of the transformed polynomial have been determined, it is still necessary to transform the zeros of the transformed polynomial into the zeros of the original locator polynomial. 
     A further known option for error correction using a BCH code consists of initially determining, from the syndrome components of the error syndrome, the locator polynomial whose zeros then in turn specify the bit positions to be corrected. In this case, the zeros of the locator polynomial can be determined according to Chien&#39;s algorithm. In some regards, the locator polynomial is referred to as “error-location polynomial”. A disadvantage in this case is the great time outlay for determining the zeros of the locator polynomial. 
     SUMMARY 
     The present disclosure provides techniques for accelerating error correction and hence being able to carry out a faster error correction. 
     In some embodiments, a method is proposed for processing a bit sequence. The method determines a first partial error syndrome si of an error syndrome and a second partial error syndrome s 2  of the error syndrome for the bit sequence. The method also determines a first comparison value based on a bit position and the first partial error syndrome, and determines a second comparison value based on the bit position and the second partial error syndrome. A bit value at the bit position is changed to a corrected bit value when a comparison of the first comparison value with the second comparison value assume a specified value. Otherwise the bit value is not changed and, thus, is left at the bit value. The bit position can located in the error syndrome (e.g., the first partial errror syndrome and/or the second partial error syndrome), and thus could correspond to a transformed bit sequence, which is based on the bit sequence. 
     Consequently, an error at the bit position may be corrected (or else not corrected) depending on a result of the comparison. In this case, it is advantageous that the two comparison values are determined locally only in relation to the current bit position and which further bit position is erroneous need not be known at this time, for example even in the case of a 2-bit error correction. 
     In some embodiments, an error code capable of correcting at least a 2-bit error is used for the correction. 
     In some embodiments, the error code is a BCH code. 
     In some embodiments, the bit position is corrected should the first comparison value equal the second comparison value. 
     In a development, the first partial error syndrome Si and the second partial error syndrome S 2  each have m components of the error syndrome and m&gt;2. 
     In a development, the bit position is assigned a value β, the first comparison value is determined as (S 1 +β) k  and the second comparison value is determined as S 2 +β k , wherein k≠=0, and S 1 , S 2  and β are elements of a Galois field. 
     By way of example, S 1 , S 2  and β can be elements of the Galois field GF(2m). The operation “+” then denotes addition in the Galois field and (S 1 +β) k  and β k  denote the k-th power of S 1 +β and β, respectively, in the Galois field. 
     The approach described here can be used advantageously for correcting a bit position when a 2-bit error and/or a 1-bit error occur. 
     In some embodiments, the Galois field is GF(2 m )and m&gt;2. 
     In some embodiments, r bit positions i 0 , i 1 , . . . , i r−1  of the bit sequence are assigned r values α i     0   , α i     1   , α i     2   , α i     r−1   , wherein first comparison values and second comparison values are determined for bit positions to be corrected, wherein r≥1 and α is a generator of the Galois field. 
     In some embodiments, k=3 or k=−1. 
     In some embodiments, the method is used for error correction of a 2-bit error at bit positions i and j, wherein the first partial error syndrome is determined as s 1 =α i + j  and wherein the second partial error syndrome is determined as s 2 =α k·i +α k·j . The comparison supplies a correction signal for correcting the i-th bit. The correction signal is determined such that it assumes a first value if (s 1 +α i ) k =s 2 α k·i  applies, and assumes a second value if (s 1 α i ) k ≠s 2 α k·i  applies, wherein α i , α j , α k·i , α k·j  are elements of a Galois field GF(2 m ), m≥3 and k is an integer not equal to 0, and + denotes addition in the Galois field. 
     In some embodiments, a plurality of correction signals are determined, in each case one for a different bit, wherein the plurality of correction signals are at least partially determined with overlapping timing. 
     Consequently, the plurality of correction signals can be determined for example in parallel, e.g., simultaneously by parts of an item of hardware in particular. In this case, “parallel” can be understood to mean that the correction signals are not only determined in sequential fashion but are at least partially determined simultaneously. Consequently, there can be at least two correction signals which are determined simultaneously or parts which lead to these correction signals may be determined simultaneously. 
     In some embodiments, different correction signals are determined by means of different components. 
     Each of these components may comprise at least one hardware component and/or at least one software component. 
     In some embodiments, the first comparison value and the second comparison value are at least partially determined simultaneously. 
     In some embodiments, a third partial error syndrome is determined. 
     In some embodiments, the third partial error syndrome is a syndrome of a 3-bit error-correcting BCH code. 
     In some embodiments, the specified value in the correction of a 2-bit error is constant. 
     In some embodiments, in the correction of the 3-bit error, the specified value is determined on the basis of the respective bit position to be corrected. 
     In some embodiments, when the bit position to be corrected is an erroneous first bit of a 3-bit error, the specified value equals the value of the product of the second and the third bit position and the sum of the second and the third bit position, where the second bit position represents the position of the second bit error and the third bit position represents the position of the third bit error and where the product and the sum of the bit positions are determined in a Galois field GF(2 m ). 
     In some embodiments, the specified value is determined on the basis of a symmetric function of the erroneous bit positions. 
     In some embodiments, the symmetric function is determined using partial error syndromes of a BCH code. 
     In some embodiments, a parity is determined for the bit sequence. 
     In some embodiments, the specified value is constant if the parity of the bit sequence equals 0 and the partial error syndrome si is not equal to 0. 
     In some embodiments, the specified value is constant if the parity of the bit sequence equals 1 and s 1   3 =s 2 , where si is the first partial error syndrome and s 2  is the second partial error syndrome. 
     In some embodiments, a device for processing a bit sequence is also proposed, said device being configured to: determine a first partial error syndrome si of an error syndrome and a second partial error syndrome s 2  of the error syndrome for the bit sequence, determine a first comparison value on the basis of a bit position and the first partial error syndrome, determine a second comparison value on the basis of the bit position and the second partial error syndrome, correct the bit position should a comparison between the first comparison value and the second comparison value assume a specified value, not correct the bit position should the comparison between the first comparison value and the second comparison value not assume the specified value. 
     In some embodiments, the device comprises a plurality of components, more particularly processing units and/or circuits, on the basis of which the correction or the non-correction of bit positions is at least in part implementable in simultaneous fashion. 
     In some embodiments, the device is part of a memory or a memory system or is embodied separately from the memory or the memory system. 
     The device may be part of the memory or embodied separately from the latter. In particular, the device may comprise a processing unit which carries out the steps mentioned here. The processing unit may comprise at least one of the following components: a processor, a microcontroller, a circuit, an ASIC, an FPGA, a logic unit. 
     The processing unit can be realized in the form of at least one physical unit. In particular, the processing unit may be distributed among a plurality of physical units. 
     The explanations given above in relation to the methods apply accordingly to the device. The steps described here of the method may be carried out by means of the device. 
     The above-described properties, features and advantages of this invention and the manner in which they are achieved will be described below in conjunction with a schematic description of exemplary embodiments, which are explained in more detail in conjunction with the drawings. In this case, the same elements or elements with the same effect may be provided with identical reference signs for a better overview. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  shows an exemplary symbolic block diagram for a possible correction of a multiplicity of bit positions; 
         FIG. 2  shows a block diagram based on  FIG. 1 , additionally with a bit error coding signal, on the basis of which the correction can be switched inactive; 
         FIG. 3  shows a first alternative for realizing the comparison value generator, shown in  FIG. 1 , for processing the partial error syndrome s 1 ; 
         FIG. 4  shows a first alternative for realizing the comparison value generator, shown in  FIG. 1 , for processing the partial error syndrome s 2 ; 
         FIG. 5  shows a second alternative for realizing the comparison value generator, shown in  FIG. 1 , for processing the partial error syndrome s 1 ; and 
         FIG. 6  shows a second alternative for realizing the comparison value generator, shown in  FIG. 1 , for processing the partial error syndrome s 2 . 
     
    
    
     DETAILED DESCRIPTION 
     By way of example, the determination of a correction value for a bit to be corrected is proposed. By way of example, the bit is part of a bit sequence. The correction value can be determined using an error code. 
     Error syndromes, in particular partial error syndromes, can be determined for the error code. By way of example, a first partial error syndrome and a second partial error syndrome may be determined. A first comparison value is ascertained on the basis of the first partial error syndrome and a bit position to be corrected, and a second comparison value is ascertained on the basis of the second partial error syndrome and the bit position to be corrected. If the two comparison values are identical, the correction value can be set equal to a first value (e.g., “1”). If the two comparison values are not equal, the correction value can be set equal to a second value (e.g., “0”). 
     In this context, the first comparison value and the second comparison value, and hence also the correction value for the bit position, in each case are determined advantageously directly from one of the partial error syndromes and the bit position, without it being necessary to ascertain a locator polynomial and the zeros thereof by way of a search method, for example. 
     If use is made of a Galois field GF(2 m ) with m&gt;2, each bit position to be corrected may be reversibly assigned an m-component value. On the basis of this value and the first syndrome component, it is possible to determine the first comparison value. Accordingly, the second comparison value can be determined using this value and the second syndrome component. 
     In one option, correction values for a plurality of bit positions, in particular for all bit positions, are determined according to this scheme. Preferably, correction values for at least two bit positions can be determined in parallel. In this case, “determined in parallel” means that the correction values are determined at least partly simultaneously (that is to say at least partly with overlapping timing), preferably using different hardware and/or software. 
     Various bit positions to be corrected 
     i 0 ,i 1 , . . . , i r  
 
can be reversibly uniquely assigned various values
 
β i0 , . . . , β i     r    
 
in pairs. The bit positions can be denoted by
 
0, 1, . . . , r
 
and the values can be denoted by
 
β 0 , . . . , β r  
 
in simplified notation.
 
     The first comparison value for the bit position i j  to be corrected, with j=0, . . . , r can be determined as 
     (s 1 β i     j   ) k  
 
and the second comparison value for the bit position to be corrected can be determined as
 
s 2 β ij   k ,
 
where s 1  denotes the first partial error syndrome, s 2  denotes the second partial error syndrome and k denotes a specified value.
 
     Here, k is not equal to 0; s 1 , s 2 and β may be determined as values of a Galois field. If the Galois field is GF(2 m ) with m&gt;2, s 1 , s 2  and β can be described as m-component binary vectors in their vector representation. Then, formation of exponentials is likewise determined in the corresponding Galois field. 
     In one option, all bit positions to be corrected 
     i 0 ,i 1 ,i 2 , . . . i n−1  
 
are assigned pairwise different values
 
β i     0   ,β i     1   , β i     2   , . . . , β i     n−1    
 
of the Galois field. If a is a generator or primitive element of the Galois field,
 
     
       
         
           
             
               
                 β 
                 
                   i 
                   0 
                 
               
               = 
               
                 α 
                 
                   i 
                   0 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 β 
                 
                   i 
                   1 
                 
               
               = 
               
                 α 
                 
                   i 
                   1 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 β 
                 
                   i 
                   2 
                 
               
               = 
               
                 α 
                 
                   i 
                   2 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             ⋮ 
           
         
       
       
         
           
             
               β 
               
                 i 
                 
                   n 
                   - 
                   1 
                 
               
             
             = 
             
               α 
               
                 i 
                 
                   n 
                   - 
                   1 
                 
               
             
           
         
       
     
     is defined in one option. 
     A correction value Δ r  for the r-th bit can be determined as 1 if 
       ( s   1 +α i     r   ) k   =s   2 +α k·i     r      (1) applies, and a correction value Δ r  can be determined as 0 if
 
       ( s   1 +α i     r   ) k   ≠s   2 +α k·i     r      (2)
 
     applies. 
     An advantageous variant consists of the term s 1 +α i     r    being realized by virtue of the components of si in which air equals 1 being inverted and the components of s 1  in which α i     r    equals 0 remaining unchanged. 
     The addition of s 1  and α i     r    in the Galois field GF(2 m ), which corresponds to a component-by-component XOR operation on si and α i     r    in their vector representation, can be realized by means of inverters which invert the components of s 1  in which air equals 1 and the components of s 1  in which α i     r    equals 0 remain unchanged. Thus, to implement s 1 +α i     r    in this example, only inverters and no XOR gates are required. 
     Accordingly, the term s 2 +α k·i     r    can be realized by virtue of the components of s 2  in which α k·i     r    equals 1 being inverted and the components of s 2  in which α k·i     r    equals 0 remaining unchanged. 
     A bit error-correcting code which can correct at least two bit errors can be used as an error code. By way of example, an appropriate BCH code may be used. An option consists of incorporating a parity (that is to say at least one parity bit) into the error detection. 
     An H-matrix 
     
       
         
           
             
               
                 
                   H 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             
                               H 
                               1 
                             
                           
                         
                         
                           
                             
                               H 
                               2 
                             
                           
                         
                       
                       ) 
                     
                     = 
                     
                       ( 
                       
                         
                           
                             
                               α 
                               
                                 i 
                                 0 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 1 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 2 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 3 
                               
                             
                           
                           
                             … 
                           
                           
                             
                               α 
                               
                                 i 
                                 
                                   n 
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   0 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   1 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   2 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   3 
                                 
                               
                             
                           
                           
                             … 
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
     may be used to describe a 2-bit error-correcting BCH code. The values α j  are elements of the Galois field GF(2 m ) in their vector representation as m-component binary vectors, wherein the exponents should be interpreted modulo 2 m −1. Furthermore, n≤2 m −1 applies. 
     A 2-bit error-correcting and 3-bit error-detecting BCH code with included parity may be described by an H-matrix 
     
       
         
           
             
               
                 
                   H 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             
                               H 
                               1 
                             
                           
                         
                         
                           
                             
                               H 
                               2 
                             
                           
                         
                         
                           
                             P 
                           
                         
                       
                       ) 
                     
                     = 
                     
                       ( 
                       
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               1 
                             
                           
                           
                             
                               α 
                               2 
                             
                           
                           
                             
                               α 
                               3 
                             
                           
                           
                             … 
                           
                           
                             
                               α 
                               
                                 n 
                                 - 
                                 1 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               3 
                             
                           
                           
                             
                               α 
                               6 
                             
                           
                           
                             
                               α 
                               9 
                             
                           
                           
                             … 
                           
                           
                             
                               α 
                               
                                 3 
                                 · 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             … 
                           
                           
                             1 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
     for example. In this case, the following applies: 
     
       
         
           
             
               
                 i 
                 0 
               
               = 
               0 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 i 
                 1 
               
               = 
               1 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 i 
                 2 
               
               = 
               2 
             
             , 
             
               
 
             
             ⁢ 
             ⋮ 
           
         
       
       
         
           
             
               
                 i 
                 r 
               
               = 
               r 
             
             , 
             
               
 
             
             ⁢ 
             ⋮ 
           
         
       
       
         
           
             
               i 
               
                 n 
                 - 
                 1 
               
             
             = 
             
               n 
               - 
               1. 
             
           
         
       
     
     If 
       x′=x′ 0 , . . . ,x′ n−1  
 
     is a binary vector to be corrected (that is to say a bit sequence which might be erroneous), then the error syndrome s is determined as follows: 
         s=H·x′   (5)
 
     For an H matrix with 
     
       
         
           
             H 
             = 
             
               ( 
               
                 
                   
                     
                       H 
                       1 
                     
                   
                 
                 
                   
                     
                       H 
                       2 
                     
                   
                 
               
               ) 
             
           
         
       
     
     the first partial error syndrome s1 may be determined as 
         s   1   =H   1   ·x′   (6)
 
     and the second partial error syndrome s2 may be determined as 
         s   2   =H   2   ·x′   (7)
 
     with the matrix H 2  also being referred to as matrix H 3  and the partial error syndrome s 2  also being referred to as partial error syndrome s 3  in the case of a binary BCH code. 
     In the case of a 2-bit error, the partial error syndromes s 1  and s 2  of the error syndrome are determined as: 
         s   1 =α i +α j    (8)
 
         s   2 =α 3·i +α 3·j    (9)
 
     For the partial error syndrome 
         s   P =[1, . . . , 1 ]·x′   
     the following applies in the case of a 2-bit error: 
         s   P =1+1=0 
     For the i-th bit, the correction value Δ i  for a 2-bit error is as follows: 
     
       
         
           
             
               
                 
                   
                     Δ 
                     i 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               1 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               for 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ( 
                                   
                                     
                                       s 
                                       1 
                                     
                                     + 
                                     
                                       α 
                                       i 
                                     
                                   
                                   ) 
                                 
                                 3 
                               
                             
                             = 
                             
                               
                                 s 
                                 2 
                               
                               + 
                               
                                 α 
                                 
                                   3 
                                   · 
                                   i 
                                 
                               
                             
                           
                         
                       
                       
                         
                           
                             
                               0 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               for 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ( 
                                   
                                     
                                       s 
                                       1 
                                     
                                     + 
                                     
                                       α 
                                       i 
                                     
                                   
                                   ) 
                                 
                                 3 
                               
                             
                             ≠ 
                             
                               
                                 s 
                                 2 
                               
                               + 
                               
                                 α 
                                 
                                   3 
                                   · 
                                   i 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
     If a 2-bit error is present in bit positions i and j, then taking account of equations (8) and (9) above 
         s   1 +α i +α i +α j +α i =α j  
 
         s   2 +α 3i =α 3i +α 3j +α 3i =α 3j  
 
     and hence 
       ( s   1 +α i ) 3 =α 3j   =s   2 +α 3i  
 
     with the correction value Δ i =1. 
     For r≠i,j, once again taking account of equations (8) and (9), the following applies: 
         s   1 +α r =α i +a j +α r  
 
         s   2 +α 3r =α 3i +α 3j +α 3r  
 
     and hence 
       ( s   1 +α r ) 3   ≠s   2 +α 3r  
 
     with the correction value Δ i =0. 
     The bit positions 
     
       
         
           
             
               
                 i 
                 0 
               
               = 
               0 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 i 
                 1 
               
               = 
               1 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 i 
                 2 
               
               = 
               2 
             
             , 
             
               
 
             
             ⁢ 
             ⋮ 
           
         
       
       
         
           
             
               i 
               
                 n 
                 - 
                 1 
               
             
             = 
             
               n 
               - 
               1 
             
           
         
       
     
     are reversibly uniquely assigned the elements α 0 , α 1 , α 2 , α n−1  of the Galois field GF(2 m ) in their vector representation as m-component binary vectors, for example. 
     For the bit position i to be corrected,
         a first comparison value
 
(s 1 +α i ) 3  
 
is determined on the basis of the first partial error syndrome Si and the bit position i and
   a second comparison value
 
s 2 [α i ] 3 =s 2 +α 3i  
 
is determined on the basis of the second partial error syndrome s 2  and the bit position i.
       

     If the first and second comparison values correspond, Δ i =1 arises as correction value and the i-th bit position is corrected. If the two comparison values do not correspond, Δ i =0 arises as correction value and there is no correction at the i-th bit position. 
     For a 1-bit error at the error position j, the following applies: 
       s 1 =α j  
 
       s 2 =α 3·j  
 
     Hence, the first comparison value is determined as 
       ( s   1 +α i ) 3 =(α j +α i ) 3  
 
     and the second comparison value is determined as 
       ( s   1 +α 3·i =α 3·j +α 3·i  
 
     for for a bit position i to be corrected. If the error position j and the bit position i to be corrected correspond (that is to say i=j), then the following applies: 
       ( s   1 +α i ) 3 =(α i +α i ) 3 =0 3 =0 =s   2 +α 3·i =α 3·i +α 3·i =0.
 
     The first comparison value and the second comparison value are the same even in the case of the 1-bit error in position i and there is a correction of the bit position i. 
     If the error position j and the bit position i to be corrected do not correspond (that is to say i≠j), then the following applies: 
       ( s   1 +α i ) 3 =(α j +α i ) 3   ≠s   2 +α 3·i +α 3·j +α 3·i  
 
     In this case, the first comparison value and the second comparison value are not the same, and so there is no correction at the bit position i since the error is present at another bit position j. 
     A comparison of the first comparison value and of the second comparison value, which are each determined as m-component binary vectors, can be implemented for example by a component-by-component exclusive or operation (XOR operation) and a subsequent or operation (OR operation). 
     EXAMPLE: H-MATRIX WITH PARITY 
     A further example of an H-matrix of a code for 2-bit error correction and 3-bit error detection is as follows: 
     
       
         
           
             
               
                 
                   H 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             
                               H 
                               1 
                             
                           
                         
                         
                           
                             
                               H 
                               
                                 - 
                                 1 
                               
                             
                           
                         
                         
                           
                             P 
                           
                         
                       
                       ) 
                     
                     = 
                     
                       
                         ( 
                         
                           
                             
                               
                                 α 
                                 0 
                               
                             
                             
                               
                                 α 
                                 1 
                               
                             
                             
                               
                                 α 
                                 2 
                               
                             
                             
                               
                                 α 
                                 3 
                               
                             
                             
                               … 
                             
                             
                               
                                 α 
                                 
                                   n 
                                   - 
                                   1 
                                 
                               
                             
                           
                           
                             
                               
                                 α 
                                 0 
                               
                             
                             
                               
                                 α 
                                 
                                   - 
                                   1 
                                 
                               
                             
                             
                               
                                 α 
                                 
                                   - 
                                   2 
                                 
                               
                             
                             
                               
                                 α 
                                 
                                   - 
                                   3 
                                 
                               
                             
                             
                               … 
                             
                             
                               
                                 α 
                                 
                                   - 
                                   
                                     ( 
                                     
                                       n 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                           
                             
                               1 
                             
                             
                               1 
                             
                             
                               1 
                             
                             
                               1 
                             
                             
                               … 
                             
                             
                               1 
                             
                           
                         
                         ) 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
     The partial error syndromes s 1  and s 2  of the error syndrome arise as follows for the 2-bit error: 
         s   1 =α i +α j    (12)
 
         s   2 =α −i +α −j    (13)
 
     The values α j  again are elements of the Galois field GF(2 m ) in their vector representation as m-component binary vectors, wherein the exponents should be interpreted modulo 2 m −1. Furthermore, n≤2 m −1 applies. 
     For the i-th bit, the correction value Δ i  for the 2-bit error is determined as follows: 
     
       
         
           
             
               
                 
                   
                     Δ 
                     i 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               1 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               for 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ( 
                                   
                                     
                                       s 
                                       1 
                                     
                                     + 
                                     
                                       α 
                                       i 
                                     
                                   
                                   ) 
                                 
                                 
                                   - 
                                   1 
                                 
                               
                             
                             = 
                             
                               
                                 s 
                                 2 
                               
                               + 
                               
                                 α 
                                 
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                       
                       
                         
                           
                             
                               0 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               for 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ( 
                                   
                                     
                                       s 
                                       1 
                                     
                                     + 
                                     
                                       α 
                                       i 
                                     
                                   
                                   ) 
                                 
                                 
                                   - 
                                   1 
                                 
                               
                             
                             ≠ 
                             
                               
                                 s 
                                 2 
                               
                               + 
                               
                                 α 
                                 
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
     The first comparison value for the bit position i is 
       (s 1 +α i ) −1  
 
     and the second comparison value for this bit position is 
       s 2 +α −i  
 
     Further Exemplary Embodiments 
       FIG. 1  shows an exemplary diagram for r bit positions 0 to r−1 to be corrected. 
     An m-bit wide partial error syndrome Si is applied to an m-bit wide input  113 , which is connected to the inputs of r first comparison value generators  11  to  13 . The comparison value generators  11  to  13  are suited to determining a first comparison value per bit position on the basis of the partial error syndrome s 1  and on the basis of the bit position. 
     An m-bit wide partial error syndrome s 2  is applied to an m-bit wide input  114 , which is connected to the inputs of r second comparison value generators  14  to  16 . The comparison value generators  14  to  16  are suited to determining a second comparison value per bit position on the basis of the partial error syndrome s 2  and on the basis of the bit position. 
     Now, a comparison of the first comparison value with the second comparison value is carried out for each bit position by means of a comparator. To this end, r comparators  17  to  19  are provided, the inputs of which are connected to the appropriate outputs of the comparison value generators. 
     A respective correction value Δ 0  to Δ r −1  for the respective bit position is provided at the output of the comparator  17  to  19 . By way of example, the correction value is 1 if the comparison value generators connected to the comparator supply the same output signals and the correction value is 0 if the comparison value generators supply unequal output signals. 
     The output of the respective comparator  17  to  19  is connected to the input of an XOR gate  110  to  112 . A possibly erroneous bit x 0   1  to x r−1   1  is applied to the other input of the respective XOR gate  110  to  112 . A corrected bit 
     
       
         
           
             
               
                 x 
                 0 
                 cor 
               
               = 
               
                 
                   x 
                   0 
                   ′ 
                 
                 + 
                 
                   Δ 
                   0 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             ⋮ 
           
         
       
       
         
           
             
               x 
               
                 r 
                 - 
                 1 
               
               cor 
             
             = 
             
               
                 x 
                 
                   r 
                   - 
                   1 
                 
                 ′ 
               
               + 
               
                 Δ 
                 
                   r 
                   - 
                   1 
                 
               
             
           
         
       
     
     is provided at the output of the XOR gate  110  to  112 . Here, + denotes addition modulo 2. 
     In this case, a bit is referred to as corrected bit if a correction value has been added to a possibly erroneous bit. Here, the correction value can equal 1 if the bit was erroneous and the correction value can equal 0 if the bit was not erroneous. Independently of whether or not the bit was erroneous, the resultant bit following the addition of the correction value is referred to as corrected bit in this case. The addition is implemented modulo 2 and can be realized by an XOR operation. 
     As already explained above, the determination of the corrected bit is implemented for all bit positions. By way of example, the following applies to the bit position 0: The output of the comparison value generator  11  is connected to the first input of the comparator  17  and the output of the comparison value generator  14  is connected to the second input of the comparator  17 . The output of the comparator  17  supplies the correction value Δ 0  to the first input of the XOR gate  110 , at the second input of which the possibly erroneous bit x′ 0  is applied. At its output, the XOR gate  110  consequently supplies the corrected bit x 0   corr . This is implemented accordingly for the further bit positions 1 to r−1. 
       FIG. 2  shows an exemplary arrangement on the basis of the representation shown in  FIG. 1 . An AND gate  21  to  23  is arranged between the output of the respective comparator  17  to  19 . The first input of the AND gate  21  to  23  is connected to the output of the comparator  17  to  19  and the second input of the AND gate  21  to  23  is connected to an image error coding signal  201 . The output of the AND gate  21  to  23  is connected to the XOR gate  110  to  112 . 
     The arrangement shown in  FIG. 2  once again applies per bit position. By way of example, for the bit position 0, the output of the comparator  17  is connected to the first input of the AND gate  21 . The second input of the AND gate is connected to the bit error coding signal  201  The output of the AND gate  21  is connected to the first input of the XOR gate  110 . These explanations apply accordingly to the further bit positions 1 to r−1, with the bit error coding signal  201  being applied to all second inputs of the AND gates  21  to  23 . 
     The bit error coding signal  201  is for example a binary value 1 if a 1-bit error or a 2-bit error was determined on account of the error syndrome, and a binary value 0 if the error syndrome equals 0, and hence no errors are indicated by the error syndrome. Consequently, what follows from the link to the respective AND gate  21  to  23  is that no change of the value of the bit x′ 0  to x′ r−1  applied to the XOR gate  110  to  112  is implemented, that is to say no correction is carried out. 
       FIG. 3  shows an exemplary configuration of the comparison value generators  11  to  13  of  FIG. 1 . 
     By way of example, a 2-bit error-correcting BCH code with an H-matrix as per equation (4) is used. The possibly to be corrected bit positions are the bit positions 0 to r−1. 
     Each comparison value generator  11  to  13  comprises a series connection of an adding member  31  to  33  and a third power generator  34  to  36 . 
     The structure of the comparison value generator  11  for the bit position 0 can be described as follows: The comparison value generator  11  comprises the series connection of the adding member  31  and the third power generator  34 . The adding member  31  facilitates a component-by-component XOR operation on the first partial error syndrome s 1  and α 0  in its vector representation. It is an option to realize the XOR operation on the partial error syndrome s 1  and α 0  by virtue of inverting those components of s 1  where α 0  equals 1 and leaving the components of s 1  in which α 0  equals 0 unchanged. In a Galois field GF(2 m ) 
     
       
         
           
             
               
                 α 
                 0 
               
               = 
               
                 ( 
                 
                   
                     0 
                     ⁢ 
                     …01 
                   
                   
                     ︸ 
                     m 
                   
                 
                 ) 
               
             
             , 
           
         
       
     
     and so the first component of s 1  is inverted while all other components of s 1  remain unchanged. 
     The third power generator  34  is provided to form and output, in the Galois field GF(2 m ), the third power (s 1 +α 0 ) 3  of the value (s 1 +α 0 ) applied to its input. The third power generator  34  can be realized as a combinational circuit. 
     This is implemented accordingly for the further bit positions  1  to r−1, wherein the respective adding member correspondingly carries out an addition with α 1  to α r−1 . 
       FIG. 4  shows an exemplary configuration of the comparison value generators  14  to  16  of  FIG. 1 . 
     Each comparison value generator  14  to  16  comprises an adding member  41  to  43 . 
     The structure of the comparison value generator  14  for the bit position 0 can be described as follows: The comparison value generator  14  comprises the adding member  41  in order to XOR-link, component-by-component, the partial error syndrome s 2  and α 0  functionally in its vector representation. It is an option to realize the XOR operation on the partial error syndrome s 2  and α 0  by virtue of inverting those components of s 2  where α 0  equals 1 and leaving the components of s 2  where α 0  equals 0 unchanged. 
     This is implemented accordingly for the further bit positions j (with j=1, . . . , r−1), wherein the respective adding member accordingly carries out an addition with α 3j . 
     The Third Power Generator 
     A third power generator in a Galois field GF(2 m ) can be realized as a combinational circuit with m binary inputs and m binary outputs. It is one option to describe the combinational functionality by a value table and to realize the value table as a circuit using a synthesis tool. 
     For i=0, . . . , 2 m −1, the input value α i  in its vector representation as a m-component binary vector is assigned the corresponding output value α 3·i  in such a value table. The input value 
     
       
         
           
             ( 
             
               
                 0 
                 ⁢ 
                 …0 
               
               
                 ︸ 
                 m 
               
             
             ) 
           
         
       
     
     can be assigned the output value 
     
       
         
           
             
               ( 
               
                 
                   0 
                   ⁢ 
                   …0 
                 
                 
                   ︸ 
                   m 
                 
               
               ) 
             
             . 
           
         
       
     
     The exponents should be interpreted modulo 2 m −1 and a is a generator of the Galois field. 
     For elucidating purposes, a Galois field GF(2 3 ) with the modular polynomial 
         M ( x )= x   3   +x+ 1 
     is considered, for which the elements α 0  to α 6  are represented in their vector representation in the following table “Exponential representation and vector representation”, wherein the element 0 is shown as 000: 
     
       
         
           
               
               
               
             
               
                   
                   
               
               
                   
                 Exponential representation 
                 Vector representation 
               
               
                   
                   
               
             
            
               
                   
                 0 
                 000 
               
               
                   
                 α 0   
                 001 
               
               
                   
                 α 1   
                 010 
               
               
                   
                 α 2   
                 100 
               
               
                   
                 α 3   
                 011 
               
               
                   
                 α 4   
                 110 
               
               
                   
                 α 5   
                 111 
               
               
                   
                 α 6   
                 101 
               
               
                   
                   
               
            
           
         
       
     
     Value tables for Galois fields up to GF(2 10 ) are shown in [Lin, S.; Costello, D.: Error Control Coding, Prentice Hall, 1983, pages 561 to 577] for example. 
     The third power generator outputs α 3·i  on the basis of an input of α i , wherein the exponents should be interpreted modulo 2 3 −1=7 in this case. That is to say, the following relationships arise between input and output: 
     
       
         
           
               
               
               
             
               
                   
                   
               
               
                   
                 Input 
                 Output 
               
               
                   
                   
               
             
            
               
                   
                 α 0   
                 α 0   
               
               
                   
                 α 1   
                 α 3   
               
               
                   
                 α 2   
                 α 6   
               
               
                   
                 α 3   
                 α 2   
               
               
                   
                 α 4   
                 α 5   
               
               
                   
                 α 5   
                 α 1   
               
               
                   
                 α 6   
                 α 4   
               
               
                   
                   
               
            
           
         
       
     
     A corresponding binary value table on the basis of the vector representations of the values α i  shown above is elucidated by the following table of the third power generator in GF(2 3 ): 
     
       
         
           
               
               
               
             
               
                   
                   
               
               
                   
                 Input value 
                 Output value 
               
               
                   
                   
               
             
            
               
                   
                 000 
                 000 
               
               
                   
                 001 
                 001 
               
               
                   
                 010 
                 011 
               
               
                   
                 011 
                 100 
               
               
                   
                 100 
                 101 
               
               
                   
                 101 
                 110 
               
               
                   
                 110 
                 111 
               
               
                   
                 111 
                 010 
               
               
                   
                   
               
            
           
         
       
     
     Example: Comparison Value Generator with Galois Field Inverter 
       FIG. 5  shows an exemplary alternative configuration of the comparison value generators  11  to  13  of  FIG. 1 . 
     A 2-bit error-correcting code with an H-matrix as per equation (11) is used in exemplary fashion. The bit positions possibly to be corrected are the bit positions 0 to r−1. 
     Each comparison value generator  11  to  13  comprises a series connection of an adding member  51  to  53  and a Galois field inverter  54  to  56 . 
     The structure of the comparison value generator  11  for the bit position 0 can be described as follows: The comparison value generator  11  comprises the series connection of the adding member  51  and the Galois field inverter  54 . The adding member  51  facilitates a component-by-component XOR operation on the first partial error syndrome s 1  and α 0  in its vector representation. The Galois field inverter  54  is provided to form and output, in the Galois field GF(2 m ), (s 1 +α 0 ) −1  on the basis of the value (s 1 +α 0 ) applied to its input. The Galois field inverter  54  can be realized as a combinational circuit. 
     This is implemented accordingly for the further bit positions 1 to r−1, wherein the respective adding member correspondingly carries out an addition with α 1  to α r−1 . 
       FIG. 6  shows an exemplary configuration of the comparison value generators  14  to  16  of  FIG. 1 . 
     Each comparison value generator  14  to  16  comprises an adding member  61  to  63 . 
     The structure of the comparison value generator  14  for the bit position 0 can be described as follows: The comparison value generator  14  comprises the adding member  61  in order to XOR-link, component-by-component, the partial error syndrome s 2  and α 0  functionally in its vector representation. 
     This is implemented accordingly for the further bit positions j (with j=1, . . . , r−1), wherein the respective adding member correspondingly carries out an addition with α j . 
     The Galois field inverter in a Galois field GF(2 m ) can be realized as a combinational circuit with m binary inputs and m binary outputs. It is one option to describe the combinational functionality thereof by a value table and to realize the value table as a circuit using a synthesis tool. 
     For i=0, . . . ,2 m −1, the input value α i  in its vector representation as a m-component binary vector is assigned the corresponding output value α −i  in such a value table. The input value 
     
       
         
           
             ( 
             
               
                 0 
                 ⁢ 
                 …0 
               
               
                 ︸ 
                 m 
               
             
             ) 
           
         
       
     
     can be assigned the output value 
     
       
         
           
             ( 
             
               
                 0 
                 ⁢ 
                 …0 
               
               
                 ︸ 
                 m 
               
             
             ) 
           
         
       
     
     The exponents should be interpreted modulo 2 m− 1 and α is a generator of the Galois field. Furthermore, α 0 =α −0  applies. 
     For elucidating purposes, the Galois field GF(2 3 ) with the modular polynomial 
         M ( x )= x   3   +x+ 1 
     is considered, for which the elements α 0  to α 6  are represented in the table labeled “Exponential representation and vector representation” above. 
     The Galois field inverter outputs α 0  when α 0  is input, and outputs α 7−i  when α i  is input, wherein the exponents should be interpreted modulo 2 3 −1=7 in this case. That is to say, the following applies: 
     
       
         
           
               
               
               
             
               
                   
                   
               
               
                   
                 Input 
                 Output 
               
               
                   
                   
               
             
            
               
                   
                 α 0   
                 α 0   
               
               
                   
                 α 1   
                 α 6   
               
               
                   
                 α 2   
                 α 5   
               
               
                   
                 α 3   
                 α 4   
               
               
                   
                 α 4   
                 α 3   
               
               
                   
                 α 5   
                 α 2   
               
               
                   
                 α 6   
                 α 1   
               
               
                   
                   
               
            
           
         
       
     
     A corresponding binary value table on the basis of the vector representations of the values α i  shown above is elucidated by the following table of the Galois field inverter in GF(2 3 ): 
     
       
         
           
               
               
               
             
               
                   
                   
               
               
                   
                 Input value 
                 Output value 
               
               
                   
                   
               
             
            
               
                   
                 000 
                 000 
               
               
                   
                 001 
                 001 
               
               
                   
                 010 
                 101 
               
               
                   
                 011 
                 110 
               
               
                   
                 100 
                 111 
               
               
                   
                 101 
                 010 
               
               
                   
                 110 
                 011 
               
               
                   
                 111 
                 100 
               
               
                   
                   
               
            
           
         
       
     
     Fast correction of 3-bit errors 
     A fast correction of 3-bit errors is presented below in exemplary fashion. To this end, a 3-bit error-correcting BCH code may be used. 
     A 3-bit error-correcting BCH code may be described by an H-matrix 
     
       
         
           
             
               
                 
                   H 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             
                               H 
                               1 
                             
                           
                         
                         
                           
                             
                               H 
                               2 
                             
                           
                         
                         
                           
                             
                               H 
                               3 
                             
                           
                         
                       
                       ) 
                     
                     = 
                     
                       ( 
                       
                         
                           
                             
                               α 
                               
                                 i 
                                 0 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 1 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 2 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 3 
                               
                             
                           
                           
                             … 
                           
                           
                             
                               α 
                               
                                 i 
                                 
                                   n 
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   0 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   1 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   2 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   3 
                                 
                               
                             
                           
                           
                             … 
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   0 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   1 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   2 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   3 
                                 
                               
                             
                           
                           
                             … 
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
     By way of example, the values a′ are elements of the Galois field GF(2 m ) in their vector representation as m-component binary vectors, wherein the exponents should be interpreted modulo ( 2   m −1). The following apply: n≤2 m −1 and m&gt;2. 
     Additionally, a 3-bit error-correcting BCH code may be described by an H-matrix: 
     
       
         
           
             
               
                 
                   H 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             
                               H 
                               1 
                             
                           
                         
                         
                           
                             
                               H 
                               2 
                             
                           
                         
                         
                           
                             
                               H 
                               3 
                             
                           
                         
                       
                       ) 
                     
                     = 
                     
                       ( 
                       
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               1 
                             
                           
                           
                             
                               α 
                               2 
                             
                           
                           
                             
                               α 
                               3 
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 n 
                                 - 
                                 1 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               3 
                             
                           
                           
                             
                               α 
                               6 
                             
                           
                           
                             
                               α 
                               9 
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 · 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               5 
                             
                           
                           
                             
                               α 
                               10 
                             
                           
                           
                             
                               α 
                               15 
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 · 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
     In this case, the following apply: 
     
       
         
           
             
               
                 
                   
                     
                       i 
                       0 
                     
                     = 
                     0 
                   
                   , 
                 
               
             
             
               
                 
                   
                     
                       i 
                       1 
                     
                     = 
                     1 
                   
                   , 
                 
               
             
             
               
                 
                   
                     
                       i 
                       2 
                     
                     = 
                     2 
                   
                   , 
                 
               
             
             
               
                 
                   . 
                   
                       
                   
                   . 
                   
                       
                   
                   . 
                 
               
             
             
               
                 
                   
                     
                       i 
                       r 
                     
                     = 
                     r 
                   
                   , 
                 
               
             
             
               
                 ⋮ 
               
             
             
               
                 
                   
                     i 
                     
                       n 
                       - 
                       1 
                     
                   
                   = 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
     
     If 
       x′=x′ 0 , . . . , x′ n−1  
 
     is a binary vector to be corrected, then the error syndrome s is determined as 
         s=H·x′   (17)
 
     For the H-matrix with 
     
       
         
           
             H 
             = 
             
               ( 
               
                 
                   
                     
                       H 
                       1 
                     
                   
                 
                 
                   
                     
                       H 
                       2 
                     
                   
                 
                 
                   
                     
                       H 
                       3 
                     
                   
                 
               
               ) 
             
           
         
       
     
     the first partial error syndrome s 1  can be determined as 
         s   1   =H   1   ·x′   (18)
 
     the second partial error syndrome s 2  can be determined as 
         s   2   =H   2   ·x′   (19)
 
     and the third partial error syndrome s 3  can be determined as 
         s   x   =H   3   ·x′   (20)
 
     In the case of a binary BCH code, the matrix H 2  can be referred to as matrix H 3 , the partial error syndrome s 2  can be referred to as partial error syndrome s 3 , the matrix H 3  can be referred to as matrix H 5  and the partial error syndrome s 3  can be referred to as partial error syndrome s 5 . 
     While two partial error syndromes, for example the partial error syndromes s 1  and s 2 , are used for the correction of a 2-bit error, the partial error syndrome s 3  is additionally used to correct a 3-bit error. 
     One option is to use the parity of bits for error detection and/or error correction. A 3-bit error-correcting BCH code with parity can be described by an H-matrix. 
     
       
         
           
             
               
                 
                   H 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             
                               H 
                               1 
                             
                           
                         
                         
                           
                             
                               H 
                               2 
                             
                           
                         
                         
                           
                             
                               H 
                               3 
                             
                           
                         
                         
                           
                             
                               H 
                               P 
                             
                           
                         
                       
                       ) 
                     
                     = 
                     
                       ( 
                       
                         
                           
                             
                               α 
                               
                                 i 
                                 0 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 1 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 2 
                               
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 3 
                               
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 i 
                                 
                                   n 
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   0 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   1 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   2 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   3 
                                 
                               
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 ⁢ 
                                 
                                   i 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   0 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   1 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   2 
                                 
                               
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   3 
                                 
                               
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 ⁢ 
                                 
                                   i 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                         
                         
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             1 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
     where H P  denotes a parity matrix. Alternatively, a 3-bit error-correcting BCH code with parity may also be described by the H-matrix 
     
       
         
           
             
               
                 
                   H 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             
                               H 
                               1 
                             
                           
                         
                         
                           
                             
                               H 
                               2 
                             
                           
                         
                         
                           
                             
                               H 
                               3 
                             
                           
                         
                         
                           
                             
                               H 
                               P 
                             
                           
                         
                       
                       ) 
                     
                     = 
                     
                       ( 
                       
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               1 
                             
                           
                           
                             
                               α 
                               2 
                             
                           
                           
                             
                               α 
                               3 
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 n 
                                 - 
                                 1 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               3 
                             
                           
                           
                             
                               α 
                               6 
                             
                           
                           
                             
                               α 
                               9 
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 3 
                                 · 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             
                               α 
                               0 
                             
                           
                           
                             
                               α 
                               5 
                             
                           
                           
                             
                               α 
                               10 
                             
                           
                           
                             
                               α 
                               15 
                             
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             
                               α 
                               
                                 5 
                                 · 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             
                               . 
                               
                                   
                               
                               . 
                               
                                   
                               
                               . 
                             
                           
                           
                             1 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
     In this respect, reference is made to equations (15) and (16) above, which were augmented by the matrix H P . 
     With the binary vector x′ to be corrected, the error syndrome s arises as 
         s=H·x′   (23)
 
     With 
     
       
         
           
             H 
             = 
             
               ( 
               
                 
                   
                     
                       H 
                       1 
                     
                   
                 
                 
                   
                     
                       H 
                       2 
                     
                   
                 
                 
                   
                     
                       H 
                       3 
                     
                   
                 
                 
                   
                     
                       H 
                       P 
                     
                   
                 
               
               ) 
             
           
         
       
     
     the following follows for the partial error syndromes s1, s2, s3 and s4: 
     
       
      
       s 
       1 
       =H 
       1 
       ·x′ 
      
     
     
       
      
       s 
       2 
       =H 
       2 
       ·x′ 
      
     
     
       
      
       s 
       3 
       =H 
       3 
       ·x′ 
      
     
         s   4   =s   P   =H   P   ·x′=x   0   +x   1   +. . . +x   n−1 . 
     In this case, “+” denotes addition modulo 2, corresponding to an XOR operation. The partial error syndrome s P  is the parity of the bits x 0  to x n−1 . 
     The partial error syndromes s 1 , s 2  and s 3  of the error syndrome arise for the 3-bit error in bit positions i, j and k as 
         s   1 =α i +α j +α k    (24)
 
         s   2 =α 3i α 3j α 3k    (25)
 
         s   3 =α 5i +α 5j +α 5k    (26)
 
     The bit positions i, j and k may also be described, for example, by the values a i , a j , a k , by elements of the Galois field GF(2 m ), by the binary values x′ i , x′ j , x′ k  to be corrected or by i, j and k. 
     For a  3 -bit error in bit positions i, j and k, the following applies: 
       ( s   1 +α i ) 3   =s   2 +α 3i +α j ·α k )α j +α k )   (27)
 
     This emerges by recalculation. In this case, α j ·α k  is the product of the elements α j  and α k  in the Galois field GF(2 m ) and α j +α k  denotes their sum in the Galois field, which may be determined for example in the vector representation of α j  and α k  as m-component of binary vectors by the component-by-component XOR operation on these binary vectors. 
     In the case of a 3-bit error in bit positions a i , α j  and α k , the partial error syndromes s 1  and s 2  are determined by equations (24) and (25). 
     With 
         s   1 +α i =α j +α k    (28)
 
         s   2 +α 3i =α 3j +α 3k    (29)
 
     it is possible to verify by insertion into equation (27) that: 
     
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         
                           s 
                           1 
                         
                         + 
                         
                           α 
                           i 
                         
                       
                       ) 
                     
                     3 
                   
                   = 
                   
                     
                       
                         
                           ( 
                           
                             
                               s 
                               1 
                             
                             + 
                             
                               α 
                               i 
                             
                           
                           ) 
                         
                         2 
                       
                       · 
                       
                         ( 
                         
                           
                             s 
                             1 
                           
                           + 
                           
                             α 
                             i 
                           
                         
                         ) 
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         
                           ( 
                           
                             
                               α 
                               j 
                             
                             + 
                             
                               α 
                               k 
                             
                           
                           ) 
                         
                         2 
                       
                       · 
                       
                         ( 
                         
                           
                             α 
                             j 
                           
                           + 
                           
                             α 
                             k 
                           
                         
                         ) 
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         ( 
                         
                           
                             α 
                             
                               2 
                               ⁢ 
                               j 
                             
                           
                           + 
                           
                             
                               α 
                               j 
                             
                             · 
                             
                               α 
                               k 
                             
                           
                           + 
                           
                             
                               α 
                               j 
                             
                             · 
                             
                               α 
                               k 
                             
                           
                           + 
                           
                             α 
                             
                               2 
                               ⁢ 
                               k 
                             
                           
                         
                         ) 
                       
                       · 
                       
                         ( 
                         
                           
                             α 
                             j 
                           
                           + 
                           
                             α 
                             k 
                           
                         
                         ) 
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         ( 
                         
                           
                             α 
                             
                               2 
                               ⁢ 
                               j 
                             
                           
                           + 
                           
                             α 
                             
                               2 
                               ⁢ 
                               k 
                             
                           
                         
                         ) 
                       
                       · 
                       
                         ( 
                         
                           
                             α 
                             j 
                           
                           + 
                           
                             α 
                             k 
                           
                         
                         ) 
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         α 
                         
                           3 
                           ⁢ 
                           j 
                         
                       
                       + 
                       
                         
                           α 
                           
                             2 
                             ⁢ 
                             j 
                           
                         
                         · 
                         
                           α 
                           k 
                         
                       
                       + 
                       
                         
                           α 
                           
                             2 
                             ⁢ 
                             k 
                           
                         
                         · 
                         
                           α 
                           j 
                         
                       
                       + 
                       
                         α 
                         
                           3 
                           ⁢ 
                           k 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         α 
                         
                           3 
                           ⁢ 
                           j 
                         
                       
                       + 
                       
                         α 
                         
                           3 
                           ⁢ 
                           k 
                         
                       
                       + 
                       
                         
                           α 
                           j 
                         
                         · 
                         
                           α 
                           k 
                         
                         · 
                         
                           ( 
                           
                             
                               α 
                               j 
                             
                             + 
                             
                               α 
                               k 
                             
                           
                           ) 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       s 
                       2 
                     
                     + 
                     
                       α 
                       
                         3 
                         ⁢ 
                         i 
                       
                     
                     + 
                     
                       
                         α 
                         j 
                       
                       · 
                       
                         α 
                         k 
                       
                       · 
                       
                         
                           ( 
                           
                             
                               α 
                               j 
                             
                             + 
                             
                               α 
                               k 
                             
                           
                           ) 
                         
                         . 
                       
                     
                   
                 
               
             
           
         
       
     
     In this case, it should be observed that addition modulo 2 of two equal values yields 0. 
     In the case of a 3-bit error in bit positions i, j and k, a comparison of a first value (s 1 +α i ) 3  with a second value s 2 +α 3i  yields the specified value α j α k (α j +α k ) if an error is corrected in the bit position i. If (s 1 +α i ) 3  and s 2 +α 3i  differ by a different value than α j α k (α j +α k ), there is no correction. 
     To be able to determine for the i-th bit position whether a 3-bit error, where the i-bit is erroneous and corrected, is present, for example the value 
       α j α k (α j +α k )   (30)
 
     is determined on the basis of the partial error syndromes and only the bit position i. The two further erroneous bit positions j and k need not be determined for the correction of the i-th bit position. 
     The value (α j +α k ) from equation (30) of the two further erroneous bit positions can be determined on the basis of the i-th bit position α i  and on the basis of the partial error syndrome s 1 : 
     α j +α k =s 1 +α i    
     This follows immediately from equation (24). 
     The value α j α k  from equation (30) can be represented on the basis of the i-th bit position using the symmetric function σ 2    
       σ 2 =α i α j +α i α k +α j α k    (31)
 
     as 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             α 
                             j 
                           
                           ⁢ 
                           
                             α 
                             k 
                           
                         
                         = 
                         
                           
                             
                               σ 
                               2 
                             
                             + 
                             
                               
                                 α 
                                 i 
                               
                               ⁢ 
                               
                                 α 
                                 j 
                               
                             
                             + 
                             
                               
                                 α 
                                 i 
                               
                               ⁢ 
                               
                                 α 
                                 k 
                               
                             
                           
                           = 
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             
                               σ 
                               2 
                             
                             + 
                             
                               
                                 α 
                                 i 
                               
                               · 
                               
                                 ( 
                                 
                                   
                                     α 
                                     j 
                                   
                                   + 
                                   
                                     α 
                                     k 
                                   
                                 
                                 ) 
                               
                             
                           
                           = 
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             σ 
                             2 
                           
                           + 
                           
                             
                               α 
                               i 
                             
                             · 
                             
                               ( 
                               
                                 
                                   s 
                                   1 
                                 
                                 + 
                                 
                                   α 
                                   i 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   32 
                   ) 
                 
               
             
           
         
       
     
     Hence, the following arises from equation (27) in conjunction with equation (32) and equation (28): 
       ( s   1 +α i ) 3   =s   2 +α 3i +(σ 2 +α i ( s   1 +α i ))·( s   1 +α i )   (33)
 
     For σ 2 , the following furthermore emerges by means of the partial error syndromes s 1 , s 2  and s 3  as per equations (24), (25) and (26) which in turn are symmetric functions of the bit positions to be corrected: 
     
       
         
           
             
               σ 
               2 
             
             = 
             
               
                 
                   
                     
                       s 
                       1 
                       2 
                     
                     · 
                     
                       s 
                       2 
                     
                   
                   + 
                   
                     s 
                     3 
                   
                 
                 
                   
                     s 
                     1 
                     3 
                   
                   + 
                   
                     s 
                     2 
                   
                 
               
               . 
             
           
         
       
     
     This can be verified by insertion into equations (24), (25) and 26. 
     Consequently, a common value of the symmetric function σ 2 , which is determined by the syndrome components s 1 , s 2  and s 3 , can be used for all bit positions to be corrected. 
     By way of example, a binary correction value Δ i  for the i-th bit position in the case of a 3-bit error is determinable as per 
     
       
         
           
             
               
                 
                   
                     
                       Δ 
                       i 
                     
                     = 
                     
                       
                         1 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         for 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             ( 
                             
                               
                                 s 
                                 1 
                               
                               + 
                               
                                 α 
                                 i 
                               
                             
                             ) 
                           
                           3 
                         
                       
                       = 
                       
                         
                           s 
                           2 
                         
                         + 
                         
                           α 
                           
                             3 
                             ⁢ 
                             i 
                           
                         
                         + 
                         
                           
                             ( 
                             
                               
                                 σ 
                                 2 
                               
                               + 
                               
                                 
                                   α 
                                   i 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       s 
                                       1 
                                     
                                     + 
                                     
                                       α 
                                       i 
                                     
                                   
                                   ) 
                                 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                             ( 
                             
                               
                                 s 
                                 1 
                               
                               + 
                               
                                 α 
                                 i 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       Δ 
                       i 
                     
                     = 
                     
                       
                         0 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         for 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             ( 
                             
                               
                                 s 
                                 1 
                               
                               + 
                               
                                 α 
                                 i 
                               
                             
                             ) 
                           
                           3 
                         
                       
                       ≠ 
                       
                         
                           s 
                           2 
                         
                         + 
                         
                           α 
                           
                             3 
                             ⁢ 
                             i 
                           
                         
                         + 
                         
                           
                             ( 
                             
                               
                                 σ 
                                 2 
                               
                               + 
                               
                                 
                                   α 
                                   i 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       s 
                                       1 
                                     
                                     + 
                                     
                                       α 
                                       i 
                                     
                                   
                                   ) 
                                 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                             
                               ( 
                               
                                 
                                   s 
                                   1 
                                 
                                 + 
                                 
                                   α 
                                   i 
                                 
                               
                               ) 
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   34 
                   ) 
                 
               
             
           
         
       
     
     A first comparison value (s 1 +α i ) 3  is determined on the basis of the bit position i and the first partial error syndrome s 1 . A second comparison value s 2 +α 3i  is determined on the basis of the bit position i and the second partial error syndrome s 2 . 
     The bit position i is corrected with Δ i =1 if the comparison of the first comparison value to the second comparison value assumes a specified value, in this case the specified value 
       (α j α k )(α j +α k )=(σ 2 α i ( s   1 +α i ))( s   1 + 60   i )   (35)
 
     The bit position i is not corrected, or is corrected with Δ i =0, if the comparison of the first comparison value to the second comparison value does not assume the specified value as per equation (35). 
     An advantage of the method presented here for forming a correction value for the i-th bit is, for example, that values that depend on the syndrome components can be formed and provided only once (e.g., centrally). Thus, for example the value 
       s 1 σ 2  
 
     can be determined once and can be provided for a plurality of bit positions. Advantageously, the formation of the term s 1 +α i  does not require a component-by-component XOR operation. Instead, inverters can be used in simplified fashion to this end: The components of s 1  in which α i  equals 1 are inverted; components in which α i  equals 0 remain unchanged. Corresponding explanations apply to the addition of α 3i . 
     Likewise, the value 
       s 1   2 +σ 2  
 
     need only be formed once and can be provided as an m-bit wide value for all bit positions to be corrected. In each bit position i to be corrected, all that still is required is a multiplication by the constant α i . For the i-th bit position, the value s 1 +α i  can advantageously be realized by inverting the bits of the m-bit vector s 1  in which the bits of α i  equal 1. It is consequently possible to dispense with a component-by-component XOR operation, significantly reducing the outlay. 
     In an alternative embodiment, the rewritten form 
       (σ 2 +α i ( s   1 +α i ))( s   1 +α i )= s   1 σ 2 +α i ( s   1   2 +σ 2 )+α 3i  
 
     can be used. What then follows from equation (34) is that 
     
       
         
           
             
               
                 
                   
                     
                       Δ 
                       i 
                     
                     = 
                     
                       
                         1 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         for 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             ( 
                             
                               
                                 s 
                                 1 
                               
                               + 
                               
                                 α 
                                 i 
                               
                             
                             ) 
                           
                           3 
                         
                       
                       = 
                       
                         
                           s 
                           2 
                         
                         + 
                         
                           α 
                           
                             3 
                             ⁢ 
                             i 
                           
                         
                         + 
                         
                           
                             s 
                             1 
                           
                           ⁢ 
                           
                             σ 
                             2 
                           
                         
                         + 
                         
                           
                             α 
                             i 
                           
                           ⁡ 
                           
                             ( 
                             
                               
                                 s 
                                 1 
                                 2 
                               
                               + 
                               
                                 σ 
                                 2 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           α 
                           
                             3 
                             ⁢ 
                             i 
                           
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       Δ 
                       i 
                     
                     = 
                     
                       
                         0 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         for 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             ( 
                             
                               
                                 s 
                                 1 
                               
                               + 
                               
                                 α 
                                 i 
                               
                             
                             ) 
                           
                           3 
                         
                       
                       ≠ 
                       
                         
                           s 
                           2 
                         
                         + 
                         
                           α 
                           
                             3 
                             ⁢ 
                             i 
                           
                         
                         + 
                         
                           
                             s 
                             1 
                           
                           ⁢ 
                           
                             σ 
                             2 
                           
                         
                         + 
                         
                           
                             α 
                             i 
                           
                           ⁡ 
                           
                             ( 
                             
                               
                                 s 
                                 1 
                                 2 
                               
                               + 
                               
                                 σ 
                                 2 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           
                             α 
                             
                               3 
                               ⁢ 
                               i 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   36 
                   ) 
                 
               
             
           
         
       
     
     A further option consists, in equation (27), of representing the value α j ·α k  on the basis of the i-th bit position using a symmetric function σ 3    
       σ 3 =α i α j α k    (37)
 
     as 
       α j α k =σ 2 ·α −i    (38)
 
     The following then emerges from equation (27): 
       ( s   1 +α i ) 3   =s   2 +α 3i +σ 3 ·( s   1 +α i )·α −i    (39)
 
     Using the partial error syndromes s 1 , s 2 and the symmetric function σ 2 , the symmetric function σ 3  can be represented by: 
       σ 3   =s   1   3   +s   2 s 1 ·σ 2    (40)
 
     This can be verified by inserting the values s 1 , s 2  and σ 2 . 
     If 1-bit errors, 2-bit errors and 3-bit errors should be corrected, it is an option, if a 1-bit error or a 2-bit error occurs, to determine a correction value Δ i  for the i-th bit such that 
     
       
         
           
             
               
                 
                   
                     
                       Δ 
                       i 
                     
                     = 
                     
                       
                         1 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         for 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             ( 
                             
                               
                                 s 
                                 1 
                               
                               + 
                               
                                 α 
                                 i 
                               
                             
                             ) 
                           
                           3 
                         
                       
                       = 
                       
                         
                           s 
                           2 
                         
                         + 
                         
                           α 
                           
                             3 
                             ⁢ 
                             i 
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       Δ 
                       i 
                     
                     = 
                     
                       
                         0 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         for 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             ( 
                             
                               
                                 s 
                                 1 
                               
                               + 
                               
                                 α 
                                 i 
                               
                             
                             ) 
                           
                           3 
                         
                       
                       ≠ 
                       
                         
                           s 
                           2 
                         
                         + 
                         
                           α 
                           
                             3 
                             ⁢ 
                             i 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   41 
                   ) 
                 
               
             
           
         
       
     
     applies, and that equation (34), for example, applies in the case of a 3-bit error. 
     In the case of a 1-bit error or a 2-bit error, a comparison value between 
       (s 1 +α i ) 3  
 
     and 
       s 2 +α 3i  
 
     is constant and identical for all bit positions. In the case of a 3-bit error, this comparison value is determined by the bit position i, and the values of the symmetric function σ 2  and the component of the error syndrome s 1 , which are the same for all bit positions, because, in accordance with the explanations above, the additional term (σ 2 +α i (s 1 +α i ))(s 1 +α i ) is also added. 
     Even if a 2-bit error is present, the correction value Δ i  for the i-th bit can be determined according to equation (34), because for the 2-bit error in bit positions i and j with 
     
       
         
           
             
               
                 σ 
                 2 
               
               = 
               
                 
                   
                     s 
                     3 
                   
                   + 
                   
                     
                       s 
                       1 
                       2 
                     
                     ⁢ 
                     
                       s 
                       3 
                     
                   
                 
                 
                   
                     s 
                     1 
                     3 
                   
                   + 
                   
                     s 
                     2 
                   
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 s 
                 1 
               
               = 
               
                 
                   α 
                   i 
                 
                 + 
                 
                   α 
                   j 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 s 
                 2 
               
               = 
               
                 
                   α 
                   
                     3 
                     ⁢ 
                     i 
                   
                 
                 + 
                 
                   α 
                   
                     3 
                     ⁢ 
                     j 
                   
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 s 
                 3 
               
               = 
               
                 
                   α 
                   
                     5 
                     ⁢ 
                     i 
                   
                 
                 + 
                 
                   α 
                   
                     5 
                     ⁢ 
                     j 
                   
                 
               
             
           
         
       
     
     σ 2  is determined as
 
 σ 2 =α i ·α j  
 
     Hence, 
       (σ 2 +α i ( s   1 +α i ))( s   1 +α i )=0
 
     and in the case of a 2-bit error, the correction value is determinable by 
       ( s   1 +α i ) 3   +s   2 +α 3i  
 
     as required. 
     Whether there is no error or whether there is a 1-bit error or whether there is a 2-bit error or whether there is a 3-bit error can be determined using the error syndrome components s 1 , s 2 , s 3  and s 4 =s P :
         If no error is present, all error syndrome components s 1 , s 2 , s 3  and s 4 =s P  are equal to 0. Otherwise an error is present.   If a 1-bit error is present, s 1   3 =s 2  and s P =1 then and applies.   If a 2-bit error is present, s P =0 then s 1   3 ≠s 2  and applies.   If a 3-bit error is present, s P =1 and s 1   3 ≠s 2  applies.       

     Even though the invention was illustrated more closely and described in detail by the at least one exemplary embodiment shown, the invention is not restricted thereto, and other variations can be derived herefrom by a person skilled in the art without departing from the scope of protection of the invention.