Designing Efficient Codes for Synchronization Error Channels

Transcription

1 Designing Efficient Codes for Error Channels Hao Wang Bill Lin Department of Electrical and Computer Engineering University of California, San Diego Abstract For communications and networking channels, coding techniques are widely used to correct errors in corrupted s. The Quality of Protection (QoP) that can be provided via error correction directly affects the Quality of Service (QoS) experienced by users. The errors are commonly assumed to be substitution or erasure errors. Such systems rely on perfect synchronization so that no bit is deleted and no extra bit is inserted. However, in a system without the presence of perfect synchronization, special coding algorithms may be required to correct potential insertion or deletion errors in transmitted s. Especially for systems suffering from frequent loss of synchronization, packets may require many retransmissions to guarantee reliable communication. Such schemes may become too expensive to be practical. In this paper, we propose a new synchronization channel error model based on the observations from current communication systems. In this model, the channel introduces at most t synchronization errors in each run of the transmitted sequence. We present run-length limited permutation codes capable of correcting synchronization errors based on this channel error model. Compared to previously developed codes, our codes have the advantage of correcting frequent synchronization errors, and therefore they are suitable for disruptive network channels that suffer severe synchronization failures. Index Terms Quality of Protection (QoP) I. INTRODUCTION In communications and networking systems where s are transmitted from senders to receivers, codes with the ability to correct errors are commonly applied to detect or recover from corrupted s. The error detection and correction capability provides for the Quality of Protection (QoP), which directly affects the Quality of Service (QoS) experienced by users. In such systems, typically only additive errors are considered, such as substitution errors and erasure errors. In a substitution error, a bit is flipped from 0 to 1, or vice versa. In an erasure error, a bit value becomes ambiguous and it is impossible to tell if it is 0 or 1 by just checking the bit itself. For example, Internet protocols such as TCP include checksum bits to help detect simple substitution errors and erasure errors in packets. If an error is detected, the receiver or the routers along the packet path will require the sender to retransmit the entire packet. For such systems to work, there is an underlying assumption of perfect synchronization, meaning that no bit is lost and no extra bit is added to the sent during data transport. If the total length of the /packet is known to the receiver by either receiving the information from the sender during the transmission, or by following a protocol adopted by both the sender and the receiver, the receiver can always tell the ending of the received /11/$26.00 c 2011 IEEE by simply calculating its total length. The received ends when its length matches the length of the transmitted. For applications or protocols where the receiver cannot get lengths from the sender, special sequences are commonly adopted as end-of- bits to encapsulate each /packet. Such special sequences are not allowed to appear anywhere else in the transmitted s. The endof- sequences are designed to sustain a limited amount of substitution or erasure errors, so that they are not easily lost beyond recovery during transmission. If the special sequences are detected by the receiver after error correction, the s can thus be further decapsulated. In a system without perfect synchronization, special coding algorithms and transmission protocols have to be deployed. For a network link that transmits s continuously, the consequence of even a single synchronization error can be catastrophic. A sudden loss of perfect synchronization will cause bits in the s to be deleted or extra bits inserted. Moreover, a deleted or inserted bit will cause future transmitted bits to be out of synchronization, which potentially increases the bit error rate (BER) significantly and renders the remainder of the symbol stream useless. Current techniques for detecting the end of a will not be applicable for such systems. Consider that the lengths are transmitted explicitly. For a receiver, knowing that the transmission channel is suffering from synchronization errors, the knowledge of the original length is not useful in detecting the end of a received reliably, since the can be either longer or shorter than its original size due to insertion or deletion errors, or the combination of the two. For protocols that use special sequences to detect the end of a, the end-of- sequence has to be conceivably significantly longer and more complicated to accommodate various potential synchronization error patterns occurring both in the original and in the end-of- sequence. In case the s are detected by the receiver to be corrupted beyond error correction, retransmissions will always be expensive, since any future retransmission will have to endure the same hostile channel environment. Especially for applications where retransmission is undesirable, such as intervehicle communication where on-time delivery is critical, or large-scale sensor network where power is limited, or satellite and interplanetary communication where round-triptime is substantial, there is strong incentive to design coding algorithms that can correct synchronization errors. Consider a communication system using pulse-amplitude

