A General Construction of Integer Codes Correcting Specific Errors in Binary Communication Channels

Abstract

Integer codes have been successfully applied to various areas of communication and computer technology. They demonstrate good performance in correcting specific kinds of errors. In many cases, the used integer codes are constructed by computer search. This paper presents an algebraic construction of integer codes over the ring of integers modulo $A=2^n+1$ capable of correcting at least up to two bit errors in a single b-byte. Moreover, the codes can correct some configurations of three or more erroneous bits, but not all possible ones. The construction is based on the use of cyclotomic cosets of 2 modulo A.

1. Introduction

In many binary communication channels, the majority of errors, besides uniformly distributed single-bit errors, consist of error configurations of several bits that are closely placed in a subsequence of b consecutive bits. We call such a subsequence b-bits byte (b-byte in short). We avoid the term b-burst, since its classical definition requires the first and the last bits to be 1s, while the error configurations considered in the paper have a more general form.

Integer codes are codes over a ring of integers modulo given a positive integer, and have been studied—though only from theoretical point of view—since the beginning of coding theory. Such codes for correcting asymmetric errors are proposed in [1,2]. The name "integer codes" appears for the first time in [3], where such codes are applied to magnetic recording and frame synchronization. Since that time, integer codes have been successfully used in many applications. Error control systems for flash memory [4,5,6,7] and coded modulation [8,9,10] are two examples for such applications. In [11], integer codes are applied to cryptographic construction. Integer codes over ${\mathbb{Z}}_A$ with $A=2^b-1$ that correct configurations of error bits in a single b-byte are found via computer search in [12,13,14,15,16]. The specific use of integer codes is presented in [17].

Herein, we propose an algebraic construction of codes over the ring ${\mathbb{Z}}_A$ of integers modulo $A=2^b+1$. The obtained codes can correct at least up to two bit errors in a b-byte. The codes can simultaneously correct some configurations of three or more erroneous bits, but not all possible ones.

The next section contains a summary of existing results and necessary notations and definitions that are required for reading the paper. The proposed construction based on the cyclotomic cosets of 2 modulo $A=2^b+1$ is described in Section 3. Section 4 discusses applications of constructed codes to error control in binary channels.

2. Preliminaries

Let us recall the basic definitions concerning integer codes.

Definition 1. 

Let ${\mathbb{Z}}_A$ be the ring of integers modulo A. An integer code of length n with parity-check matrix $\mathbf{H}\in {\mathbb{Z}}_A^{m\times n}$, is referred to as a subset of ${\mathbb{Z}}_A^n$, defined by

$$\mathcal{C}\left(\mathbf{H}\right)=\{\mathbf{c}\in {\mathbb{Z}}_A^n|\mathbf{c}{\mathbf{H}}^T=\mathbf{0}\}$$

where all zero vectors $\mathbf{0}\in {\mathbb{Z}}_A^m.$ (We will write only $\mathcal{C}$ if there is no possibility for ambiguity.)

$\mathcal{C}$ is said to be ${[n,n-m]}_A$ integer code. Let us note that in this paper, the notation only means that $\mathbf{H}$ has m rows, n columns, and entries from ${\mathbb{Z}}_A$, not that C is a linear code. For the not-prime A, the code $\mathcal{C}$ is a submodule, not a linear subspace. However in our case, the difference does not concern correcting properties of considered codes.

The idea behind use of integer codes is that they demonstrate better performance in correcting specific types of errors. The parity-check matrix $\mathbf{H}$ can be chosen, thinking about dominant errors.

Definition 2. 

Let $k_i$ and $l_j$ be positive integers, $i=1,\dots ,s,j=1,\dots ,m.$ The code $\mathcal{C}\left(\mathbf{H}\right)$ is said to be a single $(\pm k_1,\pm k_2,\dots ,\pm k_s,l_1,l_2,\dots ,l_m)$ that is error correctable if it can correct any error vector with only one nonzero entry with value $l_j$ or $\pm k_i.$

