Bit Flipping Moment Balancing Schemes for Insertion, Deletion and Substitution Error Correction

TL;DR

This paper introduces two efficient bit flipping schemes that modify existing substitution error correcting codes to also correct insertion/deletion errors with minimal additional flips, maintaining code rate and decoder compatibility.

Contribution

It presents novel moment balancing schemes that enable existing substitution error correcting codes to correct insertion/deletion errors without extra parity bits or decoder modifications.

Findings

The schemes can correct single insertion/deletion errors or multiple substitution errors.

Number of bit flips remains small relative to code length.

Applicable to long codes in channels with dominant substitution errors.

Abstract

In this paper, two moment balancing schemes, namely a variable index scheme and a fixed index scheme, for either single insertion/deletion error correction or multiple substitution error correction are introduced for coded sequences originally developed for correcting substitution errors only. By judiciously flipping bits of the original substitution error correcting code word, the resulting word is able to correct either a reduced number of substitution errors or a single insertion/deletion error. The number of flips introduced by the two schemes can be kept small compared to the code length. It shows a practical value of applying the schemes to a long substitution error correcting code for a severe channel where substitution errors dominate but insertion/deletion errors can occur with a low probability. The new schemes can be more easily implemented in an existing coding system than any previously published moment balancing templates since no additional parity bits are required which also means the code rate remains same and the existing substitution error correcting decoder requires no changes. Moreover, the work extends the class of Levenshtein codes capable of correcting either single substitution or single insertion/deletion errors to codes capable of correcting either multiple substitution errors or single insertion/deletion error.

Figures

Tables

Table 1. TABLE I : Bit flipping moment balancing template of a (7, 16, 3) Hamming code with m = 8 𝑚 8 m=8

Code word	$\sigma \left(𝐜\right)$	$S$
0 0 0 0 0 0 0	0	{}
1 0 0 1 1 1 0	0	{}
1 0 1 1 0 0 0	0	{}
1 1 0 0 0 1 0	1	{1} or {7}
1 0 1 0 0 1 1	1	{1}
0 0 0 1 0 1 1	1	{2, 5}
1 1 1 0 1 0 0	3	{3}
0 1 0 1 1 0 0	3	{6, 7}
0 0 1 1 1 0 1	3	{3}
0 1 0 0 1 1 1	4	{4}
0 1 1 0 0 0 1	4	{4}
1 1 1 1 1 1 1	4	{4}
1 0 0 0 1 0 1	5	{3} or {5}
0 0 1 0 1 1 0	6	{2} or {6}
1 1 0 1 0 0 1	6	{4, 6}
0 1 1 1 0 1 0	7	{1}

Table 2. TABLE II : Bit-inverting moment balancing template of a (7, 16, 3) Hamming code with m = 8 𝑚 8 m=8

Code word	$\sigma \left(𝐜\right)$	$S$
0 0 0 0 0 0 0	0	{}
1 0 0 1 1 1 0	0	{}
1 0 1 1 0 0 0	0	{}
1 1 0 0 0 1 0	1	{1}
1 1 0 0 0 1 0	1	{7}
1 0 1 0 0 1 1	1	{1}
1 1 1 0 1 0 0	3	{3}
0 0 1 1 1 0 1	3	{3}
0 1 0 0 1 1 1	4	{4}
0 1 1 0 0 0 1	4	{4}
1 1 1 1 1 1 1	4	{4}
1 0 0 0 1 0 1	5	{3}
1 0 0 0 1 0 1	5	{5}
0 0 1 0 1 1 0	6	{2}
0 0 1 0 1 1 0	6	{6}
0 1 1 1 0 1 0	7	{1}

Table 3. TABLE III : Fixed index bit flipping moment balancing scheme of an (15, 32, 7) BCH code with m = 16 𝑚 16 m=16

Code word	$\sigma \left(𝐜\right)$	Variable Indices Bit Flipping Code I	Fixed Indices Bit Flipping Code II
000000000000000	0	000000000000000	000000000000000
100001010011011	3	100001010011111	010101000011011
010001111010110	6	010000111010110	000101101010110
110000101001101	11	110010101001101	000000111001101
001000111101011	14	011000111101011	011000111101011
101001101110000	15	100101101110000	011001101110000
011001000111101	8	011001010111101	011001010111101
111000010100110	3	110000010100110	001000010100110
000101001101110	4	000001001101110	000001001101110
100100011110101	7	110100010110101	010100001110101
010100110111000	6	110100010111000	000000110111000
110101100100011	11	110111100100011	000101110100011
001101110000101	8	001101100000101	001101100000101
101100100011110	1	001100100011110	001100100011110
011100001010011	10	011101001010011	001100011010011
111101011001000	13	111101001011000	011001001001000
000010100110111	11	000010100100111	100110100110111
100011110101100	14	110011110101100	110011110101100
010011011100001	7	110011001100001	110011001100001
110010001111010	0	110010001111010	110010001111010
001010011011100	13	001010011011000	111010011011100
101011001000111	2	101110001000111	111111011000111
011011100001010	1	011011100001011	101011100001010
111010110010001	4	111010110011001	111110100010001
000111101011001	5	000101101011001	110111111011001
100110111000010	0	100110111000010	100110111000010
010110010001111	9	010110110001111	100110000001111
110111000010100	10	010111100010100	100111010010100
001111010110010	13	001011110110010	111111010110010
101110000101001	2	101110000101011	111010000101001
011110101100100	5	011100101100100	101010101100100
111111111111111	8	111111101111111	111111101111111

