PROCESSING A DATA WORD

Abstract

For example, an approach is proposed for processing a data word in which a data word is received in which a first syndrome of a first code is determined, wherein the first syndrome has components, and in which, if the syndrome of the first code detects an error, a second syndrome of a second code is determined, wherein the second syndrome includes the components of the first syndrome.

Description

[0001] The invention relates to the processing of a data word, in particular the detection and / or correction of an error in the data word.

[0002] The data word is defined, for example, by a predefined set of bits that are read from a memory. These bits can include data bits and / or redundancy bits, the latter being used for error correction.

[0003] The object of the invention is to improve known approaches to error detection and / or error correction with regard to, for example, performance or energy consumption.

[0004] This problem is solved according to the features of the independent claims. Preferred embodiments can be found in particular in the dependent claims.

[0005] To solve the task, a procedure for processing a data word is given. - where a data word is received, - in which a first syndrome of a first code is determined, wherein the first syndrome has components, - in which, if the syndrome of the first code detects an error, a second syndrome of a second code is determined, the second syndrome comprising the components of the first syndrome.

[0006] The components of the syndrome can also be referred to as syndrome components.

[0007] It is advantageous that the syndrome calculation for the received data words is not performed completely, but only partially, i.e., to the extent of the first syndrome. Since most data words are usually error-free, this can result in significant savings in time, computing power, and energy.

[0008] The term "code" here refers to an error code capable of correcting at least one error and detecting at least two errors. The code is defined by a matrix H (control matrix). The code has length n, dimension k = n - r, and minimum distance d, and has 2 k different code words.

[0009] The first code is contained within the second code, i.e., the control matrix of the second code also includes the control matrix of the first code.

[0010] It is a further development that the received data word is recognized as error-free if no errors were detected based on the first syndrome of the first code.

[0011] It is a further development that, in the event that an error is detected based on the first syndrome of the first code, this error is corrected using the second code.

[0012] It is a further development that the first code can detect at least t bit errors and the second code can correct t bit errors.

[0013] It is a further development that the first code has a minimum distance of t + 1.

[0014] It is further information that the first code and / or the second code is a linear code.

[0015] It is a further development that the data word has data bits or data bits and redundancy bits.

[0016] It is a further development that, in the event that an error is detected based on the first syndrome of the first code, this error is corrected only in the data bits using the second code.

[0017] A method for processing a data word is also proposed, - where a data word is received, - in which a first syndrome of a first code is determined, - where, if the syndrome of the first code detects an error, a syndrome of another code is determined and an error correction is carried out based on the syndrome of the further code, or, - if error correction is not possible using the additional code, a second syndrome of a second code is determined, - where the second code is contained within the second code and the first code is contained within the second code.

[0018] One option is for the second code to "contain" a multitude of codes, meaning that there are several additional codes between the first and second codes, each performing a part of the error correction based on an increasing number of syndrome components (also called syndrome coordinates). This corresponds to a stepwise escalation of error correction: Starting with the (first) additional code, an increasing number of syndrome components are calculated, and an attempt is made to perform error correction based on these. If this is successful, the error correction can be completed with fewer syndrome components than those required for the second code. Since every other code is contained within the second code, the second code encompasses all syndrome components. In principle: No.(sC)>No.(sCp)>…>No.(sC2)>No.(sC1), where number (s Y ) indicates the number of syndrome components of syndrome s for the code Y.

[0019] Code C1 is contained within code C2, and so on. All codes C i (with i=1, ..., p) are contained in the code C i+1 (if any) and also in the second code C.

[0020] Thus, only the final stage of error correction involves calculating all syndrome components of the second code C. This is advantageous only if error correction was previously impossible using parts of the syndrome components.

[0021] It is a further development that, in the event that an error not correctable by the further code is detected based on the further syndrome of the further code, this error is corrected by means of the second code.

[0022] A device for processing a data word is also specified, which is set up to perform the steps of the procedure described herein.

[0023] For this purpose, the device may comprise a processing unit, in particular a processor unit, and / or at least a partially hardwired or logic circuit arrangement, which is configured, for example, such that the method described herein can be carried out. Any type of processor or computer with the necessary peripherals (memory, input / output interfaces, input / output devices, etc.) may be provided. The preceding explanations concerning the method apply accordingly to the device. The respective device may be implemented in a single component or distributed across several components.

[0024] Furthermore, a computer program product is specified that can be directly loaded into the memory of a digital computer and includes program code segments by means of which the steps of the procedure described herein can be carried out.

[0025] Furthermore, the above-mentioned problem is solved by means of a computer-readable storage medium, e.g., any memory, comprising instructions executable by a computer (e.g., in the form of program code) that are suitable for the computer to perform steps of the procedure described here.

