Using cantor sets for error detection

Error detection is a fundamental need in most computer networks and communication systems in order to combat the effect of noise. Error detection techniques have also been incorporated with lossless data compression algorithms for transmission across communication networks. In this paper, we propose to incorporate a novel error detection scheme into a Shannon optimal lossless data compression algorithm known as Generalized Luröth Series (GLS) coding. GLS-coding is a generalization of the popular Arithmetic Coding which is an integral part of the JPEG2000 standard for still image compression. GLS-coding encodes the input message as a symbolic sequence on an appropriate 1D chaotic map Generalized Luröth Series (GLS) and the compressed file is obtained as the initial value by iterating backwards on the map. However, in the presence of noise, even small errors in the compressed file leads to catastrophic decoding errors owing to sensitive dependence on initial values, the hallmark of deterministic chaos. In this paper, we first show that repetition codes, the oldest and the most basic error correction and detection codes in literature, actually lie on a Cantor set with a fractal dimension of \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{upgreek} \usepackage{mathrsfs} \setlength{\oddsidemargin}{-69pt} \begin{document} }{}$ \frac{1}{n} $\end{document}1n, which is also the rate of the code. Inspired by this, we incorporate error detection capability to GLS-coding by ensuring that the compressed file (initial value on the chaotic map) lies on a Cantor set. Even a 1-bit error in the initial value will throw it outside the Cantor set, which can be detected while decoding. The rate of the code can be adjusted by the fractal dimension of the Cantor set, thereby controlling the error detection performance.


INTRODUCTION
Computers and communication systems invariably have to deal with the ill effects of noise, which can lead to errors in computation and information processing. In a landmark paper published in 1950, Richard Hamming addressed this problem by introducing mathematical techniques for error detection and correction (Hamming, 1950). Since then, coding theory has burgeoned to be a field of its own right, boasting of important research and developments in the art and science of error detection and correction (Lin & Costello, 1983). Error detection/correction techniques have therefore been a fundamental part of most computing systems and communication networks, typically applied on the input data after data compression (lossy/lossless) and encryption (Bose, 2008).
Shannon's separation theorem (Shannon, 1959) states that under certain assumptions, data compression (source coding) and error protection (channel coding) can be performed 1 Progressive transmission refers to the successive approximation property of the bitstream where successive bits transmitted across the channel improve the fidelity of reconstruction at the decoder. separately and independently (sequentially) while still maintaining optimality. However, in several practical scenarios, these assumptions are not met and hence there is a need for joint source channel coding. In image/video browsing and web-based applications, it is highly desirable to have the property of progressive transmission 1 (Said & Pearlman, 1996). However, even the slightest error can wreak havoc on a progressive bitstream. Hence, there is a need for incorporating error detection when decoding a compressed progressive bitstream.
Lossless data compression refers to the removal of redundancy in the data-a prerequisite step in most storage and communication systems before the application of an encryption algorithm and error control coding (for error detection/correction). Consider an i.i.d. binary message source S which emits '0' with probability p (0 < p < 1). A binary message M of length N from such a source needs to be losslessly compressed. Shannon (Shannon, 1948) showed that such a message can at best be losslessly compressed to ≥ H (S)·N bits on an average, where H (S) is the Shannon's entropy of the source. For an individual binary message M from such an i.i.d. source, we can compute H (·) as follows: where p = Number of zeros in M N . There are several lossless compression algorithms in literature -Shannon-Fano coding, Huffman coding, Arithmetic coding, Lempel-Ziv coding and others (Cover & Thomas, 2006;Sayood, 2000). Among these, Arithmetic coding (Rissanen & Langdon, 1979) achieves the Shannon entropy limit for increasing message lengths. Arithmetic coding is used extensively in several practical applications owing to its speed, efficiency and progressive bitstream property. In fact, it is used in JPEG2000 (Taubman & Marcellin, 2002), the international standard for still image compression, replacing the popular Huffman coding which was used in the earlier JPEG (Wallace, 1992) standard.
In 2009 (Nagaraj, Vaidya & Bhat, 2009), it was shown that Arithmetic coding is closely related to a 1D non-linear chaotic dynamical system known as Generalized Luröth Series (GLS). Specifically, it was shown that lossless compression or encoding of the binary message M can be performed as follows. First, the message M is treated as a symbolic sequence on an appropriately chosen chaotic GLS. The initial value on the GLS corresponding to this symbolic sequence is computed by iterating backwards on the map. This initial value (written in binary) serves as the compressed file. For decompression, we start with this initial value (the compressed file) and iterate forwards on the (same) GLS, and record the symbolic sequence. This symbolic sequence is the decoded M . Such a simple lossless compression algorithm (known as GLS-coding) was proved to achieve Shannon's entropy limit (Nagaraj, Vaidya & Bhat, 2009). Arithmetic coding turns out to be a special case of GLS-coding (Nagaraj, Vaidya & Bhat, 2009).
Unfortunately, it turns out that GLS-coding (hence also arithmetic coding), having the progressive bitstream property, is very sensitive to errors. Even a single bit error in the compressed file can lead to catastrophic decoding errors. This has been well documented in the data compression literature (Boyd et al., 1997) and researchers have since been trying to enhance Arithmetic coding with error detection and correction properties (Anand, Ramchandran & Kozintsev, 2001;Pettijohn, Hoffman & Sayood, 2001). In this work, our 2 One could alternately use the skewbinary map. There are eight possible modes of GLS in this case and all are equivalent in terms of compression ratio performance (Nagaraj, Vaidya & Bhat, 2009). aim is to incorporate error detection into GLS-coding by using Cantor set while not sacrificing much on the lossless compression ratio performance of GLS-coding. As we shall demonstrate, Cantor set has desirable properties that enable efficient error detection with GLS-decoding.
The paper is organized as follows. In 'GLS-Coding and Decoding', we briefly describe GLS-coding of a binary message and its sensitivity to errors. In 'Error Detection Using Cantor Set', we explore Cantor set and describe its wonderful properties that enable error detection. Particularly, it is shown that Repetition codes belong to a Cantor set. Inspired by this, we incorporate error detection into GLS-coding using a Cantor set in 'Incorporating Error Detection into GLS-Coding Using a Cantor Set' and show simulation results of the proposed method. We conclude with open challenging problems in 'Conclusions and Future Work'.