Table 4. TABLE IV: Comparison between OFMB scheme and moment balancing template [ 1 ] for ( n 𝑛 n , k 𝑘 k , d m ​ i ​ n subscript 𝑑 𝑚 𝑖 𝑛 d_{min} ) substitution error correcting codes.

	Moment Balancing Template [1]	One-Flip Moment Balancing Scheme
Code word length	$n+\lfloor {\log }_{2}n\rfloor +1$	$n$
Information length	$k$	$k-1$
$s$ insertion/deletion correction	1	1
Minimum Hamming distance	$d_{min}$	$d_{min}-2$

Equations

$$\sigma (\mathbf{x})=\sum _{i=1}^{n}i{x}_i\equiv a(\mathrm{mod}m).$$

$$\left\{\begin{array}{c}0000000,1001110,1011000,0100010\\ 1100011,0010011,1100100,0001101\\ 0101111,0111001,1110111,1010101\\ 1000001,0110110,0010100,1111010\end{array}\right\}.$$

$$M^{\prime}\geq\Bigl{\lceil}\frac{M(\lceil\frac{n}{2}\rceil+1)}{n+1}\Bigr{\rceil}\geq\Bigl{\lceil}\frac{M}{2}\Bigr{\rceil}.$$

$$d_{min}^{\prime }\ge d_{min}-2.$$

$$\begin{array}{rl}& |C(n,d_{min},1{)}^{\ast }|\ge \max \{\frac{2^{n-1}}{V_2(n,d_{min}+1)},\\ & \frac{2^{n-\lfloor {\log }_{2}n\rfloor -1}}{V_2(n-\lfloor {\log }_{2}n\rfloor -1,d_{min}-1)}\}.\end{array}$$

$$|C(n,d_{min},1{)}^{\ast }|\ge 2^{n-1-H_2(\frac{d_{min}+1}{n})n},$$

$$2^{\left(H_2(\delta )+o(1)\right)n}\le V_2(n,\delta n)\le 2^{H_2(\delta )n},$$

$$\frac{2^{n-1}}{V_2(n,d_{min}+1)}=2^{n-1-H_2({\delta }_1)n}$$

$$\frac{2^{n-\lfloor {\log }_{2}n\rfloor -1}}{V_2(n-\lfloor {\log }_{2}n\rfloor -1,d_{min}-1)}=2^{n-\lfloor {\log }_{2}n\rfloor -1-H_2({\delta }_2)(n-\lfloor {\log }_{2}n\rfloor -1)}.$$

$$\begin{array}{rl}\Delta =& \underset{\text{exponent of the right term in eqrefofmb-b}}{\underbracket{n-1-H_2({\delta }_1)n}}-\left(\underset{\text{exponent of the right term in eqrefmbt-b}}{\underbracket{n-\lfloor {\log }_{2}n\rfloor -1-H_2({\delta }_2)(n-\lfloor {\log }_{2}n\rfloor -1)}}\right)\\ & =\underset{\text{first term}}{\underbracket{n\left(H_2({\delta }_2)-H_2({\delta }_1)\right)}}+\underset{\text{second term}}{\underbracket{\lfloor {\log }_{2}n\rfloor \left(1-H_2({\delta }_2)\right)}}-\underset{\text{third term}}{\underbracket{H_2({\delta }_2)}}.\end{array}$$

$$\frac{d_{min}-1}{n-\lfloor {\log }_{2}n\rfloor -1}>\frac{d_{min}+1}{n},$$

$$\frac{(d_{min}+1)(\lfloor {\log }_{2}n\rfloor +1)}{2n}>1$$

Full text

I Introduction

Synchronization errors at symbol level are defined as insertion and deletion errors. During a transmission, the event that an unknown symbol is put in at an unknown index is called an insertion error and the event that at an unknown index an unknown symbol is left out is called a deletion error. The moment balancing template technique was investigated to correct insertion/deletion errors [1, 2, 3]. In this paper, we further extend this early work to two new schemes, which can correct either substitution errors or a single insertion/deletion error.

By using number theory, codes were invented to correct asymmetric errors, substitution errors and insertion/deletion errors [4, 5, 6, 7, 8, 9, 10, 11]. These codes were proposed to have a deterministic code construction and a deterministic insertion/deletion error correcting capability. With ‘deterministic’ we mean guaranteed correction of all specified error patterns, as opposed to the correction of most patterns with a high probability as in [12]. The difference between ‘deterministic’ and ‘probabilistic’ has been well addressed in [11]. In this paper, we focus on one construction proposed by Varshamov and Tenengolts [4], often called the Varshamov-Tenengolts (VT) construction. Levenshtein discovered that the same construction can be used to generate codes to correct single insertion/deletion error [5]. The single insertion/deletion error correcting code generated based on the VT construction is called the Levenshtein code. The relationship among group theoretic codes, the VT construction and Levenshtein codes was investigated by Constantin and Rao [7]. Levenshtein codes with additional rules were found to be able to correct either a single substitution error or a single insertion/deletion error [5]. In [6], a class of codes capable of correcting a deletion and a prefix substitution error was presented. The VT construction has been further implemented in single nonbinary insertion/deletion error correcting codes presented by Tenengolts [8] and ST codes presented by Abdel-Ghaffar [10]. In [9], the high-order spectrum-null code construction published in [13] was found to be a subset of a Levenstein code. Helberg and Ferreira [14] presented a class of codes which can correct multiple insertion/deletion errors based on a construction which is a generalization of the Varshamov-Tenengolts construction [10, 11]. Dolecek and Anantharam [15, 16] presented a class of codes which can correct multiple repetition errors based on some high-order moment conditions. Codes for adjacent and burst insertion/deletion error correction were investigated in [17, 18, 19, 20, 21, 22]. Some recent results on multiple insertion/deletion error correcting codes can be found in [23]. Since Schulman and Zuckerman [24] presented the first asymptotically good construction of insertion/deletion error correcting codes, some recent results are presented in [25, 26, 27, 28, 29, 30, 31, 32, 33]. The ‘synchronization string’ construction presented in [27, 28, 29, 30, 33] can efficiently convert insertion/deletion errors into erasures and substitution errors by using an index en/decoding method and then the erasures and substitution errors can be further corrected.

