The Basic Properties of QR Codes

Let (n, (n + 1) / 2, d) denote a binary QR code with generator polynomial g(x) over a ground field GF(2) and let n be a prime number of the form n = 8l ± 1, where l is an arbitrary positive integer and m be the smallest positive integer such that n divides 2^m – 1. The set Qn of quadratic residues modulo n is the set of nonzero squares modulo n; that is,

}.

1 1

for mod

{  ²   

 j j x n x n

Q_n (2.11)

Let m be the smallest positive integer such that n divides 2^m – 1 and let  be a generator of the multiplicative group of all nonzero elements in GF(2^m). Then the element  = ^u in GF(2^m), where u = (2^m – 1)/n, is a primitive n-th root of unity in GF(2^m). A binary (n, k, d) QR code is a cyclic code with the generator polynomial g(x) of the form,









Qn

i

x i

x

g( ) (  ). (2.12)

A codeword of the (n, k, d) QR code is a binary vector c = (cn-1,…, c1, c0) so that its associated polynomial c(x) = cn-1x ^n-1 + … + c1x + c0 is a multiple of g(x). If the codeword c is transmitted through a noisy channel, and if the vector r = (rn-1,…, r1, r0) is received, then the polynomial r(x) = rn-1x ^n-1 + … + r1x + r0 corresponding to r can be expressed as a sum of the code polynomial c(x) and the error (or error pattern) polynomial e(x) = en-1x ^n-1 + … + e1x + e0, namely r(x) = c(x) + e(x). The set of known syndromes is obtained by evaluating r(x) at the roots of g(x), i.e.,

n

The following lemma given in [16] shows that the mapping between the syndromes and error patterns is one-to-one. For a detailed proof, see [16].

Lemma 2.1 For a (n, k, d) binary cyclic code with the error-correcting capability



^{( 1)/2}



 d

t , the mapping between the syndromes of a code and the error patterns e of weight ≤ t is one-to-one.

If, during the data transmission, v errors occur in the received vector r, then the error polynomial has v nonzero terms, namely, e(x)x^l1 x^lv, where 0  l1 <…< lv  n–1.

And the syndrome S can be written as _i S_i Z1ⁱ Z_vⁱ, where iQ_n and Z_j ^lj for all 1  j  v, are called the error locators. Expanding Eq. (2.13), we obtain the following a sequence of 2t algebraic syndrome equations in the v unknown error locations.

t

Eq. (2.14) is called Power-sum symmetric functions. Since they form s system of nonlinear algebraic equations in multiple variables, they are somewhat difficult to solve in a direct manner. For any binary QR codes, there is an obvious relation among syndromes, namely S_2i S_i², with sub-index modulo n if necessary. Assume that v errors occur: One

defines the error-locator polynomial L(x) to be the polynomial of degree v

where the coefficients of L(x) are

v

The expressions in Eq. (2.16) are the elementary symmetric functions of the error locators. In order to develop the algebraic decoding algorithm, it is well known that the power sums Si and the elementary symmetric functions σj are related by the following Newton identities. For the detailed proof, see [2].

Theorem 2.10 (The Newton identities) For a binary QR code, there is a unique set of identities between the power sums Si and the elementary symmetric functions σj given in the following:

If there is a sufficient number of consecutive known syndromes for a given number of errors, one can directly solve from Newton’s identities for σj, 1 ≤ j ≤ v. However, if there are not enough consecutive syndromes, one first tries to find the unknown syndromes, and then to

find L(z) from the Newton identities. In either case, once L(z) is found, the error pattern is found by a Chien search method of the roots of L(z) over the set of all the n-th roots of unity.

Finally, the error location numbers are the reciprocals of these roots.

The parameters of binary QR codes with code length less than or equal to 241 are listed in Table 2.9.

Table 2.9 The parameters of some binary QR codes

n k d n k d n k d

7 4 3 79 40 15 167 84 23

17 9 5 89 45 17 191 96  27

23 12 7 97 49 15 193 97  27

31 16 7 103 52 19 199 100  31

41 21 9 113 57 15 223 112  31

47 24 11 127 64 19 233 117  25

71 36 11 137 69 21 239 120  31

73 37 13 151 76 19 241 121  31

Chapter 3

Algebraic Decoding Algorithm of the Binary Systematic (23, 12, 7) Golay Code

3.1 Background of the Binary Systematic (23, 12, 7) Golay Code

To introduce the binary (23, 12, 7) Golay code, we first compute the set of quadratic residues, modulo 23, Q23 as follows:

}. root of unity in GF(2¹¹), and the power 11 is the smallest positive integer such that 232¹¹–1.