2 modulation (PAM) as an example. The signal detected by a receiver can be expressed in general as follows, r(t) = i A i g(t it τ i )+n(t), (1) where A i { 1,+1} is the sign of the i-th bit and g( ) is the shape of the pulse. Also in (1),n( ) is additive noise introduced by the communication channel, T is the sampling interval at the receiver, and τ i is the uncertainty due to the inaccuracy of sampling timing for the i-th bit. If synchronization is not precise at the receiver, the uncertainty of the sampling timing may lead to oversampling or undersampling of a pulse, which would introduce insertion or deletion errors. Even though phase-locked loops (PLL) are commonly applied in such scenarios to keep the clock at the receiver synchronized with the one at the sender, extreme phase changes, such as the one caused by the Doppler effect [1] due to sudden speed changes of mobile units, can render the PLL out of lock, which would in turn induce synchronization errors. It is worth noting that in such systems, an insertion error can only insert a redundant bit that is the same as at least one of its neighbors. For example, if the original sequence is 1, 1, 1,, an insertion error after the first bit cannot generate a sequence 1,0,1,1,. When synchronization error happens, if the sequence is not resynchronized, a single synchronization error will propagate and cause all the following bits to be out of synchronization. Such an error may be beyond the correcting capability of any substitution and erasure error correcting codes. Another example of synchronization error is the pulse-position modulation (PPM) [2] in optic communication systems. For such systems working in an environment with multipath interference, it is extremely difficult to accurately determine the exact pulse position with respect to the transmitted pulse, which may render a receiver out of synchronization with a sender, and thus cause synchronization errors. While most of the prior work focused on developing codes for substitution and erasure error channels, i.e. FEC, there is recently growing interest in developing codes for synchronization error corrections. In designing codes for synchronization error correction, there are two applicable channel error models. In the first model, the channel introduces at most t synchronization errors in every n mixed bits. In the second model, the channel introduces synchronization errors with the restriction that an insertion error introduces a bit that is the same as one of its neighboring bit. And there are at most t synchronization errors to a sequence of bits of the same value. Therefore the model can be regarded as that there are at most t synchronization errors in every run of 0 s or 1 s, where a run is defined as a sequence of bits of the same value. The PAM and PPM systems may suffer from synchronization errors that fit this model. Significant research efforts have been put forth on developing codes for the first model, and several codes [3] [8] capable of correcting t synchronization errors in each codeword of length n were proposed. However, for the second model, which is suitable for many communications and networking systems, the coding problem has remained open. In this paper, we provide the first work on describing this second channel error model and the coding solutions to correct such errors. In contrast to the previous work, we make the following contributions: First, we introduce a synchronization channel error model. The s transmitted on the channel/link are in the form of runs. In each run there are at most t synchronization errors introduced by the channel, where t is a constant. This model is well supported by the fact that for many communications and networking channels, synchronization errors are more likely to occur due to failures in clock recovery when transmitting a sequence of bits of the same value. errors may also occur on channels experiencing the Doppler effect [1], where a run of bits may suffer synchronization errors due to clock frequency shifts. In both cases, an insertion error can only introduce a new bit that is the same as at least one of its neighboring bits. It is worth noting that power failures on a data link cause only erasure errors, but not deletion errors, when the clocks at the receiver and sender are synchronized. Second, we design codes capable of correcting frequent synchronization errors using the channel error model, while providing code rates of up to Our codes can correct synchronization errors with error rate of up to 35.36%. The codes can be concatenated with traditional error correcting codes to also correct substitution errors. Third, we design a family of codes capable of correcting frequent synchronization errors and also one substitution error in each run, using the same error model. Finally, we provide efficient encoding and decoding algorithms for our codes. The algorithms are of complexity O(n), where n is the number of runs in a codeword. Therefore the encoders and decoders are suitable for supporting network line speed operations. The rest of the paper is organized as follows. In Section II, we present the related work. In Section III, we describe our system architecture. In Section IV, we show our runlength limited permutation code and its encoding and decoding algorithms. In Section V, we present synchronization error correcting run-length limited permutation codes, together with their code rates. In Section VI, we develop run-length limited permutation codes capable of correcting synchronization errors and substitution errors. In Section VII, we provide the performance evaluation of the codes. Finally, we conclude the paper in Section VIII. II. RELATED WORK The research on codes capable of correcting synchronization errors was first presented by Levenshtein in his seminal paper [3] in In that paper, various bounds on the capacity of synchronization error correcting codes were provided. Also, the author introduced a code family capable of correcting one synchronization error per codeword. Deletion channel was investigated in [9] and a random coding scheme was provided. Recently, there has been considerable work on modeling synchronization error channels and calculating channel information rates [10] [14]. In [10], a new upper bound on deletion channel capacity was provided to be 0.49(1 d), where d is the deletion probability on each bit. This bound is much tighter than the best previously known bound in [11]. The general case that n bits are sent and just one bit is deleted was investigated in [12], with many interesting open problems