In this paper we further investigate two new schemes which can convert a substitution error correcting code word into a sequence which may also correct a single insertion/deletion error based on systematic encoding, the so-called moment balancing template [1]. When compared to the systematic encoding in conventional error correcting codes, there is the similarity that the parity bits have fixed indices in the sequence, while the difference is that they are not always at adjacent indices. By judiciously choosing the parity bits, the sequences generated by this scheme can correct a single insertion/deletion error. The number of parity bits is small of the same order as the number of parity bits in a Hamming code of comparable length. The idea behind this scheme is to manipulate the first-order moment property of a sequence, which is also the key to the Varshamov-Tenengolts construction and the Levenshtein codes. Moment balancing templates for different types of sequences can be found in [1, 2, 3]. In the previous studies on moment balancing templates, the template is composed of information bits and parity bits. It is significant that in this paper, we present two new schemes for substitution error correcting codes that require no additional parity bits to balance the moment of a sequence, thus reducing overhead and also retaining the code rate with the trade-off of possibly reducing the substitution error correcting capability to some extent.

The main contribution of this paper is to introduce two general schemes for the moment balancing purpose, namely a variable index scheme and a fixed index scheme. Moreover, the special case of variable index schemes, the one-flip method can be considered as an extension of Levenshtein codes that can correct single insertion/deletion or single substitution error. Based on the special case, the lower bound of cardinalities of multiple substitution errors or single insertion/deletion error correcting codes can be therefore derived.

The paper is organized as follows. In Section II, we review the VT construction and the insertion/deletion/substitution error correcting codes and the moment balancing templates based on this construction. The variable index scheme as well as its special case, one-flip scheme are presented in Section III. The fixed bit flipping scheme is introduced in Section IV. The analysis and discussion of the two new schemes are presented in Section V. The paper is concluded in Section VI.

II Varshamov-Tenengolts Construction and Moment Balancing Templates

A brief introduction to the VT construction and some different classes of error correcting codes based on the VT construction follows.

Let ${\mathbf{x}}=x_{1}x_{2}\ldots x_{n}$ denote a binary code word. Given $a\in Z_{m}$ for all ${\mathbf{x}}\in\mathcal{C}_{a}$, the moment function of ${\mathbf{x}}$ is defined as

[TABLE]

• •

If $\sum_{i=1}^{n}{c_{i}x_{i}}\equiv a\pmod{3},$ where $c_{i}=1$ if $i$ is odd and $c_{i}=2$ if $i$ is even, $\mathcal{C}_{a}$ is a substitution-transposition correcting code [10].

• •

If $m\geq n+1$, $\mathcal{C}_{a}$ is a single insertion/deletion correcting code [5].

• •

If $m\geq 2n$, $\mathcal{C}_{a}$ is a single insertion/deletion or substitution correcting code [5].

• •

If $m\geq 2n-2$ and $\sum_{i=1}^{n}{c_{i}x_{i}}\equiv b\pmod{2}$, where $b\in\{0,1\}$, $\mathcal{C}_{a}$ is a single insertion/deletion or prefixing substitution correcting code [6].

Let ${\boldsymbol{\alpha}}=\alpha_{1}\alpha_{1}\ldots\alpha_{n}$ denote a binary sequence derived from ${\mathbf{x}}$ according to the relation rule $\alpha_{i}={\begin{cases}1,\text{ if }x_{i}\geq x_{i-1},\\ 0,\text{ if }x_{i}<x_{i-1}.\\ \end{cases}}$

Here $\alpha_{1}$ can be any binary symbol. Tenengolts presented two selection rules to construct a non-binary single insertion/deletion correcting code as follows. When $\sum_{i=1}^{n}{x_{i}}\equiv\beta\pmod{q},$ and $\sum_{i=1}^{n}{(i-1)\alpha_{i}}\equiv\gamma\pmod{n},$ for some fixed integers $\beta$ and $\gamma$, $\mathcal{C}$ is a non-binary single insertion/deletion correcting code [8].

Note that a code that can correct $s$ deletions can also correct $s$ insertions [5], where $s$ is positive integer.

A brief introduction to the moment balancing template follows.