Let  be a primitive element in GF(2¹¹) such that  is a generator of the multiplicative group of 2¹¹–1 nonzero elements in GF(2¹¹). A binary (23, 12, 7) Golay code is a QR code or a cyclic code with the generator polynomial g(x) of the form

, manner is a perfect code in a sense that the codewords and their three error correction spheres

exhaust the vector space of 23-bit binary vectors. Because the minimum distance of this code is d = 7, the inequality 2v + 1 ≤ 7 is valid, where v is the actual number of errors to be corrected. Hence, the (23, 12, 7) Golay code allows for the correction of up to



^{( 1)/2}



^3

t  d errors, where

 

x denotes the greatest integer less than or equal to x.

From Section 2.5.1, we know that a binary vector c = (c22,…, c1, c0) is a codeword if and only if its associated polynomial c(x) = c22x ²² + … + c1x + c0 is a multiple of g(x), where ci

 GF(2). If r = (r22,…, r1, r0) is a received vector, then its associated polynomial r(x) = r22x ²² + … + r1x + r0 can be expressed as a sum of the transmitted code polynomial c(x) and the error polynomial e(x) = e22x ²²+ … + e1x + e0; that is, r(x) = c(x) + e(x) or r = c + e. From Eq. (2.13), the set of known syndromes is obtained by evaluating r(x) at the roots of g(x); that is,

0 1

22

22( ) ( )

)

( e e e

e

S_i  ⁱ  ⁱ _ ⁱ  , (3.3)

where i  Q23. If v  t errors occur in the received vector, then the error polynomial has v nonzero terms, namely, e(x) x^r1 x^r2  x^r3 x^rv, where 0  r1 < r2 <…< rv  22. For i

 Q23, the i-th syndrome S is given by _i S_i (^r1)ⁱ(^r2)ⁱ (^rv)ⁱ= Z1ⁱZ2ⁱ Z_vⁱ,

where the error locators are Z_j  ^rj for all 1  j  v.

For the (23, 12, 7) Golay code, one has the following equalities among the known syndromes: S₂ S₁² , S₄ S₁²² , S₈S₁²³ , S₁₆ S₁²⁴ , S₉ S₁²⁵ , S₁₈ S₁²⁶ , S₁₃ S₁²⁷ ,

28

1

3 S

S  , S₆ S₁²⁹, S₁₂ S₁²¹⁰ . Thus, all the known syndromes can be expressed as some powers of S1. Table 3.1 shows the values of indices ti if ⁱ

i j

t S

S  ² for the (47, 24, 11) QR code.

The numbers in the leftmost column and the first row indicate the indices j’s and i’s, respectively.

Table 3.1 The values of indices ⁱ

3.2 Algebraic Decoding Algorithm Developed by Elia

In ADA, the most important work for decoding the (23, 12, 7) QR code is to compute the unknown syndrome S5. Elia [7] developed an ingenious method to avoid the computation of S5.

Since  is a root of g(x), ³, and ⁹ are also roots of g(x). By using these roots, we can compute three syndromes as follows:

S1 = r()= e(), S3 = r(³) = e(³), and S9 = r(⁹) = e(⁹), (3.4)

where S1, S3, and S9 are called the known syndromes of this code.

From Eq. (2.15), we have the following error-locator polynomial

3

Furthermore, Combining these, we find

3 D¹³⁶⁵. Finally, once L(x) is known we can use the Chien search [5] to find the error locations.

Elia’s algorithm for decoding the (23, 12, 7) Golay code is summarized as below.

0, no errors if S1 = 0.

3.3 The Decoding of the Binary (24, 12, 8) Golay Code

A binary (24, 12, 8) Golay code can be formed by adding an overall parity-check bit to the (23, 12, 7) Golay code. The following extension of decoding algorithm for the (24, 12, 8) Golay code can be used to correct three errors and detect four errors. To illustrate this, let r denote the received word as expressed as the binary form without its overall parity bit p. It is convenient also to let the symbol P denote the decoding procedure of the (23, 12, 7) code. The

decoding scheme of the code augmented by a parity bit given in [17] is summarized in the following:

i) If there are v ≤ t – 1 = 3 – 1 = 2 errors occurred in the received word r, then it can be decoded by P regardless of the value of the overall parity bit.