The existence of codes with the above defined property implies a lower bound for the size A of the alphabet:

$$A\ge (2s+m)n+1.$$

(1)

Indeed, the $(2s+m)n$ possible single $(\pm k_1,\pm k_2,\dots ,\pm k_s,l_1,l_2,\dots ,l_m)$ error vectors $\mathbf{e}$ must have pairwise disjoint syndromes ${\mathbf{eH}}^T$.

The sequence of bits in a binary communication channel can be considered as a sequence of blocks of bits with the same length b. (We call such blocks b-bytes, but b is not necessarily equal to 8). The advantage of this consideration is that the blocks can be interpreted as nonnegative integers less than $2^b$, that is, as elements of ${\mathbb{Z}}_A$ with $A\ge 2^b.$ Hence, the binary input sequence can be transformed into a sequence of elements of ${\mathbb{Z}}_A$, and then it can be encoded using integer codes over ${\mathbb{Z}}_A$ with $A\ge 2^b.$

It seems the natural choice is $A=2^b,$, but it is not the right choice in any case. Indeed, the situation is more complex. Note that changing one bit in a b-byte is equivalent to adding or subtracting $2^i,i=0,1,\dots ,b-1$ to the integer corresponding to the b-byte. However, $2^i$ divides $2^b$, which generates complications. If $A>2^b$, there are elements of A that cannot be transmitted over the channel; thus, they must not appear as coordinates of the codewords. Hence, the encoding procedure has to comply with this requirement.

Let $B\in \{0,1,\dots ,2^b-1\}$ be the integer corresponding to a given b-byte sent through the communication channel. At the other end of the channel, the received b-byte may differ in several bits from the original. This difference results in adding a nonzero integer $E,-2^b<E<2^b,$ to B, that is, the integer value of the received b-byte is $V=B+E$.

Here is the correspondence between single-bit errors and E in a b-byte.

E1 

The $(i+1)$-th bit $1\to 0$: $E=-2^i,i=0,1,\dots ,b-1$.

E2 

The $(i+1)$-th bit $0\to 1$: $E=2^i,i=0,1,\dots ,b-1$.

All other error configurations in a single b-byte correspond to combinations of E1 and E2; thus, E is a sum of powers (positive or negative) of 2. For example, in the case of transposition of two adjacent different bits (The existence of such errors has been reported in the literature), $E=2^i-2^{i-1}=2^{i-1}$ or $E=-2^i+2^{i-1}=-2^{i-1}$. Note that the same values correspond to the change of one bit in the b-byte. It may seem amusing, but the decoding procedure of integer codes corrects the b-byte. The explanation is in the difference between the corresponding values of B (in $V=B+E$). We also discuss this fact in Section 4.

3. Construction of Integer Code

In this section, we propose a construction of a class of integer codes that is based on cyclotomic cosets.

Recall a cyclotomic coset of q modulo $A,(A,q)=1,$ with leader s is the set

$$C_s=\{s{q}^i(modA)\mid i=0,1,\dots m-1\},$$

where m is the minimal positive integer, such that $s{q}^m\equiv s(modA)$. The two cyclotomic cosets are either disjoint, $C_s\cap C_t=\varnothing$; or they coincide, $C_s=C_t.$

Hereafter, in this paper, $A=2^b+1$.

There are two arguments for our choice:

• $A=2^b+1$ is coprime with 2; thus, we can use cyclotomic cosets of 2 modulo A.
• $A=2^b+1$ is the smallest integer greater than $2^b$. Hence, we have to avoid the use of only $2^b$ as a coordinate of a codeword.

Here are several simple but useful properties of cyclotomic cosets of 2 modulo $2^b+1$. Their proofs are straightforward.

P1 

If b has odd divisor d, then $2^{\frac{b}{d}}+1$ divides $2^b+1.$ In partial, if b is odd, $3\left|\right(2^b+1).$

P2 