Let $\mathcal{C}$ be a $[K,k]$ binary code, which is not necessarily linear, of length $K$ that has $2^{k}$ code words. Each code word $\mathbf{c}=(c_{1}c_{2}\cdots c_{K})$ in the code $\mathcal{C}$ is mapped into a distinct sequence $\mathbf{x}=(x_{1}x_{2}\cdots x_{n})$ whose moment is congruent to a fixed integer $a$ modulo another fixed integer $m$. Similar to the systematic encoding for substitution error correcting codes, the mappings in which the code bits $c_{1}c_{2}\cdots c_{K}$ appear in fixed indices in the sequence $\mathbf{x}$, i.e., $c_{i}=x_{\gamma(i)}$ for some $1\leq\gamma(1)<\gamma(2)<\cdots<\gamma(K)\leq n$, are achieved in a moment balancing template. The remaining bits in $\mathbf{x}$, which are called balancing bits and denoted by $b_{1},b_{2},\ldots,b_{n-K}$, are positioned in the $n-K$ indices that are not occupied by code bits. In particular, $b_{i}=x_{\beta(i)}$ where $1\leq\beta(1)<\beta(2)<\cdots<\beta(n-K)\leq n$ and $\cup_{i}\gamma(i)$ and $\cup_{i}\beta(i)$ are disjoint sets whose union is $\{1,2,\ldots,n\}$. Let $\sigma_{c}(\mathbf{x})=\sum_{i=1}^{K}\gamma(i)c_{i}\pmod{m}$ and $\sigma_{b}(\mathbf{x})=\sum_{i=1}^{n-K}\beta(i)b_{i}\pmod{m}$. Then, $\sigma_{c}(\mathbf{x})$ and $\sigma_{b}(\mathbf{x})$ indicate the contribution of the code bits and the balancing bits, respectively, to the moment of $\mathbf{x}$. In particular, $\sigma_{c}(\mathbf{x})+\sigma_{b}(\mathbf{x})\pmod{m}=\sigma(\mathbf{x})\pmod{m}$.

III Variable Index Bit Flipping Moment Balancing Scheme

We present a moment balancing scheme by flipping bits without adding extra balancing bits to balance the moment value of a code word in order to enable a substitution error correcting code word to correct a single insertion or deletion error. By flipping a bit whose index is unknown to the receiver, we artificially create a substitution error which can be corrected together with channel errors. In our work, only the individual bits are flipped, which is different to a bit inversion operation based on the Knuth algorithm [34] for the dc-free balancing purpose, which involves a specific bit and all the following bits. In this section, we will introduce in general a variable index bit flipping moment balancing scheme, namely multiple-flip moment balancing (MFMB) scheme in Section III-A, and a special variable index bit flipping moment balancing scheme, namely one-flip moment balancing (OFMB) scheme in Section III-B.

III-A Multiple-Flip Moment Balancing Scheme

In the rest of the paper let $\mathcal{C}$ be a $(n,M,d_{min})$ binary code, which is not necessarily linear, of length $n$ that has $M$ code words and the minimum Hamming distance $d_{min}$. We are interested in mapping each code word $\mathbf{c}=(c_{1}c_{2}\cdots c_{n})$ in the code $\mathcal{C}$ into a distinct binary sequence $\mathbf{x}=(x_{1}x_{2}\cdots x_{n})$ whose moment is congruent to a fixed integer modulo another fixed integer. This is possible if and only if $M$ is at most equal to the number of distinct sequences of length $n$ satisfying this congruence condition. In this paper, we focus on mappings in which by flipping a minimal number of bits in $\mathbf{c}$ to obtain $\mathbf{x}$ whose moment is congruent to a fixed integer modulo another fixed integer. Let $d_{H}(\cdot,\cdot)$ denote the Hamming distance of two sequences. Given $\mathbf{c}=(c_{1}c_{2}\cdots c_{n})$ and a constant integer $a\in\{0,1,\ldots,m-1\}$ where the constant integer $m>n$, $\mathbf{x}$ is generated on argument $\mathbf{x}=\underset{\sigma(\mathbf{x})=a}{\arg\min}d_{H}(\mathbf{c},\mathbf{x})$. We further define $d$ as the maxima of all Hamming distances of each ${\mathbf{c}}\in\mathcal{C}$ and its corresponding $\bf x$, i.e., $d=\max_{\forall\mathbf{c}\in\mathcal{C}}d_{H}(\mathbf{c},\mathbf{x})$.

Lemma 1

Let $\mathcal{C}$ be a $(n,M,d_{min})$ code. If $d_{min}>2d$, all $\mathbf{x}$’s constitute a new $(n,M,d_{min}^{\prime})$ single insertion/deletion error correcting code, where $d_{min}^{\prime}\geq d_{min}-2d$.

Proof:

Since a maximum of $d$ bit flipping operations for each code word in $\mathcal{C}$ have been carried out, any two sequences $\mathbf{x}$’s generated from two different code words in $\mathcal{C}$ are distinct given $d_{min}>2d$. However, the minimum Hamming distance of the set of all $\mathbf{x}$’s is reduced to $d_{min}^{\prime}$, where $d_{min}^{\prime}\geq d_{min}-2d$. ∎

Lemma 2

For an arbitrary sequence $\mathbf{c}=(c_{1}c_{2}\cdots c_{n})$ of length $n$, maximally $\lfloor\log_{2}n\rfloor+1$ bits need to be inverted to obtain $\mathbf{x}=(x_{1}x_{2}\cdots x_{n})$ with $\sigma(\mathbf{x})=a$, where $2^{\lfloor\log_{2}n\rfloor+1}\geq m>n$.

Proof:

Given the fixed indices $i\in\{2^{0},2^{1},2^{2},\ldots,2^{\lfloor\log_{2}n\rfloor}\}$, when converting $\bf c$ into $\bf x$ by inverting some bits in these fixed indices, the obtained values of $\sigma(\mathbf{x})$ take on all values from 0 to $m-1$ [1]. ∎

In Lemma 2, we present an upper bound of maximum number of bit flips for a code. Therefore, we have $0\leq d\leq\lfloor\log_{2}n\rfloor+1$.

The following theorem illustrates the MFMB scheme.

Theorem 1