3 suggested. In [13], [14], bounds on the channel capacity for deletion channel with small deletion probabilities were developed. It is worth noting that at the time of this writing, despite significant efforts, channel capacities for different synchronization error channels are unknown and are generally different depending on the specific channel models. In the design of codes, Ullman [4] presented a technique of constructing codes capable of correcting single synchronization error per block of the codeword. A family of codes capable of correcting one synchronization error per segment was introduced in [5], where a segment is defined as a sequence of mixed bits of 0 s and 1 s. Segments are separated by segment markers that do not appear in the segments. In their work [5], the proposed codes can only correct one synchronization error per segment. To find the codewords for a segment size, all possible sequences have to be exhaustively enumerated and tested, which is computational expensive and difficult to implement for segment size greater than 9 bits. In [6], a Reed- Muller code capable of correcting synchronization errors was presented. This code can correct insertion errors and a single deletion error. It can also correct substitution errors based on the underlying Reed-Muller code. However, its code rate goes to zero as the size of the code increases, due to the low code rate of Reed-Muller codes. The idea of using run-length limited code to correct synchronization errors was first introduced in [7], where the codewords are of fixed-length, and they are generated by codewords of a q-ary Lee metric based code. It was shown that the code is capable of correcting(q 1)/2 synchronization errors per codeword. In [8], a transformation was introduced to convert any substitution error correcting code to a code that can correct only synchronization errors. First, a codeword is partitioned into a number of blocks. Then, each block is treated as a Gray codeword, and the codeword is mapped to an integer. These integers are then regarded as run-lengths to construct a run-length limited code to correct synchronization errors. However, this code cannot allow deletion errors to eliminate a whole run. Therefore, it is crucial to find a suitable substitution error correcting code to start with, which makes it difficult to implement. III. SYSTEM ARCHITECTURE Our system architecture is shown in Fig. 1. The input s are a sequence of symbols containing the information to be delivered from the source to the destination. The source encoder converts these symbols to sequences of bits of 0 s and 1 s. These sequences of bits are then translated to other sequences of 0 s and 1 s by channel encoder to realize high efficiency and robustness against synchronization errors introduced by the channel. The modulator converts the sequences of bits to electrical waveforms suitable for transmission on the channel links. Upon reception, the demodulator converts the waveforms back to sequences of 0 s and 1 s. The channel decoder corrects the potential synchronization error in the sequences and translates the sequences to the original sequences for the source decoder. The source decoder recovers the symbol stream from the sequences of 0 s and 1 s to get the original s. After the channel encoder, an (Non-Return-to-Zero Inverted) mapping is included. We call the sequences input output Source Source Channel Channel Fig. 1. reverse Modulator Demodulator System architecture. Error Channel entering the code bits and the sequences leaving the channel bits. In the mapping, channel bit sequence has a transition at a clock boundary if the corresponding code bit is 1, and no transition if the code bit is 0. For channel bits, a run of 1 is defined as a sequence of consecutive 1 s that is separated by at least one 0. The number of 1 s in a run is defined as its run-length. Similarly, we define a run of 0 s. On the other hand, for code bits a run is defined as a sequence of 0 s following a single bit 1. So if there are l 0 s in a run, its run-length is l+1. The number of 0 s in a run can be zero. Sequences are transmitted in the synchronization error channel in the form of channel bits. A deletion error decreases the run-length of the current run by 1. After being mapped to code bits, a deletion error decreases the run-length of the current run by 1, which means that a 0 bit is deleted. In channel bits, an insertion error increases the run-length of the current run by 1, i.e. the inserted bit is the same as at least one of its neighboring bits. Therefore the channel model fits the second model in Section I. After being mapped to code bits, an insertion error increases the run-length of the current run by 1, i.e., a 0 bit is inserted. IV. RUN-LENGTH LIMITED PERMUTATION CODE In this section, we present new codes called run-length limited permutation () codes. The codes are built on the run-length limited code [15] which is a code allowing only certain run-lengths to appear in its codewords. For a code, its codewords are of the same length and they are generated using run-based permutations. To avoid the necessity of distinguishing the runs of 0 and the runs of 1 in the channel bits, we shall use code bits in the following discussion. For example, a run of length 3 is of the form 100. We define d as the minimum run-length separation of a code. So if there are k different run-lengths in a code, d is defined as follows, d = min 1 i<j k L i L j, (2) where L 1, L 2, L k are different run-lengths. We define a codeword U in a code as follows, U = (L 1,, L }{{ 1,L } 2,, L }{{} 2 n 1 n 2,, L k,, L k ), (3) }{{} n k where n 1, n 2,, n k are the numbers of occurrence of each run-length. The codebook consists of U and all of its run-based permutations. In the following we will describe the encoding and decoding algorithms for codes. The code C n with n runs can be written as C n = r 1 r 2 r 3 r n, where r 1, r 2, r n are runs. For any codeword X n of this code, we define a weightenumerating function as W n (X α ) = {Y n C n : Y α = X α }, (4)

4 where X α = r 1 r 2 r α is the first α runs of the codeword X n. So W n (X α ) is the number of codewords that start with X α. A. Preprocessing For all possible X α, α = 1, 2,, n, we first calculate W n (X α ) and keep the results in a hash table as hash values. The hash table uses X α as hash keys. Let L 1, L 2,, L k be the different run-lengths in code C n, with L 1 < L 2 < < L k. The total numbers of occurrences for these run-lengths are N 1, N 2,, N k, respectively. We denote the number of runs of lengths L 1, L 2,, L k other than the runs already appeared in X α as N 1 (X α ), N 2 (X α ),, N k (X α ). So we have W n (X α ) = ( k i=1 N i(x α ))! k i=1 (N i(x α )!). (5) B. Encoding of Code The code encoder can be implemented as a list encoder, which takes only linear time for each codeword. The list encoder is enabled by the fact that for most communications and networking systems, senders and receivers share all the possible symbols to be transmitted, such as the ASCII scheme. For a symbol to be sent, both the encoder and decoder keep a mapping which gives the symbol an order T, just as in the ASCII scheme where each character is assigned a fixed and published order. The encoder will then use the following algorithm to translate the order T to a codeword in code C n. Let L 1, L 2,, L k be the different runs of C n, with L 1 < L 2 < < L k. The total numbers of occurrences for these runs are N 1, N 2,, N k, respectively. The encoding algorithm finds the codeword Y n in code C n that is of reverse lexicographical order of T. Codeword Y n can be written as Y 1 Y 2 Y n, where each Y i is a run. We define Y j as the first j runs of the codeword. So Y j = Y 1 Y 2 Y j. Also we denote the number of runs of lengths L 1, L 2,, L k other than the runs already appeared in Y j as N 1 (Y j ), N 2 (Y j ),, N k (Y j ), respectively. In the encoding algorithm there are at most nk iterations, which can be further reduced to nlog 2 k iterations if binary search is adopted on the k run-lengths. As shall be shown in Section V, to design codes with near optimal code rate, k can be chosen as a constant value as small as 4. The encoding algorithm is effectively of complexity O(n) for a codeword. Thus the code is linear-time encodable, which is a highly desired property. ENCODER(T) 1 for j 0 to n 1 2 do for i 1 to k 3 do if N i (Y j ) > 0 4 then if T > W n (Y j L i ) 5 then T T W n (Y j L i ) 6 i i+1 7 else Y j+1 Y j L i 8 j j +1 9 N i (Y j ) N i (Y j ) 1 10 else i i+1; 11 return Y n C. Decoding of Code For any received word by the decoder, we first make sure that the word is indeed a codeword by checking the number of occurrence of each run in the word. If it is not a codeword, the decoding process fails. Otherwise the decoder applies the following algorithm to translate this codeword Y n to an order T, from which the original symbol is recovered. The decoded symbols form a symbol stream which is also the received. There are at most nlog 2 k iterations in the algorithm. By setting k to be a small constant, the time complexity of the decoding algorithm is O(n). Thus the code is also linear-time decodable. DECODER(Y n ) 1 T 0 2 for j 0 to n 3 do for i 1 to k 4 do if N i (Y j 1 ) > 0 5 then if Y j > L i 6 then T T+W n (Y j 1 L i ) 7 i i+1 8 else j j +1 9 N i (Y j 1 ) N i (Y j 1 ) 1 10 else i i+1; 11 return T V. SYNCHRONIZATION ERROR CORRECTING CODE In this section, we present codes that are capable of correcting synchronization errors. The system architecture is shown in Fig. 2. The synchronization decoder is a run-length decoder. It takes as its input the current run and output the run whose length is the closest in length to the input run. Thus, if there is a run of length L b in a received word and L 1, L 2,, L k are valid runs of the code, and arg min 1 i k L i L b = β, (6) then this run will be decoded as a run of length L β. input output Fig. 2. reverse Modulator Demodulator Error Channel System architecture for synchronization error channel. Lemma 1: For a code capable of correcting one synchronization error in each run, we have d 3 and min i L i 2. Proof: We shall prove it by contradiction. Assume that there is a code with d < 3 capable of correcting one synchronization error. So there must be two runs in this code of run-lengths L i and L j, where L i L j 2. Consider L i > L j and L i L j < 2, also there is a deletion error in a run of run-length L i. The received run will be mistakenly decoded as a run of length L j instead. Also, if L i L j = 2, the received run will be of equal distance to L j and L i, thus the decoder can only randomly pick one of them, with half

5 the time making a mistake. If the minimum run-length is one, a deletion error will delete the whole run in the channel bits and merge the two neighboring runs. The merged run would then be mistakenly decoded as a run of similar length, which would cause an error. Thus Lemma 1 is proved. Lemma 2: For a code capable of correcting t synchronization errors in each run, we have d 2t + 1 and min i L i t+1. Proof: Lemma 2 can be proved similarly to Lemma 1. We define the optimal code containing k different run-lengths capable of correcting t synchronization errors and zero substitution error in each run as such a code with the maximum code rate. We denote it as (k,t,0)- code. It will be clear that the code rate of a (k,t,0)- code increases as k increases, and decreases as t increases.. Theorem 1: A (k,t,0)- code has the following properties. 1) The run-lengths of this code are L i = (t+1)+(2t+1)(i 1), 1 i k. (7) 2) The probability of occurrence for run-length L i is given by Prob(L i ) = 2 LiR, 1 i k, (8) with R such that L i 2 LiR = 1. (9) 3) R is the code rate. Proof: Theorem 1 is easily proved by Lemma 1, Lemma 2 and the method developed in [16], and thus omitted. From Theorem 1 it is clear that the (,1,0)- code has a minimum run-length 2 and minimum run-length separation d = 3. The run-lengths of this code are 2+3(i 1), where 1 i k is a positive integer. Its code rate is The probabilities of occurrences for different run-lengths for the (9,1,0)- code are shown in Table I. Its code rate is It can correct synchronization errors with error rate up to 35.36%. The size of the code can be chosen arbitrarily as long as the run-length distribution approximates Table I. So the total number of codewords can be tuned according to the specific application. In Fig. 3, the code rates of several (k,t,0)- codes are provided. It is worth noting that these codes can be easily concatenated with traditional error correcting code to correct substitution errors. TABLE I RUN-LENGTH DISTRIBUTION FOR (9,1,0)- CODE (1 i 9). i run-length occurrence i run-length occurrence % % % % % % % % % VI. SUBSTITUTION ERROR CORRECTING RUN-LENGTH LIMITED PERMUTATION CODE In this section, we present codes capable of correcting synchronization and substitution errors. Let s consider a code consisting of runs of lengths 4+7(i 1), where i is a code rate R (,1,0) ( k,1,0) ( k,2,0) ( k,3,0) number of different run-lengths k Fig. 3. Code rates of some (k,t,0)- codes. positive integer. This is a code with minimum run-length 4 and minimum run-length separation d = 7. We shall prove that this code is capable of correcting one synchronization error and one substitution error in each run, using the system architecture as shown in Fig. 4. Interestingly, this code is also the (,3,0)- code. input output Fig. 4. reverse Modulator Demodulator and Error Channel System architecture for synchronization-substitution error channel. In the presence of substitution errors, the number of runs in the received word may differ from the number of runs in the transmitted codeword. Also, the number of bits in the received word may differ from the number of bits in the transmitted codeword due to synchronization errors. Thus the substitution decoder will not be able to decide the ending of the received sequence corresponding to a transmitted codeword directly. Therefore, we design the substitution decoder as a sliding window decoder using only local information, as shown in Fig. 5, to recover the runs in the received word sequentially. The window covers the current run, the previous run, and the following two runs. The substitution decoder checks the run-lengths of these four runs to recover the current run. For convenience, let s consider the codes in the form of channel bits for the rest of the section. Lemma 3: With minimum run-length 4 and minimum runlength separation d = 7, the code is capable of correcting one synchronization error and one substitution error in each run, using the encoder and decoders shown in Fig. 4. Proof: See Appendix A for a proof. A. One Error Correcting Code error and one substitution error correcting codes have the following properties.

