{'fraction_non_alphanumeric': 0.03394720687538367, 'fraction_numerical': 0.0073357888275015345, 'mean_word_length': 4.501139721401435, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Large Alphabet Source Coding using Independent Component Analysis

Large alphabet source coding is a basic and well-studied problem in data compression. It has many applications such as compression of natural language text, speech and images. The classic perception of most commonly used methods is that a source is best described over an alphabet which is at least as large as the observed alphabet. In this work we challenge this approach and introduce a conceptual framework in which a large alphabet source is decomposed into"as statistically independent as possible"components. This decomposition allows us to apply entropy encoding to each component separately, while benefiting from their reduced alphabet size. We show that in many cases, such decomposition results in a sum of marginal entropies which is only slightly greater than the entropy of the source. Our suggested algorithm, based on a generalization of the Binary Independent Component Analysis, is applicable for a variety of large alphabet source coding setups. This includes the classical lossless compression, universal compression and high-dimensional vector quantization. In each of these setups, our suggested approach outperforms most commonly used methods. Moreover, our proposed framework is significantly easier to implement in most of these cases.


I. INTRODUCTION
A SSUME a source over an alphabet size m, from which a sequence of n independent samples are drawn. The classical source coding problem is concerned with finding a sample-to-codeword mapping, such that the average codeword length is minimal, and the samples may be uniquely decodable. This problem was studied since the early days of information theory, and a variety of algorithms [1], [2] and theoretical bounds [3] were introduced throughout the years.
The classical source coding problem usually assumes an alphabet size m which is small, compared with n. Here, we focus on a more difficult (and common) scenario, where the source's alphabet size is considered "large" (for example, a word-wise compression of natural language texts). In this setup, m takes values which are either comparable (or even larger) than the length of the sequence n. The main challenge in large alphabet source coding is that the redundancy of the code, formally defined as the excess number of bits used over the source's entropy, typically increases with the alphabet size [4].
In this work we propose a conceptual framework for large alphabet source coding, in which we reduce the alphabet size by decomposing the source into multiple components which are "as statistically independent as possible". This allows us to encode each of the components separately, while benefiting from the reduced redundancy of the smaller alphabet.
To utilize this concept we introduce a framework based on a generalization of the Binary Independent Component Analysis (BICA) method [5]. This framework efficiently searches for an invertible transformation which minimizes the difference between the sum of marginal entropies (after the transformation is applied) and the joint entropy of the source. Hence, it minimizes the (attainable) lower bound on the average codeword length, when applying marginal entropy coding.
We show that while there exist sources which cannot be efficiently decomposed, their portion (of all possible sources over a given alphabet size) is small. Moreover, we show that the difference between the sum of marginal entropies (after our transformation is applied) and the joint entropy, is bounded, on average, by a small constant for every m (when the averaging takes place uniformly, over all possible sources of the same alphabet size m). This implies that our suggested approach is suitable for many sources of increasing alphabet size.
We demonstrate our method in a variety of large alphabet source coding setups. This includes the classical lossless coding, when the probability distribution of the source is known both to the encoder and the decoder, universal lossless coding, in which the decoder is not familiar with the distribution of the source, and lossy coding in the form of vector quantization. We show that our approach outperforms currently known methods in all these setups, for a variety of typical sources.
The rest of this manuscript is organized as follows: After a short notation section, we review the work that was previously done in large alphabet source coding in Section III. Section IV presents the generalized BICA problem, propose two different algorithms, and demonstrate their behavior on average and in worst-case. In Section V we apply our suggested framework to the classical lossless coding problem, over large alphabets. We then extend the discussion to universal compression in Section VI. In Section VII we further demonstrate our approach on vector quantization, with a special attention to high dimensional sources and low distortion. Throughout this paper we use the following standard notation: underlines denote vector quantities, where their respective components are written without underlines but with index. For example, the components of the n-dimensional vector X are X 1 , X 2 , . . . X n . Random variables are denoted with capital letters while their realizations are denoted with the respective lower-case letters. P X (x) P (X 1 = x 1 , X 2 = x 2 . . . ) is the probability function of X while H (X) is the entropy of X. This means H (X) = − x P X (x) log P X (x) where the log function denotes a logarithm of base 2 and lim x→0 x log (x) = 0. Specifically, we refer to the binary entropy of a Bernoulli distributed random variable X ∼ Ber(p) as H b (X), while we denote the binary entropy function as h b (p) = −p log p − (1 − p) log (1 − p).

III. PREVIOUS WORK
In the classical lossless data compression framework, one usually assumes that both the encoder and the decoder are familiar with the probability distribution of the encoded source, X. Therefore, encoding a sequence of n memoryless samples drawn form this this source takes on average at least n times its entropy H (X), for sufficiently large n [3]. In other words, if n is large enough to assume that the joint empirical entropy of the samples,Ĥ (X), is close enough to the true joint entropy of the source, H (X), then H (X) is the minimal average number of bits required to encode a source symbol. Moreover, it can be shown [3] that the minimum average codeword length,l min , for a uniquely decodable code, satisfies H (X) ≤l min ≤ H (X) + 1. (1) Entropy coding is a lossless data compression scheme that strives to achieve the lower bound,l min = H (X). Two of the most common entropy coding techniques are Huffman coding [1] and arithmetic coding [2].
The Huffman algorithm is an iterative construction of variable-length code table for encoding the source symbols. The algorithm derives this table from the probability of occurrence of each source symbol. Assuming these probabilities are dyadic (i.e., − log(p(x)) is an integer for every symbol x ∈ X), then the Huffman algorithm achievesl min = H (X). However, in the case where the probabilities are not dyadic then the Huffman code does not achieve the lower-bound of (1) and may result in an average codeword length of up to H (X) + 1 bits. Moreover, although the Huffman code is theoretically easy to construct (linear in the number of symbols, assuming they are sorted according to their probabilities) it is practically a challenge to implement when the number of symbols increases [6].
Huffman codes achieve the minimum average codeword length among all uniquely decodable codes that assign a separate codeword to each symbol. However, if the probability of one of the symbols is close to 1, a Huffman code with an average codeword length close to the entropy can only be constructed if a large number of symbols is jointly coded. The popular method of arithmetic coding is designed to overcome this problem.
In arithmetic coding, instead of using a sequence of bits to represent a symbol, we represent it by a subinterval of the unit interval [2]. This means that the code for a sequence of symbols is an interval whose length decreases as we add more symbols to the sequence. This property allows us to have a coding scheme that is incremental. In other words, the code for an extension to a sequence can be calculated simply from the code for the original sequence. Moreover, the codeword lengths are not restricted to be integral. The arithmetic coding procedure achieves an average length for the block that is within 2 bits of the entropy. Although this is not necessarily optimal for any fixed block length (as we show for Huffman code), the procedure is incremental and can be used for any block-length. Moreover, it does not requir the source probabilities to be dyadic. However, arithmetic codes are more complicated to implement and are a less likely to practically achieve the entropy of the source as the number of symbols increases. More specifically, due to the well-known underflow and overflow problems, finite precision implementations of the traditional adaptive arithmetic coding cannot work if the size of the source exceeds a certain limit [7]. For example, the widely used arithmetic coder by Witten et al. [2] cannot work when the alphabet size is greater than 2 15 . The improved version of arithmetic coder by Moffat et al. [8] extends the alphabet to size 2 30 by using low precision arithmetic, at the expense of compression performance.
Notice that a large number of symbols not only results with difficulties in implementing entropy codes: as the alphabet size increases, we require an exponentially larger number of samples for the empirical entropy to converge to the true entropy.
Therefore, when dealing with sources over large alphabets we usually turn to a universal compression framework. Here, we assume that the empirical probability distribution is not necessarily equal to the true distribution and henceforth unknown to the decoder. This means that a compressed representation of the samples now involves with two parts -the compressed samples and an overhead redundancy (where the redundancy is defined as the number of bits used to transmit a message, minus the number of bits of actual information in the message).
As mentioned above, encoding a sequence of n samples, drawn from a memoryless source X, requires at least n times the empirical entropy,Ĥ(X). This is attained through entropy coding according to the source's empirical distribution. The redundancy, on the other hand, may be quantified in several ways.
One common way of measuring the coding redundancy is through the minimax criterion [4]. Here, the worst-case redundancy is the lowest number of extra bits (over the empirical entropy) required in the worst case (that is, among all sequences) by any possible encoder. Many worst-case redundancy results are known when the source's alphabet is finite. A succession of papers initiated by [9] show that for the collection I n m of i.i.d. distributions over length-n sequences drawn from an alphabet of a fixed size m, the worst-case redundancy behaves asymptotically as m−1 2 log n m , as n grows. Orlitsky and Santhanam [10] extended this result to cases where m varies with n. The standard compression scheme they introduce differentiates between three situations in which m = o(n), n = o(m) and m = Θ(n). They provide leading term asymptotics and bounds to the worst-case minimax redundancy for these ranges of the alphabet size. Szpankowski and Weinberger [11] completed this study, providing the precise asymptotics to these ranges. For the purpose of our work we adopt the leading terms of their results, showing that the worst-case minimax redundancy, when m → ∞, as n grows, behaves as follows: ii For n = o(m):R(I n m ) n log iii m = αn + l(n): In a landmark paper from 2004, Orlitsky et al. [12] presented a novel framework for universal compression of memoryless sources over unknown and possibly infinite alphabets. According to their framework, the description of any string, over any alphabet, can be viewed as consisting of two parts: the symbols appearing in the string and the pattern that they form. For example, the string "abracadabra" can be described by conveying the pattern "12314151231" and the dictionary Together, the pattern and dictionary specify that the string "abracadabra" consists of the first letter to appear (a), followed by the second letter to appear (b), then by the third to appear (r), the first that appeared (a again), the fourth (c), etc. Therefore, a compressed string involves with a compression of the pattern and its corresponding dictionary. Orlitsky et al. derived the bounds for pattern compression, showing that the redundancy of patterns compression under i.i.d. distributions over potentially infinite alphabets is bounded by 3 2 log e n 1/3 . Therefore, assuming the alphabet size is m and the number of uniquely observed symbols is n 0 , the dictionary can be described in n 0 log m bits, leading to an overall lower bound of n 0 log m + n 1/3 bits on the compression redundancy.
An additional (and very common) universal compression scheme is the canonical Huffman coding [13]. A canonical Huffman code is a particular type of Huffman code with unique properties which allow it to be described in a very compact manner. The advantage of a canonical Huffman tree is that one can encode a codebook in fewer bits than a fully described tree. Since a canonical Huffman codebook can be stored especially efficiently, most compressors start by generating a non-canonical Huffman codebook, and then convert it to a canonical form before using it.
In canonical Huffman coding the bit lengths of each symbol are the same as in the traditional Huffman code. However, each code word is replaced with new code words (of the same length), such that a subsequent symbol is assigned the next binary number in sequence. For example, assume a Huffman code for four symbols, A to D: This way we do not need to store the entire Huffman mapping but only a list of all symbols in increasing order by their bit-lengths and record the number of symbols for each bit-length. This allows a more compact representation of the code, hence, lower redundancy.
An additional class of data encoding methods which we refer to in this work is lossy compression. In the lossy compression setup one applies inexact approximations for representing the content that has been encoded. In this work we focus on vector quantization, in which a high-dimensional vector X ∈ R d is to be represented by a finite number of points. Vector quantization works by clustering the observed samples of the vector X into groups, where each group is represented by its centroid point, such as in k-means and other clustering algorithms. Then, the centroid points that represent the observed samples are compressed in a lossless manner.
In the lossy compression setup, one is usually interested in minimizing the amount of bits which represent the data for a given a distortion measure (or equivalently, minimizing the distortion for a given compressed data size). The rate-distortion function defines the lower bound on this objective. It is defined as where X is the source, Y is recovered version of X and D(X, Y ) is some distortion measure between X and Y . Notice that since the quantization is a deterministic mapping between X and Y , we have that I(X; Y ) = H(Y ).
The Entropy Constrained Vector Quantization (ECVQ) is an iterative method for clustering the observed samples from X into centroid points which are later represented by a minimal average codeword length. The ECVQ algorithm minimizes the Lagrangian where λ is the Lagrange multiplier and E (l(X)) is the average codeword length for each symbol in X. The ECVQ algorithm performs an iterative local minimization method similar to the generalized Lloyd algorithm [14]. This means that for a given clustering of samples it constructs an entropy code to minimize the average codeword lengths of the centroids. Then, for a given coding of centroids it clusters the observed samples such that the average distortion is minimized, biased by the length of the codeword. This process continues until a local convergence occurs. The ECVQ algorithm performs local optimization (as a variant of the k-means algorithm) which is also not very scalable for an increasing number of samples. This means that in the presence of a large number of samples, or when the alphabet size of the samples is large enough, the clustering phase of the ECVQ becomes impractical. Therefore, in these cases, one usually uses a predefined lattice quantizer and only constructs a corresponding codebook for its centroids.
It is quite evident that large alphabet sources entails a variety of difficulties in all the compression setups mentioned above: it is more complicated to construct an entropy code for, it results in a great redundancy when universally encoded and it is much more challenging to design a vector quantizer for. In the following sections we introduce a framework which is intended to overcome these drawbacks.

IV. GENERALIZED BINARY INDEPENDENT COMPONENT ANALYSIS
A common implicit assumption to most compression schemes in that the source is best represented over its observed alphabet size. We would like to challenge this assumption, suggesting that in some cases there exists a transformation which decomposes a source into multiple "as independent as possible" components whose alphabet size is much smaller.

A. Problem Formulation
Suppose we are given a binary random vector X ∼ p of a dimension d. We are interested in an invertible transformation Y = g(X) such that Y is of the same dimension and alphabet size, g : 2 d → 2 d . In addition we would like the components (bits) of Y to be as "statistically independent as possible". Notice that an invertible transformation of a vector X is actually a one-toone mapping (i.e. permutation) of its m = 2 d alphabet symbols. Therefore, there exist 2 d ! possible invertible transformations.
To quantify the statistical independence among the components of the vector Y we use the well-known total correlation measure as a multivariate generalization of the mutual information, This measure can also be viewed as the cost of encoding the vector Y component-wise, as if its components were statistically independent, compared to its true entropy. Notice that the total correlation is non-negative and equals zero iff the components of Y are mutually independent. Therefore, "as statistically independent as possible" may be quantified by minimizing C(Y ). The total correlation measure was first considered as an objective for minimal redundancy representation by Barlow [15]. It is also not new to finite field ICA problems, as demonstrated in [16].
Since we define Y to be an invertible transformation of X we have H(Y ) = H(X) and our minimization objective is We notice that P (Y j = 0) is the sum of probabilities of all words whose j th bit equals 0. We further notice that the optimal transformation is not unique. For example, we can always invert the j th bit of all words, or even shuffle the bits, to achieve the same minimum.
In the following sections we review and introduce several methods for solving (8). As a first step towards this goal we briefly describe the generalized BICA method. A complete derivation of this framework appears in [17]. Then, Sections IV-C,IV-D and IV-E provide a simplified novel method for (8) and discuss its theoretical properties.

B. Piece-wise Linear Relaxation Algorithm
In this section we briefly review our suggested method, as it appears in detail in [17]. Let us first notice that the problem we are dealing with (8) is a concave minimization problem over a discrete permutation set which is a hard problem. However, let us assume for the moment that instead of our "true" objective (8) we have a simpler linear objective function. That is, where π j = p(Y j = 0) and the last equality changes the summation over d bits to a summation over all m = 2 d symbols.
In order to minimize this objective function over the m given probabilities p we simply sort these probabilities in a descending order and allocate them such that the largest probability goes with the smallest coefficient c i and so on. Assuming both the coefficients and the probabilities are known and sorted in advance, the complexity of this procedure is linear in m.
We now turn to the generalized BICA problem, defined in (8). Since our objective is concave we would first like to bound it from above with a piecewise linear function which contains k pieces, as shown in Figure 1. We show that solving the piecewise linear problem approximates the solution to (8) as closely as we want. First, we notice that all π j s are exchangeable (in the sense that we can always interchange them and achieve the same result). This means we can find the optimal solution to the piece-wise linear problem by going over all possible combinations of "placing" the d variables π j in the k different regions of the piece-wise linear function. For each of these combinations we need to solve a linear problem (9), where the minimization is with respect to allocation of the m given probabilities p, and with additional constraints on the ranges of each π j . For example, assume d = 3 and the optimal solution is such that two π j s (e.g. π 1 and π 2 ) are at the first region R 1 and π 3 is at the second region R 2 , then we need to solve the following constrained linear problem, where the minimization is over the allocation of the given , which determine the corresponding π j 's, as demonstrated in (9). This problem again seems hard. However, if we attempt to solve it without the constraints we notice the following: 1) If the collection of π j s which define the optimal solution to the unconstrained linear problem happens to meet the constraints then it is obviously the optimal solution with the constraints. 2) If the collection of π j s of the optimal solution does not meet the constraints (say, π 2 ∈ R 2 ) then, due to the concavity of the entropy function, there exists a different combination with a different constrained linear problem, in which this set of π j s necessarily achieves a lower minimum (since a 2 x + b 2 < a 1 x + b 1 ∀x ∈ R 2 ). Therefore, in order to find the optimal solution to the piece-wise linear problem, all we need to do is to go over all possible combinations of placing the π j s in k different regions, and for each combination solve an unconstrained linear problem (which is solved in linear time in m). If the solution does not meet the constraint then it means that the assumption that the optimal π j reside within this combination's regions is false. Otherwise, if the solution does meet the constraint, it is considered as a candidate for the global optimal solution.
The number of combinations we need to go through is equivalent to the number of ways of placing d identical balls in k boxes, which is (for a fixed k), Assuming the coefficients are all known and sorted in advance, the overall complexity of our suggested algorithm, as d → ∞, Notice that any approach which exploits the full statistical description of X would require going over the probabilities of all of its symbols at least once. Therefore, a computational load of at least O(m) = O(2 d ) seems inevitable. Still, this is significantly smaller then O(m!) = O(2 d !), required by brute-force search over all possible permutations.
It is also important to notice that even though the asymptotic complexity of our approximation algorithm is O(m log k m), it takes a few seconds to run an entire experiment on a standard personal computer (with d = 1024 and k = 8, for example). The reason is that the m factor comes from the complexity of sorting a vector and multiplying two vectors, operations which are computationally efficient on most available software. Moreover, if we assume that the linear problems coefficients (9) are calculated, sorted and stored in advance, we can place them in a matrix form and multiply the matrix with the (sorted) vector p. The minimum of this product is exactly the solution to the linear approximation problem. Therefore, the practical asympthotic complexity of the approximation algorithm drops to a single multiplication of a (log k (m) × m) matrix with a (m × 1) vector.
Even though the complexity of this method is significantly lower than full enumeration, it may still be computationally infeasible as m increases. Therefore, we suggest a simpler (greedy) solution, which is much easier to implement and apply.

C. Order Algorithm
As mentioned above, the minimization problem we are dealing with (8) is combinatorial in its essence and is consequently considered hard. We therefore suggest a simplified greedy algorithm which strives to sequentially minimize each term of the summation (8) With no loss of generality, let us start by minimizing H b (Y 1 ), which corresponds to the marginal entropy of the most significant bit (msb). Since the binary entropy is monotonically increasing in the range 0, 1 2 , we would like to find a permutation of p that minimizes a sum of half of its values. This means we should order the p i 's so that half of the p i 's with the smallest values are assigned to P (Y 1 ) = 0 while the other half of p i 's (with the largest values) are assigned to P (Y 1 ) = 1. For example, assuming m = 8 and We now proceed to minimize the marginal entropy of the second most significant bit, H b (Y 2 ). Again, we would like to assign P (Y 2 ) = 0 the smallest possible values of p i 's. However, since the we already determined which p i 's are assigned to the msb, all we can do is reorder the p i 's without changing the msb. This means we again sort the p i 's so that the smallest possible values are assigned to P (Y 2 ) = 0, without changing the msb. In our example, this leads to, Therefore, we show that a greedy solution to (8) which sequentially minimizes H b (Y j ) is attained by simply ordering the joint distribution p in an ascending (or equivalently descending) order. In other words, the order permutation suggests to simply order the probability distribution p 1 , . . . , p m in an ascending order, followed by a mapping of the i th symbol (in its binary representation) the i th smallest probability.
At this point it seems quite unclear how well the order permutation performs, compared both with the relaxed BICA we previously discussed, and the optimal permutation which minimizes (8). In the following sections we introduce some theoretical properties which demonstrate its effectiveness.

D. Worst-case Independent Representation
We now introduce the theoretical properties of our suggested algorithms. Naturally, we would like to quantify how much we "lose" by representing a given random vector X as if its components are statistically independent. Therefore, for any given random vector X ∼ p and an invertible transformation Y = g(X), we denote the cost function as appears in (8).
Since both our methods strongly depend on the given probability distribution p, we focus on the worst-case and the average case of C(p, g), with respect to p. Let us denote the order permutation as g ord and the permutation which is found by the piece-wise linear relaxation as g lin . We further define g bst as the permutation that results with a lower value of C(p, g), between g lin and g ord . This means that g bst = arg min In addition, we define g opt as the optimal permutation that minimizes (8) over all possible permutations. Therefore, for any givenp, we have that C(p, g opt ) ≤ C(p, g bst ) ≤ C(p, g ord ). In this Section we examine the worst-case performance of both of our suggested algorithms. Specifically, we would like to quantify the maximum of C(p, g) over all joint probability distributions p, of a given alphabet size m. Theorem 1: For any random vector X ∼ p, over an alphabet size m we have that In addition, H(X) ≥ 0. Therefore, we have that C(p, g opt ) is bounded from above by log(m). Let us also show that this bound is tight, in the sense that there exists a joint probability distributioñ p such that C(p, g opt ) is linear in log(m).
Then,p is ordered and satisfies P (Y i = 0) = m 6(m−1) . In addition, we notice that assigning symbols in a decreasing order top (as mentioned in Section IV-C) results with an optimal permutation. This is simply since P (Y j = 0) = m 6(m−1) is the minimal possible value of any P (Y j = 0) that can be achieved when summing any m 2 elements ofp i . Further we have that, Therefore, max p C(p, g opt ) = Θ(log(m)).
Theorem 1 shows that even the optimal permutation achieves a sum of marginal entropies which is Θ(log(m)) bits greater than the joint entropy, in the worst case. This means that there exists at least one source X with a joint probability distribution which is impossible to encode as if its components are independent without losing at least Θ(log(m)) bits. However, we now show that such sources are very "rare".

E. Average-case Independent Representation
In this section we show that the expected value of C(p, g opt ) is bounded by a small constant, when averaging uniformly over all possible p over an alphabet size m.
To prove this, we recall that C(p, g opt ) ≤ C(p, g ord ) for any given probability distribution p. Therefore, we would like to find the expectation of C(p, g ord ) where the random variables are p 1 , . . . , p m , taking values over a uniform simplex.
Proposition 1: Let X ∼ p be a random vector of an alphabet size m and a joint probability distribution p. The expected joint entropy of X, where the expectation is over a uniform simplex of joint probability distributions p is where ψ is the digamma function.
The proof of this proposition is left for the Appendix.
We now turn to examine the expected sum of the marginal entropies, d j=1 H b (Y j ) under the order permutation. As described above, the order permutation suggests sorting the probability distribution p 1 , . . . , p m in an ascending order, followed by mapping of the i th symbol (in a binary representation) the i th smallest probability. Let us denote p (1) ≤ · · · ≤ p (m) the ascending ordered probabilities p 1 , . . . , p m . Bairamov et al. [18] show that the expected value of p (i) is where K m = m k=1 1 k is the Harmonic number. Denote the ascending ordered binary representation of all possible symbols in a matrix form A ∈ {0, 1} (m×d) . This means that entry A ij corresponds to the j th bit in the i th symbol, when the symbols are given in an ascending order. Therefore, the expected sum of the marginal entropies of Y , when the expectation is over a uniform simplex of joint probability distributions p, follows where (a) follows from Jensen's inequality, (b) follows from (13) and (c) follows since m i=1 A ij = 1 2 for all j = 1, . . . , d. We now turn to derive asymptotic bounds of the expected difference between the sum of Y 's marginal entropies and the joint entropy of X, as appears in (8).
Theorem 2: Let X ∼ p be a random vector of an alphabet size m and joint probability distribution p. Let Y = g ord (X) be the order permutation. For d ≥ 10, the expected value of C(p, g ord ), over a uniform simplex of joint probability distributions p, satisfies Proof Let us first derive the expected marginal entropy of the least significant bit, j = 1, according to (14).
where (a) and (b) follow the harmonic number properties: where γ is the Euler-Mascheroni constant [19] and (c) results from the concavity of the binary entropy.
Repeating the same derivation for different values of j, we attain We may now evaluate the sum of expected marginal entropies of Y . For simplicity of derivation let us obtain E p {H b (Y j )} for j = 1, . . . , 10 according to (16) and upper bound E p {H b (Y j )} for j > 10 with h b 1 2 = 1. This means that for d ≥ 10 we have The expected joint entropy may also be expressed in a more compact manner. In Proposition 1 it is shown than E p {H(X)} = 1 log e 2 (ψ(m + 1) − ψ (2)). Following the inequality in [19], the Digamma function, ψ(m + 1), is bounded from below by ψ(m + 1) = H m − γ > log e (m) + 1 2(m+1) . Therefore, we conclude that for d ≥ 10 we have that In addition, we would like to evaluate the expected difference between the sum of marginal entropies and the joint entropy of X, that is, without applying any permutation. This shall serve us as a reference to the upper bound we achieve in Theorem 2.
Theorem 3: Let X ∼ p be a random vector of an alphabet size m and joint probability distribution p. The expected difference between the sum of marginal entropies and the joint entropy of X, when the expectation is taken over a uniform simplex of joint probability distributions p, satisfies Proof We first notice that P (X j = 1) equals the sum of one half of the probabilities p i , i = 1, . . . , m for every j = 1 . . . d.
Assume p i 's are randomly (and uniformly) assigned to each of the m symbols. Then, E{P (X j = 1)} = 1 2 for every j = 1 . . . d. Hence, To conclude, we show that for a random vector X over an alphabet size m, we have for d ≥ 10, where the expectation is over a uniform simplex of joint probability distributions p. This means that when the alphabet size is large enough, even the simple order permutation achieves, on the average, a sum of marginal entropies which is only 0.0162 bits greater than the joint entropy, when all possible probability distributions p are equally likely to appear. Moreover, we show that the simple order permutation reduced the expected difference between the sum of the marginal entropies and the joint entropy of X by more than half a bit, for sufficiently large m.

V. LARGE ALPHABET SOURCE CODING
Assume a classic compression setup in which both the encoder and the decoder are familiar with the joint probability distribution of the source X ∼ p, and the number of observations n is sufficiently large in the sense thatĤ(X) ≈ H(X).
As discussed above, both Huffman and arithmetic coding entail a growing redundancy and a quite involved implementation as the alphabet size increases. The Huffman code guarantees a redundancy of at most a single bit for every alphabet size, depending on the dyadic structure of p. On the other hand, arithmetic coding does not require a dyadic p, but only guarantees a redundancy of up to two bits, and is practically limited for smaller alphabet size [3], [7].
In other words, both Huffman and arithmetic coding are quite likely to have an average codeword length which is greater than H(X), and are complicated (or sometimes even impossible) to implement, as m increases.
To overcome these drawbacks, we suggest a simple solution in which we first apply an invertible transformation to make the components of X "as statistically independent as possible", following an entropy coding on each of its components separately. This scheme results with a redundancy which we previously defined as C(p, g) = m j=1 H(Y j ) − H(X). However, it allows us to apply a Huffman or arithmetic encoding on each of the components separately; hence, over a binary alphabet.
Moreover, notice we can group several components, Y j , into blocks so that the joint entropy of the block is necessarily lower than the sum of marginal entropies of Y j . Specifically, denote b as the number of components in each block and B as the number of blocks. Then, b × B = d and for each block v = 1, . . . , B we have that where H(Y (v) ) is the entropy of the block v and H b (Y This means we can always apply our suggested invertible transformation which minimizes d j=1 H b (Y j ), and then the group components into B blocks and encode each block separately. This results with . By doing so, we increase the alphabet size of each block (to a point which is still not problematic to implement with Huffman or arithmetic coding) while at the same time we decrease the redundancy. We discuss different considerations in choosing the number of blocks B in the following sections.
A more direct approach of minimizing the sum of block entropies B v=1 H(Y (v) ) is to refer to each block as a symbol over a greater alphabet size, 2 b . This allows us to seek an invertible transformation which minimizes the sum of marginal entropies, where each marginal entropy corresponds to a marginal probability distribution over an alphabet size 2 b . This minimization problem is referred to as a generalized ICA over finite alphabets and is discussed in detail in [17].
However, notice that both the Piece-wise Linear Relaxation algorithm (Section IV-B), and the solutions discussed in [17], require an extensive computational effort in finding a minimizer for (8) as the alphabet size increases. Therefore, we suggest applying the greedy order permutation as m grows. This solution may result in quite a large redundancy for a several joint probability distributions p (as shown in Section IV-D). However, as we uniformly average over all possible p's, the redundancy is bounded with a small constant as the alphabet size increases (Section IV-E).
Moreover, the ordering approach simply requires ordering the values of p, which is significantly faster than constructing a Huffman dictionary or arithmetic encoder.
To illustrate our suggested scheme, consider a source X ∼ p over an alphabet size m, which follows the Zipf's law distribution, P (k; s, m) = k −s m l=1 l −s where m is the alphabet size and s is the "skewness" parameter. The Zipf's law distribution is a commonly used heavy-tailed distribution, mostly in modeling of natural (real-world) quantities. It is widely used in physical and social sciences, linguistics, economics and many other fields.
We would like to design an entropy code for X with m = 2 16 and different values of s. We first apply a standard Huffman code as an example of a common entropy coding scheme. Notice that we are not able to construct an arithmetic encoder as the alphabet size is too large [7]. We further apply our suggested order permutation scheme (Section IV-C), in which we sort p in a descending order, followed by arithmetic encoding to each of the components separately. We further group these components into two separate blocks (as discussed above) and apply an arithmetic encoder on each of the blocks. We repeat this experiment for a range of parameter values s. Figure 2 demonstrates the results we achieve.
Our results show that the Huffman code attains an average codeword length which is very close to the entropy of the source for lower values of s. However, as s increases and the distribution of the source becomes more skewed, the Huffman code diverges from the entropy. On the other hand, our suggested method succeeds in attaining an average codeword length which is very close to the entropy of the source for every s, especially as s increases and when independently encoding each of the blocks.

VI. UNIVERSAL SOURCE CODING
The classical source coding problem is typically concerned with a source whose alphabet size is much smaller than the length of the sequence. In this case one usually assumes thatĤ(X) ≈ H(X). However, in many real world applications such an assumption is not valid. A paradigmatic example is the word-wise compression of natural language texts. In this setup we draw a memoryless sequence of words, so that the alphabet size is often comparable to or even larger than the length of the source sequence.
As discussed above, the main challenge in large alphabet source coding is the redundancy of the code, which is formally defined as the excess number of bits used over the source's entropy. The redundancy may be quantified as the expected number of extra bits required to code a memoryless sequence drawn from X ∼ p, when using a code that was constructed for p, rather than using the "true" code, optimized for the empirical distributionp. Another way to quantify these extra bits is to directly design a code forp, and transmit the encoded sequence together with this code.
Here again, we claim that in some cases, applying a transformation which decomposes the observed sequence into multiple "as independent as possible" components results in a better compression rate.
However, notice that now we also need to consider the number of bits required to describe the transformation. In other words, our redundancy involves not only (7) and the designated code for the observed sequence, but also the invertible transformation we applied on the sequence. This means that even the simple order permutation (Section IV-C) requires at most n log m bits Left: the curve with the squares is the average codeword length using a Huffman code, the curve with the crosses corresponds to the average codeword length using our suggested methods when encoding each component separately, and the curve with the asterisks is our suggested method when encoding each of the two blocks separately. The black curve (which tightly lower-bounds all the curves) is the entropy of the source. Right: The difference between each encoding method and the entropy of the source to describe, where m is the alphabet size and n is the length of the sequence. This redundancy alone is not competitive with Szpankowski and Weinberger [11] worst-case redundancy results, described in (3). Therefore, we require a different approach which minimizes the sum of marginal entropies (8) but at the same time is simpler to describe.
One possible solution is to seek invertible, yet linear, transformations. This means that describing the transformation would now only require log 2 m bits. However, this generalized linear BICA problem is also quite involved. In their work, Attux et al. [16] describe the difficulties in minimizing (8) over XOR field (linear transformations) and suggest an immune-inspired algorithm for it. Their algorithm, which is heuristic in its essence, demonstrates some promising results. However, it is not very scalable (with respect to the number of components log m) and does not guarantee to converge to the global optimal solution. Therefore, we would like to modify our suggested approach (Section IV-B) so that the transformation we achieve requires fewer bits to describe.
As in the previous section, we argue that in some setups it is better to split the components of the data into blocks, with b components in each block, and encode the blocks separately. Notice that we may set the value of b so that the blocks are no longer considered as over a large alphabet size (n 2 b ). This way, the redundancy of encoding each block separately is again negligible, at the cost of longer averaged codeword length. For simplicity of notation we define the number of blocks as B, and assume B = d /b is a natural number. Therefore, encoding the d components all together takes n ·Ĥ(X) bits for the data itself, plus a redundancy term according to (2) and (3), while the block-wise compression takes about bits, where the first term is n times the sum of B empirical block entropies and the second term is B times the redundancy of each block when n = o(2 b ). Two subsequent questions arise from this setup: 1) What is the optimal value of b that minimizes (21)? 2) Given a fixed value of b, how can we re-arrange d components into B blocks so that the averaged codeword length (which is bounded from below by the empirical entropy), together with the redundancy, is as small as possible? Let us start by fixing b and focusing on the second question.
A naive shuffling approach is to exhaustively or randomly search for all possible combinations of clustering d components into B blocks. Assuming d is quite large, an exhaustive search is practically infeasible. Moreover, the shuffling search space is quite limited and results with a very large value of (7), as shown below. Therefore, a different method is required. We suggest applying our generalized BICA tool as an upper-bound search method for efficiently searching for a minimal possible averaged codeword length. As in previous sections we define Y = g(X), where g is some invertible transformation of X. Every block of the vector Y satisfies (19), where the entropy terms are now replaced with empirical entropies. In the same manner as in Section V, summing over all B blocks results with (20) where again, the entropy terms are replaced with empirical entropies. This means that the sum of the empirical block entropies is bounded from above by the empirical marginal entropies of the components of Y (with equality iff the components are independently distributed).
Our suggested scheme works as follows: We first randomly partition the d components into B blocks. We estimate the joint probability of each block and apply the generalized BICA on it. The sum of empirical marginal entropies (of each block) is an upper bound on the empirical entropy of each block, as described in the previous paragraph. Now, let us randomly shuffle the d components of the vector Y . By "shuffle" we refer to an exchange of positions of Y 's components. Notice that by doing so, the sum of empirical marginal entropies of the entire vector d i=1Ĥ b (Y i ) is maintained. We now apply the generalized BICA on each of the (new) blocks. This way we minimize (or at least do not increase) the sum of empirical marginal entropies of the (new) blocks. This obviously results with a lower sum of empirical marginal entropies of the entire vector Y . It also means that we minimize the left hand side of (22), which upper bounds the sum of empirical block entropies, as the inequality in (22) suggests. In other words, we show that in each iteration we decrease (at least do not increase) an upper bound on our objective. We terminate once a maximal number of iterations is reached or we can no longer decrease the sum of empirical marginal entropies.
Therefore, assuming we terminate at iteration I 0 , encoding the data takes about bits, where the first term refers to the sum of empirical block entropies at the I 0 iteration, the third term refers to the representation of I 0 · B invertible transformation of each block during the process until I 0 , and the fourth term refers to the bit permutations at the beginning of each iteration. Hence, to minimize (23) we need to find the optimal trade-off between a low value of B v=1Ĥ [I0] (Y (v ) and a low iteration number I 0 . We may apply this technique with different values of b to find the best compression scheme over all block sizes.

A. synthetic experiments
In order to demonstrate our suggested method we first generate a dataset according to the Zipf law distribution which was previously described. We draw n = 10 6 realizations from this distribution with an alphabet size m = 2 20 and a parameter value s = 1.2. We encounter n 0 = 80, 071 unique words and attain an empirical entropy of 8.38 bits (while the true entropy is 8.65 bits). Therefore, compressing the drawn realizations in its given 2 20 alphabet size takes a total of about 10 6 × 8.38 + 1.22 × 10 6 = 9.6 · 10 6 bits, according to (4). Using the patterns method [12], the redundancy we achieve is the redundancy of the pattern plus the size of the dictionary. Hence, the compressed size of the data set according to this method is lower bounded by 10 6 × 8.38 + 80, 071 × 20 + 100 = 9.982 · 10 6 bits. In addition to these asymptotic schemes we would also like to compare our method with a common practical approach. For this purpose we apply the canonical version of the Huffman code. Through the canonical Huffman code we are able to achieve a compression rate of 9.17 bits per symbol, leading to a total compression size of about 1.21 · 10 7 bits.
Let us now apply a block-wise compression. We first demonstrate the behavior of our suggest approach with four blocks (B = 4) as appears in Figure 3. To have a good starting point, we initiate our algorithm with a the naive shuffling search method (described above). This way we apply our optimization process on the best representation a random bit shuffling could attain (with a negligible d log d redundancy cost). As we can see in Figure 3.B, we minimize (23) over I 0 = 64 and B v=1Ĥ (Y (v) ) = 9.09 to achieve a total of 9.144 · 10 6 bits for the entire dataset. Table I summarizes the results we achieve for different block sizes B. We see that the lowest compression size is achieved over B = 2, i.e. two blocks. The reason is that for a fixed n, the redundancy is approximately exponential in the size of the block b. This means the redundancy drops exponentially with the number of blocks while the minimum of B v=1Ĥ (Y (v) ) keeps increasing. In other words, in this example we earn a great redundancy reduction when moving to a two-block representation while not losing too much in terms of the average code-word length we can achieve. We further notice that the optimal iterations number grows with the number of blocks. This results from the cost of describing the optimal transformation for each block, at each iteration, I 0 B · b2 b , which exponentially increase with the block size b. Comparing our results with the three methods described above we are able to reduce the total compression size in 8 · 10 5 bits, compared to the minimum among all our competitors.

B. real-world experiments
We now turn to demonstrate our compression framework on real world data sets. For this purpose we use collections of word frequencies of different natural languages. These word frequency lists are publicly available 1 and describe the frequency each word appears in a language, based on hundreds of millions of words, collected from open source subtitles 2 or based on different dictionaries and glossaries [20]. Since each word frequency list holds several hundreds of thousands of different words, we choose a binary d = 20 bit representation. We sample 10 7 words from each language and examine our suggested framework, compared with the compression schemes mentioned above. The results we achieve are summarized in Table II. Notice the last column provides the percentage of the redundancy we save, which is essentially the most we can hope for (as we cannot go lower than n ·Ĥ(X) bits). As in the previous experiment, our suggested algorithm achieves the lowest compression size applied with two blocks after approximately I 0 = 10 iterations, from the same reasons mentioned above. Compared to the other methods, our suggested framework shows to achieve significantly lower compression sizes for all languages, saving an average of over one million bits per language.

VII. VECTOR QUANTIZATION
Vector quantization refers to a lossy compression setup, in which a high-dimensional vector X ∈ R d is to be represented by a finite number of points. This means that the high dimensional observed samples are clustering into groups, where each group is represented by a representative point. For example, the famous k-means algorithm [21] provides a method to determine the clusters and the representative points (centroids) for an Euclidean loss function. Then, these centroid points that represent the observed samples are compressed in a lossless manner.
As described above, in the lossy encoding setup one is usually interested in minimizing the amount of bits which represent the data for a given a distortion (or equivalently, minimizing the distortion for a given compressed data size). The rate-distortion function defines the lower bound on this objective. In vector quantization, the representation is a deterministic mapping (defined as P (Y |X)) from a source X to its quantized version Y . Therefore we have that H(Y |X) = 0 and the rate distortion is simply  where D(X, Y ) is some distortion measure between X and Y .

A. Entropy Constrained Vector Quantization
The Entropy Constrained Vector Quantization (ECVQ) is an iterative method for clustering the observed samples into centroid points which are later represented by a minimal average codeword length. The ECVQ algorithm aims to find the minimizer of where the minimization is over three terms: the vector quantizer (of X), the entropy encoder (of the quantized version of X) and the reconstruction module of X from its quantized version.
Let us use a similar notation to [22]. Denote the vector quantizer α : x → C as a mapping from an observed sample to a cluster in C , where C is a set of m clusters. Further, let γ : C → c be a mapping from a cluster to a codeword. Therefore, the composition α • γ is the encoder. In the same manner, the decoder is a composition γ −1 • β, where γ −1 is the inverse mapping from a codeword to a cluster and β : C → y is the reconstruction of x from its quantized version. Therefore, the Lagrangian of the optimization problem (25) is The ECVQ objective is to find the coder (α, β, γ) which minimizes this functional. In [22], Chou et al. suggest an iterative descent algorithm similar to the generalized Lloyd algorithm [14]. Their algorithm starts with an arbitrary initial coder. Then, for a fixed γ and β it finds a clustering α(X) as the minimizer of: Notice that for an Euclidean distortion, this problem is simply k-means clustering, with a "bias" of λ |γ (i)| on its objective function.
For a fixed α and β, we notice that each cluster i ∈ C has an induced probability of occurrence p i . Therefore, the entropy encoder γ is designed accordingly, so that |γ(i)| is minimized. The Huffman algorithm could be incorporated into the design algorithm at this stage. However, for simplicity, allow the fiction that codewords can have non-integer lengths, and assign Finally, for a fixed α and γ, the reconstruction module β is For example, for an euclidean distortion measure, β(i)'s are simply the centroids of the clusters i ∈ C .
Notice that the value objective (26), when applying each of the three steps (27-29), is non-increasing. Therefore, as we apply these three steps repeatedly, the ECVQ algorithm is guarenteed to converge to a local minimum. Moreover, notice that for an Euclidean distortion measure, step (27) of the ECVQ algorithm is a variant of the k-means algorithm. However, the k-means algorithms is known to be computationally difficult to execute as the number of observed samples increases. Hence, the ECVQ algorithm is also practically limited to a relatively small number of samples.
As in previous sections, we argue that when the alphabet size is large (corresponds to low distortion), it may be better to encode the source component-wise. This means, we would like to construct a vector quantizer such that the sum marginal entropies of Y is minimal, subject to the same distortion constraint as in (24). Specifically, Notice that for a fixed distortion value, R (D) ≤R (D) as sum of marginal entropies is bounded from below by the joint entropy. However, since encoding a source over a large alphabet may result with a large redundancy (as discussed in previous sections), the average codeword length of the ECVQ (25) is not necessarily lower than our suggested method (and usually even much larger).
Our suggested version of the ECVQ works as follows: we construct α and β in the same manner as ECVQ does, but replace the Huffman encoder (in γ) with our suggested relaxation to the BICA problem (Section IV-B). This means that for a fixed α, β, which induce a random vector over a finite alphabet size (with a finite probability distribution), we seek for a representation which makes its components "as statistically independent as possible". The average codeword lengths are then achieved by arithmetic encoding on each of these components.
This scheme results not only with a different codebook, but also with a different quantizer than the ECVQ. This means that a quantizer which strives to construct a random vector (over a finite alphabet) with the lowest possible average codeword length (subject to a distortion constraint) is different than our quantizer, which seeks for a random vector with a minimal sum of marginal average codeword lengths (subject to the same distortion).
Our suggested scheme proves to converge to a local minimum in the same manner that ECVQ does. That is, for a fixed α, β, our suggested relaxed BICA method finds a binary representation which minimizes the sum of marginal entropies. Therefore, we can always compare the representation it achieves in the current iteration with the representation it found in the previous iteration, and choose the one which minimizes the objective. This leads to a non-increasing objective each time it is applied. Moreover, notice that we do not have to use the complicated relaxed BICA scheme and apply the simpler order permutation (Section IV-C). This would only result with a possible worse encoder but local convergence is still guaranteed.
To illustrate the performance of our suggested method we conduct the following experiment: We draw 1000 independent samples from a six dimensional bivariate Gaussian mixture. We apply both the ECVQ algorithm, and our suggest BICA variation of the ECVQ, on these samples. Figure 4 demonstrates the average codeword length we achieve for different Euclidean (mean square error) distortion levels.
We first notice that both methods performs almost equally well. The reason is that 1000 observations do not necessitate an alphabet size which is greater than m = 1000 to a attain a zero distortion. In this "small alphabet" regime, our suggest approach does not demonstrate its advantage over classical methods, as discussed in previous sections. However, we can still see it performs equally well.
As we try to increase the number of observations (and henceforth the alphabet size) we encounter computational difficulties, which result from repeatedly performing a variant of the k-means algorithm (27). This makes both ECVQ and our suggested method quite difficult to implement over a "large alphabet size" (many observations and low distortion).
However, notice that if Gersho's conjecture [23] is true, and the best space-filling polytope is a lattice, then the optimum d-dimensional ECVQ at high resolution (low distortion) regime takes the form of a lattice [24]. This means that for this setup, γ is simply a lattice quantizer. This idea is described in further detail in the next section.

B. Vector Quantization with Fixed Lattices
As demonstrated in the previous section, applying the ECVQ algorithm to a large number of observations n with a low distortion constraint, is impractical. To overcome this problem we suggest using a predefined quantizer in the form of a lattice. This means that instead of seeking for a quantizer γ that results with a random vector (over a finite alphabet) with a low average codeword length, we use a fixed quantizer, independent of the samples, and construct a codebook accordingly. Therefore, the performance of the codebook strongly depends on the empirical entropy of the quantized samples. Since we are dealing with fixed lattices (vector quantizers), it is very likely that the empirical entropy of the quantized samples would be significantly different (lower) than the true entropy in low distortion regimes (large alphabet size). Therefore, the compressed data would consist of both the compressed samples themselves and a redundancy term, as explained in detail in Section VI.
Here again, we suggest that instead of encoding the quantized samples over a large alphabet size, we should first represent them in an "as statistically independent as possible" manner, and encode each component separately.
To demonstrate this scheme we turn to a classic quantizing problem, of a standard d-dimensional normal distribution. Notice this quantizing problem is very well studied [3] and a lower bound for the average codeword length, for a given distortion value D, is given by In this experiment we draw n samples from a standard d-dimensional multivariate normal distribution. Since the span of the normal distribution is infinite, we use a lattice which is only defined in a finite sphere. This means that each sample which falls outside this sphere is quantized to its nearest quantization point on the surface of the sphere. We define the radius of the sphere to be 5 times the variance of the source (hence r = 5). We first draw n = 10 5 samples from d = 3, 4 and 8 dimensional normal distributions. For d = 3 we use a standard cubic lattice, while for d = 4 we use an hexagonal lattice [24]. For d = 8 we use an 8-dimensional integer lattice [24]. The upper row of Figure 5 demonstrates the results we achieve for the three cases respectively (left to right), where for each setup we compare the empirical joint entropy of the quantized samples (dashed line) with the sum of empirical marginal entropies, following our suggested approach (solid line). We further indicate the rate distortion lower bound (31) for each scenario, calculated according to the true distribution (line with x's). Notice the results are normalized according to the dimension d. As we can see, the sum of empirical marginal entropies is very close to the empirical joint entropy for d = 3, 4. The rate distortion indeed bounds from below both of these curves. For d = 8 the empirical joint entropy is significantly lower than the true entropy (especially in the low distortion regime). This is a results of an alphabet size which is larger than the number of samples n. However, in this case too, the sum of empirical marginal entropies is close to the joint empirical entropy. The behavior described above is maintained as we increase the number of samples to n = 10 6 , as indicated in the lower row of Figure 5. Notice again that the sum of marginal empirical entropies is very close to the joint empirical entropy, especially on the bounds (very high and very low distortion). The reason is that in both of these cases, where the joint probability is either almost uniform (low distortion) or almost degenerate (high distortion), there exists a representation which makes the components statistically independent. In other words, both the uniform and degenerate distributions can be shown to satisfy We further present the total compression size of the quantized samples in this universal setting. Figure 6 shows the amount of bits required for the quantized samples, in addition to the overhead redundancy, for both Huffman coding and our suggested scheme. As before, the rows correspond to n = 10 5 and n = 10 6 respectively, while the columns are d = 3, 4 and 8, from left to right. We first notice that for d = 3, 4 both methods perform almost equally well. However, as d increases, there exists a significant different between the classical coding scheme and our suggested method, for low distortion rate. The reason is that for larger dimensions, and low distortion rate, we need a very large number of quantization points, hence, a large alphabet size. This is exactly the regime where our suggested method demonstrates its enhanced capabilities, compared with standard methods. VIII. CONCLUSIONS In this work we introduce a conceptual framework for large alphabet source coding. We suggest to decompose a large alphabet source into components which are "as statistically independent as possible" and then encode each component separately. This way we overcome the well known difficulties of large alphabet source coding, at the cost of: (i) Redundancy which results from encoding each component separately.
(ii) Computational difficulty of finding a transformation which decomposes the source. We propose two methods which focus on minimizing these costs. The first method is a piece-wise linear relaxation to the BICA (Section IV-B). This method strives to decrease (i) as much as possible, but its computationally complexity is quite involved. Our second method is the order permutation (Section IV-C) which is very simple to implement (hence, focuses on (ii)) but results with a larger redundancy as it is a greedy solution to (7).
We show that while not every source can be efficiently decomposed into independent components, the vast majority of sources do decompose very well (that is, with only a small redundancy term) as the alphabet size increases. More specifically, we show that the average difference between the sum of marginal entropies (after the "simpler" order permutation is applied) and the joint entropy of the source is bounded by a small constant, as m increases. This means that even the order permutation, which is inferior to the relaxed BICA method, is capable of achieving a very low redundancy for many large alphabet sources.
We demonstrate our suggested framework on three major large alphabet compression scenarios, which are the classic lossless source coding problem, universal source coding and vector quantization. We show that in all of these cases, our suggested approach achieves a lower average codeword length than most commonly used methods.
All this together leads us to conclude that decomposing a large alphabet source into " as statistically independent as possible" components, followed by entropy encoding of each components separately, is both theoretically and practically beneficial.