Integer Codes Correcting up to Two Errors of Type ±1

Abstract

Let ${\mathbb{Z}}_q$ be the ring of integers modulo q (not necessarily a prime power). $[n,n-1]$ and $[n,n-2]$ codes over ${\mathbb{Z}}_q$ that are capable of correcting up to two errors of type ±1 are proposed. The application of these codes to QAM is discussed. A comparison with convolutional codes of the same rate in simulated QAM communications shows better performance of the proposed codes.

1. Introduction

Let ${\mathbb{Z}}_q$ be the ring of integers modulo q (not necessarily a prime power). An ${[n,n-m]}_q$ integer code is said to be a subset of ${\mathbb{Z}}_q^n$, defined by

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

where $\mathbf{H}$ is an $m\times n$ matrix with elements from ${\mathbb{Z}}_q$ and it is called a parity-check matrix.

If a codeword $\mathbf{c}\in {\mathbb{Z}}_q^n$ is sent through a noisy communication channel, the vector $\mathbf{r}$ received at the other end can be presented in the form $\mathbf{r}=\mathbf{c}+\mathbf{e}$, where $\mathbf{e}=(e_1,\dots ,e_n)\in {\mathbb{Z}}_q^n$ is called the error vector.

One of the earliest applications of integer codes is the one proposed by Varshamov and Tenengolz in [1,2]. They used integer codes for correcting single asymmetric errors. Vinck and Morita [3] applied such codes to magnetic recording and frame synchronization.

Reading and writing in flash memory can be considered as a communication channel with alphabet ${\mathbb{Z}}_q$. Errors appearing during the processes of reading and writing in flash memory are symmetric limited-magnitude (e.g., ±1 or ±2) or asymmetric (e.g., (1,2,3)). Hence, the entries of the error vector have those values, and integer codes are potentially suitable for this application. A general method of construction of asymmetric limited-magnitude error-correcting codes is provided by Cassuto et al. [4]. Systematic codes that correct single limited-magnitude systematic asymmetric errors and achieve a higher rate than those given in [4] were proposed by T. Klove and B. Bose [5] and Klove et al. in [6].

Morita and the authors of this paper proposed in [7,8] how integer codes can be applied to coded modulation. The investigations presented in [9,10,11,12,13] are in the same area. Several specific uses of integer codes are described in [14,15,16,17,18,19,20].

All the cited works above propose codes that can correct a single error of a given type. In [21] a ${[4,2]}_9$ code capable of correcting up to two errors of type ±1 is given, and it is described how to apply this code to error control in 64-QAM. Khachatrian et al. [22] construct ${[12,8]}_5,{[17,12]}_7,$ and ${[21,16]}_9$ codes capable of correcting two errors of type ±1 or ±2.

We shall say that a code $\mathcal{C}(\mathbf{H})$ is a double $\pm 1$ errors correctable if the decoding procedure can successively recover the error vector if it has up to two nonzero entries and their values are 1 or $-1$.

In this paper, we propose constructions of codes over ${\mathbb{Z}}_q$ that are double $\pm 1$ errors correctable and apply them to communication based on Quadrature Amplitude Modulation (QAM). The proposed codes have high rates, namely ${[n,n-1]}_q$ and ${[n,n-2]}_q$. Such codes have parity-check matrix $\mathbf{H}$ of the form

$$(i):\mathbf{H}=(1h_2{h}_3\dots h_n)\mathrm{and}(ii):\mathbf{H}=\left(\begin{array}{ccccc}1& 0& h_{13}& \dots & h_{1n}\\ 0& 1& h_{23}& \dots & h_{2n}\end{array}\right),$$

(1)

respectively, where h_i, h_ij $\in {\mathbb{Z}}_q$.

The next parts of the paper are organized as follows. Section 2 presents constructions of the proposed integer codes. In Section 3 applications of the proposed codes to QAM communications are described. Two examples of the codes are discussed in detail. Those codes are compared with convolutional codes having the same code rate. The results from comparisons are presented graphically.

Concluding remarks are presented and discussed in Section 4.

In the Appendix A, a list of double ±1 error-correctable integer codes with block length $n\le 12$ is given.

2. Construction of Integer Codes Correcting Double Errors of Type ±1

Let $\mathcal{C}$ be an integer code with parity check matrix

$$\mathbf{H}=({\mathbf{h}}_{\mathbf{1}}{\mathbf{h}}_{\mathbf{2}}\dots {\mathbf{h}}_{\mathbf{n}}),$$