[0026] The properties, characteristics, and advantages described above, as well as the manner in which they are achieved, are further explained in connection with the following schematic description of exemplary embodiments, which are further clarified in conjunction with the drawings. For clarity, identical or equivalent elements may be designated with the same reference numerals. Fig. Figure 1 shows a control matrix H, where a region of this control matrix determines a control matrix H1'. Fig. Figure 2 shows an example control matrix H3 with a dashed-marked area that is called a submatrix of the control matrix H3. Fig. Figure 3 shows an example control matrix H5 with two submatrices. Fig. Figure 4 shows an example control matrix H6 of a systematic linear (15, 4, 8) code C and three submatrices. Fig. Figure 5 shows a schematic diagram of escalated syndrome calculations according to Example 5. Fig. Figure 6 shows an example flowchart for a reduced syndrome calculation. Introduction, Terms

[0027] The following notations are used: GF(2) = {0, 1} is the finite field of order two, GF(2) n is the n-dimensional vector space of all binary row vectors of length n and c T GF is the transposed vector of a vector c. The abbreviation GF denotes the Galois field.

[0028] H is a binary r × n matrix, i.e., a matrix with entries of zeros and ones, having r rows and n columns. If the r rows of the matrix H are linearly independent as vectors of the vector space V=GF(2) n , the matrix H has rank r.

[0029] The matrix H defines a linear code C of length n and dimension k = n - r. The code C is the null space of the matrix H, i.e. C={c∈GF(2)n:HcT=0}.

[0030] The matrix H is called the parity check matrix of code C. Code C is uniquely defined by the parity check matrix H. However, the reverse is not true: a code C has multiple (equivalent) parity check matrices.

[0031] The code C is a k-dimensional linear subspace of the n-dimensional GF(2) vector space V=GF(2) n Therefore, code C contains exactly 2 kDifferent vectors, referred to as codewords of code C. Every linear code contains the zero vector 0 as one of its codewords.

[0032] The number of ones in a vector v from V=GF(2) n The Hamming weight w(v) of the vector v is called the minimum distance d of a code C. This is the smallest Hamming weight found among all non-zero codewords. d=min{w(c):c∈C withc≠0}.

[0033] In a linear code with minimum distance d, two different codewords differ by at least d coordinates. This is the basis for a code's ability to detect and / or correct a certain number of bit errors (which can occur, for example, during data transmission or storage).

[0034] A code with the minimum distance d can detect all t-bit errors with 1 ≤ t ≤ d-1 and correct all e-bit errors with 1 ≤ e < d / 2.

[0035] A code can therefore detect at least twice as many bit errors as it can correct. For example, if the minimum distance d=5, all 1-bit and 2-bit errors can be corrected, and all 1-bit, 2-bit, 3-bit, and 4-bit errors can be detected. Similarly, with a minimum distance of d=4, all 1-bit errors can be corrected, and all 1-bit, 2-bit, and 3-bit errors can be detected.

[0036] A key component for error detection and correction is the so-called syndrome calculation.

[0037] The syndrome S(y) of the received data word y is a column vector of length r. Only codewords are transmitted. If no errors occurred during transmission, the received data word y is identical to the transmitted codeword c, and the syndrome S(y) is zero. If one or more bits were corrupted (inverted) during transmission, the received data word y differs from the transmitted codeword c at the corresponding positions, the so-called error positions. The syndrome S(y) is then almost always non-zero. An exception is the rare case where the corrupted received data word y is itself another codeword (different from the transmitted one): In this case, S(y) = 0, which allows for the false interpretation that the data word y is error-free.

[0038] A syndrome of y is determined by the rxn control matrix H of the code. It holds that S(y)=H⋅yT.

[0039] The control matrix H of a linear code is not uniquely determined. For every invertible r × r matrix J with r = n - k, H′=J⋅H also a control matrix of code C. For this reason, the syndrome is only defined relative to a given control matrix H.

[0040] Although a linear code has numerous equivalent check matrices, in practice predominantly codes are used for which an efficient error correction algorithm is known. The error correction algorithm uses properties of a specific check matrix H, and it requires as input the syndrome calculated with this check matrix. From an implementation perspective, the check matrix H of the code, and thus also the syndromes S(y) of vectors y from V=GF(2), are therefore... n clearly determined.

[0041] Furthermore, from an implementation point of view, a linear code C is a structured vector space and an efficient method for error correction with a distinguished control matrix H for syndrome calculation.

[0042] Code C preferably has the following main properties: - Main feature 1: All error-free data words y are recognized as error-free. - Main feature 2: All sufficiently small errors that occur during transmission are corrected. "Sufficiently small" here means, in particular, that fewer than d / 2 bit errors have occurred in the transmitted codeword, where d is the minimum distance of the code.