6 received sequence decoded sequence Fig. 5. ' r i-1 ' r i ' r i+1 * * rj r 1 j ' r i+2 Sliding window substitution decoder. Lemma 4: A code capable of correcting synchronization errors and also one substitution error in each run doesn t contain a run of length 2. Proof: Let s assume there is a run of length 2 in such a code. The channel bits containing run of length 2 can be written as r i 1 r i r i+1, and the run-length of r i is l i = 2. If a substitution error happens to either bit of r i and a deletion error happens to the other bit, r i will be lost. Also r i 1 and r r+1 will merge to one single run. The merged run would be mistakenly decoded as a run of similar length, therefore causing a decoding error. Lemma 5: For a code capable of correcting synchronization errors and also one substitution error in each run, it doesn t contain a run of length 3. Proof: If a code contains run of length 3 and no shorter runs, runs of length 3 must occur multiple times in a codeword. Actually, as we will see later the shortest run-length appears most frequently in a codeword for an optimal code. Also, the size of the code should be large enough to provide enough codewords. Thus in a practical code, runs of length 3 must occur five times or more. Due to the permutation type of design, there must be a codeword containing five consecutive runs of length 3. Now, let s construct two specific codewords of a code. The first codewordx 1 = r 1 r 2 r 3 r 4 r 5 r 6 r 7 r n has runsr 1 = 111, r 2 = 000, r 3 = 111, r 4 = 000, and r 5 = 111. Consider the following error pattern. A substitution error happens to the second bit of r 2, the first bit of r 3, and the second bit of r 4. Also a deletion error happens to the first bit of r 2, the last bit of r 3 and the last bit of r 4. The sequence becomes r 6 r 7 r n. (10) The other codeword X 2 = r 1 r 2 r 3 r 4 r 5 r n 2 r n 1 r n has runs r 1 = 111, r 2 = 000, r 3 = 111, r 4 = r 6, r 5 = r 7,, r i = r i+2,, r n 2 = r n, r n 1 = 111, and r n = 000, if n is even (or r n 1 = 000 and r n = 111, if n is odd). Consider the following error pattern. A substitution error to the second bit of r 2. An insertion error to run r 1, the beginning of run r 2, and run r 3. The resultant sequence is, r 6 r 7 r n (11) Here is the dilemma. If the substitution decoder decodes the received sequence to , the last two runs of X 2 will be cut out. Otherwise, if the substitution decoder decodes the received sequence to , two extra runs will be added to X 1. Therefore, it is impossible to distinguish and correct such error patterns. Thus we cannot allow run-length 3. Lemma 6: For a code capable of correcting one synchronization error and one substitution error in each run, the minimum run-length separation d 7. Proof: We prove this lemma by contradiction. Assume there is a code with d 6 that can correct one synchronization error and one substitution error in each run. For a codeword of such a code, we express its channel bits as r i 1 r i r i+1, and l i is the run-length of r i. We assume there is another run r j in the codeword of run-length l j such that l j = l i +6. If an insertion error happens to r i, and a substitution error happens to the last bit of r i 1 and the first bit of r i+1, then the length of r i becomes l i +3, which is of equal distance to l i and l j. The synchronization decoder can only randomly pick one to decode to with half the time making a mistake, which contradicts our assumption. Theorem 2: The code that is capable of correcting one synchronization error and one substitution error in each run using the decoders shown in Fig. 4 has minimum runlength 4 and the minimum run-length separation d = 7. Proof: The theorem is a direct result of Lemma 4, Lemma 5, and Lemma 6. Corollary 1 (Decoding Algorithm for ): The substitution decoder is a sliding window decoder, where the decoded sequence r1 r 2 r 3 are sent to the output sequentially as the decoding process continues. The time complexity to decode a codeword using this decoder is O(n), where n is the number of runs in a codeword. Thus the code is linear-time decodable. SUBSTITUTION DECODER(r 1 r 2 r 3 r m) 1 i 1, j 1 2 while i m 3 do if i = 1 and l i = 1 4 then if l i+1 = 1 5 then r j r i r i+1 r i+2 6 i i+3, j j +1 7 else r j r i r i+1 8 i i+2, j j +1 9 else if 1 < i < m and l i = 1 10 then if l i+1 > 1 11 then r j 1 r i 1 r i r i+1 12 i i+2 13 else if i < m 1 14 then r j 1 r i 1 r i 15 r j r i+1 r i+2 16 i i+3 17 j j else r j 1 r i 1 r i 19 r i+1 r i+1 20 i i+2 21 else if i = m and l i = 1 22 then r j 1 r i 1 r i 23 i i+1 24 else i i+1 25 return new sequence r 1 r 2 r j 1 B. Code Rates for Optimal One Error Correcting Code An optimal code containing k different run-lengths capable of correcting t synchronization errors and one substitution error in each run using encoders and decoders shown in Fig. 4 is such a code of maximum code rate. We denote the code as the (k,t,1)- code.

