Code rate

Code rateMain

Community hub

Code rate

8 pages, 0 posts

0 subscribers

Recent from talks

Be the first to start a discussion here.

Recent from talks

Be the first to start a discussion here.

Contribute something

About hubMembersContent overviewUpdatesRules

Main reference articles

Code rate

View on Wikipedia

from Wikipedia

This article relies largely or entirely on a single source. Relevant discussion may be found on the talk page. Please help improve this article by introducing citations to additional sources.
Find sources: "Code rate" – news · newspapers · books · scholar · JSTOR (April 2024)

In telecommunication and information theory, the code rate (or information rate^[1]) of a forward error correction code is the proportion of the data-stream that is useful (non-redundant). That is, if the code rate is $k/n$ for every $k$ bits of useful information, the coder generates a total of $n$ bits of data, of which $n-k$ are redundant.

If $R$ is the gross bit rate or data signalling rate (inclusive of redundant error coding), the net bit rate (the useful bit rate exclusive of error correction codes) is $\leq R\cdot k/n$ .

For example: The code rate of a convolutional code will typically be 1⁄2, 2⁄3, 3⁄4, 5⁄6, 7⁄8, etc., corresponding to one redundant bit inserted after every single, second, third, etc., bit. The code rate of the octet oriented Reed Solomon block code denoted RS(204,188) is 188/204, meaning that $204 - 188 = 16$ redundant octets (or bytes) are added to each block of 188 octets of useful information.

A few error correction codes do not have a fixed code rate—rateless erasure codes.

Note that bit/s is a more widespread unit of measurement for the information rate, implying that it is synonymous with net bit rate or useful bit rate exclusive of error-correction codes.

References

[edit]

^ Huffman, W. Cary, and Pless, Vera, Fundamentals of Error-Correcting Codes, Cambridge, 2003.

This computer science article is a stub. You can help Wikipedia by adding missing information.

Revisions and contributors Edit on Wikipedia Read on Wikipedia

View on Grokipedia

from Grokipedia

In coding theory, the code rate is a measure of the efficiency of an error-correcting code, defined as the ratio of the number of information symbols

k

to the total number of symbols

n

in a codeword, denoted

R = k/n

. This parameter represents the fraction of the transmitted data that carries useful information, with the remainder consisting of redundant bits added for error detection and correction.^[1]^[2]^[3] The code rate plays a critical role in balancing data throughput and error resilience in communication systems. A higher code rate implies greater efficiency and higher information density but reduces the redundancy available for correcting errors, making the code more susceptible to noise. Conversely, a lower rate introduces more redundancy, enhancing error-correcting capability at the cost of reduced effective bandwidth. This trade-off is central to the design of practical codes, such as linear block codes and convolutional codes.^[4]^[5] According to Claude Shannon's noisy-channel coding theorem, reliable communication over a noisy channel is achievable with arbitrarily small error probability if the code rate is below the channel's capacity, which depends on the noise characteristics and signal power. This theorem establishes the theoretical limit on achievable rates and has guided the development of modern coding schemes that approach capacity, such as turbo codes and low-density parity-check codes. Code rates are essential in diverse applications, including wireless communications, digital storage devices, and satellite systems, where optimizing rate directly impacts performance and resource utilization.^[6]^[7]

Fundamentals

Definition

In coding theory, the code rate is defined as the proportion of useful information-carrying symbols to the total number of symbols in an encoded message within forward error correction schemes.^[3] This measure, often denoted as

R

, captures the efficiency of data transmission by indicating how much of the encoded output consists of actual information versus added redundancy.^[8] The code rate quantifies the inherent trade-off between transmission efficiency and error resilience: a higher rate implies less redundancy, allowing more information per unit of transmission but offering reduced protection against noise or errors, while a lower rate incorporates more redundant symbols (such as parity bits) to enhance detection and correction capabilities at the cost of bandwidth.^[3] In general terms,

R = \frac{k}{n}

, where