[0043] If an error occurs during the transmission of a codeword that is no longer sufficiently small, i.e., more than d / 2 bit errors have occurred, the following cases can be distinguished: - Case A: The received data word is recognized as erroneous (and uncorrectable). - Case B: The received, erroneous data word is incorrectly classified as error-free because its syndrome is zero. (The transmitted codeword has been corrupted into another codeword; a codeword is recognized, therefore the syndrome is zero, but it is the wrong codeword.) - Case C: The syndrome is non-zero; the erroneously received data word is fed to the error correction algorithm, which, however, constructs an incorrect error vector from it. In this case, a so-called decoding error occurs.

[0044] The uncorrectable data words of a code can therefore be divided into two classes: - Into class I of data words identifiable as faulty (case A). - Into class II of data words that are incorrect but are either not recognized as faulty (case B) or are recognized as faulty, but are transformed into an incorrect codeword (different from the correct codeword) during the "error correction" process (case C).

[0045] The relative sizes of class I and class II together determine the secondary property of the code: Class I should be as large as possible and class II as small as possible: Then as many errors as possible will be detected and as few errors as possible will remain undetected. Reduced syndrome calculation

[0046] Errors occur relatively rarely during typical data transmission. This means that the syndromes of the received data words are usually zero. Therefore, error correction is unnecessary. In this case, syndrome calculation is always performed, while error correction is rarely executed. The average processing time and power consumption of the decoding process are thus largely determined by the processing time and power consumption for the syndrome calculation, respectively.

[0047] The exemplary embodiments described herein aim to perform the syndrome calculation for the received data words not completely, but only up to a certain point. Such partial determination of the syndrome can be sufficient to detect possible errors in the received message and to reduce the overall computational effort (processing power, duration, power consumption) for the syndrome calculation and thus for the decoding.

[0048] For example, a shortened syndrome can be determined: - If the shortened syndrome is zero, the received message is classified as error-free. - If the abbreviated syndrome is not equal to zero (then, of course, the complete syndrome is also not equal to zero), an error has occurred. Only in this case is the missing part of the complete syndrome calculated and the error correction performed using the complete syndrome.

[0049] Preferably, linear codes can be used for which the main properties 1 and 2 are fully preserved in a (suitable) abbreviated syndrome calculation. With these codes, the abbreviated syndrome calculation only affects the secondary properties of the code. Suitable codes for a simplified syndrome calculation

[0050] Codes for a shortened syndrome calculation preferably fulfill the following condition: The linear (n, k, d) code C has an error correction algorithm with an associated control matrix H, which contains a submatrix H1, whose null space defines a (weaker) code C1, and the code C1 can already detect all errors that the original code C can and should correct.

[0051] For illustrative purposes, code C will be referred to as the strong code and code C1 as the weak code.

[0052] From the above condition follows a necessary and sufficient condition for the minimum distances of the two codes C and C1: If the (strong) code C has the minimum distance d=2t+1 or d=2t+2 If the (weak) code C1 has at least the minimum distance d1=t+1.

[0053] In order for the (strong) code C to correct up to t bit errors, the (weak) code C1 must be able to detect at least up to t bit errors.

[0054] The greatest power savings occur when the (weak) code C1 has exactly the minimum distance d1 = t + 1. This case represents an optimum for a suitable code C with minimum length n.

[0055] Furthermore, it is proposed to use such linear codes C, for which a (weak) code C1 with the minimum distance d1 = t + 1 exists in the sense of the above description, for error correction.

[0056] Different approaches are presented below. Method 1: C and C1 have the same length

[0057] The (weak) error-detecting code C1 and the original error-correcting (strong) code C have the same length n.

[0058] As a vector space, code C1 contains code C as a subspace. The abbreviated syndrome calculation is then the regular syndrome calculation in the weakened code C1. This means that code C1 does not need to be implemented separately; it is part of the syndrome calculation for code C.

[0059] This method is preferably used when the goal is to correct all coordinates of the received message word or to verify them as error-free. If only parts of a received message word are of interest, it is sufficient to correct the coordinates contained within them (this is explained in more detail below in Method 2).

[0060] Method 1 is particularly suitable for codes with non-canonical check matrices. Linear codes with efficient error correction algorithms often have non-canonical check matrices for syndrome calculation: The error correction algorithm then requires syndromes as input, which must be calculated using a specific non-canonical check matrix.

[0061] Codes with canonical control matrices are described below under Method 2. Example 1:

[0062] As an example, a double-error-correcting BCH code C of length n = 15 is considered. This code has dimension k = 7 and minimum distance d = 5. The check matrix H is given by: H=[10001001101011101001101011110000100110101111000010011010111 1100011000110001000110001100011001010010100101011110111101111]

[0063] The codewords c ∈ C and the incoming message words y have a length of 15. The syndrome S(y) is a column vector of length 8.