If $A=2^b+1=(2^k+1)B$, then $C_B$ has length $2k$. If there is a cyclotomic coset of length $2k$, then $2^k+1$ divides A.

Lemma 1. 

If $A=2^b+1$, then the cyclotomic cosets $C_s$ of 2 modulo A have even length. In partial for s and A coprime, the length $|C_s|=2b$ and

$$C_s=\{s,2s,\dots ,2^{b-1}s,-s,-2s,\dots ,-2^{b-1}s\}.$$

Proof. 

$2^b\equiv -1(modA)$ gives $2^{2b}\equiv 1(modA)$. Hence, the order m of 2 modulo A is a divisor of $2b$. The assumption $m\mid b$ leads to $2^b\equiv 1(modA)$, which is a contradiction. Thus, $m=2k$, where $k|b$, that is, $|C_1|$ is an even number. Let $d=gcd(s,A),s=d{s}_1,A=d{A}_1.$ Let $l=|C_s|,$ i.e., l be the smallest positive integer such that $s(2^l-1)\equiv 0(modA)$. If $d=1$, then $A\mid (2^l-1);$ thus (see above), $l=2b.$ Otherwise, we have $(2^l-1)\equiv 0(mod{A}_1)$, where l is the minimal positive integer with this property. Since $2^{2b}\equiv 1(mod{A}_1)$ we have $l|2b$. Hence, $l=2k,k|b.$ The structure of $C_s$ follows from $2^b\equiv -1(modA)$. □

Let S be the set of the leaders of all cyclotomic cosets with length $2b$.

Theorem 1. 

Any integer code over ${\mathbb{Z}}_A,A=2^b+1,$ having parity check matrix $\mathbf{H}=(h_1,h_2,\dots ,h_n),$ where $h_j\in S,$ can correct single $\pm 2^i-$ error, $i=0,1,\dots ,b-1$.

Proof. 

Syndromes $\pm 2^i{h}_j$ belong to the coset $C_{h_j}$ and since cyclotomic cosets are disjoint, all syndromes corresponding to single $\pm 2^i-$ errors are pairwise different. □

We have to note that if $s\in {\mathbb{Z}}_A$ is the corresponding value to a given bit errors configuration in a b-byte then its cyclic shifts corresponds to $s{2}^i\in C_s$. This simple observation leads us to the following

Theorem 2. 

Let $\mathcal{E}$ be a set of cyclotomic cosets containing $C_1$. If there exist $h_2,\dots ,h_n\in {\mathbb{Z}}_A$ such that $\mathcal{E},h_2\mathcal{E},\dots ,h_n\mathcal{E}$ are disjoint sets of different cosets, then the code with check matrix $\mathbf{H}=(1,h_2,\dots ,h_n)$ can correct error values belonging to $\mathcal{E}$, and of course, bit error configurations corresponding to them.

Proof. 

The proof is straightforward. □

4. Application of the Constructed Codes

In this section, we will apply the considered integer codes to correct up to two erroneous bits in a b-byte. As we have noted in the Introduction, there are binary channels where these types of errors dominate. The experiments with simulations of several channels we have made also confirm this observation. We shall explain the idea behind these simulations by describing in short one such form of optical wireless communication (for an example, we will describe one of our experiments in this direction). We generated a very long random binary sequence and applied simulation procedure of the optical wireless channel given in [18] to determine the error sequence (the difference between the input and output sequences). Then, with a code of length n over ${\mathbb{Z}}_{2^b+1}$ in the mind, we divided the error sequence into blocks of nb-bytes. The next step is to count the number of 1s in each block and how they are distributed among b-bytes: what part of blocks contain only one 1, what part of blocks have two 1s in one b-byte, and so on.

Table 1. The case $n=3,b=10$.