GLS-CODING AND DECODING
In this section, we shall briefly describe GLS-coding first proposed by Nagaraj, Vaidya & Bhat (2009). We are given a message M , of length L, from a binary i.i.d. source S. Our aim is to losslessly compress M . To this end, we first determine the probability of zeros in M , denoted by p. We then construct the GLS map T p as follows: The GLS-map, also known as the skew-tent map 2 , T p , has two intervals: [0,p) and [p,1) which are tagged with the symbols '0' and '1' respectively. Starting with any initial value x 0 ∈ [0,1), the above map T p can be applied iteratively to yield the real-valued time series The symbolic sequence of this time series, denoted by {S i }, is simply obtained by: Given the symbolic sequence {S i }, the inverse of T p is given by: For GLS-coding, we begin by treating the given message M as a symbolic sequence of length L on the GLS T p . The goal is to obtain the initial value x 0 ∈ [0,1) which when iterated forwards on T p produces the symbolic sequence {S i } (= message M ). To obtain x 0 , we begin by initializing START 0 = 0.0 and END 0 = 1.0. We then determine the inverse images of START 0 and END 0 by iterating backwards on T p , by using T −1 p and starting with the last symbol S L−1 . At the end of the first back-iteration, we obtain START 1 and END 1 . We determine the inverse images of START 1 and END 1 (given S L−2 ) to determine the new interval [START 2 ,END 2 ). This is repeated L times to yield the final interval  Given the symbolic sequence {S i }, the inverse of T p is given by: For GLS-coding, we begin by treating the given message M as a symbolic sequence {S i } i=L−1 i=0 of length 73 L on the GLS T p . The goal is to obtain the initial value x 0 ∈ [0, 1) which when iterated forwards on T p 74 produces the symbolic sequence {S i } (= message M). To obtain x 0 , we begin by initializing START 0 = 0.0 75 and END 0 = 1.0. We then determine the inverse images of START 0 and END 0 by iterating backwards on 76 T p , by using T −1 p and starting with the last symbol S L−1 . At the end of the first back-iteration, we obtain 77 START 1 and END 1 . We determine the inverse images of START 1 and END 1 (given S L−2 ) to determine the 78 new interval [START 2 , END 2 ). This is repeated L times to yield the final interval [START L−1 , END L−1 ).