ii) If there are more than 2 errors occurred in the received word, then after using P to decode r, the parity p’ is recomputed and then compared with the received parity p. If p’  p, four errors are detected from the decoder.

3.4 A Fast Method for Computing the Multiplication and Inverse in GF(2

^m

)

The computation of the inverse and multiplication is very complicated in the Finite field.

The following theorem given in [37] provides a very fast method to reduce the computational complexity in the Finite field. Thus, the decoding time can be significantly reduced.

Theorem 3.1 Let (n, k, d) be a binary QR code over GF(2) and let α be a primitive root of unity in GF(2^m) such that α^2m α. If an element   GF(2^m), then the inverse of  in GF(2^m) has ^-1^2m2. Let 2^m – 2 be decomposed as 2¹ + 2² + 2³ +…+ 2^m-1, then ^-1 can be expressed as

^-1 = ^{2122232m1} = ²¹²²²³_^2m1. (3.13)

For example, for the binary (23, 12, 7) Golay code, the inverse of an element   GF(2¹¹) is ^-1 = ^2m-2 = ^211-2 = ²⁰⁴⁶. However, the power of  is very large, thereby increasing the computational complexity. Next, also by using Theorem 3.1, the power 2046 be first

decomposed as the binary representation 2¹ + 2² +…+ 2¹⁰, then ^-1 can be expressed as ^-1

= ^{212223210} = ²¹²²²³_²¹⁰ . Moreover, D^1/3 = D¹³⁶⁵ =

9 8 7 6 5 4 3 2