k

represents the dimension or number of information symbols and

n

the total length of the encoded sequence, though this is normalized by the alphabet size in non-binary cases to reflect the logarithmic information content.^[9] The concept of code rate originates in Claude Shannon's 1948 foundational work on information theory, where rate is tied to channel capacity—the maximum reliable transmission rate—and demonstrates that codes operating below this capacity can achieve arbitrarily low error probabilities through appropriate redundancy.^[10]

Notation

In coding theory, the code rate is standardly denoted by the symbol

R

, representing the ratio of information-bearing content to the total encoded output.^[11] For block codes, the primary notation employs

k

to indicate the number of information symbols or bits and

n

for the total length of the codeword in symbols or bits, yielding the formula

R = \frac{k}{n}.

This convention is widely adopted for linear block codes, where

k

corresponds to the dimension of the code subspace over the finite field.^[12]^[13] In general non-linear block codes, an equivalent expression uses

M

for the number of codewords and

q

for the alphabet size, giving

R = \frac{\log_q M}{n}

, which simplifies to

\frac{k}{n}

for linear codes since

M = q^k

.^[13] Variations in notation appear across contexts; for instance,

m

is occasionally substituted for

k

to denote the message length, particularly in early or applied descriptions of encoding processes.^[12] For convolutional codes, the notation parallels block codes with

k

input bits and

n

output bits per encoding step, maintaining

R = \frac{k}{n}

; alternatively, some treatments use

b

for the number of input bits and

v

for output bits to emphasize the per-step ratio

R = \frac{b}{v}

.^[14] The terminology distinguishes the code rate

R

from the broader information rate, though the terms are often used interchangeably to describe the efficiency of data preservation in the encoded stream as a proportion of non-redundant content.^[11] This rate is conventionally expressed as a fraction (e.g.,

\frac{1}{2}

) or decimal equivalent (e.g., 0.5) for clarity in analysis and design.^[12] The code rate is inherently dimensionless as a pure ratio, but its interpretation varies by symbol alphabet: in binary codes (

q = 2

), it directly measures bits per bit, while for q-ary codes (

q > 2

), it quantifies symbols per symbol, with the bit-level information rate scaling as

R \log_2 q

bits per channel use.^[13]

Code Rate in Code Types

Block Codes

Block codes are a class of error-correcting codes characterized by fixed-length codewords, where each block consists of

k

information symbols that are encoded into a total of

n

symbols, with

n > k

.^[15] This structure ensures that the encoding process operates on discrete blocks of data, introducing redundancy through the addition of

n - k

parity or check symbols to enable error detection and correction.^[16] The code rate

R

for a block code is precisely defined as the ratio of the number of information symbols to the total number of symbols in the codeword, given by

R = \frac{k}{n},

where

k

represents the dimension of the code (the number of independent information symbols) and

n

is the block length (the length of each codeword).^[17] This rate quantifies the efficiency of the encoding, indicating the proportion of the transmitted symbols that carry actual information versus redundancy.^[18] A representative example is the (7,4) Hamming code, a binary linear block code that encodes 4 information bits into 7-bit codewords, yielding a rate of

R = \frac{4}{7} \approx 0.571

.^[19] Here, the redundancy consists of

n - k = 3

parity bits, which allow the code to correct single-bit errors but inherently reduce the rate compared to uncoded transmission.^[20] In block codes, the rate decreases as more parity symbols are incorporated to enhance error-correcting capability, since increasing

n - k

while holding

k

fixed lowers the

k/n

ratio.^[3] For linear block codes, which form a subspace of the vector space over a finite field, this rate formula remains invariant, as the linearity preserves the dimensional structure where

k

is the dimension of the code subspace.^[21]

Convolutional Codes