79
All points within this final interval have the same symbolic sequence (= M = {S i }). We take the mid-point as the compressed file. Since x 0 is a real number (between 0 and 1), we write 81 its binary representation to the file. The number of bits needed to represent the compressed file x 0 is 82 ⌈− log 2 (END L−1 − START L−1 )⌉ bits. This is proved to be Shannon optimal 3 in (Nagaraj et al., 2009) and 83 Arithmetic coding is shown to be a special case of GLS-coding 4 .

84
GLS-decoding is straightforward. At the decoder, given the value of p, we construct the GLS (skew-85 tent map) T p as described earlier. Given that we know x 0 (the compressed file ), all that we need to do is 86 iterate forwards on the map T p for L (= length of message M) iterations and output the symbolic sequence 87 {S i }. This is the decoded message and in the absence of any noise, this is exactly the same as M which 88 was input to the encoder.

89
As an example, consider M = 0010110100 (L = 10). In this case, p = 6 10 = 0.6 and T 0.6 is shown in as the compressed file. Since x 0 is a real number (between 0 and 1), we write its binary representation to the file. The number of bits needed to represent the compressed file x 0 is −log 2 (END L−1 − START L−1 ) bits. This is proved to be Shannon optimal 3 in Nagaraj, Vaidya & Bhat (2009) and Arithmetic coding is shown to be a special case of GLS-coding 4 .
GLS-decoding is straightforward. At the decoder, given the value of p, we construct the GLS (skew-tent map) T p as described earlier. Given that we know x 0 (the compressed file), all that we need to do is iterate forwards on the map T p for L (= length of message M ) iterations and output the symbolic sequence {S i }. This is the decoded message and in the absence of any noise, this is exactly the same as M which was input to the encoder.
As an example, consider M = 0010110100 (L = 10). In this case, p = 6 10 = 0.6 and T 0.6 is shown in Fig

Effect of single-bit error on GLS-decoding: sensitive dependence on initial value of the map
Thus far, we have discussed lossless coding in the absence of any kind of noise. However, in practical applications, noise is unavoidable. If the data is in a compressed form, then it is quite likely that the decoder would be unable to decode or would decode incorrectly. Even detecting whether an error has occurred helps in several communication protocols since a repeat request could be initiated.
In GLS-coding, the compressed file is the initial value of the symbolic sequence (the message M ) on the appropriate GLS. Since GLS is a chaotic map, it exhibits sensitive dependence on initial values, the hallmark of deterministic chaos (Alligood, Sauer & Yorke, 1996). A small perturbation in the initial value will result in a symbolic sequence which decoder would be unable to decode or would decode incorrectly. Even detecting whether an error has 97 occurred helps in several communication protocols since a repeat request could be initiated.

98
In GLS-coding, the compressed file is the initial value of the symbolic sequence (the message M) on 99 the appropriate GLS. Since GLS is a chaotic map, it exhibits sensitive dependence on initial values, the 100 hallmark of deterministic chaos (Alligood et al., 1996). A small perturbation in the initial value will result 101 in a symbolic sequence which is uncorrelated to the original symbolic sequence after a few iterations.

102
This means that with a very high probability, even a slight amount of noise that is added to the initial 103 value (compressed file) will result in a wrongly decoded message (symbolic sequence), which will be very 104 different from the actual intended message. This is demonstrated in Fig. 2. The first bit of the compressed 105 file is flipped and GLS-decoding is performed. The difference in the decoded message from the original 106 message is shown in Fig. 2(A). As it can be seen, the decoded message is very different from the original 107 message. On the other hand, if the middle bit of the compressed file is flipped then the decoded image is 108 accurate up to 5000 bits and the remaining 5000 bits are wrongly decoded ( Fig. 2(B)). The error affects 109 only those bits which are subsequently decoded.