7 Theorem 3: The (k,t,1)- code has the following properties. 1) The run-lengths of this code are L i = (t+3)+(2t+5)(i 1), (12) where 1 i k. 2) The probability of occurrence for run-length L i is with R such that 3) R is the code rate. Prob(L i ) = 2 LiR, 1 i k, (13) L i 2 LiR = 1. (14) We omit the proof since it is similar to Theorem 1. It is shown in Theorem 3 that the (k,1,1)- code has a minimum run-length 4 and minimum run-length separation d = 7. If k is infinite, the code is a (,1,1)- code, which has a code rate about It easy to see that the code rate of (k,t,1)- code increases as k increases, and decreases as t increases. The probabilities of occurrences for different run-lengths for the (9,1,1)- code are shown in Table II. Its code rate is The size of the code can be chosen arbitrarily as long as the run-length distribution follows Table II. So the total number of codewords can be tuned for a specific application. In Fig. 6, the code rates of several (k,t,1)- codes are provided. TABLE II RUN-LENGTH DISTRIBUTION FOR (9,1,1)- CODE (1 i 9). i run-length occurrence i run-length occurrence % % % % % % % % % code rate R (,1,1) ( k,1,1) ( k,2,1) ( k,3,1) number of different runlengths k Fig. 6. Code rates of some (k,t,1)- codes. VII. PERFORMANCE EVALUATION The codes presented in this paper are under the assumption that the packet boundaries are not protected. I.e., there is no need to design end of markers to distinguish the end of a codeword or. Any part of the transmitted is subject to the same channel condition, and synchronization errors can appear anywhere in the transmitted. The encoder takes O(nlog 2 k) iterations to encode a codeword. Let s consider an example of code for ASCII characters. For the code, there are five runs of length 2, two runs of length 5, and one runs of length 8 in each codeword. Simple calculation shows that the size of the code is 168, which is sufficient to support all 128 standard ASCII characters. Its code rate is Each codeword of the code contains eight runs, and there are only three different runlengths. The code is capable of correcting one synchronization error in each run. In each step of decoding, the length of the current run in consideration is compared with 5. If the runlength is smaller than 5, then it is 2. If the run-length is larger than 5, then it is 8. The comparison takes one clock cycle. Therefore, the encoding procedure for a codeword takes only 8 cycles, which is the number of runs in a codeword. The encoding for different codewords can be further pipelined to achieve even faster encoding speed. The decoder has the same complexity as the encoder. The synchronization decoder takes linear time with respect to the number of runs in a codeword. So it also takes only 8 clock cycles to decode a codeword by the synchronization decoder. Therefore, the code is linear-time encodable and decodable, which is more efficient than polynomial-time encodable and decodable codes such as the segment code in [5]. Moreover, this code can correct synchronization errors with error rate up to 28.57%. The codes can be easily concatenated with existing substitution or erasure error correcting codes as shown in Fig. 7. Such a design has several advantages. First, as seen in Section VI, the code rates for codes capable of correcting only synchronization errors are much higher than those for codes capable of correcting both synchronization and substitution errors. The (4,1,0)- code has code rate more than twice of that for the (4,1,1)- code. Thus it is preferable to use code to correct only synchronization errors. Second, by concatenating the synchronization error correcting code with a substitution error correcting code, more efficient substitution error correcting code with better substitution error correcting capability can be incorporated. Thus the system can be made more resilient to substitution errors. Third, with concatenation, the design of the substitution decoder can be separated from the synchronization decoder, which makes the system more adaptable to different applications with different channel error models by replacing only the substitution encoder and decoder. Fig. 8 illustrates the code rates for various synchronization error correcting codes containing different number of codewords. The codes are codes with four different runs, Reed-Muller codes in [6], and segment codes in [5]. The code rate for -code increases as the number of codewords in the code increases. The code rate quickly approaches , which is the optimal code rate for the (4,1,0)- code.