SNR in dB	1 Bit in a Codeword	2 Bits in 1 Symbol	2 Bits in 2 Symbols	3 or More Bits in a Codeword
1	0.00223	0.00067	0.00423	0.02573
2	0.00431	0.00167	0.00555	0.02057
3	0.00727	0.00319	0.00584	0.01419
4	0.01046	0.00453	0.00452	0.00797
5	0.01237	0.00461	0.00247	0.00341
6	0.01171	0.00372	0.00088	0.00125
7	0.00871	0.00141	0.00022	0.00021
8	0.00503	0.00042	$3\times {10}^{-5}$	$2\times {10}^{-5}$
9	0.00221	0.00008	$2\times {10}^{-6}$	$2\times {10}^{-6}$
10	0.00077	$9\times {10}^{-6}$	$6\times {10}^{-8}$	$1\times {10}^{-7}$

illustrates the results that we obtained. With the exception of the cases of the very small signal-to-noise ratio (SNR $\le 4$ decibels (dB)), the considered error configurations (columns two and three) are the majority. Very soon (SNR $\ge 7$ dB), the error configuration that consists of one erroneous bit per a codeword (see second column of Table 1) becomes the dominant error type.

Now, let us fix some notations. In this paper, the leftmost bit is the least significant bit and the rightmost bit is the most significant in a b-byte, that is, the latter represents the number $2^{b-1}$.

Let $a_1\dots a_i\dots a_{i+k}\dots a_b$ be an arbitrary b-byte. Below lists the possible error transformation of i-th and $(i+k)$-th bits and the corresponds to them the alteration E of the integer value of the byte.

T1	… 0 … 0 …	→	… 1 … 1 …	$E=2^{i-1}+2^{k-1}=(1+2^k)2^{i-1}$
T2	… 1 … 1 …	→	… 0 … 0 …	$E=-2^{i-1}-2^{k-1}=-(1+2^k)2^{i-1}$
T3	… 1 … 0 …	→	… 0 … 1 …	$E=-2^{i-1}+2^{k-1}=(2^k-1)2^{i-1}$
T4	… 0 … 1 …	→	… 1 … 0 …	$E=2^{i-1}-2^{k-1}=-(2^k-1)2^{i-1}$

where $k=1,\dots ,b-1$ and $i=1,\dots ,b-k$.

Obviously, the error values $E\in C_{2^k+1}$ for T1 and T2, while $E\in C_{2^k-1}$ for T3 and T4. However, since $A=2^b+1$, we have

$$2^k+1\equiv 2^k-2^b=-2^k(2^{b-k}-1)(modA)$$

as well as

$$2^k-1\equiv 2^k+2^b=2^k(2^{b-k}+1)(modA).$$

Hence,

$$C_{2^k+1}=C_{2^{b-k}-1},k=1,\dots ,b-1$$

Therefore, we can conclude that cosets $C_{2^k\pm 1}$, but only for $k=1,\dots ,\lfloor b/2\rfloor$, contain error values E for error configurations T1–T4. (Note that for b, even $C_{2^{b/2}+1}=C_{2^{b/2}-1}$.)

Hence the set of error values is a proper subset of

$$\mathcal{E}=\{\cup C_{2^k\pm 1},k=1,\dots ,\lfloor b/2\rfloor \}$$

Theorem 3. 

If $\mathcal{E}$ consists of t cyclotomic cosets, then

$$2btn\le 2^b$$

is a necessary condition for the existence of an integer code that can correct the error configurations of types T1–T4 defined by $\mathcal{E}$. In partial a necessary condition for the code to correct all the considered error configurations T1–T4 is

$$2b(b-2)n\le 2^b$$

(2)

Proof. 

If $\mathbf{H}=(h_1,h_2,\dots ,h_n)$ is a parity check matrix of an integer code capable to correct all error configurations T1–T4, the sets of cyclotomic cosets $\left\{h_i\mathcal{E}\right\}$ have to be disjoint, with lengths of $2b$ each. Hence, we obtain the following necessary condition (inequality):

$$2bnt\le A-1=2^b,n\ge 2.$$

Since t is at most $b-2$ we obtain (2). □

Example 1 