where ${\mathbf{h}}_i$ are columns of length m. For $\mathcal{C}$ to be a double ±1 errors correctable code, all elements of the set of syndromes

$$\mathcal{S}=\{\pm {\mathbf{h}}_i,\pm ({\mathbf{h}}_i\pm {\mathbf{h}}_j)\}$$

must be pairwise distinct and different from zero. By counting the number of elements of $\mathcal{S}$ we obtain the following lower bound for q

Lemma 1.

$$q^m\ge 2n^2+1.$$

The cases $m=1$ and $m=2$ are the lower bounds given by Proposition 1 in [21].

Also we can observe the following useful property of the considered codes.

Lemma 2

([21]). Let $\mathcal{C}(\mathbf{H})$ be a double $\pm 1$ errors correctable code. Multiplication of a column of $\mathbf{H}$ by $-1$ is a transformation that preserves the property of $\mathcal{C}$ to be a double $\pm 1$ error-correctable code.

Proof. 

The multiplication of a column of $\mathbf{H}$ by $-1$ does not change the set S of syndromes but only permutes its elements, that is, only changes the 1-1 correspondence between errors and syndromes. Hence, the code does not lose its property to correct up to two $\pm 1$ errors. □

Corollary 1.

If $\mathcal{C}(\mathbf{H})$ is a double $\pm 1$ error-correctable code, we can assume that one row of $\mathbf{H}$ consists of elements of ${\mathbb{Z}}_q$ less than or equal to $q/2$.

Indeed, one of a or $-a$ in ${\mathbb{Z}}_q$ is less than or equal to $q/2$.

2.1. The Case ${[n,n-1]}_q$

The codes with the shortest block length are ${[2,1]}_q$ codes and according to Lemma 1 $q\ge 9$. Such double $\pm 1$ errors correctable codes indeed exist. We have the following:

Proposition 1.

If $\mathbf{H}=(1a),$ where