Convolutional codes are a class of error-correcting codes generated using a linear shift register that processes an input sequence to produce a continuous output stream, where each output symbol depends on the current input bit and a finite number of previous input bits stored in the register's memory.^[22] The encoder typically operates by sliding a window over the input bits, computing parity checks via modulo-2 addition of selected bits within the window, resulting in an interleaved stream of information and parity bits that contrasts with the fixed-block processing of block codes.^[22] This structure allows for streaming encoding and decoding, making convolutional codes suitable for real-time applications in noisy channels.^[23] The code rate

R

for convolutional codes is defined as

R = \frac{b}{v}

, where

b

represents the number of input bits processed per time unit (or branch), and

v

denotes the number of output bits generated per time unit.^[22] For instance, a rate-1/2 convolutional code processes one input bit to produce two output bits, one of which carries the input information while the other serves as a parity bit.^[22] This rate measures the efficiency of information transmission relative to the total output, with lower rates providing greater redundancy for error correction at the cost of bandwidth.^[24] The constraint length

K

, which equals the number of shift register stages plus one, determines the memory span influencing each output symbol but does not alter the nominal code rate

R = \frac{b}{v}

.^[22] A larger

K

incorporates more previous bits into parity computations, increasing the minimum distance between codewords and thereby enhancing error-detection and correction capabilities, which improves the effective rate by reducing the impact of errors on throughput.^[22] However, this comes at the expense of higher decoding complexity, as the number of possible states grows exponentially with

K

.^[23] A prominent example is the NASA standard (2,1,7) convolutional code with rate

R = \frac{1}{2}

and constraint length

K = 7

, widely adopted in deep space communications such as the Voyager missions for its balance of performance and implementability.^[25] In this code, the encoder uses two generator polynomials to produce parity bits:

g_1(D) = 1 + D^2 + D^3 + D^5 + D^6

(octal 171) for the first output stream and

g_2(D) = 1 + D + D^3 + D^5 + D^6

(octal 133, with symbol inversion on this path) for the second, where the outputs are the modulo-2 convolution of the input sequence with these polynomials.^[26] This configuration yields two output bits per input bit, providing robust error correction over long-distance links with high noise levels.^[26]

Significance

Relation to Error Correction

The code rate

R = k/n

in an error-correcting code represents the ratio of information bits

k

to the total number of codeword bits

n

, where a lower rate introduces more redundancy to enhance error correction capabilities. This redundancy directly impacts the minimum Hamming distance

d

, the smallest number of positions in which any two distinct codewords differ, as greater redundancy allows for a larger

d

, enabling the code to tolerate more errors. Specifically, the Singleton bound establishes that

d \leq n - k + 1

, which rearranges to

R = k/n \leq 1 - (d-1)/n

, demonstrating that achieving a higher

d

necessitates a lower rate by allocating more bits to parity or check information. The error correction capacity of a code is quantified by the maximum number of errors

t

it can reliably correct, given by

t = \lfloor (d-1)/2 \rfloor

, ensuring that spheres of radius

t

around codewords do not overlap. A lower code rate facilitates a larger

d

, thereby increasing

t

and improving the code's ability to correct errors in noisy channels, as the added redundancy provides more degrees of freedom to distinguish erroneous received words from valid codewords. This relationship holds across linear and nonlinear codes, with the floor function accounting for the integer nature of error counts.^[27] In practice, high-rate codes approaching

R \approx 1

offer limited error detection and virtually no reliable correction, as their small

d

(often

d=1

2

) allows only detection of few errors without the capability to identify the correct codeword. Conversely, low-rate codes, such as those with

R = 1/3

, incorporate substantial redundancy to achieve larger

d

, enabling correction of multiple errors per block, though at the cost of reduced data throughput. For instance, the repetition code, which encodes each information bit

n

times to form a codeword of length

n

and rate

R = 1/n

, has

d = n

and corrects up to

t = \lfloor (n-1)/2 \rfloor

errors via majority decoding, illustrating extreme redundancy for robust correction but with very low efficiency unsuitable for high-data-rate applications.^[27]/06%3A_Information_Communication/6.25%3A_Repetition_Codes)