8 input output Fig. 7. reverse Modulator Demodulator System architecture with code concatenation. and Error Channel code rate (4,1,0)- code Reed-Muller code segment code Compared to codes, the code rate for the Reed-Muller code quickly approaches zero as the number of codewords in a code increases, which limits the code useful only for applications requiring very small code size. The diminishing code rate is due to the underlying first order Reed-Muller code which has a code rate of r+1 n, where n is the number of bits in a codeword and n = 2 r. The segment code represents many other codes correcting synchronization errors under the first channel model introduced in Section I, which states that there can be at most t synchronization errors in every n mixed bits. The number n is typically chosen to be the length of a codeword. Therefore, by fixing the error correcting capability t as the length of a codeword increases, which corresponds to the increase in the number of codewords in a code or simply the size of a code, the synchronization error correcting capability of a segment code decreases. So even though it appears that the segment code achieves higher code rate as the size of the code increases, it error correcting capability decreases, which makes it an unfair comparison with our code which has fixed error correcting capability. In general, the segment code is only suitable for applications requiring a smaller number of codewords or with diminishing synchronization error probability. On the other hand, the codes presented in this paper is designed for the second channel model, which is a more realistic assumption for communication systems using PAM or PPM. Moreover, as the size of the code increases, its error correcting capability stays the same, which is essential for applications where a large number of codewords are required while providing robustness against severe synchronization error channels, such as disruptive network channels. VIII. CONCLUSION In this paper, we provided the first work on describing a new synchronization channel error model, where the channel introduces at most t synchronization errors in every run of a transmitted. We proposed run-length limited permutation codes that are capable of correcting t synchronization errors and up to one substitution error in each run. In addition, we presented efficient encoding and decoding algorithms. Our codes have the feature that the code rates stay the same as the sizes of the codes increase, which is essential for many applications to provide robustness against synchronization errors while providing a large number of codewords. Such a feature is generally in lack in previous proposed synchronization error correcting codes. Also, the run-lengths of a code are easily chosen based on the number of synchronization Fig number of codewords Code rates of some synchronization error correcting codes. errors to correct. It is worth noting that if a received word contains the maximum number of correctable synchronization errors, then the error rate, which is an upper bound of the correctable error rate, can be very high. For example, consider the optimal (9,1,0)- Code. If a received contains the maximum number of correctable synchronization errors, the error rate is about 35.36%. Therefore, our codes are applicable to communications and networking systems that are subject to frequent synchronization failures. APPENDIX A PROOF OF LEMMA 3 In order to prove Lemma 3, we first describe the substitution decoder. The transmitted sequence is denoted as r 1 r 2 r 3 r s, where r i is a run. The input sequence to the substitution decoder is denoted as r 1 r 2 r 3 r m. Also, the output of the substitution decoder is denoted as r1 r2 r3 rt. If the sequence is decodable, we expects = t. It is worth nothing that if l i 3 l i l i + 3, run ri can be corrected by the synchronization decoder from Lemma 2 since d = 7, where l i and l i are the run-lengths of r i and ri, respectively. Let l i represent the run-length of r i. The sliding window contains runs r i 1 r i r i+1 and r i+2. For each run r i in the received sequence, the substitution decoding decides if it fits one of the following cases. [Case 1] If i = 1, l i = 1, and l i+1 > 1, then combine r i and r i+1. [Case 2] If i = 1, l i = 1, and l i+1 = 1, then combine r i, r i+1, and r i+2. [Case 3] If 1 < i < m, l i = 1, and l i+1 > 1, then combine r i 1, r i, and r i+1. [Case 4] If 1 < i < m 1, l i = 1, and l i+1 = 1, then combine r i 1 and r i, and combine r i+1 and r i+2. [Case 5] Ifi = m 1,l i = 1, andl i+1 = 1, then combine r i 1, r i, and r i+1. [Case 6] If i = m and l i = 1, then combine r i 1 and r i. We shall prove Lemma 3 by induction. First, we show that the substitution decoder and synchronization decoder can correct any error patterns in the first run r 1 of the received sequence. We will only focus on when there is a substitution error in the current run, since with d = 7, error patterns of one synchronization error and no substitution error can always be corrected by the synchronization decoder. It is worth