Let $\mathcal{C}$ be a $(n,M,d_{min})$ code. Let $a$, $d$ and $m$ be three integers, where $0\leq d\leq\lfloor\log_{2}n\rfloor+1$, $2d<d_{min}$, $0\leq a<m$ and $2^{\lfloor\log_{2}n\rfloor+1}\geq m>n$. (a) Any code word $\bf c$ in $\mathcal{C}$ can be turned into a distinct sequence $\bf x$ with $\sigma(\mathbf{x})=a$ by flipping maximum $d$ bits at unknown indices. (b) All distinct sequences constitute a new code that can correct a single insertion/deletion error or at least $\lfloor\frac{d_{min}-2d-1}{2}\rfloor$ substitution errors. (c) If all possible bit flip indices are known, the resulting code can correct a single insertion/deletion error or at least $\lfloor\frac{d_{min}-d-1}{2}\rfloor$ substitution errors. A single insertion/deletion error correcting code which also can correct no less than $\lfloor\frac{d_{min}-\lfloor\log_{2}n\rfloor-2}{2}\rfloor$ of substitution errors is guaranteed.

Proof:

First, according to Lemma 2, maximum $\lfloor\log_{2}n\rfloor+1$ bit flips are required to satisfy the condition of $\sigma(\mathbf{x})=a$, although the possible indices of bit flips are fixed (known). The number of necessary bit flips in variable (unknown) indices cannot be more than that of fixed case. Second, since in a general case $d$ bit flips can appear at any unknown indices, according to Lemma 1, the resulting code can correct at least $\lfloor\frac{d_{min}-2d-1}{2}\rfloor$ substitution errors. Furthermore, the resulting code satisfies the condition of $\sigma(\mathbf{x})=a$ and can correct a single insertion/deletion error. Third, if the possible bit flip indices are known, the errors at the unknown indices can be considered as erasures. Therefore, the resulting code can correct a single insertion/deletion error or at least $\lfloor\frac{d_{min}-d-1}{2}\rfloor$ substitution errors. Since $d=\lfloor\log_{2}n\rfloor+1$ bit flips at known indices are sufficient, the number of substitution errors can be corrected by the resulting code is lower bounded by $\lfloor\frac{d_{min}-\lfloor\log_{2}n\rfloor-2}{2}\rfloor$. ∎

Example 1

For simplicity we start with a code with $d_{min}=3$ and convert it into a code correcting single insertion/deletion error. Let $a=0$. Choose $\mathcal{C}$ as a (7, 16, 3) Hamming code (the element after the code word in each row is the modulo value and the support set in each row shows the indices of inverting bits) and $m=n+1=8$. Let $S=\{i:c_{i}\neq x_{i}\}$ be the support set to include all indices of the inverted bits in $\bf c$. It is evident that $|S|=d_{H}(\mathbf{c},\mathbf{x})$.

To balance the moment value of each code word in Table I to be 0, no inverting operation is required for the first three code words. To balance code word 1100010, the first or the seventh bit is inverted. Two inverting operations are required for three code words (underlined). Since $d_{min}=3$, in a general case, two distinct code words can be flipped into one identical sequence by more than one inverting operation for either code word. Therefore, two bit flips choices will not be considered in this case.

However, it is observed that the balancing choice of a given code word is not unique. As shown in the rows where the code word are highlighted in bold, there are at least two options to balance one code word. In this example, a single insertion/deletion error correcting code is achieved as shown in Table II by excluding the code words which require two bits to balance and therefore drain the substitution error correcting capability of the original code, and including multiple balanced code words derived from one original code word. In this case, the code rate is not comprised by using Table II to encode. Including multiple balanced code words generated from the same original code word, however, heavily affects the substitution error correcting capability of the resulting code. The intention of showing Table II is to demonstrate a bit flipping approach to implement the VT construction.

To this end, we can derive the following code based on the bit flipping scheme:

[TABLE]

There is a small observation leading to the following lemma.

Lemma 3

Let $\sigma^{\prime}=a-\sigma({\bf{c}})\pmod{m}$. If $\sigma^{\prime}=i$ and $m=2i$ , where $i\in\{1,2,\ldots,n\}$, in order to balance the sequence $\bf c$ to have $\sigma({\bf x})=a$, only 1 bit flip at the $i$’th index is required.

Proof:

When inverting the $i$’th bit of $\bf{c}$ from 0 to 1, $\sigma^{\prime}=i$. When inverting the $i$’th bit of $\bf{c}$ from 1 to 0, $\sigma^{\prime}=m-i$. Let $i=m-i$, we obtain $m=2i$. Therefore, one bit flip at the $i$’th index is sufficient to obtain $\bf{x}$ from $\bf{c}$ to have $\sigma({\bf x})=a$. ∎

The special balancing case presented by Lemma 3 is not rare and the numerical examples can be found in Table I for the original code words 0100111, 0110001 and 1111111 to be balanced.

Note that in the earlier example, we conceptually choose a short Hamming code with $d_{min}=3$. In practical systems, we may choose long BCH codes with larger $d_{min}$ to retain most of the substitution error correcting capability and add an insertion/deletion error correcting capability to the sequences.

The validation and efficiency (in terms of the number of bit-flips introduced) of variable index scheme depend on ($n$, $a$, $m$) and the original code. For example, it is impossible to balance the sequence 010101 for $a=0$ and $m=7$ by less than three bit-flips. Therefore, in the code construction stage, a proper selection procedure is required, which involves selecting $a$ and $m$, and/or expunging some code words to optimize the code rate and/or the error correcting capability. In the next section, we will provide a guaranteed scheme by expunging some code words.

III-B One-Flip Moment Balancing Scheme

The property presented by the following lemma is the key to the OFMB scheme.

Lemma 4