[0064] The first four rows of the control matrix H result in a 4 x 15 submatrix H1: H1=[100010011010111010011010111100001001101011110000100110101111]

[0065] The null space C1 of matrix H1 is a linear (15, 11, 3) code. Since code C1 has a minimum distance d1 = 3, it can detect all 1-bit errors and all 2-bit errors. The original BCH code C has a minimum distance d = 5 and can therefore correct all 1-bit errors and all 2-bit errors.

[0066] The (long) syndrome S(y) of y in the BCH code C is given by: S(y)=H⋅yT=(s1,s2,s3,s4,s5,s6,s7,s8)T

[0067] The (shorter) syndrome s(y) of y in the code C1 is the first half of the long syndrome S(y) and is therefore given by: s(y)=H1⋅yT=(s1,s2,s3,s4)T

[0068] If the incoming data word y is error-free, then both syndromes are zero.

[0069] Fig. Figure 6 shows an example flowchart for the reduced syndrome calculation. In step 701, the data word y is received. In the subsequent step 702, only the (short) syndrome s(y) is initially calculated. In step 703, it is then checked whether the short syndrome s(y) is equal to zero. If s(y) = 0, the data word y is already classified as error-free. If, however, the short syndrome s(y) ≠ 0, the process branches to step 704 and calculates the long syndrome S(y). Since the short syndrome s(y) already represents the first half of the long syndrome S(y), only the second half of S(y) needs to be calculated in this case. The long syndrome S(y) serves as input to the error correction algorithm (step 705). If a 1-bit error or a 2-bit error is present, it can be corrected.

[0070] This approach enables significant power savings for the hardware implementation of the code's associated error correction procedure: Since a large proportion of the received data words y are error-free, only the small syndrome s(y) is calculated for them. Because only half of the circuitry is active for syndrome calculation, the power savings during decoding are approximately 50%.

[0071] It should be noted that the two codes used in the example, (15, 7, 5) and (15, 11, 3), have the shortest possible length for the given parameters. The error detection property is available for 11 data positions in the shorter code, while the error correction property is only needed for 7 data positions in the longer code.

[0072] In Example 1, the calculation of the short syndrome was performed based on the first four rows of matrix H. It is also possible to use a different selection of four rows. For example, if the first, fifth, sixth, and seventh rows of matrix H are used, the short syndrome results in the vector (s1, s5, s6, s7). The 4x15 submatrix of matrix H, consisting of the aforementioned four rows, has three empty columns, namely columns 2, 7, and 12. Thus, in this case, the underlying code C1 for error detection is a linear (12, 8, 3) code whose check matrix H1' is given by H1′=[100101101111100110011001001100110011010101010101]

[0073] Fig. Figure 1 illustrates how the control matrix H1' is derived from matrix H according to the preceding description. The control matrix H1', ​​identified by the dashed lines, is a submatrix of matrix H.

[0074] The new, associated code C1 is not yet optimal: For this, a (11, 7, 3) code would be necessary, whose 4 × 11 control matrix does not appear as a submatrix in the matrix H.

[0075] If the new shortened syndrome (s1, s5, s6, s7) T If the value of y is not equal to zero, then the remaining syndrome coordinates s2, s3, s4, and s8 are calculated using the matrix H. The complete syndrome is S(y) = (s1, s2, s3, s4, s5, s6, s7, s8) T This forms the input for the error correction algorithm.

[0076] If the shortened syndrome (s1, s5, s6, s7) T If the value is zero, this means (assuming that at most a 2-bit error has occurred) that the coordinates y1,y3,y4,y5,y6;y8,y9,y10,y11,y13,y14 and y15 are error-free. To determine the complete codeword, the missing coordinates y2, y7, and y12 are calculated from the 12 already known coordinates. After this, the complete transmitted codeword is available.

[0077] This approach is also correct if transmission errors should have occurred at positions 2, 7 or 12.

[0078] As previously explained, the main properties of the code are preserved in the power-saving operating mode (with the abbreviated syndrome calculation). The approach proposed here only affects the secondary properties of the code in such a way that the number of possible decoding errors of undecipherable received messages increases due to the abbreviated syndrome calculation (case A above becomes case B).

[0079] To illustrate, let's assume a 3-bit error occurs in a BCH codeword. Since the BCH code C in Example 1 has a minimum distance d=5, 3-bit errors cannot be corrected. Because the codeword length n=15, there are a total of (153)=15!3!⋅(15−3)!=455 There are several possibilities for a 3-bit error. Of these 455 possible error patterns, 275 data words with a 3-bit error are identified by the error correction algorithm as faulty and undecipherable. Referring to the classes introduced above, this means that Class I (Case A) contains 275 elements. The remaining 180 data words with a 3-bit error are incorrectly classified as decodable and transformed by the error correction algorithm into a different BCH codeword (Case C). Class II therefore contains 180 elements. (Case B does not occur in this example because the syndrome of a codeword with a 3-bit error in a code with a minimum distance d=5 cannot be zero.)