$$3\le a\le \left\{\begin{array}{c}(q-3)/2,q\mathit{odd}\hfill \\ (q-4)/2,q\mathit{even}\hfill \end{array}\right.$$

then $\mathcal{C}(\mathbf{H})$ is a double $\pm 1$ errors correctable code over ${\mathbb{Z}}_q$.

Proof. 

The set of syndromes is $S=S_1\cup (-S_1),$ where

$$S_1=\{1,a-1,a,a+1\}.$$

In both cases $a+1<q/2,$ thus the subsets $S_1$ and $-S_1$ have no common element. Hence, all elements of S are different. □

Remark 1.

If we fix $a\ge 3$ the Proposition 1 gives a lower bound for $q.$

Example 1.

Let $n=2.$ Then $q\ge 9$ and according to Proposition 1 the code with $\mathbf{H}=(13)$ is a double $\pm 1$ error-correctable code with $q=9.$

Example 2.

Let $n=3.$ Then $q\ge 19$, however, double $\pm 1$ error-correctable codes do not exist for $q=19$ and 20. The code with $\mathbf{H}=(138)$ is a double $\pm 1$ errors correctable code for $q=21$. Moreover, it is such a code considered as a code over ${\mathbb{Z}}_q$ with $q=32.$

The following matrices define double $\pm 1$ error-correctable codes for $n=4\mathit{and}5$.

$$\begin{array}{cc}\mathbf{H}=(13818):& q=46,49,q\ge 53\hfill \\ \mathbf{H}=(1381838):& q=96,q\ge 113\hfill \\ \mathbf{H}=(141022):& q=56,q\ge 65\hfill \end{array}$$

(2)

A construction of $\mathbf{H}=(h_1{h}_2\dots h_n)$ defining a double $\pm 1$ error-correctable code:

1.

Set $h_1=1,h_2=a$, where a satisfies the conditions of Proposition 1;

2.

Set $h_{i+1}=2h_i+2,i=2,3,4,\dots$.

Theorem 1.

The construction described above gives a parity-check matrix of a double $\pm 1$ errors correctable code for $q>6h_{n-1}+4.$

Proof. 

We proceed by induction on n. Let $h_1=1,h_2=a$, where a satisfies the conditions of Proposition 1, and $h_3=2a+2.$ Then, $h_3-h_2=a+2>h_2+h_1$ and the set $S_1$ corresponding to ${\mathbf{H}}_3=(1a2a+2)$ is

$$S_1=\{1,a-1,a,a+1,a+2,2a+1,2a+2,2a+3,3a+2\}$$

It is easy to check that $-S_1=q-S_1$ has no common elements with $S_1$ at least if $q>6a+4=6h_2+4.$

Assume ${\mathbf{H}}_n=(h_1{h}_2\dots h_n)$ obtained by the Construction is a parity-check matrix of a double ±1 error-correctable code. Let

$$S_1^{(n+1)}=\{h_i\pm h_j,i>j,j,i=1,2,\dots \}$$

be the set of the sums and differences of any two elements of the matrix ${\mathbf{H}}_{n+1}=({\mathbf{H}}_n{h}_{n+1}),h_{n+1}=2h_n+2.$ Obviously

$$S_1^{(n+1)}=S_1^{(n)}\cup \left\{h_{n+1}\right\}\cup \{h_{n+1}\pm h_j,j=1,\dots ,n\}$$

Since $h_{n+1}\pm h_j=(h_n+2)+(h_n\pm h_j)$ the sets $\{h_{n+1}+h_j\}$ and $\{h_i+h_j\},i,j=1,\dots ,n$ do not overlap. The same holds for $\{h_{n+1}-h_j\}$ and $\{h_i-h_j\}$. We have to prove that there are no common elements of $\{h_{n+1}-h_j\}$ and $\{h_i+h_j\}$. It is easy to check that

$$h_k=2^{k-2}a+2(2^{k-2}-1).$$

Then,

$$h_{n+1}-h_k=(2^{n-1}-2^{k-2})(a+2),k\ge 2$$

and

$$h_i+h_j=(2^{i-2}-2^{j-2})(a+2)-4.$$

Since $a\ge 3$ the values $h_{n+1}-h_k$ and $h_i+h_j$ cannot be equal (the reminders are different). Therefore, all elements of $S_1^{(n+1)}$ are nonzero and pairwise distinct. Also, they are not greater than $3h_n+2$. Hence, for $q>6h_n+4$

$$-S_1^{(n+1)}\cap S_1^{(n+1)}=\varnothing$$

Therefore, the code with parity-check matrix ${\mathbf{H}}_{n+1}$ is a double ±1 error-correctable code. □

2.2. The Case ${[n,n-2]}_q$

The ${[n,n-2]}_q$ codes require twice the block length n than ${[n,n-1]}_q$ codes to achieve the same code rate as the ${[n,n-1]}_q$ codes but can reduce the value of q. For some applications, a larger value of q is not a problem, but a constellation with $q^2$ signal points with such q is too large for practical use.

Lemma 3.

If $\mathcal{C}(\mathbf{H})$ is a double $\pm 1$ error-correctable code over ${\mathbb{Z}}_q$, then

$$\begin{array}{c}\hfill q^2\ge 2n^2+1,\mathit{for}q\mathit{odd},\end{array}$$

(3)

$$\begin{array}{c}\hfill q^2\ge 2n^2+4,\mathit{for}q\mathit{even}.\end{array}$$

(4)

Proof. 

The bound in the case q odd is given by Lemma 1. When q is even, we must exclude as potential syndromes

$$\pm \left(\begin{array}{c}q/2\\ 0\end{array}\right),\pm \left(\begin{array}{c}0\\ q/2\end{array}\right),\pm \left(\begin{array}{c}q/2\\ q/2\end{array}\right)$$

since $-q/2=q/2$ in ${\mathbb{Z}}_q$. Hence, $q^2-3\ge 2n^2+1.$ □

A trivial construction of ${[n,n-2]}_q$ code can be obtained using an ${[n,n-1]}_q$ code. The entries of the columns of the new code are the entries of the ${[n,n-1]}_q$ code and zero. For example, H$=(13)$ gives the following parity-check matrix of a double ±1 errors correctable $[4,2]$ code:

$$\left(\begin{array}{cccc}1& 0& 3& 0\\ 0& 1& 0& 3\end{array}\right).$$

However this construction does not reduce the size q of the alphabet. The minimal q required by the above matrix is $q=9$ (the same as the value required by H$=(13)$), while, e.g.,

$$\left(\begin{array}{cccc}1& 0& 3& 1\\ 0& 1& 1& 3\end{array}\right)$$

enables $q=7.$

The above construction leads us to the idea of constructing $\mathbf{H}$ as a concatenation of submatrices of the form

$$\left(\begin{array}{cc}a& b\\ b& a\end{array}\right),a-b\ge 2.$$

(5)

The bound for the difference $a-b$ follows from the fact that submatrix

$$\left(\begin{array}{cccc}1& 0& a& b\\ 0& 1& b& a\end{array}\right)$$

of (1-(ii)) defines a double $\pm 1$ error-correcting code, too.

Theorem 2.

If positive integers a and b satisfy the conditions

$$a-b\ge 2,(a,b)\ne (3,1),\mathit{and}a\ne 3b+2$$

(6)

the matrix

$$\mathbf{H}=\left(\begin{array}{cccc}1& 0& a& b\\ 0& 1& b& a\end{array}\right)$$

(7)

defines a double $\pm 1$ correctable code over ${\mathbb{Z}}_q$ with $q=a+b+2.$

In the cases $a=3b+2$ and $a=3,b=1$ the size of the alphabet $q=a+b+3.$

Proof. 

When $n=4$ Lemma 3 requires $q\ge 6$ but when $q=6$ in the case $a=3,b=1$ the error vectors $(0-110)$ and $(01-10)$ have the same syndrome since $3=-3$ in ${\mathbb{Z}}_6$. Hence, $q\ge 7.$ In case $q=7$, there is no such problem.

One can write all 32 syndromes corresponding to all error vectors with weight two or one and entries 1 or −1 and check that they are different with the exception of the following cases:

Syndromes

$$\pm \left(\begin{array}{c}a-b\\ b-a\end{array}\right)\mathrm{and}\pm \left(\begin{array}{c}1\\ -1\end{array}\right)$$

must be different, thus $a-b>1.$

If $a=3b+2$ and $q=a+b+2$ we have in ${\mathbb{Z}}_q$

$$b-a=(a+b+2)-(a-b)=a+b+2-(2b+2)=a-b$$

Hence, syndromes of error vectors $(001-1)$ and $(00-11)$ are equal, and the code cannot be double $\pm 1$ correctable. However, increasing q by one solves the problem. □

To obtain a code with odd length n we add one column to the parity-check matrix of a double $\pm 1$ correctable code of length $n-1$ and check whether the property is preserved. Very often a column of the form $\left(\begin{array}{c}c\\ c\end{array}\right)$, is a successful choice.

In the Appendix A we give a list of double $\pm 1$ error-correctable ${[n,n-2]}_q$ codes with the minimum possible q.

3. Application of Proposed Codes to Communication Schemes Based on Quadrature Amplitude Modulation

Quadrature Amplitude Modulation (QAM) is a communication scheme for data transmission using signals that are sums of two orthogonal signals with prescribed amplitudes. The set of possible signals can be presented as a lattice of points that is usually called a constellation. The most used in practice type of QAM is the one whose constellation is a square. It is referred to here as SQAM.

Applications of the proposed codes consist of the following steps:

1.

The input binary sequence is transformed into a sequence of pairs of elements of ${\mathbb{Z}}_q$. Each pair represents horizontal and vertical coordinates of a signal point of the constellation of $q^2$-SQAM with $q=2^m.$

2.

The sequences of horizontal and vertical coordinates are independently encoded by the code over ${\mathbb{Z}}_q$

3.

The sequence of received signal points (with added AWGN) is transformed into two sequences (of horizontal and vertical coordinates) over ${\mathbb{Z}}_q$.

4.

After decoding each of those sequences, they are transformed into a binary sequence with the length of the input one.

Comparing the input and output sequences, we can compute the bit error rate (BER) for different values of signal-to-noise ratio (SNR). The obtained information enables us to compare the performance of the proposed codes with other methods of encoding, e.g., trellis decoding with convolutional codes

Remark 2.

If we apply the codes to $2^m$-SQAM, the natural choice is $q=2^m$; however, a similar procedure can be performed with $q=2^m-1$ or $q=2^m+1.$ We refer the reader to [23].

Example 3.

Consider communication based on 1024-SQAM. We demonstrate the proposed error-correcting scheme by the use of the ${[3,2]}_{32}$ integer code with $\mathbf{H}=(138)$ (see Example 2). Let 10110011101000101001 be the input binary sequence. First, we transform it into a sequence of pairs of elements of ${\mathbb{Z}}_{32}$: $(22,14),(17,9).$ Compute the parity-check pair $(x,y)$ by

$$x=-3\times 22-8\times 17=22(\mathrm{mod}32);y=-3\times 14-8\times 9=14(\mathrm{mod}32).$$

Let the sent three pairs be detected at the receiver as

$$(21,14),(23,13),(17,10)$$

We compute syndromes that correspond to the horizontal and vertical coordinates by

$$(212317)\times {(138)}^{\prime }=2(\mathrm{mod}32);(141310)\times {(138)}^{\prime }=5(\mathrm{mod}32).$$

The error vectors corresponding to the computed syndromes are

$${\mathbf{e}}_1=(-110)\mathit{and}{\mathbf{e}}_2=(0-11),\mathit{respectively}.$$

The error vectors are determined by using a $32\times 3$ table whose rows are error vectors and the index of each row is its syndrome. (A row whose index is not a syndrome of an error vector of the considered type is the all-zeros vector.) Computing

$$(212317)-(-110)=(222217);(141310)-(0-11)=(14149)$$

we find the sent pairs: $(22,14),(22,14),(17,9).$ Removing the parity-check pair (the first pair), we reconstruct the sent sequence of elements of ${\mathbb{Z}}_{32}$. The last step is to transform it into a binary sequence.

Example 4.

Consider communication based on 256-SQAM and ${[8,6]}_{16}$ code over ${\mathbb{Z}}_{16}$ defined by

$$\mathit{H}=\left(\begin{array}{cccccccc}0& 1& 0& 5& 2& 4& 3& 6\\ 1& 0& 5& 0& 4& 2& 6& 3\end{array}\right).$$

Encoding and decoding procedures are similar to those described in Example 3. However, in this case two parity-check coordinate pairs $(x_1,y_1),(x_2,y_2)$ are sent through the channel in addition to the six information coordinate pairs $(a_i,b_i),i=1,\dots ,6,$ where

$$\begin{array}{c}\hfill x_1=-(5a_1+4a_3+2a_4+6a_5+3a_6)(\mathrm{mod}16),\\ \hfill x_2=-(5a_2+2a_3+4a_4+3a_5+6a_6)(\mathrm{mod}16),\\ \hfill y_1=-(5b_1+4b_3+2b_4+6b_5+3b_6)(\mathrm{mod}16),\\ \hfill y_2=-(5b_2+2b_3+4b_4+3b_5+6b_6)(\mathrm{mod}16).\end{array}$$

To evaluate the performance of proposed codes we develop a software that simulates a communication based on SQAM in presence of additive white Gaussan noise (AWGN) in two variants: with the use of the proposed codes and trellis encoding with convolution codes with the same coding rate, respectively. The input and the output are binary sequences with the same length, which enables BER versus SNR to be determined.

The first step is to develop software that simulates a communication based on SQAM in presence of AWGN to be written. The input consists of the SNR and a sequence of pairs representing the coordinates of sent signal points. The output is a sequence of the coordinate pairs of the signal points detected at the receiver.

The simulation of the AWGN channel is extended with encoding and decoding parts. The former transforms the input binary sequence into one of the coordinate pairs using an integer code or another code (in our investigations, a convolutional one). The latter part performs the inverse operation: it transforms the sequence of coordinate pairs into a binary sequence after correcting the detected errors.

Note that we use one and the same software for simulating an AWGN channel during the experiments with both types of codes. All the simulations have been done under the assumption that the half-distance d between signal points is $d=1$. The energy of the noise is a function of SNR and the average energy of a signal point of the constellation. In the experiments with the convolutional code, we use Gray mapping.

Figure 1 presents results of simulation of 1024-SQAM using the code from Example 3 and a convolutional code with the same rate 2/3. This code has constraint length [5 4] and generator matrix [23 35 0; 0 5 13] (the rows of the matrix are given in octal; we refer the reader to [24,25] for details about the use of the convolutional code).

Figure 1. BER vs. SNR per bit for codes considered in Example 3 (1024-SQAM).

Figure 2 presents results of simulation of 256-SQAM using the code from Example 4 and a punctured convolutional code with the same rate 3/4. This code is obtained by puncturing a code with constraint length 7 and generator matrix [133 171]. The puncturing pattern is [1; 1; 0; 1; 1; 0] (see [26]).

Figure 2. BER vs. SNR per bit for codes considered in Example 4 (256-SQAM).

Both figures present the values of BER obtained by transmitting 10⁹ bits per each value of SNR. For encoding and decoding for convolutional codes in experiments are used functions “convenc” and “vitdec” with option “hard” from communication toolbox of Matlab (R2026b).

4. Conclusions

The codes ${\mathbb{Z}}_q$ proposed in this paper have very high rates and simple encoding and decoding. Encoding is a computation of only linear expressions. Decoding can be done by using a syndrome error table. Both operations are very fast and simple for modern digital devices.

Simulations of their applications to QAM communications show that these codes can be considered as a competitive tool for error correction in QAM communications.

Appendix A.1. The Case n = 4

In this case, minimum possible size of the alphabet is $q=7$ and

$$\mathbf{H}=\left[\begin{array}{cccc}0& 1& 3& 1\\ 1& 0& 1& 3\end{array}\right],\mathbf{H}=\left[\begin{array}{cccc}0& 1& 4& 1\\ 1& 0& 1& 4\end{array}\right].$$

Appendix A.2. The Case n = 5

Lemma 1 gives $q\ge 8$; however, a computer search shows that required codes do not exist for $q=8$. Then the minimum possible $q=9$ and the exhaustive search gives

$$\mathbf{H}=\left[\begin{array}{ccccc}0& 1& 0& 3& 2\\ 1& 0& 3& 0& 2\end{array}\right],\mathbf{H}=\left[\begin{array}{ccccc}0& 1& 0& 3& 2\\ 1& 0& 3& 0& 4\end{array}\right],\mathbf{H}=\left[\begin{array}{ccccc}0& 1& 0& 2& 3\\ 1& 0& 3& 4& 2\end{array}\right],$$

$$\mathbf{H}=\left[\begin{array}{ccccc}0& 1& 0& 3& 4\\ 1& 0& 3& 3& 1\end{array}\right],\mathbf{H}=\left[\begin{array}{ccccc}0& 1& 0& 3& 4\\ 1& 0& 3& 4& 2\end{array}\right],\mathbf{H}=\left[\begin{array}{ccccc}0& 1& 1& 4& 3\\ 1& 0& 4& 1& 3\end{array}\right].$$

Appendix A.3. The Case n = 6

Then minimum possible $q=10$ and

$$\mathbf{H}=\left[\begin{array}{cccccc}0& 1& 0& 3& 2& 4\\ 1& 0& 3& 0& 4& 2\end{array}\right].$$

Appendix A.4. The Case n = 7

Then minimum possible $q=12$ and

$$\mathbf{H}=\left[\begin{array}{ccccccc}0& 1& 0& 4& 2& 5& 3\\ 1& 0& 4& 0& 5& 2& 3\end{array}\right].$$

Appendix A.5. The Case n = 8

Then minimum possible $q=13$ and

$$\mathbf{H}=\left[\begin{array}{cccccccc}0& 1& 0& 5& 2& 4& 3& 6\\ 1& 0& 5& 0& 4& 2& 6& 3\end{array}\right].$$

Appendix A.6. The Case n = 9

Then minimum possible $q=17$ and

$$\mathbf{H}=\left[\begin{array}{ccccccccc}0& 1& 0& 5& 1& 8& 4& 7& 7\\ 1& 0& 5& 0& 8& 1& 7& 4& 7\end{array}\right],$$

$$\mathbf{H}=\left[\begin{array}{ccccccccc}0& 1& 0& 7& 2& 6& 5& 7& 3\\ 1& 0& 7& 0& 6& 2& 7& 5& 3\end{array}\right],$$

$$\mathbf{H}=\left[\begin{array}{ccccccccc}0& 1& 1& 3& 1& 8& 3& 7& 6\\ 1& 0& 3& 1& 8& 1& 7& 3& 6\end{array}\right].$$

Appendix A.7. The Case n = 10

Then minimum possible $q=19$ and

$$\mathbf{H}=\left[\begin{array}{cccccccccc}0& 1& 0& 6& 3& 8& 4& 6& 5& 9\\ 1& 0& 6& 0& 8& 3& 6& 4& 9& 5\end{array}\right],$$

$$\mathbf{H}=\left[\begin{array}{cccccccccc}0& 1& 1& 4& 1& 9& 2& 6& 4& 9\\ 1& 0& 4& 1& 9& 1& 6& 2& 9& 4\end{array}\right].$$

Appendix A.8. The Case n = 11

Then minimum possible $q=21$ and

$$\mathbf{H}=\left[\begin{array}{ccccccccccc}0& 1& 0& 4& 1& 6& 3& 10& 4& 7& 9\\ 1& 0& 4& 0& 6& 1& 10& 3& 7& 4& 9\end{array}\right].$$

Appendix A.9. The Case n = 12

Then minimum possible $q=23$ and

$$\mathbf{H}=\left[\begin{array}{cccccccccccc}0& 1& 5& 8& 8& 10& 1& 7& 3& 11& 6& 11\\ 1& 0& 8& 5& 10& 8& 7& 1& 11& 3& 11& 6\end{array}\right].$$