($\mathbf{b}=\mathbf{9},\mathbf{n}=\mathbf{2}$ (see Appendix A.2)). The minimal b that satisfies inequality (2) (for the minimal $n=2$) is $b=8$, but a required code does not exist. Such a code exists for $b=9$ and $n=2$. In that case, $\mathbf{H}=\left(123\right)$ and

$$\mathcal{E}\subseteq C_1\cup C_3\cup C_5\cup C_7\cup C_9\cup C_{15}\cup C_{17}$$

$$23\mathcal{E}\subseteq C_{23}\cup C_{39}\cup C_{53}\cup C_{11}\cup C_{45}\cup C_{21}\cup C_{25}$$

Example 2 

($\mathbf{b}=\mathbf{10},\mathbf{n}=\mathbf{3}$ (see Appendix A.3)). In this case, a code that corrects all two-bit errors in a single b-byte per a codeword exists: the code with $\mathbf{H}=\left(11927\right)$

$$\mathcal{E}\subset C_1\cup C_3\cup C_5\cup C_7\cup C_9\cup C_{15}\cup C_{17}\cup C_{31},C_{33}=C_{31}$$

$$19\mathcal{E}\subset C_{19}\cup C_{57}\cup C_{35}\cup C_{39}\cup C_{171}\cup C_{105}\cup C_{43}\cup C_{109}$$

$$27\mathcal{E}\subset C_{27}\cup C_{59}\cup C_{55}\cup C_{51}\cup C_{53}\cup C_{155}\cup C_{107}\cup C_{47}$$

Length $n=3$ is the maximal possible value for the existence of such a code.

Example 3 

($\mathbf{b}=\mathbf{8},\mathbf{n}=\mathbf{4}$ (see Appendix A.1)). If we restrict ourselves to $\mathcal{E}=C_1\cup C_3\cup C_5$, that is, to the case when we correct only erroneous bits that are either adjacent or there is one correct bit between them, we can construct codes with larger rates.

When $b=8,$ i.e. $A=257,$ the code with $\mathbf{H}=\left(17919\right)$ (the rate is 3/4) corrects a single b-byte of the aforesaid configurations with up to 2 erroneous bits. Indeed,

$$7\mathcal{E}=C_7\cup C_{21}\cup C_{23};9\mathcal{E}=C_9\cup C_{27}\cup C_{45};19\mathcal{E}=C_{19}\cup C_{25}\cup C_{11}.$$

Figure 1 presents in graphical form probability of bit error (BER) versus signal/noise ratio per bit in decibels for the aforesaid simulation of noisy wireless optical channel [18]. The blue curve gives BER in the case when no error correcting codes are used. The green and red curves correspond to applying the codes given in Example 1 and Example 2, respectively. The reader can note that the code from Example 2 demonstrates slightly worse performance, but this is the price we pay for the higher code rate.

5. Discussion

In this paper, we propose a general construction of codes over ${\mathbb{Z}}_{2^b+1}$, which can be used for correcting two erroneous bits (as well as several specific configurations of erroneous bits) in a single b-byte in a codeword of $n\ge 2$ b-bytes. Like any integer codes, the proposed codes have very simple encoding and decoding without involving arithmetic in finite fields. The proposed construction avoids the exhaustive computer search commonly used for construction similar codes. Determining the cyclotomic cosets of 2 modulo $2^b+1$ can be performed with the simplest mathematical packages (even manually).

Figure 1 (and other our experiments) show that the proposed codes demonstrate good performance. This performance is in some sense unexpected, since the application of integer codes to the considered binary channel is not so proper as their application to coded modulation and flash memory. For example, we performed a comparison between the code given in Example 2 and a BCH code with close length and rate. Our expectation was for the BCH code to demonstrate better performance since the considered errors are not strongly dominant. However, the results were similar. Hence, with their simple encoding and decoding procedures, integer codes are at least commensurable with other codes with similar parameters, but have complicated encoding and decoding.