Theoretical Bounds

The theoretical bounds on code rates establish fundamental limits on the efficiency of error-correcting codes in reliable communication over noisy channels. Central to these limits is Shannon's noisy-channel coding theorem, which asserts that for a discrete memoryless channel with capacity

C

, reliable communication is possible if and only if the code rate

R

satisfies

R < C

, measured in bits per channel use.^[10] This capacity

C

represents the supremum of rates at which information can be transmitted with arbitrarily low error probability as the block length

n

approaches infinity. For the binary symmetric channel (BSC) with crossover probability

p

, the capacity is given by

C = 1 - H_2(p)

, where

H_2(p) = -p \log_2 p - (1-p) \log_2 (1-p)

is the binary entropy function.^[10] The implications of this theorem for code rates are profound: if

R > C

, the probability of decoding error tends to 1 as

n \to \infty

, rendering reliable communication impossible regardless of the coding scheme. Conversely, for any

R < C

, there exist codes achieving error probability approaching 0 for sufficiently large

n

, enabling near-error-free transmission at rates up to but not exceeding the capacity.^[10] These achievability and converse results highlight the channel capacity as the ultimate upper bound on code rates, independent of specific code structures. For finite-length block codes capable of correcting up to

t

errors, the Hamming bound (also known as the sphere-packing bound) provides a non-asymptotic upper limit on the achievable rate. For a

q

-ary block code of length

n

that corrects

t

errors, the rate

R = k/n

satisfies

R \leq 1 - \frac{\log_q |B_q(n, t)|}{n},

where

k

is the dimension, and

|B_q(n, t)|

is the volume of a Hamming ball of radius

t

q

-ary space of length

n

, given by

|B_q(n, t)| = \sum_{i=0}^t \binom{n}{i} (q-1)^i.

This bound arises from the requirement that disjoint spheres of radius

t

around codewords must pack into the entire space without overlap, limiting the number of codewords

q^k

to at most

q^n / |B_q(n, t)|

.^[28] Codes achieving equality in this bound are termed perfect, such as the Hamming codes for

t=1

. In the asymptotic regime as

n \to \infty

, modern codes can approach the Shannon capacity closely. Turbo codes, introduced by Berrou, Glavieux, and Thitimajshima, achieve rates within 0.5 dB of capacity on the AWGN channel for moderate block lengths using iterative decoding.^[29] Similarly, low-density parity-check (LDPC) codes, originally proposed by Gallager, perform within 0.0045 dB of capacity on the binary erasure channel and near the Shannon limit on other channels with belief propagation decoding, demonstrating that rates arbitrarily close to

C

are attainable for large

n

.^[30]

Applications and Techniques

Digital Communications

In digital communications, the code rate plays a crucial role in channel coding schemes that integrate with modulation techniques to enable reliable data transmission over noisy channels. By determining the ratio of information bits to total encoded bits, the code rate influences the trade-off between error resilience and spectral efficiency, allowing systems to adapt to fluctuating channel conditions such as fading or interference. For example, in 5G New Radio (NR), polar codes with low code rates around 1/3 are employed for control channels like the Physical Downlink Control Channel (PDCCH) to provide robust protection for short payloads and critical signaling, ensuring low latency and high reliability in varying environments.^[31] Standards in wireless and satellite communications exemplify the practical application of code rates. In Wi-Fi systems under IEEE 802.11n, convolutional codes and Low-Density Parity-Check (LDPC) codes support rates ranging from 1/2 to 5/6, combined with modulation schemes like 64-QAM, to optimize throughput in high-data-rate scenarios such as video streaming. Similarly, the DVB-S2 standard for satellite broadcasting uses LDPC codes with adaptive rates up to 9/10, paired with modulations from QPSK to 32-APSK, to maximize link capacity while accommodating diverse propagation conditions.^[32] Adaptive coding and modulation (ACM) techniques dynamically adjust the code rate based on signal-to-noise ratio (SNR) measurements to maintain target bit error rates (BER), typically below