1) 6(2 ) 4(2 ) 3(2 ) 3(2 ) 2(2 ) 2(2 ) 2 2 6(2

1        

D = D¹D⁶⁽²¹⁾D⁶⁽²²⁾D²⁹ . Thus, the power of the syndromes can easily be accomplished by using successive squaring operations and multipliers. Such a fast computational method can efficiently reduce the computer execution time up to hundreds of times when the power of the syndrome is very large. Therefore, the improved ADA is considerably faster in decoding time than that of the method given in [7].

Chapter 4

Syndrome-Weight Decoding Algorithm of the Binary Systematic (23, 12, 7) Golay Code

The syndrome decoder [5] is a very efficient method of decoding a linear code over a noisy channel. In essence, the syndrome decoder is a minimum distance decoding using the syndrome together with the corresponding error pattern (syndrome-error pattern) lookup table.

Due to the linearity of the code, a binary (n, k, d) QR code with minimum distance d is capable of correcting up to t errors, where ^{t d}



^{( 1)/2}



. The full size of the syndromes-error pattern lookup table is Rn ^

_

^t_i1

 

ⁿi . Therefore, for the (23, 12, 7) Golay

code, R23 =

_

³_i1

 

i²³ = 2047, and thus this table is called the full lookup table (FLT). Each syndrome and error pattern needs 2 and 3 bytes, respectively, to store in the memory. Thus, the total memory size for the FLT is (2047  (2 + 3)) / 1024 ≒ 10 kbytes. However, such a large memory is somewhat less efficient in practice. For this reason, searching a syndrome in this large table requires highly computational complexity. In this chapter, the reduction of the memory requirement of the proposed algorithm is considered.

4.1 Syndrome Decoder with a Reduced-Size Lookup Table

To reduce the memory requirement, the well-known syndrome decoder with a RSLT [5, p118] is used. The syndrome decoder with a RSLT is a very efficient method of decoding linear cyclic codes over a noisy channel for moderate code lengths. In essence, the syndrome

decoder is a minimum distance decoding using the syndromes corresponding to their error patterns in the lookup table. Due to the property of cyclic code, it allows for the lookup table to be reduced in memory size.

In order to illustrate the syndrome decoder with a RSLT, the following theorem is needed.

For a detailed proof, see [5, p118].

Theorem 4.1 Let s(x) be the syndrome polynomial corresponding to a received polynomial r(x). Also, let r⁽¹⁾(x) be the polynomial obtained by cyclically shifting the coefficients of r(x) one bit to the right. Then the remainder obtained when dividing xs(x) by g(x) is the syndrome s⁽¹⁾(x) corresponding to r⁽¹⁾(x).

Definition 4.1 Using Theorem 4.1, if n is prime, then the number of the syndromes and error patterns of the syndrome decoder needs 1/n of the size of FLT, namely R_n / . If n n is not

prime, then the number of the syndromes and error patterns of the syndrome decoder only needs



^Rn /ⁿ



, where

 

x denotes the least integer large than or equal to x. This reduced table is called the reduced-size lookup table (RSLT).

For (15, 5, 7) cyclic code, the RSLT has



R15^/15



=

 

_



 





 3 1

15 /15

i i = 39 elements.

Therefore, the required memory size of the RSLT is 39  (2 + 2) = 156 bytes. For (23, 12, 7) Golay code, the RSLT has R₂₃/23 = ³

 

^/23

1

 23

 i

i = 2047/23 = 89 elements. Therefore, the required memory size of the RSLT is 89  (2 + 3) = 445 bytes. For (31, 16, 7) QR code, the RSLT has R₃₁/31 = ³

 

^/31

1

 31



i i = 4491/31 = 161 elements. Therefore, the required memory size of the RSLT is 161  (2 + 4) = 966 bytes. For these codes, the relationship of the syndromes and their corresponding error patterns in the RSLT is shown in Appendix A.

For the binary systematic (23, 12, 7) Golay code, it follows from (2.8) that the k  n generator matrix G can be expressed as follows:

 

From Eq. (2.9), namely c = mG, one can obtain the systematic codeword.

Example 4.1

For the binary systematic (23, 12, 7) Golay code, assume that the message vector is m = (000000000001). Using Eq. (2.9) and Eq. (4.2), one obtains the codeword c = (01011100011000000000001).

follows: identity matrix. The vector form of syndrome can be defined by

s = rH^T=(r ₂₂, ,r₀,r₁)

The syndrome decoder only needs to compute the syndrome of r for every received word, find the corresponding error pattern, and correct r. Thus, the computation of the error-locator polynomial L(z) needed in the ADA can be completely avoided. This is the reason why the syndrome decoder significantly reduces the computational complexity. If r occurs with no error, then the syndrome s = rH^T = (c + 0)H^T = cH^T = 0, where 0 denotes a zero vector;

otherwise, s = rH^T = (c + e)H^T = 0 + eH^T = eH^T.

Example 4.2

The codeword c is given in the Example 4.1. Assume that the error pattern is e = (00000000000000000000000000000000000000000000110), then the received word is r = c + e = (11101110110111000110001000000000000000000000111) and the syndrome is s = rH^T = (10111111011).

In order to reduce the searching speed in the RSLT, the well-known binary search algorithm [38] is used. For the (31, 16, 7) QR code, for example, Let N = 161 be the number of all syndromes in the RSLT. Then, the time complexity of finding a target in the RSLT is at most O(log2N) = log2(161) ≒ 8 times. If the linear search algorithm is used to find the syndrome, then the time complexity is at most O(N) = 4991 times. Therefore, the average searching speed in the RSLT can be saved up to 624 times. The relationship of the syndromes in ascending order and their corresponding error patterns in the RSLT is shown in Appendix A.

The syndrome decoding algorithm associated with the RSLT is summarized as follows:

1. Given a received word r and set i = 0 for 0  i  n – 1.

2. Compute the syndrome of r⁽ⁱ⁾; that is, s⁽ⁱ⁾ = r⁽ⁱ⁾(α) or s⁽ⁱ⁾ = r⁽ⁱ⁾H^T. 3. If s⁽ⁱ⁾ = 0, there are no errors and then go to step 7.

4. Search the RSLT. If s⁽ⁱ⁾ is in the RSLT, then obtain ej from the RSLT, where 1  j  N and go to step 6.

5. Set i = i + 1. Cyclically shift the syndrome left by one bit modulo g(x). Go to step 4.

6. If i  0, then cyclically shift ej left by n – i bits to obtain the error pattern e and then subtract e from r to obtain the corrected codeword c; otherwise, c = r + ej.

7. Stop.

Example 4.3

The codeword c is given in the Example 4.1. The decoding steps of the syndrome decoder algorithm with the RSLT are shown below.

Assume that the error pattern is e = (00000000000101100000000).

2. Compute the syndrome of r⁽⁰⁾; that is, s⁽⁰⁾ = (10111011111).

3. Since s⁽⁰⁾  0, there are errors in r. Go to step 4.

4. Search the RSLT. In this case, s⁽⁰⁾ is not in the RSLT. Go to step 5.

5. Set i = 0 + 1 = 1. Cyclically shift the syndrome left by one bit modulo g(x), namely s⁽¹⁾

= (00101011101). Go to step 4.

4. Search the RSLT. In this case, s⁽¹⁾ is not in the RSLT. Go to step 5.

5. Set i = 1 + 1 = 2. Cyclically shift the syndrome left by one bit modulo g(x), namely s⁽²⁾

= (01010111010). Go to step 4.

4. Search the RSLT. In this case, s⁽²⁾ is not in the RSLT. Go to step 5.



5. Set i = 14 + 1 = 15. Cyclically shift the syndrome left by one bit modulo g(x), namely s⁽¹⁵⁾ = (10111111011). Go to step 4.

4. Search the RSLT. In this case, s⁽¹⁵⁾ is in the RSLT, then its corresponding error pattern is ej = e61 = (00000000000000000001011) in the Table A.2b of Appendix A. Go to step 6.

6. Cyclically shift e20 left by 23 – 15 = 8 bits to obtain the original error pattern e = (00000000000101100000000) and then subtract e from r to obtain the corrected codeword c = r + e = (01011100011000000000001).

7. Stop.

4.2 The Proposed Syndrome-Weight Decoding Algorithm

The memory size of the RSLT needed in the syndrome decoder is still too large, so it is hard to implement in the decoder chip. To overcome this problem, an efficient syndrome-weight decoding algorithm (SWDA) with a refined lookup table (RLT) is proposed

SWDA uses the properties of the cyclic code, the weight of syndrome, and the syndrome decoder with a RSLT to reduce the number of the syndromes and their corresponding coset leaders in the RSLT to reduce the lookup table size.

4.2.1 Construction of the Refined Lookup Table

In order to construct the RLT needed in SWDA, the following definitions, lemmas, and theorem are needed. The proof of Lemma 4.1 is obvious.

Definition 4.2 Let a = (an-1,…, a0) be a binary vector of length n. We call message section and parity check section respectively, the vectors am = (ak-1,…, a0) and ap = (an-1,…, ak) of length k and n – k.

Lemma 4.1 Let a = (an-1,…, a1, a0) and b = (bn-1,…, b1, b0) be two binary vectors, then

w(a + b) = w(a) + w(b) -



 n i ₁aibi

2 . (4.5)

It is obvious to see that if aibi = 0 for all 1 ≤ i ≤ n, then by Lemma 4.1, one obtains

w(a + b) = w(a) + w(b). (4.6)

Lemma 4.2 Let e be an error pattern and ep, em be respectively its parity check section and message section. Let sp and sm be the syndromes corresponding to ep and em, respectively.

Assume that w(e)  t, then we have

(i) w(sp) = w(ep);

(ii) w(sm)  d – w(em);

operator in programming or the extension by zeros on the right in mathematics.

Proof: By Eq. (4.4), (i) is obvious. Again, by Eq. (4.4), since ((sm << k) + em)H^T = ((sm << k) + em) 

 _ P I_{n k}

= (sm << k) 

 _ P I_{n k}

+ em 

 _ P I_{n k}

= sm + sm = 0, ((sm << k)+ em) is thus a codeword, which proves (iii). Hence, w((sm << k) + em) = w(sm) + w(em)  d, i.e., w(sm)  d – w(em). The proof is thus completed.

Theorem 4.2 For the binary systematic (n, k, d) QR codes, assume that there are v errors in the received word, where 1 ≤ v ≤ t. All v errors occur in the n – k parity check section if and only if the weight of syndrome w(s) = v.

Proof: By Lemma 4.2, it is clear that if all v errors occur in the parity check section then the weight of syndrome w(s) = v. Conversely, assume that the weight of the syndrome is w(s) = v.

Assume moreover that there are u and v – u errors in the message and parity check section respectively, where 1 ≤ u ≤ v. By Eq. (4.4), the syndrome of the error pattern e, where e = em + ep, is given by s = eH^T = (em + ep)H^T = sm + sp. Moreover, because w(s) = w(sm + sp), w(s) must be in the range of [w(sm) – w(sp), w(sm) + w(sp)]. Thus, by Lemma 4.2, one has w(s)  w(sm) – w(sp)  (d – u) – (v – u) = d – v = 2t + 1 – v. Hence, w(s)  t + 1 for 1 ≤ v ≤ t. Such a result contradicts the assumption w(s) = v. As a result, if w(s) = v ≤ t, then the number of errors is v and all the errors lie in the parity check section of the received word r. The proof is thus completed.

Definition 4.2 The refined lookup table (RLT) is a part of RSLT that the coset leaders only

have errors appear in the message section of RSLT.

For (23, 12, 7) Golay code, upon inspection of Table A.2a, it is obvious that if the weight of coset leader is w(ei) = 3 for all 13 ≤ i ≤ 89, then one can delete the coset leaders that have

one error in the parity check section. Thus, the error positions in the message section of these deleted error patterns can be substituted by the weight of the coset leader w(ej) = 2 for 2 ≤ j ≤ 12. From Table A.2a, one observes that s23 – s2 = (00000000001) and its weight is w(s23 – s2)

= 1 which implies that only one error occurs in the parity check section of r. In this case, one can replace this coset leader e23 by e2 while decoding, and then e23 can be omitted in RSLT.

Similarly, the coset leaders from e24 to e32 can be also replaced by e2. The procedure described in Table A.2a is repeated recursively, the coset leaders from e41 to e49, e56 to e63, e68 to e74, e77

to e82, e83 to e87, e88 to e89, can be replaced by e3, e4, e5, e6, e7, and e8, respectively. The parity check section is all zero; thus, the parity check section can be omitted in RLT. Therefore, the RLT for decoding the binary (23, 12, 7) Golay code, as given in Table B.2 of Appendix B, only consists of N23 = 42 syndromes corresponding to coset leaders. The sizes of the RLT for the binary (15, 5, 7) cyclic code and the binary (31, 16, 7) QR code are N15 = 9 and N31 = 72, respectively, as given in Table B.2 of Appendix B. By using a message length k, one can obtain an equation for the size of the RLT for these codes given by



 



 





 

 



 4

) 1 ) (

1 2 2 )(

( k k k ²

k

N . (4.7)

Table 4.1 shows the comparison of the syndrome number between RSLT and RLT in three different codes. Table 4.2 shows the memory size between RSLT and RLT in three different codes. From Table 2, we can see that the CLT for the three codes results in a (1-27/156)100%  82.7%, (1-168/445)100%  62.3%, and (1-288/966)100%  70.2%

reduction of memory size, respectively.

Table 4.1 Comparison of the syndrome number between RSLT and RLT in three different codes

Codes RSLT RLT Decreased percentage

(15, 5, 7) 39 9 76.9%

(23, 12, 7) 89 42 52.8%

(31, 16, 7) 161 72 55.3%

Table 4.2 Comparison of the memory size between RSLT and RLT in three different codes (in bytes)

Codes RSLT RLT Decreased percentage

(15, 5, 7) 156 27 82.7%

(23, 12, 7) 445 168 62.3%

(31, 16, 7) 966 288 70.2%

4.2.2 Decoding Procedure of SWDA

For binary systematic (23, 12, 7) Golay code, for example, given a received codeword r, initially set counter to be i = 0. First, the syndrome is computed directly and then the weight of this syndrome w(s) is calculated. If w(s) = 0, no error is occurred in the received word. If w(s) ≤ 3, where 3 =



^(71)/2



is the error capability of this code, then this tacitly implies that at most 3 errors occur in the parity check section of r. In this case, the syndrome is shifted left by k = 12 bits to form a 23-bit length word, and the corrected codeword is then obtained by subtracting this 23-bit length word from r. If w(s) > 3, then the syndrome difference, denoted by sdj for 1 ≤ j ≤ 42, is computed by subtracting this syndrome from the first syndrome patterns, denoted by s1, in the RLT. Finally, the difference of this new weight of this syndrome, denoted by w(s_d1) = w(s – s1), is computed. Three cases are needed to be considered as follows:

Case 1: If the message section occurs one error, then the parity check section probably has 0, 1, or 2 errors; that is, w(s_d1) ≤ 2.

Case 2: If the message section occurs two errors, then the parity check section probably has 0 or 1 error; that is, w(s_d1) ≤ 1.

Case 3: If the message section occurs three errors, then the parity check section probably has no errors; that is, w(s_d1) = 0.

If one of the three cases is satisfied, then one can correct the received word; otherwise the difference of the next syndrome in RLT, namely w(s_d2), is computed and is repeated to check the above mentioned three cases again. If no any cases are satisfied after checking the final syndrome difference w(s_d42), then one shifts the syndrome left by one bit which means that one proceeds a cyclic shift of the received word left by one bit. Increased i by one, the previous procedure is repeated until the received word is corrected.

The proposed SWDA for decoding the (15, 5, 7) cyclic code, the (23, 12, 7) Golay code, and the (31, 16, 7) QR code is stated explicitly as follows:

1) Initially set counter to be i = 0 for 0 ≤ i ≤ n – 1 and give a received word r.

2) Compute the syndrome of r⁽ⁱ⁾ and its weight; that is, s⁽ⁱ⁾ = r⁽ⁱ⁾().

3) If w(s⁽ⁱ⁾) = 0, no errors occur and then go to step 9.

4) If w(s⁽ⁱ⁾) ≤ 3, there are errors occurred in the parity check section, then c = r –

4) If w(s⁽ⁱ⁾) ≤ 3, there are errors occurred in the parity check section, then c = r –

在文檔中 I-Shou University Institutional Repository:Item 987654321/11819 (頁 46-0)