[0080] The approach proposed here, using the abbreviated syndrome calculation, yields the following: The (short) code C1 is a linear (15, 11, 3) code with 2 11= 2048 codewords. Of these, 35 codewords have a Hamming weight of 3. If a 3-bit error occurs in the transmitted BCH codeword during transmission at precisely the positions where a 1 is found in one of the aforementioned 35 codewords, then the short syndrome s(y) of the received data word y has the value zero, and the received message y is classified as error-free, even though it contains a 3-bit error. This means that the originally empty case B now contains 35 elements, and case A only 240 elements. Case C contains 180 elements in both cases, i.e., with shortened and full syndrome calculations.

[0081] If, instead, the long syndrome S(y) had been calculated for the message y, it would have been determined that it was non-zero. The value S(y) would have been fed into the error correction algorithm, and the error correction algorithm would have classified y as erroneous and uncorrectable.

[0082] In summary, the conventional method detects 275 of the 455 possible patterns for 3-bit errors. In power-saving mode, only 240 of all 3-bit errors are detected.

[0083] The difference in the code's secondary properties plays a minor role in practical applications, as the occurrence of uncorrectable errors is very unlikely. Assume the probability of a bit error at any position during data transmission is p = 0.002 and the code has a length of n = 15. In this case, 97% of the transmitted codewords arrive without errors. Furthermore, it follows that a 1-bit error occurs in 2.91% of transmissions, a 2-bit error in 0.04%, and a 3-bit error only in 2.8 × 10⁻⁵ of transmissions. 5 Transmissions occur. Systematic codes:

[0084] Let the code C be a linear (n, k, d) code. In a codeword c ∈ C, k coordinates can be freely chosen. The remaining n - k coordinates of the codeword are then linear combinations (i.e., XOR sums for codes over GF(2)) of the k freely chosen coordinates. In a so-called systematic code, the k freely chosen coordinates appear explicitly in the codeword.

[0085] The codewords c in a systematic linear (n, k, d) code often have the form c=(b1,…,bk,ck+1,…,cn).

[0086] This means that the k freely selectable message bits b1, ..., b k c for redundancy bits r = n - k k+1 , ..., c n to be expanded.

[0087] In many applications, only the transmitted message bits are of interest. The redundancy bits serve solely to detect and correct potential transmission errors in the message bits. The decoding process is considered complete once the error-free nature of the message bits has been verified or any erroneous message bits have been corrected. Erroneous redundancy bits are not corrected.

[0088] The main properties 1 and 2 mentioned above can therefore be modified as follows: - Main feature 1: The error-free message bits in a received data word y are recognized as error-free. It must be recognizable that the message bits are correct; the other bits are of secondary importance. If needed, they can be deterministically recalculated from the message bits. - Main feature 2: All sufficiently small errors in the message bits that occur during transmission are corrected. "Sufficiently small" here means, in particular, that fewer than d / 2 bit errors have occurred in the transmitted codeword, where d is the minimum distance of the code.

[0089] The control matrix H of a systematic (n, k, d) code C has the form H=(A,I), where A is an r × k matrix and I is the r × r identity matrix with r = n - k. Example 2:

[0090] The control matrix H2=[11101000110101001011001001110001] defines a systematic linear (8, 4, 4) code (a Reed-Muller code). Four redundancy bits c5, ..., c8 are appended to four message bits b1, ..., b4. For an arbitrary row vector c=(b1,b2,b3,b4,c5,c6,c7,c8) The redundancy bits are derived from the message bits as follows:

[0091] It holds true that c is a codeword if and only if H⋅cT=0, that is, precisely when the following is true: b1⊕b2⊕b3⊕c5=0, b1⊕b2⊕b4⊕c6=0, b1⊕b3⊕b4⊕c7=0 b2⊕b3⊕b4⊕c8=0.

[0092] The following follows: c5=b1⊕b2⊕b3, c6=b1⊕b2⊕b4, c7=b1⊕b3⊕b4 and c8=b2⊕b3⊕b4. Method 2:

[0093] The (weak) error-detecting code C1 and the original (strong) error-correcting (n, k, d) code C have the same dimension k, but different lengths: The code C1 is a (n1, k, d1) code with n1 < n and d1 = t + 1, if the error-correcting code C has the minimum distance d = 2t + 1 or d = 2t + 2.

[0094] The codes C1 and C therefore contain the same number (exactly 2). k) Codewords. The codewords of code C1 are abbreviated codewords of C. It is assumed that an abbreviated codeword of a systematic code C1 consists of the first n1 coordinates of the corresponding codeword of the systematic code C.