10^{-5}

. In good channel conditions (high SNR), higher code rates are selected to boost efficiency, whereas low rates enhance error correction in poor conditions (low SNR), as implemented in DVB-S2's ACM mode where the return link feedback enables per-user rate optimization. This approach ensures consistent performance across heterogeneous networks, such as satellite links affected by weather.^[32]^[33] The impact of code rate on system throughput is quantified by the effective data rate formula:

\text{Effective data rate} = R \times f_s \times \log_2 M

where

R

is the code rate,

f_s

is the symbol rate, and

M

is the constellation size (e.g., 16 for 16-QAM). This relationship highlights how lower code rates, while improving reliability, reduce overall throughput unless compensated by higher-order modulation or increased symbol rates, a principle central to standards like 5G NR and IEEE 802.11n.

Rate Adjustment Methods

Puncturing is a technique used to increase the code rate of a convolutional code by selectively deleting certain parity bits from the output of a lower-rate mother code, thereby reducing redundancy without altering the encoder structure. For instance, a rate-1/3 convolutional code can be punctured by removing one of the three output streams, resulting in an effective rate of 2/3. This method preserves the systematic nature of the code and allows for flexible rate adaptation in systems requiring variable throughput. Repetition coding decreases the effective code rate by appending multiple copies of the encoded symbols, enhancing error resilience in noisy environments at the cost of increased bandwidth. A rate-1/2 code, for example, can be repeated twice to achieve an effective rate of 1/4, which is particularly useful for channels with high error rates where additional redundancy is beneficial. This approach is straightforward to implement and compatible with existing decoders that treat repetitions as additional parity information. (Note: Lin and Costello, "Error Control Coding: Fundamentals and Applications", but URL to publisher; alternatively, use IEEE paper if needed, but this is standard text.) Rate-compatible punctured convolutional (RCPC) codes form a family derived from a single low-rate mother code by applying varying degrees of puncturing, ensuring that higher-rate codes are subsets of lower-rate ones to enable incremental redundancy transmission. These codes maintain the same minimum free distance across rates, facilitating seamless transitions between rates such as from 1/2 to 8/9 without performance degradation in hybrid ARQ schemes. Introduced by Hagenauer, RCPC codes are widely adopted for their compatibility and decoding efficiency using the Viterbi algorithm.^[34] Hybrid methods often integrate puncturing with interleaving to adjust rates dynamically while mitigating burst errors, as seen in the Universal Mobile Telecommunications System (UMTS) where rate matching employs puncturing for high-rate voice and data traffic to align the coded bit rate with channel capacity. In UMTS, the process combines convolutional or turbo encoding with puncturing patterns specified in 3GPP standards, allowing adaptation for multiplexed transport channels without redesigning the core code. This combination ensures robust performance in varying mobile conditions by spreading punctured bits across interleaved blocks.^[35]

Info Pages

Talk Pages

Special Pages

Code rate

Recent from talks

Recent from talks

Contribute something

Contribute something

Media Pages

Timelines

Articles

Notes collections

Notes

Notes

Days in Chronicle

Code rate

See also

References

Code rate

Fundamentals

Definition

Notation

Code Rate in Code Types

Block Codes

Convolutional Codes

Significance

Relation to Error Correction

Theoretical Bounds

Applications and Techniques

Digital Communications

Rate Adjustment Methods

References

Add your contribution

Related Hubs

Contribute something

History

Media collections

Code rate

Recent from talks

Recent from talks

Contribute something

Contribute something

Media Pages

Timelines

Articles

Notes collections

Notes

Notes

Days in Chronicle

Code rate

See also

References

Code rate

Fundamentals

Definition

Notation

Code Rate in Code Types

Block Codes

Convolutional Codes

Significance

Relation to Error Correction

Theoretical Bounds

Applications and Techniques

Digital Communications

Rate Adjustment Methods

References

Add your contribution

Related Hubs

Contribute something