Hubbry Logo
Shannon codingShannon codingMain
Open search
Shannon coding
Community hub
Shannon coding
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Shannon coding
Shannon coding
Shannon coding
View on Wikipedia
from Wikipedia

In the field of data compression, Shannon coding, named after its creator, Claude Shannon, is a lossless data compression technique for constructing a prefix code based on a set of symbols and their probabilities (estimated or measured). It is suboptimal in the sense that it does not achieve the lowest possible expected code word length like Huffman coding does, and never better than but sometimes equal to the Shannon–Fano coding (Fano's method).

The method was the first of its type, the technique was used to prove Shannon's noiseless coding theorem in his 1948 article "A Mathematical Theory of Communication",[1] and is therefore a centerpiece of the information age.

Shannon–Fano coding methods gave rise to the field of information theory and without its contributions, the world would not have any of the many successors; for example Huffman coding, or arithmetic coding. Much of our day-to-day lives are significantly influenced by digital data and this would not be possible without Shannon-Fano coding and the ongoing evolution of its methods.[2][page needed]

In Shannon coding, the symbols are arranged in order from most probable to least probable, and assigned codewords by taking the first bits from the binary expansions of the cumulative probabilities Here denotes the ceiling function (which rounds up to the next integer value).

Example

[edit]

In the table below is an example of creating a code scheme for symbols a1 to a6. The value of li gives the number of bits used to represent the symbol ai. The last column is the bit code of each symbol.

i pi li Previous value in binary Codeword for ai
1 0.36 2 0.0 0.0000 00
2 0.18 3 0.36 0.0101... 010
3 0.18 3 0.54 0.1000... 100
4 0.12 4 0.72 0.1011... 1011
5 0.09 4 0.84 0.1101... 1101
6 0.07 4 0.93 0.1110... 1110

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Shannon coding

View on Grokipedia
from Grokipedia
Shannon coding is a foundational technique in for constructing prefix-free variable-length codes used in lossless data compression, where the codeword length assigned to each symbol is the ceiling of the negative base-2 logarithm of its probability of occurrence, ensuring that the expected code length is at most one bit greater than the source's . Developed as a practical instantiation of principles from Claude Shannon's 1948 noiseless source coding theorem, which establishes that data from a discrete memoryless source can be compressed to its without loss, Shannon coding provides a straightforward way to approximate optimal encoding by directly deriving code lengths from symbol probabilities rather than building complex trees. In this method, symbols are ordered by decreasing probability, and binary codewords are assigned using the cumulative : for a symbol with probability pip_i, the code begins with the binary representation of the interval [S,S+pi)[S, S + p_i), where S=∑j<ipjS = \sum_{j<i} p_j, truncated to the length ⌈−log⁡2pi⌉\lceil -\log_2 p_i \rceil, guaranteeing the prefix-free property via the Kraft inequality. This approach yields codes that are uniquely decodable without delimiters, making it suitable for streaming or concatenated data, though it is generally suboptimal compared to , which achieves expected lengths closer to the entropy bound by optimizing the tree structure. For instance, in a binary source with probabilities 0.99 and 0.01, Shannon coding assigns lengths 1 and 7, resulting in an expected length of 1.06 bits, versus the entropy of approximately 0.08 bits, demonstrating its efficiency within the H≤L<H+1H \leq L < H + 1 bound. Despite its simplicity, Shannon coding has influenced extensions like dynamic and arithmetic coding, and remains a benchmark for understanding the trade-offs in entropy coding algorithms.

Background

Prefix Codes

A prefix code, also known as a prefix-free code, is a variable-length coding scheme in which no codeword serves as a prefix of any other codeword. This structural property guarantees unique decodability, allowing a receiver to unambiguously reconstruct the original sequence of symbols from the concatenated codewords without requiring explicit delimiters or additional metadata. The notion of prefix codes emerged in the context of efficient data representation for communication systems, as introduced by in his seminal 1948 paper "A Mathematical Theory of Communication." In this work, Shannon illustrated coding examples that satisfy the prefix condition to enable reliable message recovery, laying the groundwork for modern source coding techniques. A fundamental bound on the lengths of codewords in a prefix code is provided by the Kraft inequality. For a code over an alphabet of size DD with codeword lengths l1,l2,…,lml_1, l_2, \dots, l_m, the inequality asserts that ∑i=1mD−li≤1.\sum_{i=1}^m D^{-l_i} \leq 1. This condition is both necessary and sufficient for the existence of a prefix code with those lengths; it limits how short the codewords can be collectively, preventing overlaps that would violate the prefix property. Prefix codes enable instantaneous decoding, where each codeword can be recognized and decoded immediately upon receipt, without lookahead into subsequent bits. This efficiency arises from their tree-based representation: codewords correspond to paths from the root to leaves in a DD-ary tree, with the prefix condition ensuring that no codeword path passes through another codeword's leaf. In the binary case (D=2D=2), this manifests as a binary tree structure.

Source Coding Theorem

The source coding theorem, also known as the noiseless coding theorem, applies to a discrete memoryless source, in which symbols are generated independently and identically distributed according to a known probability distribution. The entropy H(X)H(X) of such a source quantifies the fundamental limit on lossless compression and is defined as H(X)=−∑ipilog⁡2pi,H(X) = -\sum_i p_i \log_2 p_i, where pip_i is the probability of the ii-th symbol. This quantity represents the average amount of uncertainty or information per source symbol, measured in bits, and serves as the theoretical minimum average code length required for unique decodability. The theorem states that for this source, there exists a prefix code with average codeword length LL satisfying H(X)≤L<H(X)+1H(X) \leq L < H(X) + 1 bits per symbol. The lower bound establishes the necessity: no uniquely decodable code can achieve an average length below the entropy, as proved using the Kraft inequality, which bounds the total code space based on codeword lengths and source probabilities. The upper bound demonstrates sufficiency: a code can be constructed to approach within 1 bit of the entropy, with the proof relying on assigning code lengths proportional to −log⁡2pi-\log_2 p_i and leveraging the asymptotic equipartition property for block coding, though for single symbols, methods like achieve the bound directly when probabilities are dyadic (i.e., of the form k/2mk/2^m), allowing exact attainment of H(X)H(X). These results imply that variable-length prefix codes, such as , can efficiently approximate the entropy bound, enabling near-optimal compression for sources with known statistics, particularly when probabilities align with binary fractions to minimize redundancy.

Formal Definition

Code Construction

can be applied to any discrete probability distribution by assigning code lengths li=⌈−log⁡2pi⌉l_i = \lceil -\log_2 p_i \rceil. When probabilities are dyadic, meaning each pi=2−kip_i = 2^{-k_i} for some integer ki≥1k_i \geq 1, the code achieves the entropy bound exactly, as the code lengths match the negative log-probabilities precisely. For non-dyadic probabilities, the ceiling function approximates the ideal lengths, ensuring the expected code length satisfies H≤L<H+1H \leq L < H + 1, though grouping less probable symbols into blocks can further approach optimality. The construction algorithm proceeds as follows. First, compute the code length li=⌈−log⁡2pi⌉l_i = \lceil -\log_2 p_i \rceil for each symbol ii. Second, sort the symbols in decreasing order of probability. Then, assign codewords using the cumulative probability distribution: for the ii-th symbol, let S=∑j<ipjS = \sum_{j < i} p_j, and form the codeword as the first lil_i bits of the binary expansion of a number in the half-open interval [S,S+pi)[S, S + p_i). This ensures distinct prefix-free codewords, with higher-probability symbols receiving shorter codes. In terms of binary tree interpretation, each codeword corresponds to a unique path from the root to a leaf at depth lil_i, where left branches are labeled 0 and right branches are labeled 1. The ordering by decreasing probability fills the tree from left to right, placing more probable symbols at shallower depths and ensuring no leaf is an internal node. The design inherently guarantees the prefix property via the Kraft inequality, as the lengths satisfy ∑2−li≤1\sum 2^{-l_i} \leq 1, preventing any codeword from being a prefix of another. This feature allows for instantaneous decodability during reception. This method of code construction aligns with the Source Coding Theorem by assigning lengths approximately equal to the self-information −log⁡2pi-\log_2 p_i, thereby approaching the entropy limit.

Length and Probability Assignment

In Shannon coding, the codeword length lil_i for each symbol ii with probability pip_i is assigned as li=⌈−log⁡2pi⌉l_i = \lceil -\log_2 p_i \rceil, which ensures that li−1<−log⁡2pi≤lil_i - 1 < -\log_2 p_i \leq l_i. This assignment approximates the ideal length −log⁡2pi-\log_2 p_i by rounding up to the nearest integer, guaranteeing that the resulting lengths satisfy the Kraft inequality for prefix codes while minimizing inefficiency relative to the source entropy. The average codeword length LL is then given by L=∑ipiliL = \sum_i p_i l_i. For any discrete memoryless source, this satisfies H(X)≤L<H(X)+1H(X) \leq L < H(X) + 1, where H(X)=−∑ipilog⁡2piH(X) = -\sum_i p_i \log_2 p_i is the entropy of the source. This bound demonstrates that Shannon coding achieves near-optimality, with the average length deviating from the entropy by less than 1 bit per symbol. When the source probabilities are dyadic, meaning each pi=2−kip_i = 2^{-k_i} for some integer kik_i, the assigned lengths yield exact optimality such that L=H(X)L = H(X). In non-dyadic cases, however, the ceiling operation introduces redundancy, causing LL to exceed H(X)H(X) by up to but less than 1 bit. The redundancy of the code is quantified as L−H(X)<1L - H(X) < 1, with the exact value in dyadic scenarios being zero due to the precise match between probabilities and lengths. For general distributions, this redundancy arises solely from the integer constraint on lengths and can be expressed as ∑ipi(li+log⁡2pi)\sum_i p_i (l_i + \log_2 p_i), highlighting the approximation's impact on efficiency.

Properties

Instantaneous Decodability

Shannon codes are prefix codes, meaning no codeword is a prefix of another. This property is guaranteed because the assigned code lengths li=⌈−log⁡2pi⌉l_i = \lceil -\log_2 p_i \rceil satisfy the Kraft inequality ∑i2−li≤1\sum_i 2^{-l_i} \leq 1, allowing the construction of a prefix-free set of codewords using the cumulative probability intervals. The prefix-free property implies instantaneous decodability: the receiver can decode each symbol as soon as its complete codeword is received, without needing additional bits or lookahead. Decoding proceeds by reading bits from the stream and checking against the codeword set (e.g., via a binary tree or trie) until a full codeword matches, then outputting the corresponding symbol and continuing with the next bit. This enables efficient, real-time processing without buffering the entire message. This decodability corresponds to a binary tree where each codeword defines a unique path to a leaf labeled with the symbol, and no leaf lies on the path to another leaf, ensuring unambiguous resolution upon reaching a leaf. The prefix-free condition also provides inherent error detection: if the received bit sequence does not match any valid codeword path, it indicates a transmission error, though do not include formal error correction mechanisms.

Optimality Bounds

Shannon codes achieve the entropy bound precisely when the source probabilities pip_i are dyadic, i.e., each pi=k/2mp_i = k / 2^m for integers kk and mm, ensuring that the ideal code lengths −log⁡2pi-\log_2 p_i are integers. In such cases, the average code length LL equals the entropy H(X)H(X), making the code optimal among all uniquely decodable codes for binary alphabets. For arbitrary probability distributions, Shannon codes assign lengths li=⌈−log⁡2pi⌉l_i = \lceil -\log_2 p_i \rceil, resulting in an average length satisfying H(X)≤L<H(X)+1H(X) \leq L < H(X) + 1. This matches the upper bound established by the source coding theorem for the minimal achievable average length of binary prefix codes. Consequently, Shannon codes are optimal among prefix codes for dyadic sources, as they coincide with under these conditions, but become suboptimal for non-dyadic probabilities due to the ceiling operation, which introduces unavoidable redundancy from rounding up non-integer lengths. The redundancy R=L−H(X)R = L - H(X) for Shannon codes satisfies 0≤R<10 \leq R < 1, quantifying the inefficiency relative to the entropy lower bound. This redundancy is particularly pronounced in cases of uniform distributions over non-power-of-two symbol sets, where all code lengths are equal and exceed the ideal log⁡2n\log_2 n by up to nearly 1 bit, or in highly non-dyadic distributions where many probabilities have fractional −log⁡2pi-\log_2 p_i close to 1, maximizing the cumulative rounding loss. Extensions of Shannon codes to non-binary alphabets involve generalizing the length assignment to li=⌈−log⁡Dpi⌉l_i = \lceil -\log_D p_i \rceil for size D>2D > 2, preserving similar optimality properties for dyadic-like distributions in base DD.

Examples

Basic Encoding Example

To illustrate the basic encoding process in Shannon coding, consider a source with symbols A, B, and C having dyadic probabilities p(A)=12p(A) = \frac{1}{2}, p(B)=14p(B) = \frac{1}{4}, and p(C)=14p(C) = \frac{1}{4}. These probabilities, being exact negative powers of 2, enable a code where the expected length equals the H(X)=1.5H(X) = 1.5 bits per symbol. The code lengths follow from the general construction, with ki=⌈−log⁡2pi⌉k_i = \lceil -\log_2 p_i \rceil, giving kA=1k_A = 1, kB=2k_B = 2, and kC=2k_C = 2. Codewords are assigned using cumulative probabilities cA=0c_A = 0, cB=0.5c_B = 0.5, and cC=0.75c_C = 0.75, taking the first kik_i binary digits of each cic_i's fractional expansion: A maps to 0 (from 0.000...), B to 10 (from 0.1000...), and C to 11 (from 0.11000...). This yields the {0, 10, 11}. To encode a sample message such as "ABAC", substitute and concatenate the codewords:
  • A → 0
  • B → 10
  • A → 0
  • C → 11
The resulting is 010011. The average code length is L=12⋅1+14⋅2+14⋅2=1.5L = \frac{1}{2} \cdot 1 + \frac{1}{4} \cdot 2 + \frac{1}{4} \cdot 2 = 1.5 bits per symbol.

Decoding Process

The decoding process in Shannon coding leverages the prefix-free property of the codewords, allowing symbols to be identified uniquely and instantaneously upon receipt of the complete codeword, without requiring examination of future bits beyond the current match. This ensures efficient, real-time reconstruction of the original from the encoded . Decoding proceeds by sequentially reading bits from the and matching them to known codewords from the . For the basic example with code {0: A, 10: B, 11: C}, consider the 010011 from encoding "ABAC". The process unfolds step by step: the initial 0 matches A; the following 10 matches B; the next 0 matches A; and the remaining 11 matches C, yielding the decoded sequence A, B, A, C. The prefix-free nature prevents ambiguity, enabling the decoder to resolve each immediately after a match without buffering or look-ahead, which is a key advantage for streaming or low-latency applications. Edge cases include an invalid sequence that does not match any codeword prefix, which cannot map to a and triggers a decoding error. Similarly, a truncated that ends mid-codeword results in an incomplete , necessitating error detection and handling, such as retransmission requests or fallback to default values in robust systems.

Comparisons

With Huffman Coding

Huffman coding constructs optimal prefix codes through a bottom-up that builds a by repeatedly merging the two nodes with the lowest probabilities until a single root is formed, assigning codewords based on the path from the root to each . This method achieves an expected codeword length LL satisfying H(X)≤L<H(X)+1H(X) \leq L < H(X) + 1 bits for any over a finite . In contrast to Shannon coding, which assigns code lengths via the fixed formula li=⌈−log⁡2pi⌉l_i = \lceil -\log_2 p_i \rceil and constructs prefix-free codewords by ordering symbols and allocating the shortest available codes of those lengths without building an explicit tree, Huffman coding requires iterative merging that scales as O(nlog⁡n)O(n \log n) time complexity using a priority queue, where nn is the alphabet size. Shannon coding is simpler and faster to compute directly from probabilities but is optimal only when probabilities are dyadic (i.e., expressible as fractions with denominator a power of 2), as non-dyadic cases lead to inefficient length assignments that may violate tight prefix constraints. Huffman coding, however, guarantees optimality among all prefix codes for arbitrary probabilities, though at higher computational cost. When probabilities are dyadic, both methods yield identical optimal codes; for example, consider symbols A, B, C with probabilities pA=1/2p_A = 1/2, pB=1/4p_B = 1/4, pC=1/4p_C = 1/4. Shannon coding assigns lengths 1, 2, 2 and codes 0 to A, 10 to B, 11 to C, achieving L=1.5=H(X)L = 1.5 = H(X). The Huffman algorithm produces the same tree and codes: A: 0, B: 10, C: 11. For non-dyadic distributions, such as a uniform distribution over three symbols (p=1/3p = 1/3 each, H(X)≈1.585H(X) \approx 1.585), Shannon coding assigns length 2 to all, yielding L=2L = 2, while Huffman coding assigns lengths 1, 2, 2 for L≈1.667L \approx 1.667, closer to the entropy bound.

With Arithmetic Coding

Arithmetic coding represents a message as a single fractional number within the interval [0, 1), constructed by iteratively narrowing subintervals based on the cumulative probabilities of successive symbols. This approach encodes the entire sequence into a code whose length closely approximates the joint entropy H(X)H(X) of the message, without the restriction of assigning integer numbers of bits to individual symbols. Developed from concepts introduced by Peter Elias in the 1960s and practically realized by Rissanen and Langdon in 1979, it achieves near-optimal compression by leveraging the full precision of probability distributions. In contrast to Shannon coding, which constructs prefix-free codewords for symbols using integer lengths li=⌈−log⁡2pi⌉l_i = \lceil -\log_2 p_i \rceil, resulting in an average code length bounded by H(X)≤L<H(X)+1H(X) \leq L < H(X) + 1 bit per symbol and potential up to nearly 1 bit per symbol, arithmetic coding avoids such per-symbol integer constraints. Instead, it allocates bits fractionally across the message, though it requires additional bits (typically 1–2) at the end to indicate termination and resolve the final interval, ensuring unambiguous decoding. This eliminates the prefix-free requirement but introduces the need for precise interval tracking during encoding and decoding. For long messages, arithmetic coding demonstrates superior efficiency, approaching the entropy limit with total redundancy bounded by a small constant independent of message length, whereas Shannon coding's cumulative redundancy can grow linearly with the number of symbols. Shannon coding remains simpler and preferable for short messages or cases with dyadic probabilities (where pi=2−kp_i = 2^{-k}), as it avoids the overhead of managing non-integer representations. The primary trade-off lies in : arithmetic coding demands with high-precision fractions or scaled integers to prevent numerical errors, making it more resource-intensive than the straightforward binary tree traversal or direct length assignment in Shannon coding. Despite this, modern implementations mitigate the overhead through finite-precision approximations, balancing efficiency gains with practical performance.

Applications

Data Compression

Shannon coding plays a pivotal role in early lossless data compression techniques, serving as the theoretical foundation for optimal prefix codes when symbol probabilities are dyadic (powers of 1/2). Developed as part of Claude Shannon's 1948 framework for source coding, it directly inspired Robert Fano's 1949 implementation of Shannon-Fano coding, which adapted the concept into a practical for assigning variable-length codes via of probability masses. This variant marked one of the first systematic methods for encoding in applications. In practical applications, Shannon coding excels for sources with dyadic probabilities, such as those arising from geometric distributions in of —common in simple text files or bitmap images where runs of identical symbols follow a memoryless with yielding dyadic likelihoods (e.g., fair-coin flips producing run probabilities of (1/2)^{k+1} for length k). For instance, compressing sequences of repeated zeros or ones in low- binary images benefits from its exact achievement of the entropy bound without excess bits. Such scenarios occur in early or textual data with predictable repetition patterns, enabling efficient storage reductions. Implementations typically involve straightforward software encoders for educational demonstrations or resource-constrained systems, where codewords are generated by appending 1 to the binary representation of the cumulative probability interval—a that requires minimal beyond probability estimation. These can integrate with adaptive estimators to handle near-dyadic empirical distributions in real-time compression tasks. The construction's simplicity, drawing from direct logarithmic length assignment, facilitates rapid deployment in prototypes. In practice, standalone use of Shannon coding is limited in efficiency for non-dyadic probabilities, where it may incur up to nearly 1 bit per symbol excess over the , and is often outperformed by more flexible algorithms like for arbitrary probabilities. Nonetheless, its historical significance persists through influences on precursors to modern formats, such as the Shannon-Fano variant employed in the IMPLODE compression algorithm of early ZIP archives. Today, Shannon coding is primarily used in educational contexts and simple prototypes, with its principles underlying more advanced methods like in formats such as or H.264.

Channel Coding Contexts

Shannon's foundational 1948 paper introduced the , which defines as the maximum reliable transmission rate over a discrete noisy channel, thereby establishing fundamental bounds for error-correcting codes. This theorem complemented his source coding results, where instantaneous prefix codes—now known as Shannon codes—enable efficient representation with codeword lengths approximately equal to the negative logarithm of symbol probabilities. In practical applications, the prefix property of such codes facilitates synchronization in modulation schemes and basic error-detecting mechanisms, as it allows receivers to parse variable-length symbols without lookahead once alignment is achieved, aiding recovery from minor bit errors or slips in transmission. For instance, in simple forward error correction (FEC) setups, this property enables detection of malformed codewords that violate the prefix condition, enhancing reliability in low-complexity systems without dedicated sync bits. While direct use of Shannon coding is rare in channel coding due to its focus on lossless source compression, prefix-free encoding principles from source coding can precede channel protection in hybrid source-channel systems, supporting efficient decoding in noisy environments. Shannon's overarching capacity theorems have profoundly influenced modern iterative techniques in low-density parity-check (LDPC) and for channel coding, which approach within 0.04–0.7 dB of the limit via decoding on sparse graphs.

References

  1. http://web.stanford.edu/class/ee276/files/previous_notes/lecture_5.pdf
  2. https://crypto.stanford.edu/~blynn/pr/symbol.html
  3. https://people.math.harvard.edu/~ctm/home/text/others/shannon/entropy/entropy.pdf
  4. https://www.inference.org.uk/itprnn/book.pdf
  5. https://arxiv.org/abs/cs/0503085
  6. https://www.princeton.edu/~cuff/ele201/kulkarni_text/information.pdf
  7. http://helmut.knaust.info/class/201810_5311/ShETh.pdf
  8. https://cs.nyu.edu/home/people/in_memoriam/roweis/csc310-2005/notes/lec2x.pdf
  9. https://cs-114.org/wp-content/uploads/2015/01/Elements_of_Information_Theory_Elements.pdf
  10. https://web.stanford.edu/class/ee376a/files/lecture_notes.pdf
  11. https://www2.isye.gatech.edu/~yxie77/ece587/Lecture10.pdf
  12. https://planetcalc.com/8163/
  13. http://www.ee.ic.ac.uk/hp/staff/dmb/courses/infotheory/Info_4.pdf
  14. http://staff.ustc.edu.cn/~cgong821/Wiley.Interscience.Elements.of.Information.Theory.Jul.2006.eBook-DDU.pdf
  15. https://ocw.mit.edu/courses/6-450-principles-of-digital-communications-i-fall-2006/5fd6b5c839a76dd0c52d8480c3dad224_book_2.pdf
  16. https://isl.stanford.edu/~cover/papers/transIT/0172cove.pdf
  17. http://compression.ru/download/articles/huff/huffman_1952_minimum-redundancy-codes.pdf
  18. https://web.stanford.edu/class/ee376a/files/2017-18/lecture_6.pdf
  19. https://www.cs.cmu.edu/~aarti/Class/10704_Spring15/lecs/lec10.pdf
  20. https://dl.acm.org/doi/10.1147/rd.232.0149
  21. https://www.cs.cmu.edu/~aarti/Class/10704/Intro_Arith_coding.pdf
  22. https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/arith.pdf
  23. https://www.cs.cmu.edu/~aarti/Class/10704/lec9-arithmeticcoding.pdf
  24. https://hcs64.com/files/fano-tr65-ocr-only.pdf
  25. https://people.lids.mit.edu/yp/homepage/data/itbook-2022.pdf
  26. https://cs.stanford.edu/people/eroberts/courses/soco/projects/data-compression/lossless/shannonfano/index.htm
  27. http://rcvt.tu-sofia.bg/ICEST2011_2_58.pdf
  28. https://arxiv.org/pdf/cs/0611112
  29. https://ieeexplore.ieee.org/document/116938
Add your contribution
Related Hubs
User Avatar
No comments yet.