[0095] When a data word y is received, the syndrome in code C1 is first calculated (as in Method 1). If this (short) syndrome has the value zero, then the k message bits of the n-bit data word are classified as error-free and the data decoding is (successfully) completed. The coordinates yi where n1 < i ≤ n are not included in the syndrome calculation, although at least one of these coordinates y may be. i This may be incorrect. However, since these coordinates are (only) redundancy bits, error detection or correction for these coordinates y is not possible. i of secondary interest. The realization that the news bits y1=b1,…,yk=bk If the bits are error-free according to code C1, this is sufficient for decoding. If an application also requires the remaining (error-free) redundancy bits, these can be determined from the message bits.

[0096] If the syndrome calculated in code C1 is not zero, the received data word y is faulty. Now, the (strong) code C is used to calculate the long syndrome, and the error correction is performed in code C. The long syndrome is actually an extension of the short syndrome, so the coordinates already calculated for the short syndrome can be used. Example 3:

[0097] Fig. Figure 2 shows an example control matrix H3 with a dashed-marked area 201, which is referred to as a submatrix of the control matrix H3.

[0098] The control matrix H3 defines a linear systematic (15, 4, 8) code with dimension k = 4. This code protects 4 message bits against errors. Eleven redundancy bits are appended to these 4 message bits, resulting in a codeword of length n = 15. The code has a minimum distance d = 8. Therefore, all 1-bit errors, all 2-bit errors, and all 3-bit errors can be corrected within the 15-bit codeword.

[0099] The 4 x 8 submatrix of the control matrix H3 is identical to matrix H2 from Example 2. This submatrix defines a linear systematic (8, 4, 4) code C1 with a minimum distance d1 = 4. Therefore, code C1 can detect all 1-bit errors, all 2-bit errors, and all 3-bit errors. Thus, the weak code C1 can detect precisely those errors that the strong code C can correct.

[0100] Given y = (y1, ..., y 15 ) as the received data word. For the shortened vector y^=(y1,…,y8) The shortened syndrome s^=H2⋅y^T calculated. The shortened syndrome ŝ has a length of 4. If the shortened syndrome ŝ has the value zero, the eight message bits in ŷ = (y1, ..., y8) are error-free, i.e., in the entire data word y = (y1, ..., y8). 15 No more than a 3-bit error occurred. If the short syndrome ŝ is not zero, the code C will execute for the entire data word y = (y1, ..., y). 15 ) the 11-bit long syndrome s=H3⋅yT calculated. It is sufficient to calculate the remaining 7 syndrome coordinates; the first four syndrome coordinates are identical to the coordinates of the abbreviated syndrome ŝ.

[0101] The long syndrome s is entered into the error correction algorithm and all existing errors in the data word y = (y1, ..., y) are corrected. 15 ) corrected. In particular, any errors in the four message bits are corrected. b1=y1, b2=y2, b3=y3 and b4=y4 corrected.

[0102] It should be noted that the codes C (15, 4, 8) and C1 (8, 4, 4) used in this example have the shortest possible length for the given dimension and minimum distance and are therefore optimally chosen. Further designs and advantages

[0103] The preceding section addressed the following problem: Given a strong (i.e., long or large) code C for error correction, and a weak (i.e., short or small) code C1 for error detection, the code parameters (length, dimension, minimum distance) of both codes are chosen such that the weak code C1 can detect all errors that the strong code C can correct.

[0104] It should be noted that the attributes "large" and "small" refer to the code parameters and not to the size of the sets C and C1. For example, the weak code C1 can contain more codewords than the strong code C.

[0105] If the control matrix of code C1 is a submatrix of the control matrix of code C, then code C1 is "contained" in code C.

[0106] The introduction and use of the error detection code C1 is also motivated by the fact that in most cases the received data words are error-free, or that simple errors occur far more frequently than multiple errors. As the number of errors per data word increases, their probability of occurrence decreases. Therefore, in the majority of cases, error detection using the weaker code C1, which has a shorter syndrome, is sufficient to save power and / or processing time. Variant: More than two codes

[0107] The approach described here can be extended to more than two codes. For example, it is possible to use three (or more) codes that are "contained" within each other.

[0108] The strong code C is used to correct errors that occur rarely. The weak code C1 is used to determine whether the received data word contains errors or not (in most cases it is error-free, so fewer syndrome calculations are required during decoding). A medium code can be used to correct small errors (e.g., all 1-bit errors).

[0109] As previously stated, in most cases no errors occur. Furthermore, single errors occur far more frequently than multiple errors. In the example above, it was stated that 1-bit errors occur approximately 73 times more frequently than 2-bit or 3-bit errors. Example 4:

[0110] Fig. Figure 3 shows an example check matrix H5. The null space of the code C of matrix H5 is a linear (15, 6, 6) code, i.e., a (non-systematic) code with length n=15, dimension k=6, and minimum distance d=6. This code C can correct all 1-bit errors and all 2-bit errors.

[0111] In Fig. Figure 3 shows a 4 x 15 submatrix 401, which determines a linear (15, 11, 3) code C1. Code C1 is identical to the Hamming code of length 15. With this code C1, all 1-bit errors and all 2-bit errors can be detected using a 4-bit syndrome vector. sC1=(s1,s2,s3,s4)T.

[0112] Also in Fig. Figure 3 shows a 5 x 15 submatrix 402 that defines a linear (15, 10, 4) code C2. With this code C2, all 1-bit errors can be corrected and all 2-bit errors can be detected using a 5-bit syndrome vector. sC2=(sC1,s5)=(s1,s2,s3,s4,s5)T.

[0113] The large Code C can also correct all 2-bit errors, with the error correction algorithm using the 9-bit syndrome as input. s=(sC2;s6,s7,s8,s9)T=(s1,s2,s3,s4,s5,s6,s7,s8,s9)T needed.

[0114] To illustrate how it works, three calculation examples are given below: Example 4a:

[0115] The received data word is y=(001011110000001).

[0116] The syndrome s1 is identified in the code C1 using the control matrix 401. sC1=(0,0,0,0)T determined. Since the syndrome s1 is equal to zero, y is classified as error-free. Example 4b:

[0117] The received data word is y=(1111000000000100).

[0118] The syndrome is described in code C1. sC1=(1,0,0,1)T≠0 determined. Since s1 is not equal to zero, the data word y contains at least one error. Using the fifth row of matrix H5, the syndrome coordinate s5 is determined to be s5 = 1. Therefore, the syndrome s C2 given in the middle code C2 by sC2=(1,0,0,1,1)T.

[0119] The rule for error correction in code C2 is: If the syndrome s C2 If the Hamming weight is odd, a 1-bit error is present. The position of the 1-bit error can be determined by the first 4 syndrome coordinates of s. C2 can be interpreted as a binary representation of the fault location. In this case, the fault location is the position (1001)B=9.

[0120] The corrected codeword is therefore c=(111100001_000100). Example 4c:

[0121] The received data word is y=(011101110000000)

[0122] The syndrome s C1The code C1 results in sC1=(0,0,1,1)T≠0.

[0123] The syndrome sC2=(0,0,1,1,0)T It has an even Hamming weight. Therefore, it is not just a 1-bit error. Thus, the long syndrome is present. s=H4⋅yT The strong code C is calculated. The first five syndrome coordinates are already known; it results in s=(0,0,1,1,0,1,0,1,0)T.

[0124] The long syndrome is fed into the error correction algorithm. This calculates the positions of the 2-bit error in approximately 20 steps. The error positions are 7 and 11. Therefore, in this case, the corrected codeword is... c=(011101010010000).

[0125] In example 4, the three nested codes had the same length n = 15. In a subsequent example, the three codes have the same dimension k = 4. Example 5:

[0126] Fig. Figure 4 shows an example control matrix H6 of a systematic linear (15, 4, 8) code C. With this code, all 1-bit errors, all 2-bit errors, and all 3-bit errors can be corrected.

[0127] In Fig. Figure 4 shows a 4 x 8 submatrix 501, which defines a linear (8, 4, 4) code C0. Since the code C0 has a minimum distance of 4, it detects all 1-bit errors, all 2-bit errors, and all 3-bit errors. The syndrome of code C0, which must be computed for error detection, has a length of 4 and is determined by (s1,s2,s3,s4)T.

[0128] It should be noted that the code C0 does not correct errors, but only detects them.

[0129] In Fig. Figure 4 shows a 7 × 11 submatrix 502, which defines a linear (11, 4, 5) code C1. Code C1 is used to correct 1-bit errors, which, due to the special structure of submatrix 502, is hardly more computationally expensive than the syndrome calculation itself. The syndromes in code C1 have a length of 7. The syndrome in code C1 is determined by (s1,s2,s3,s4,s5s6,s7)T.

[0130] Furthermore, matrix H6 contains an 8 × 12 submatrix comprising submatrix 502 and elements 503. This 8 × 12 submatrix defines a linear (12, 4, 6) code C2. Code C2 can correct all 2-bit errors. The syndromes in code C2 have a length of 8 and the form (s1,s2,s3,s4,s5,s6,s7,s10)T.

[0131] Finally, with Code C, all 3-bit errors can also be corrected using the 11-bit syndrome. s=H6⋅yT=(s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11)T.