Let $\bf c$ denote a sequence of length $n$. The $n+1$ sequences including the original sequence $\bf c$ and $n$ different sequences each have a bit-flip from $\bf c$, have at least $\lceil\frac{n}{2}\rceil+1$ different moment values in a residue system defined by (1) with modulo $m>n$.

Proof:

By flipping one bit of $\bf c$ in $n$ different indices, $n$ different sequences are generated and each is different from $\bf c$. A bit-flip introduces a difference in (1) since $m>n$. There are only two types of bit-flips. Either a bit with value 0 is substituted by 1, or value 1 substituted by 0. The differences introduced to (1) by all possible 0-to-1 (or 1-to-0) flips are all different also thanks to $m>n$. Since there are in total $n$ possible bit-flips. At least half of them are either 0-to-1 or 1-to-0 flips. Therefore, by one bit-flips at each index, at least $\lceil\frac{n}{2}\rceil$ new moment values are introduced. Including the moment value of $\bf c$, there are $\lceil\frac{n}{2}\rceil+1$ different values introduced by $\bf c$ and the sequences with one bit-flip from $\bf c$. ∎

We consider to moment-balance a code to a new code, in which each code word has identical moment value in the residue system modulo $m=n+1$. Given a binary ($n$, $M$, $d_{min}\geq 3$) code $\mathcal{C}$, a new code $\mathcal{C}^{\prime}$ can be generated by using the OFMB scheme, actually an expunging process illustrated by the following steps:

By flipping only one bit in each index of $\bf c\in\mathcal{C}$, $n+1$ different sequences including the original word are generated from $\bf c$. These $n+1$ sequences carry at least $\lceil\frac{n}{2}\rceil+1$ different moment values according to Lemma 4. For each generated moment values, we only select one sequence even if there are multiple sequences carry the same moment value. 2. 2.

By applying Step 1 to all $\bf c\in\mathcal{C}$, at least $M(\lceil\frac{n}{2}\rceil+1)$ different sequences are generated since the original code $\mathcal{C}$ has $d_{min}\geq 3$ and for each $\bf c$ at least $\lceil\frac{n}{2}\rceil+1$ new sequences are generated in the previous step. 3. 3.

The different sequences generated in the previous step are partitioned into $m=n+1$ sets according to (1). Among them, the one with the biggest cardinality is chosen as the new code $\mathcal{C}^{\prime}$.

Theorem 2

Let $\mathcal{C}$ be a $(n,M,d_{min}\geq 3)$ code. An $(n,M^{\prime},d_{min}^{\prime}\geq d_{min}-2)$ code $\mathcal{C}^{\prime}$ exists where M^{\prime}\geq\Bigl{\lceil}\frac{M(\lceil\frac{n}{2}\rceil+1)}{n+1}\Bigr{\rceil}\geq\Bigl{\lceil}\frac{M}{2}\Bigr{\rceil}. All code words in $\mathcal{C}^{\prime}$ satisfy the residue system defined in (1) with $m=n+1$ and some $a$, and therefore $\mathcal{C}^{\prime}$ is also a single insertion/deletion error correcting code.

Proof:

As discussed in the last section, among the original code word and the new sequences generated from it by one flip, if there are multiple sequences carrying the same moment value only one sequence should be chosen in order to minimize the decrease of minimum Hamming distance of the resulting code. Therefore, in the steps shown earlier in this section, although $M(n+1)$ different sequences can be generated based on $\mathcal{C}$ and one-flip operations, only no less than $M(\lceil\frac{n}{2}\rceil+1)$ sequences are chosen. Since the sequences are partitioned into $m=n+1$ sets, the cardinality $M^{\prime}$ of the resulting code $\mathcal{C}^{\prime}$ satisfies

[TABLE]

Hence, $\mathcal{C}^{\prime}$ is a single insertion/deletion error correcting code. Moreover, in $\mathcal{C}^{\prime}$ no two code words are generated through one-flip operations from the same original code word. Therefore, the minimum Hamming distance $d_{min}^{\prime}$ of $\mathcal{C}^{\prime}$ satisfies

[TABLE]

∎

The brute-force method as shown in the steps presented earlier in this section, which is similar to the method to implement the MFMB scheme, can be used to choose a code and an encoding table.

IV Fixed Index Bit Flipping Moment Balancing Scheme

We further present a fixed index bit flipping scheme in this section. According to Lemma 2, it is guaranteed that by flipping some bits in the fixed indices $i\in\{2^{0},2^{1},2^{2},\ldots,2^{\lfloor\log_{2}n\rfloor}\}$, the moment value of the obtained sequence can be balanced. Since the indices of possible inversions are fixed, the bits in these indices can be considered as erasures at the decoder and the number of erasures is $\lfloor\log_{2}n\rfloor+1$.

An example of a fixed index bit flipping scheme follows.

Example 2

Choose $\mathcal{C}$ as a (15, 32, 7) binary primitive BCH code, $a=0$ and $m=n+1=16$.

In Table III, two obtained codes by implementing the variable index moment balancing scheme and fixed index moment balancing scheme are presented in the 3rd column and 4th column respectively. The inversions of code words in Code I are highlighted in bold. The fixed indices of Code II are the 1st, 2nd, 4th and 8th indices. Only bits in these indices are possibly inverted.

It is evident that Code I obtained by implementing the variable index scheme, compromises the substitution error correcting capability to achieve single insertion/deletion error correction. The resulting code can also correct one substitution error. The cardinality of Code I can be further increased by including more bit-flip options. The trade-off is the substitution error correcting capability of the resulting code will be further compromised. Code II obtained by implementing fixed index scheme has the same cardinality as the original code. To decode Code II, we can consider the bits at the fixed indices are erasures. In this sense, Code II can correct a single insertion/deletion error or one substitution error in addition to four erasures.