111
In GLS-coding, every real number on the interval [0, 1) represents an initial value (compressed file). Thus, 112 any error in the initial value will result in another real number which is also an initial value, but for an 113 entirely different symbolic sequence (message). It represents a valid compressed file which decodes to a 114 different message. Therefore in order to detect errors, we necessarily require that when noise gets added 115 to the initial value while transmission on the communication channel, it should result in a value that is not 116 a valid compressed file, so that at the decoder it can be flagged for error. This necessarily implies that not 117 all real numbers in the interval [0, 1) can be valid compressed files. We need to restrict the set of valid 118 compressed files to a smaller subset of [0, 1). This subset should be uncountable and dense since it should 119 be able to decode all possible (infinite length) messages. At the same time, it should have negligible 120 measure (zero measure) so that when noise is added, the probability that it falls outside the set is 1. Cantor 121 sets provide the perfect solution.

123
The well known middle-third Cantor set (Alligood et al., 1996), (Strogatz, 2018 is uncorrelated to the original symbolic sequence after a few iterations. This means that with a very high probability, even a slight amount of noise that is added to the initial value (compressed file) will result in a wrongly decoded message (symbolic sequence), which will be very different from the actual intended message. This is demonstrated in Fig. 2. The first bit of the compressed file is flipped and GLS-decoding is performed. The difference in the decoded message from the original message is shown in Fig. 2A. As it can be seen, the decoded message is very different from the original message. On the other hand, if the middle bit of the compressed file is flipped then the decoded image is accurate up to 5,000 bits and the remaining 5,000 bits are wrongly decoded (Fig. 2B). The error affects only those bits which are subsequently decoded.

ERROR DETECTION USING CANTOR SET
In GLS-coding, every real number on the interval [0,1) represents an initial value (compressed file). Thus, any error in the initial value will result in another real number which is also an initial value, but for an entirely different symbolic sequence (message). It represents a valid compressed file which decodes to a different message. Therefore in order to detect errors, we necessarily require that when noise gets added to the initial value while transmission on the communication channel, it should result in a value that is not a valid compressed file, so that at the decoder it can be flagged for error. This necessarily implies that not all real numbers in the interval [0,1) can be valid compressed files. We need to restrict the set of valid compressed files to a smaller subset of [0,1). This subset should be uncountable and dense since it should be able to decode all possible (infinite length) messages. At the same time, it should have negligible measure (zero measure) so that when noise is added, the probability that it falls outside the set is 1. Cantor sets provide the perfect solution. 5 The term 'Cantor Set' is used here in a more general sense to refer to fractals that are obtained very much like the middlethird Cantor set but with a different proportion (not necessarily 1 3 rd) removed at every iteration. Please see (Strogatz, 2018).
6 Topological Cantor sets are not selfsimilar. 7 For further details, please see the references in Loskot & Beaulieu (2004).

The Cantor set
The well known middle-third Cantor set (Alligood, Sauer & Yorke, 1996;Strogatz, 2018) is a good example to illustrate this idea. All real numbers between 0 and 1 which do not have 1 in their ternary expansion belong to this Cantor set (call it C). We note down the following ''paradoxical'' aspects of Cantor sets 5 as observed in (Strogatz, 2018): 1. Cantor set C is ''totally disconnected''. This means that C contains only single points and no intervals. In this sense, all points in C are well separated from each other. 2. On the other hand, C contains no ''isolated points''. This means that every point in C has a neighbor arbitrarily close by. These two ''paradoxical'' aspects of Cantor sets (not just for the middle third Cantor set, but even for generalized Cantor sets, as well as, topological Cantor sets 6 ) are actually very beneficial for error detection and correction. Property 1 implies that a small error will ensure that the resulting point is not in C while Property 2 ensures that we can always find the nearest point in C that can be decoded. Self-similar Cantor sets are fractal (their dimension is not an integer).
We shall show that repetition codes, one of the oldest error detection/correction codes lie on a Cantor set.

Repetition codes R n lie on a cantor set
Repetition codes are the oldest and most basic error detection and correction codes in coding theory. They are frequently used in applications where the cost and complexity of encoding and decoding are a primary concern. Loskot & Beaulieu (2004) provide a long list of practical applications of repetition codes. Repetition codes are robust against impulsive noise and used in retransmission protocols, spread spectrum systems, multicarrier systems, infrared communications, transmit delay diversity, BLAST signaling, rate-matching in cellular systems, and synchronization of ultrawideband systems 7 . Thus, repetition codes are very useful in communications.
They are described as follows. Consider a message from a binary alphabet {0,1}. A repetition code R n (n > 1, odd integer) is a block code which assigns: R n can correct up to n−1 2 bit errors since the minimum hamming distance of R n is n. Since n is chosen to be an odd positive integer (> 1), a majority count in every block of n symbols acts as a very simple but efficient decoding algorithm. The repetition code R n is a linear block code with a rate = 1 n . We shall provide a new interpretation of R n , inspired by Cantor set. Start with the real line segment (0,1]. Remove the middle (1 − 2 −n+1 ) fraction of the set (0,1]. In the remaining two intervals, remove the same fraction and repeat this process in a recursive fashion (refer to Fig. 3). When this process is carried over an infinite number of times, the set that remains is a Cantor set. Furthermore, the binary representation of every element of the Cantor set forms the codewords of R n .

171
Having established that one of the oldest error detection/correction methods, namely repetition codes, 172 belong to a Cantor set, we shall extend this idea of using Cantor set for error detection to GLS-coding.

173
First, we establish a connection between repetition codes and GLS-coding.

175
It is a common view to look at Repetition codes as block codes. In this section, we view them as 176 GLS-coding with a forbidden symbol. 177 We could re-interpret Fig. 3 in a different way. Let the middle 1 − 2 −n+1 interval be reserved for 178 the forbidden symbol 'F' (this symbol never occurs in the message to be encoded) and the intervals 179 [0, 2 −n ) and [1 − 2 −n , 1) correspond to the symbols '0' and '1' respectively. We treat all binary messages  By reserving a forbidden symbol 'F' which is not used in encoding, all pre-images of the interval 187 corresponding to 'F' have to be removed. Thus, we have effectively created the same Cantor set that 188 was referred to in the previous section. For error detection, one has to start with the initial value and 189 iterate forwards on the modified map and record the symbolic sequence. If the symbolic sequence while 190 decoding contains the symbol 'F', then it invariably means that the initial value is not a part of the Cantor 191 set and hence not a valid codeword of R n , thereby detecting that an error has occurred. Thus checking 192 whether the initial value received belongs to the Cantor set or not is used for error detection at the decoder. In order to see this, consider n = 3. Figure 3 shows how R 3 is recursively constructed. If the above step is terminated at iteration k, then there remains a set of intervals whose binary expansion (of length nk) contains the codewords for all possible binary messages of length k. For example, at k = 2 for R 3 , we can see that there are four intervals which contains real numbers with binary expansions starting from 000000, 000111, 111000 and 111111. These are the codewords for the messages 00, 01, 10 and 11 respectively. In the limit of this process, the set results in a Cantor set of measure zero which contains codewords for all binary messages which are infinitely long.

Box-counting dimension of R n
We noted that repetition codes R n lie on a Cantor set. It is very easy to compute the box-counting dimension of this Cantor set: D = lim δ→0 logB(δ) log (1/δ) where B(δ) is the number of boxes of size δ needed to cover the set. For R n , the box-counting dimension D = 1 n which is equal to the rate of the code. This establishes a very important connection between the properties of the Cantor set and the property of the code.

INCORPORATING ERROR DETECTION INTO GLS-CODING USING A CANTOR SET
Having established that one of the oldest error detection/correction methods, namely repetition codes, belong to a Cantor set, we shall extend this idea of using a Cantor set for error detection to GLS-coding. First, we establish a connection between repetition codes and GLS-coding.

Repetition codes re-visited
It is a common view to look at Repetition codes as block codes. In this section, we view them as GLS-coding with a forbidden symbol.
We could re-interpret Fig. 3 in a different way. Let the middle 1 − 2 −n+1 interval be reserved for the forbidden symbol ' F ' (this symbol never occurs in the message to be encoded) and the intervals [0,2 −n ) and [1 − 2 −n ,1) correspond to the symbols '0' and '1' respectively. We treat all binary messages as symbolic sequences on this modified map and perform GLS-coding, i.e., find the initial value of a given message M . For GLS-coding, we are treating the alphabet {0,F ,1} as taking the probabilities {2 −n ,1 − 2 −n+1 ,2 −n } respectively. The resulting initial value of GLS-coding is the codeword for the message and it turns out that it is the same as R n (M ). Thus, we have interpreted R n (M ) as a joint source channel code where the source has three alphabets and we are encoding messages that contain only 0 and 1.
By reserving a forbidden symbol 'F ' which is not used in encoding, all pre-images of the interval corresponding to 'F ' have to be removed. Thus, we have effectively created the same Cantor set that was referred to in the previous section. For error detection, one has to start with the initial value and iterate forwards on the modified map and record the symbolic sequence. If the symbolic sequence while decoding contains the symbol 'F ', then it invariably means that the initial value is not a part of the Cantor set and hence not a valid codeword of R n , thereby detecting that an error has occurred. Thus checking whether the initial value received belongs to the Cantor set or not is used for error detection at the decoder.

GLS-coding with a forbidden symbol
We have presented two new ways of looking at Repetition codes-(1) the codewords of R n lie on a Cantor set and (2) coding a message is the same as performing GLS-coding with a forbidden symbol reserved on the interval [0,1). The two are essentially the same because, by reserving a forbidden symbol F , we have effectively created a Cantor set on which all the codewords lie. But the fact that we can view R n as GLS-codes enables us to see them as joint source channel codes for the source with alphabets {0,F ,1} and with probability distribution {2 −n ,1 − 2 −n+1 ,2 −n } respectively. The natural question to ask is whether we can use the same method for a different probability distribution of 0 and 1. The answer is positive.
Instead of reserving a forbidden symbol F of length 1 − 2 −n+1 , we could chose any arbitrary value > 0 for the forbidden symbol. The value of determines the amount of redundancy that is going to be available for error detection/correction. It controls the fractal dimension of the Cantor set and hence the rate of the code. As increases, error detection/correction property improves at the cost of a slight reduction in compression ratio (note that the compression is still lossless, but no longer Shannon optimal). The probability of the symbol '0' is p, but only (1 − )p is allocated on the interval [0,1). Similarly, for the symbol '1': (1 − )(1 − p) is allocated. This single parameter can be tuned for trade-off between error control and lossless compression ratio. We shall show that a very small value of is sufficient for detecting errors without significantly increasing the compressed file size.
For encoding, as before, the binary message is treated as a symbolic sequence on the modified GLS with the forbidden symbol ' F ' and the initial value is determined. The initial value which is now on the Cantor set is the compressed file which is stored and/or transmitted to the decoder.

Error detection with GLS-decoding
The decoder is the same as before except that we now have error detection capability. If the forbidden symbol ' F ' is encountered during GLS decoding (this can happen only if noise corrupts the initial value/compressed file and throws it outside the Cantor set), then it is declared that an error has been detected. The decoder can then request the encoder to re-transmit the compressed file as is done in several protocols (Chou & Ramchandran, 2000). However, this scheme does not correct the error. It is quite possible that the noise is such that the initial value gets modified into another value which also happens to fall inside the Cantor set, in which case the decoder will not be able to detect the error (and thus we end up wrongly decoding the message). But, the probability of this occurring is very small (it is zero in the case of messages having infinite length since the measure of the Cantor set is zero). For finite length messages, the probability of such an event is given by the measure of the set of codewords (which is non-zero). In the following section, we perform rigorous experimental tests of the proposed approach.

Simulation results
Three different values of ( 1 = 0.005, 2 = 0.03, 3 = 0.05) for the length of the interval corresponding to the forbidden symbol ' F ' were used. The amount of redundancy that needs to be added is easy to determine. By introducing the forbidden symbol of length , the valid symbols occupy a sub-interval of length 1 − . Thus, each time a symbol with probability p is encoded, −log 2 ((1 − )p) bits will be spent, whereas only −log 2 (p) bits would have been spent without the forbidden symbol. Thus, the amount of redundancy is R( ) = −log 2 ((1 − )p) + log 2 (p) = −log 2 (1 − ) bits/symbol. For N symbols, this would be N · R( ) bits rounded to the nearest highest integer. Thus the rate of the code will be: As expected, this is equal to the box-counting dimension of the Cantor set. Thus, by plugging in = 1 − 2 −n+1 in Eq. (2), we obtain the rate of the repetition codes as 1 n . We introduced a single bit error (one bit is flipped in the entire compressed file) towards the end of the compressed file for binary i.i.d. sources (p = 0.1,0.3). Note that, it is much more difficult to detect errors if they happen towards the end of the compressed file than if it occurred in the beginning of the file. This is because, any error can only affect decoding for subsequent bits and if the error was towards the end-of-file (EoF), not many bits are available to catch it. Remember that the Cantor set (having zero measure) is obtained only after an infinite number of iterations. Since we are terminating after a finite number of iterations, we don't strictly get a Cantor set. In other words, the set that remains when we terminate after a finite number of iterations is an approximation to the Cantor set and it contains points which would have been discarded if we had continued iterating. The single-bit errors closer to the EoF thus decode to points which are not discarded because of this approximation (as we run out of iterations). These errors survive and go undetected.  In our simulations, the location of the single bit error was varied from the last bit to the 250th bit from end-of-file. Thus, the total number of single-bit error events introduced in the compressed bitstream is 250 for each setting of . This way, we can test the proposed method under the worst scenario 8 . Table 1 shows the amount of redundancy owing to the allocation of the forbidden symbol. Tables 2 and 3 shows the performance of the method for p = 0.1 and p = 0.3. As expected, higher values of are able to detect more errors, but at the cost of increased compressed file size. Table 4 shows the efficiency of the method. Up to 96% of single bit errors introduced at the tail of the compressed file are detected by a modest increase in the redundancy (up to 15.78%). It should be noted that errors introduced in the beginning of the compressed file can be very easily detected by the proposed method. Arithmetic coding with a forbidden symbol: prior work The idea of using a forbidden symbol into arithmetic coding was first introduced by Boyd et al. (1997). It was subsequently studied by Chou & Ramchandran (2000), Grangetto & Cosman (2002), Anand, Ramchandran & Kozintsev (2001), Pettijohn, Hoffman & Sayood (2001) and Bi, Hoffman & Sayood (2006). However, the approach that is taken in this paper is unique and entirely motivated by a non-linear dynamical systems approach, through the wonderful properties of Cantor sets. We are thus able to justify why the method actually works. To the best of our knowledge, none of the earlier researchers have made this close connection between error detection/correction for repetition codes or arithmetic coding and Cantor sets. This work paves the way for future research on error correction using fractals/Cantor sets and potentially a host of new efficient techniques using Cantor sets could be designed.

CONCLUSIONS AND FUTURE WORK
In this work, we have provided a novel application of Cantor sets for incorporating error detection into a lossless data compression algorithm (GLS-coding). Cantor sets have paradoxical properties that enable error detection and correction. Repetition codes are an example of codewords on a self-similar Cantor set which can detect and correct errors. By reserving a forbidden symbol on the interval [0,1), we can ensure that the codewords for GLS-coding lie on a Cantor set and thereby detect errors while simultaneously GLSdecoding (thus preserving progressive transmission property), and without significantly increasing the compressed file size. This approach can be applied to any mode of GLS and generalizable to larger alphabets. However, we do not know whether other efficient error control codes can be similarly designed using such Cantor sets (or other fractals in higher dimensions) and whether we can exploit the structure of the Cantor set to perform efficient error correction. These are important research directions worth exploring in the future.