[0132] Fig. Figure 5 shows a schematic diagram of the escalated syndrome calculations according to the preceding Example 5.

[0133] Step 601 checks whether the syndrome of code C0 is error-free. If so, the received data word is accepted as error-free without further syndrome calculation(s) and processed further.

[0134] If step 601 determines that at least one error is present, the process proceeds to step 602. There, it is checked whether a 1-bit error exists using code C1 and its associated syndrome, and if so, this 1-bit error is corrected. The corrected data word is then processed further.

[0135] If step 602 shows that there is no 1-bit error, the process branches to step 603. Using the extended syndrome of code C2, it is checked whether a 2-bit error is present and, if so, this 2-bit error is corrected. The corrected data word is then processed further.

[0136] If step 603 shows that there is no 2-bit error, the process branches to step 604. Using the (full) syndrome of code C, a 3-bit error can now be corrected. The corrected data word is then processed further.

[0137] The in Fig. The five given probabilities for the occurrence of error-free data words, as well as for the occurrence of 1-bit, 2-bit, and 3-bit errors, are to be understood as examples, but they show that the probabilities for higher-order errors per data word decrease significantly. Therefore, it is advantageous that longer syndromes are calculated correspondingly less frequently. Suitable codes for a simplified syndrome calculation

[0138] An optimal binary (n, k, d) code C with minimum code length n for a given dimension k and a given minimum distance d is generally not uniquely determined by these properties. For a unique description of the code C, specifying its generator matrix is ​​suitable, for example. For a parameter set (n, k, d), there often exist many matrices that generate such a code C.

[0139] Equivalence classes can be defined on this set of matrices: For example, the properties of a code do not change if rows or columns of its generator matrix are permuted. For codes in non-systematic representations, the equivalence relation can be extended beyond row and column permutations to include row and column operations (that is, linear combinations of rows or columns).

[0140] To find a sufficiently strong code C with a suitable weak code C1, one can, for example, iterate over a system of representatives of its equivalence classes and test for each representative whether it contains a suitable subcode. In practical applications, this method works primarily for short code lengths because both determining a system of representatives of non-equivalent codes is mathematically expensive, and the number of cases to be tested (and thus the size of the search space) grows exponentially.

[0141] Alternatively, the following heuristic procedure can be used to find suitable codes: Starting with an (n, k, d) code of shortest possible length, given, for example, by its generator matrix, transformations can be performed on small sub-sections of the matrix (for example, changing the bits of a few entries). After each transformation, it is tested whether the resulting matrix still generates an (n, k, d) code and whether, secondly, the matrix contains the desired subcode as a submatrix. If both conditions are met, the representation of a suitable code has been found. Otherwise, the procedure is iterated, and, for example, a systematically next transformation is applied to the original code matrix.

[0142] Although the invention has been illustrated and described in detail by the at least one embodiment shown, the invention is not limited to this embodiment and other variations can be derived by a person skilled in the art without leaving the scope of protection of the invention.

Claims

[1] Method for processing a data word, - in which a data word is received, - in which a first syndrome of a first code is determined, the first syndrome having components, - in which, if the syndrome of the first code detects an error, a second syndrome of a second code is determined, the second syndrome comprising the components of the first syndrome. [2] Method according to claim 1, wherein the received data word is recognized as error-free if no errors were detected based on the first syndrome of the first code. [3] Method according to one of the preceding claims, in which, in the event that an error has been detected on the basis of the first syndrome of the first code, this error is corrected by means of the second code. [4] A method according to any one of the preceding claims, wherein the first code can detect at least t bit errors and the second code can correct t bit errors. [5] A method according to claim 4, wherein the first code has a minimum distance of t + 1. [6] Method according to one of the preceding claims, wherein the first code and / or the second code is a linear code. [7] Method according to one of the preceding claims, wherein the data word comprises data bits or data bits and redundancy bits. [8] Method according to claim 7, wherein, in the event that an error has been detected on the basis of the first syndrome of the first code, this error is corrected by means of the second code only in the data bits. [9] Method for processing a data word, - in which a data word is received, - in which a first syndrome of a first code is determined, - in which, if the syndrome of the first code detects an error, a syndrome of a further code is determined and error correction is carried out on the basis of the syndrome of the further code, or, - if no error correction is possible using the additional code, a second syndrome of a second code is determined, - wherein the further code is contained in the second code and the first code is contained in the further code. [10] Method according to claim 9, wherein, in the event that an error which cannot be corrected by means of the further code has been detected on the basis of the further syndrome of the further code, this error is corrected by means of the second code. [11] Device for processing a data word, which is arranged to carry out the steps of the method according to one of the preceding claims. [12] A computer program product which can be loaded directly into a memory of a digital computer, comprising program code parts which are arranged to carry out steps of the method according to one of claims 1 to 10.