The following theorem illustrates the fixed index bit flipping moment balancing scheme.

Theorem 3

Let $\mathcal{C}$ be a ($n$, $M$, $d_{min}$) substitution error correcting code. Let $a$, $d$ and $m$ be three integers, where $d=\lfloor\log_{2}n\rfloor+1$, $0\leq a<m$ and $2^{\lfloor\log_{2}n\rfloor+1}\geq m>n$. Any code word $\bf c$ in $\mathcal{C}$ can be turned into a sequence $\bf x$ with $\sigma(\mathbf{x})=a$ that can correct a single insertion/deletion error or $\lfloor\frac{d_{min}-d-1}{2}\rfloor$ substitution errors by flipping maximum $\lfloor\log_{2}n\rfloor+1$ bits in the fixed indices $\{2^{0},2^{1},2^{2},\ldots,2^{\lfloor\log_{2}n\rfloor}\}$ of $\bf c$.

Proof:

According to Lemma 2, by changing the values of the bits in the fixed indices, the moment value of these bits can take on any value between 0 to $2^{\lfloor\log_{2}n\rfloor+1}-1$. Therefore, it is sufficient to turn $\bf c$ into $\bf x$, which has $\sigma(\mathbf{x})=a$. Since these bits used to balance the moment value are in the fixed indices, they can be considered as erasures by the decoder. Hence, the code can correct $\lfloor\frac{d_{min}-d-1}{2}\rfloor$ substitution errors. ∎

The decoding process for both fixed and variable index schemes can be described as follows. At the receiver, based on marker or special synchronization words inserted between frames, insertion or deletion errors are first detected. If a single insertion or deletion is detected, it can be decoded by using the algorithm presented in [5]. If there is no insertion or deletion error, the decoder proceeds with the procedure of substitution error correction. While correcting substitution errors in the sequences encoded by the fixed scheme, the bits in the fixed indices should be marked as erasures first.

V Analysis

Let $C(n,d_{min},s)$ denote a code of length $n$ which has $d_{min}$ minimum Hamming distance and also can correct $s$ insertion/deletion errors. In [5], Levenshtein introduces a class of codes which can correct single insertion/deletion or single substitution error $C(n,3,1)$. Equivalently, it gives a lower bound of cardinalities of $C(n,3,1)$, which is $\frac{2^{n}}{2n}$. In this work, we extend the code to $C(n,d_{min},1)$ and the lower bound can be further considered in the light of the schemes presented in this paper.

For the class of codes constructed in [5], the construction starts by using VT construction and the single substitution error correcting capability is a by-product. In the work, we start with a multiple substitution error correcting code and make it correct a single insertion/deletion error with a limited compromised substitution error correcting capability compared with the original code. The construction takes two steps and is deterministic.

As well known, binary MDS codes are trivial [35]. While $n$ is small, very often the performance of a linear code deteriorates drastically if its valuable substitution error correcting capability is compromised for a single insertion/deletion error correction. Therefore, if $n$ is small, non-linear codes can be considered since the new schemes are not limited to implementing linear codes. Since at most $\lfloor\log_{2}n\rfloor+1$ bits are required to turn a substitution error correcting code into a single insertion/deletion error correcting code, while $n$ is large the performance of a substitution error correcting code does not degrade as much as short codes. In this case, the linear codes are preferable considering the encoding and decoding complexities.

Here we present a new lower bound of cardinalities for a $\mathcal{C}(n,d_{min},1)$ code.

Theorem 4

There always exists a code $\mathcal{C}(n,d_{min},1)^{*}$ with the cardinality $|\mathcal{C}(n,d_{min},1)^{*}|\geq\frac{2^{n-1}}{V_{2}(n,d_{min}+1)}$, where $V_{2}(n,d_{min}+1)=\sum_{i=0}^{d_{min}+1}\binom{n}{i}$.

Proof:

The Gilbert-Varsharmov (GV) bound [36, 37] ensures the existence of binary code $\mathcal{C}$ of length $n$ with the minimum Hamming distance $d_{min}$, having $|\mathcal{C}|\geq\frac{2^{n}}{V_{2}(n,d_{min}-1)}$. Based on this result, we first start with a binary code achieving the GV bound with the minimum Hamming distance $d_{min}+2$. This binary code has the cardinality no less than $\frac{2^{n}}{V_{2}(n,d_{min}+1)}$. By using the OFMB scheme, the resulting code $\mathcal{C}^{*}$ has a reduced minimum Hamming distance $d_{min}$ and a reduced cardinality no less than approximately half of the original code. ∎

To this end, we can further develop a tighter lower cardinality bound for $C(n,d_{min},1)$ codes as follows.

Theorem 5

There always exists a code $C(n,d_{min},1)^{*}$ with the cardinality

[TABLE]

Proof:

Apply the moment balancing template (MBT) to a binary code of length $n-\lfloor\log_{2}n\rfloor-1$, achieving the GV bound with the minimum Hamming distance $d_{min}$. The resulting code of length $n$ has the minimum Hamming distance no less than $d_{min}$ and the cardinality no less than $\frac{2^{n-\lfloor\log_{2}n\rfloor-1}}{V_{2}(n-\lfloor\log_{2}n\rfloor-1,d_{min}-1)}$. Therefore, we can combine this result with the lower bound derived in Theorem 4 and give a tighter lower bound. ∎

