Blockwise and Low Density Key Error Correcting Codes

To protect the information from disturbances created by noisy channels, redundant symbols (check symbols) with the information symbols are added. These extra symbols play important role for the efficiency of the communication system. It is always important to know how much these check symbols are required for a code designed for a specific purpose. In this communication, we give lower and upper bounds on check symbols needed to a linear code correcting key errors of length upto p which are confined to a single sub-block. We provide two examples of such linear codes. We, further, obtain those bounds for the case when key error occurs in the whole code length, but the number of disturbing components within key error is upto a certain number. Two examples in this case also are provided.


Introduction
The main purpose of the coding theorists was to detect and correct the errors which are produced during communication through noisy channels. Communication channels are affected by many external and internal factors that result different types of errors in the messages sent. The coding theorists are always trying to retrieve the message even it is corrupted by various types of errors. Plenty of works have been done by many in this direction. Sharma and Gaur (2013) discussed and studied a different type of error related to the typing on a key board. Their study was on such errors w.r.t. S-K metric (partition). Later this type of error was named as "key error" in the work of Das (2014). When a person types on a key board and if by mistake, he presses a different key in the left or right side of the key, then a word with no or different meaning appears. In this case, a key error is created. The definition of a key error given in Das (2014) is as follows: "An i-key error of length p is a vector such that the i th component is non-zero and the other nonzero component are confined to immediate p consecutive components in either side of the i th component." According to the definition, the i th position of the vector is always non-zero and other errors can extend up to p th position on both side of the i th position. This means a key error of length may affect 2p+1 consecutive component. The i th position is called the entry error position of the i-key error. When the entry error position can take any place within the code length (or sub-block of code length), we simply call the error as key error.
Detection of key error is studied by Das (2014) and correction of key error is taken care of by Das (2015). A midway concept between detection and correction (called error location), was initiated by Wolf and Elspas (1963). Location and weight distribution of key error are discussed by Das and Kumar (2020). In continuation with the study of key error, in this paper, we have considered the following two cases: (i) when the length of the code is divided into some smaller length mutually exclusive subblocks and key error occurs within a single sub-block. (ii) when key error occurs in whole code length, but with low density, i.e., maximum number of disturbed components within key error should be less than a limit, called low density key error.
The case (i) is considered keeping in mind the situation when sub-blocks are independent and a corrupted sub-block with key error does not affect other sub-blocks. This is the extension work of location of key error (Das and Kumar, 2020) to correction of key error occurring within a subblock. In (Das and Kumar, 2020), location of key error was possible, but the correction of such error was not possible. In this paper, we present this case, i.e., to correct key errors of length upto p within any single sub-block of length (say) t. We present Single Blockwise Key Error (of length upto p within a sub-block of length t) Correcting Codes. We denote such codes by SBKEp/tC codes. We obtain lower as well as upper bounds on number of check symbols (redundant symbols) of such SBKEp/tC codes.
The case (ii) is considered when key error occurs in the whole code length and certain number or less components within the key error get disturbed. The possibility of certain number or less components getting disturbed is more likely than all components within key errors. Consideration of such situation is initiated by Wyner (1963). In view of this, we present here the lower as well as the upper bounds on number of check symbols for linear codes that are capable to correct key error of length upto p with hamming weight ω or fewer (ω ≤ 2p + 1) in the whole code length. We denote such codes by Kω,pEC codes.
The number of check symbols (or redundant symbols) of a code is important because the rate of information increases if the number of check symbols is lesser and decreases if the number is more. The bounds on number of check symbols (redundant symbols) tell us the limitation and capability of error detection and correction of a code.
The rest of the paper is written as follows. In Section 2, we derive lower as well as upper bounds on the number of check symbols for a SBKEp/tC code and then we give two examples of such codes. In Section 3, similar bounds for a Kω,pEC code are obtained. This is also followed by two examples. At the end, conclusion is given.

Correction of Key Errors Blockwise
We, in this section, first provide the lower number and then the upper number of check (redundant) symbols required for the linear codes which can correct key errors blockwise. The section ends with two examples of such codes. ( Proof. We prove this theorem by enumerating the total number of correctable errors occurring in f sub-blocks each of length t. From Das (2015), the total number of correctable errors in a t-tuple is . Since the code has f sub-blocks of length t, therefore the total number of correctable errors occurring in all f sub-blocks is Remark 2.2 For f = 1, Theorem 2.1 coincides with Theorem 2.1 (Das, 2015) for code length = .
  2 1 2 1 2 1 3 21 2 11 1 ( 4 1)(1 ) To prove this theorem, we construct a suitable parity check matrix H of order  for the SBKEp/tC code in need. Let us assume that the initial − 1 sub-blocks of H and the initial − 1 columns ℎ 1 , ℎ 2 , ℎ 3 , ℎ 4 , … . , ℎ −1 of the f th sub-block of H are selected appropriately. Then, we add the ℎ column ℎ of f th sub-block by the two following conditions: where , ( ), So, the total number of Now, the computation of coefficients i w 's on R. H. S. of (2) is equivalent to finding key errors of length upto p in a vector of length t, which is given by As the number of sub-blocks is − 1, so, the total number of coefficient Hence, the total number of i u 's and i w 's in expression (2) is given by Thus, the total number of linear sums due to expression (1) and (2) Now, putting this number less than r q , we get   2 1 2 1 2 1 3 21 2 11 1 ( 4 1)(1 ) By replacing by t, we get the required result.
Now, we give two examples of codes in support of our results derived above. In the first, we give an example in binary case which is followed by an example in ternary case. All the 364 key errors of length upto p = 2 occurring in the same sub-block or in different subblock and the corresponding syndromes for this code can be obtained with the help of MS-EXCEL and it is verified that the syndromes are all non-zero and distinct. So, this is a SBKE2/11C codes in binary case.
Example 2.6 Taking q = 3, p = 2, f = 2, t=11 in Theorem 2.3, we get a ternary (22, 11) linear code and its parity check matrix is given by We can verify that all the syndromes of key errors of length upto 2 occurring in same sub-block or different sub-block are non-zero and distinct. So, this is a ternary SBKE2/11C code.

Correction of Low Density Key Errors
In Das (2014), correction of key errors of length upto p occurring in the whole code length is studied. Motivated by Wyner (1963), we consider key errors of length upto p with hamming weight ω or fewer in the whole code length and correction of such errors is studied in this section. We obtain analogous bounds as presented in Section 2 and we end this section with two examples of such codes. First, we give the following identity which is used for simplification of calculation of our results. The identity can be proved easily with Pascal Formula (Balakrishnan, 1996).
For the following two results, we assume that 0 n m     if n is negative integer or smaller than m. Proof. For the proof, we count the number of key errors of length upto p with hamming weight ω or fewer in the following way.
When the entry error position is from 1 st to p th position, the number of key errors of length upto p with hamming weight ω or fewer is calculated as When the entry error position is taken from ( + 1) th upto ( − ) th position, the number of key errors of length upto p with hamming weight ω or fewer is Similarly, when the entry error position is considered in the last p components, the number of such key errors is