9 noting that in channel bits, neighboring runs consist of bits of opposite values. A substitution error at a boundary bit increases the run-length of one run and decreases the runlength of the other run. 1) If the substitution error is on the first bit of r 1, the runlengths of the sequence become 1, l 1, l 2,, where l 1 takes one of the following values: l 1 2, l 1 1, l 1 and l 1 +1, depending on whether there is a synchronization error to the rest of r 1, and whether there is an extra bit coming from r 2 to r 1 due to a substitution error on the first bit of r 2. From Case 1, we combine the first and second run of lengths 1 and l 1, thus get a new run of lengthl 1+1, where l 1 1 l 1+1 l Since d = 7, the error can be further corrected by the synchronization decoder. 2) Consider the case that a substitution error happens to the second bit of r 1. If the first bit of r 1 is deleted, this is just a special case of 1). So let s consider if the first bit ofr 1 is not deleted. Then the run-lengths of the sequence become 1, 1, l 1, l 2, where l 1 takes one of the following: l 1 3,l 1 2,l 1 1 andl 1, depending on whether there is a synchronization error to the rest ofr 1, and whether there is an extra bit coming from r 2 to r 1 due to a substitution error in r 2. From Case 2, we combine the first three runs of length 1, 1 and l 1 together. The sequence becomes l 1 +2, l 2,, and l 1 1 l 1 +2 l ) One substitution error happens to the last bit of r 1. Consider the following scenarios. a) If there is no substitution error to the first or second bit of r 2, the sequence becomes l 1, l 2 +1, where l 1 equals to l 1 2, l 1 1, or l 1, depending on whether or not there is a synchronization error to the rest of r 1. b) If there is a substitution error to the first bit of r 2, or if there is a substitution error to the second bit of r 2 and a deletion error to the first bit of r 2, the run-lengths of the sequence become l 1, 1, 1, l 2,, where l 1 equals to l 1 2, l 1 1 or l 1, depending on whether there is a synchronization error to the other part of r 1. According to Case 4, the corrected sequence is of runlengths l 1+1, l 2 +1,, where l 1 1 l 1+1 l c) If there is a substitution error to the second bit of r 2, and no deletion error to the first bit of r 2, the runlengths become l 1, 2, 1, l 2,, where l 1 equals to l 1 2, l 1 1, l 1, depending on whether there is a synchronization error. 4) One substitution error happens to the second to the last bit of r 1. Let s consider the following scenarios. a) If the last bit is deleted, this is only a special case of 3). So let s assume the last bit is not deleted. If there is no substitution error to the first or second bit of r 2, the run-lengths of the sequence can be written as l 1, 1, 1, l 2,, where l 1 takes one of the following values: l 1 3, l 1 2, and l 1 1, depending on whether there is a synchronization error to the beginning of r 1. According to Case 4, the decoded word after substitution decoder is of run-lengths l 1 +1, l 2 +1,. So we have l 1 2 l 1 +1 l 1. b) If there is a substitution error to the first bit of r 2, or a substitution to the second bit of r 2 and a deletion error to the first bit of r 2, the run-lengths become l 1, 1, 2, l 2,, where l 1 takes one of the following values: l 1 3, l 1 2, and l 1 1, depending on whether there is a synchronization error to the other part of r 1. According to Case 3, we combine the first three runs of lengthsl 1,1,2together. The sequence is of run-lengths l 1 +3, l 2,. Thus we have l 1 l 1 +3 l c) If there is a substitution error to the second bit of r 2 and no deletion error to the first bit of r 2, the runlengths become l 1, 1, 1, 1, 1, l 2,, where l 1 takes one of the following values, l 1 3, l 1 2, and l 1 1, depending on whether there is a synchronization error to the other part of r 1. According to Case 4, the sequence becomes l 1 +1, 2, 1, l 2,. So l 1 2 l 1 +1 l 1. 5) If a substitution error is in the middle part of r 1 (i.e., not the first or last two bits), r 1 will be separated into three parts. According to Case 3, we combine these three parts together. The synchronization decoder can further correct the synchronization error in the run if there is any. Second, we show that run r k can be decoded when all the substitution errors in runs until r k 1 are corrected, where 1 < k < s. Third, we need to prove that the substitution decoder can decode the last run r s. The detailed proof is omitted due to the space limit. REFERENCES [1] E. N. da C. Andrade, Doppler and the Doppler effec, Endeavour, vol. XVIII, no. 69, [2] G. Cariolaro and T. Erseghe, Pulse Position Modulation: Encyclopedia of Telecommunications. John Wiley & Sons Inc., [3] V. I. Levenshtein, Binary codes capable of correcting deletions, insertions, and reversals, Soviet Physics Doklady, vol. 10, no. 8, pp , [4] J. D. Ullman, Near-optimal, single-synchronization-error-correcting code, IEEE Transactions on Information Theory, vol. IT-12, no. 4, pp , [5] Z. Liu and M. Mitzenmacher, Codes for deletion and insertion channels with segmented errors, in The IEEE International Symposium on Information Theory, [6] L. Dolecek and V. Anantharam, Run-length properties of a Reed- Muller RM(1,m) code with applications in channels with at most one synchronization error, in 42nd Allerton Conference on Communications, Control, and Computing, [7] P. A. H. Bours, Construction of fixed-length insertion/deletion correcting runlength-limited codes, IEEE Transactions on Information Theory, vol. 40, no. 6, pp , [8] A. Orlitsky, Interactive communication of balanced distributions and of correlated files, SIAM Journal on Discrete Mathematics, vol. 6, no. 4, pp , [9] R. L. Dobrushin, Shannon s theorems for channels with synchronization errors, Problemy Peredachi Informatsii, vol. 3, no. 4, pp , [10] D. Fertonani and T. M. Duman, Novel bounds on the capacity of binary channels with deletions and substitutions, in The IEEE International Symposium on Information Theory, [11] S. Diggavi, M. Mitzenmacher, and H. D. Pfister, Capacity upper bounds for the deletion channel, in The IEEE International Symposium on Information Theory, [12] N. J. A. Sloane, On single-deletion-correcting codes, in Arxiv preprint math, [13] Y. Kanoria and A. Montanari, On the deletion channel with small deletion probability, in The IEEE International Symposium on Information Theory, [14] A. Kalai, M. Mitzenmacher, and M. Sudan, Tight asymptotic bounds for the deletion channel with small deletion probabilities, in The IEEE International Symposium on Information Theory, [15] P. A. Franaszek, Run-length-limited variable length coding with error propagation limitation, U.S. Patent , [16] E. Zehavi and J. K. Wolf, On runlength codes, IEEE Transactions on Information Theory, vol. 34, no. 1, pp , 1988.