Levenshtein [5] found a class of codes which can correct a single insertion/deletion error or a substitution error ($d_{min}\geq 3$) based on the VT construction while $m\geq 2n$. Therefore, the resulting code has a cardinality no less than $\frac{2^{n}}{2n}$. To this end, we compare the new lower bound in Theorem 4 with Levenshtein’s result for $d_{min}=3$. Since the denominator in the new lower bound is $V_{2}(n,d_{min}+1)=\binom{n}{4}+\binom{n}{3}+\binom{n}{2}+\binom{n}{1}+1$ when $d_{min}=3$, the new lower bound is not superior to Levenshtein’s result. Note that Levenshtein’s result considers arbitrary sequences and $d_{min}=3$ only. The new result considers a substitution error correcting code and any minimum Hamming distance. The new result not only increases the minimum Hamming distance range of the resulting codes, but also introduces a possible complexity reduction to the encoding and decoding process.

In Table IV, we compare the code word lengths, information lengths, insertion/deletion and substitution error correcting capabilities of the OFMB scheme and the MBT scheme applied to a substitution error correcting code.

We further compare the OFMB scheme with an alternative scheme, namely the MBT scheme [1], which starts with a multiple substitution error correcting code and encodes each code word with a systematic VT construction. To implement the MBT scheme for a substitution error correcting code achieving the GV bound with $d_{min}$ of length $n-\lfloor\log_{2}n\rfloor-1$, we insert $\lfloor\log_{2}n\rfloor+1$ balancing bits to hold the fixed indices $\{2^{0},2^{1},2^{2},\ldots,2^{\lfloor\log_{2}n\rfloor}\}$ in each code word and ensure (1) to be met by judicially choosing the values of the balancing bits. In Fig. 1 we compare the cardinalities of codes generated by the MBT template and the OFMB scheme respectively. Both resulting codes have length 265 and the original code for the MBT template has length 256. Note that both original codes are codes that achieve the GV bound. As shown in Fig. 1, while the minimum Hamming distance of the resulting code takes the value between 20 to 110， the cardinality of the code generated based on the OFMB scheme is superior to the one generated by the MBT scheme.

By the following theorem we present a comparison in an asymptotic form between the lower bounds derived based on the OFMB and the MBT schemes respectively. Let $H_{2}(\cdot)$ denote the binary entropy function.

Theorem 6** (Asymptotic bound)**

There always exists a code $C(n,d_{min},1)^{*}$ with the cardinality

[TABLE]

while $n$ is large and $\frac{(d_{min}+1)(\lfloor\log_{2}n\rfloor+1)}{2n}>1$.

Proof:

Based on Theorem 5, the lower bound of cardinalities is the maximum value between the lower bound derived based on the OFMB shceme, which is $\frac{2^{n-1}}{V_{2}(n,d_{min}+1)}$ and the one based on the MBT scheme, which is $\frac{2^{n-\lfloor\log_{2}n\rfloor-1}}{V_{2}(n-\lfloor\log_{2}n\rfloor-1,d_{min}-1)}$. Let $\delta_{1}=\frac{d_{min}+1}{n}$ and $\delta_{2}=\frac{d_{min}-1}{n-\lfloor\log_{2}n\rfloor-1}$.

Since in an asymptotic form

[TABLE]

where $0\leq\delta\leq\frac{1}{2}$, we can give an estimate of $V_{2}(n,\delta n)=2^{H_{2}(\delta)n}$. Therefore, we have

[TABLE]

and

[TABLE]

Let $\Delta$ denote the difference between the exponents of the right terms in (8) and (9). We have

[TABLE]

We have the following observations:

• •

While $n$ is large, the third term can be ignored.

• •

Since $0\leq H_{2}(\delta_{2})\leq 1$ the second term is no less than zero.

• •

Since $0\leq\delta_{1},\delta_{2}\leq\frac{1}{2}$, if $\delta_{2}>\delta_{1}$ the first term is positive.

Based on the definitions of $\delta_{1}$ and $\delta_{2}$, if $\delta_{2}>\delta_{1}$, which means

[TABLE]

the condition

[TABLE]

is required. ∎

It is evident that the new lower bound based on the OFMB scheme is guaranteed to be superior to the one derived based on the original MBT scheme if (12) is met, and there are a wide range of 2-tuple ($d_{min}$ , $n$) satisfying (12).

VI Conclusion and Future Work

The two bit flipping schemes have three major advantages compared to the original template [1]. First, insertion/deletion errors and substitution errors are channel errors. Both should be considered while designing a code for a harsh channel, and the preferred original code is likely to be substitution error correcting code already. Second, we start with the most widely used channel codes, substitution error correcting codes. The original error correcting capability, the remaining substitution error correcting capability, and single insertion/deletion correcting capability can be balanced by using the new schemes. Since the new schemes only invert the bits if necessary to satisfy moment constraint and every flip in general will cause more deduction on the substitution error correcting capability, therefore we can say the capability can be reduced if required. Third, most modern systems already are designed based on a given substitution error correcting code. The new schemes are practical to implement on top of an existing system since they require no code length change.

In this paper, we present an approach to reduce the capability of a substitution error correcting code to also correct a single insertion/deletion error - in fact thus a rate $R=1$ moment balancing template. The encoding and decoding procedures are discussed and the performance is evaluated.

The efficiency of MFMB scheme can be further evaluated in future work. An analytical approach by using generation functions involving polynomial multiplication was considered by the authors to investigate how many different moment values can be generated by multiple bit-flips from a given code word. However, as shown in [38, 39], the analytical model of number of terms of power of polynomial is still an open question to the authors’ best knowledge.