🔢 mathematics

Weight distribution bounds to relate minimum distance, list decoding, and symmetric channel performance

This paper extends recent results on the connection between list decoding radius and symmetric channel performance from linear to general codes by directly bounding weight distributions, and further improves bounds on minimum distance versus channel performance for linear codes by leveraging erasure properties and Samorodnitsky's inequalities.

Original authors: Donald Kougang-Yombi, Jan Hązła

Published 2026-04-06

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Donald Kougang-Yombi, Jan Hązła

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are sending a secret message across a noisy radio channel. The message is a long string of letters (a "codeword"). Unfortunately, the radio is full of static, and some letters might get changed or lost entirely. Your goal is to design a system of secret codes that allows the receiver to figure out the original message despite the noise.

This paper is about finding the perfect balance between how much "extra" information you add to your message (to make it robust) and how much noise you can actually tolerate.

The authors, Donald and Jan, are like detectives trying to solve a puzzle: How do the worst-case scenarios (a malicious jammer trying to break your code) relate to the random, everyday noise of a bad radio connection?

Here is the breakdown of their findings using simple analogies.

1. The Three Ways to Measure a Code's Strength

To understand the paper, you need to know three ways we test if a code is "good":

The "Minimum Distance" (The Worst-Case Shield): Imagine your codes are islands in an ocean. The "distance" is how far apart the islands are. If the islands are far apart (large distance), a storm (noise) has to be huge to push a ship from one island to another. This is the worst-case view: "What is the maximum number of errors I can guarantee to fix, no matter how the errors happen?"
List Decoding (The "Maybe" List): Sometimes, the storm is so big that the ship lands on a spot that is equidistant from two islands. You can't be 100% sure which one it is. Instead of giving up, you say, "Okay, it's definitely one of these top 5 islands." This is List Decoding. You accept a small list of possibilities rather than a single answer.
Symmetric Channel Performance (The "Real World" Test): This is the actual radio channel. The noise is random; it doesn't try to trick you maliciously. It just flips bits randomly. We want to know: "If I use this code on a real radio, will the error rate drop to zero as the message gets longer?"

2. The Big Discovery: Connecting the Dots

For a long time, mathematicians knew how to connect the "Worst-Case" (Distance) to "List Decoding." They also knew how to connect "List Decoding" to "Real World Performance" (but only for very specific types of codes).

The authors' first major breakthrough: They proved that List Decoding is the bridge.
If a code is good at making a "short list" of possibilities when the noise is bad, it is automatically good at handling random noise on a real channel. They didn't need complex, high-level math tricks to prove this; they used a clever counting method (like counting how many people are in a room wearing red hats) to show that the "weight distribution" (how the errors are spread out) naturally forces the code to work well on random channels.

The Analogy: Think of a code as a security system.

List Decoding is like a guard who, when a suspicious person enters, doesn't just say "Stop!" but says, "This person looks like one of these 3 suspects."
The authors proved: If your guard is good at making that short list of suspects, your security system will naturally be very effective at stopping random burglars, even if the burglars aren't trying to be clever.

3. Beating the "Johnson Barrier"

There is a famous rule in this field called the Johnson Bound. It's like a speed limit sign. It says: "If your code has a certain distance, you can't reliably decode more than this amount of noise."

For a long time, everyone thought this was the hard limit. You couldn't go faster.

The authors' second major breakthrough: They found a way to break the speed limit for certain codes.
They realized that if a code is not only good at handling random errors but also good at handling erasures (where letters just disappear, like a page getting torn out of a book), you can push the limit higher.

The Metaphor: Imagine you are trying to guess a word.
- Standard Limit (Johnson): You can guess the word if up to 30% of the letters are scrambled.
- The New Trick: The authors say, "What if you are also really good at guessing words when 50% of the letters are missing?"
- By combining the ability to handle "scrambled" letters (errors) and "missing" letters (erasures), they proved that for certain codes (specifically linear codes with alphabet sizes of 4 or more), you can actually handle more scrambled letters than the old Johnson rule said was possible.

4. Why This Matters

This isn't just abstract math. This is about making our digital world more efficient.

Better Data Storage: Hard drives and SSDs use these codes. If we can tolerate more noise, we can store more data in the same space without it getting corrupted.
Faster Internet: 5G and future 6G networks rely on these codes. Understanding the exact limits of how much noise a signal can handle helps engineers design faster, more reliable connections.

Summary in a Nutshell

The Problem: We want to know how much noise a code can handle. We have three ways to measure this: Worst-case distance, List Decoding, and Real-world random noise.
The Connection: The authors proved that if a code is good at making a "short list" of guesses (List Decoding), it is automatically good at handling real-world random noise.
The Upgrade: They found a way to beat the old "speed limit" (Johnson Bound) by combining the code's ability to handle errors with its ability to handle missing data (erasures).
The Result: We now have better formulas to design codes that are more robust and efficient, especially for systems that use larger alphabets (more than just 0s and 1s).

In short, they took a complex map of error-correcting codes and drew a clearer, more direct path between the "worst-case" scenarios and the "real-world" performance, showing us how to push the boundaries of what's possible.

1. Problem Statement

The paper investigates the fundamental relationships between three key properties of error-correcting codes:

Worst-case performance: Characterized by the minimum distance ( $d$ ) and list decoding radius.
Random-noise performance: Characterized by the block error probability on symmetric channels (specifically the $q$ -ary Symmetric Channel, $q$ SC $_p$ ).

The central question addressed is: Given a code family with a specific relative minimum distance $\delta$ , what is the largest crossover probability $p$ such that the code achieves vanishing block error probability on the $q$ SC $_p$ ?

While it is known that random codes achieve the Shannon capacity, and the Johnson bound ( $J_q(\delta)$ ) provides a limit for list decoding, the precise connection between list decoding capability and performance on the symmetric channel for general (non-random) codes, particularly linear codes, has been an area of active research. Previous work by Pernice, Sprumont, and Wootters (PSW) established a tight link for linear codes using "sharp threshold" techniques. This paper aims to extend these results to general codes and improve the bounds for linear codes by utilizing weight distribution properties and erasure channel performance.

2. Methodology

The authors employ a combination of combinatorial counting arguments, information-theoretic bounds, and geometric analysis of Hamming spaces.

Double Counting and Weight Distribution: Instead of relying on sharp threshold techniques used in previous works, the authors derive bounds on the weight distribution ( $A_w$ ) of a code directly. They use a double counting argument on the intersection of Hamming spheres to relate list decodability to the number of codewords at specific distances.
Poltyrev Bound: They utilize the Poltyrev bound for block error probability on the symmetric channel, which expresses the error probability in terms of the sizes of intersections of Hamming balls ( $\mu_q(n, t, w)$ ).
Erasure Channel Connection: A novel aspect of their approach is linking symmetric channel performance to erasure channel performance. They leverage inequalities by Samorodnitsky (and generalizations by AHO) which bound the weight distribution of linear codes based on their performance on the Erasure Channel ( $q$ EC $_\lambda$ ).
Optimization of Entropy Functions: The proofs involve defining and analyzing complex entropy-like functions ( $M^{(q)}$ and $F^{(q)}$ ) that characterize the asymptotic growth rates of Hamming ball intersections. These functions are used to determine thresholds where the error probability vanishes.

3. Key Contributions

A. Extension to General Codes (Theorem 1)

The authors generalize the PSW result to general (non-linear) codes.

Result: If a family of $q$ -ary codes is $(p, L)$ -list decodable and has a minimum distance $d(C_n) = \omega(\log(nL))$ , then the block error probability on the $q$ SC $_{p'}$ vanishes for any $p' < p$ .
Significance: This establishes a tight connection between list decoding radius and symmetric channel capacity for all error-correcting codes, not just linear ones. The proof relies on bounding the weight distribution via the intersection of Hamming spheres (Theorem 2) rather than sharp thresholds.

B. Improved Bounds for Linear Codes (Theorem 6 & 7)

The paper addresses the specific case of linear codes, aiming to improve upon the Johnson bound ( $J_q(\delta)$ ).

Method: They combine the minimum distance assumption with the code's performance on the erasure channel. They show that if a linear code has relative distance $\delta$ and vanishing bit error probability on the erasure channel $q$ EC $_\lambda$ , it achieves vanishing error probability on the symmetric channel $q$ SC $_p$ for $p < p^*_q(\lambda, \delta)$ .
Application to Johnson Bound: By applying Claim 29 (which states that codes with distance $\delta$ are erasure list decodable up to $\frac{q}{q-1}\delta$ ), they derive a new lower bound for the symmetric channel capacity of linear codes:
$p_{sym}^L(q, \delta) \geq p^*_q\left(\frac{q\delta}{q-1}, \delta\right)$
Improvement: For alphabet sizes $q \geq 4$ and sufficiently large relative distances $\delta$ , this new bound strictly exceeds the Johnson radius $J_q(\delta)$ . This demonstrates that the Johnson bound is not the ultimate limit for symmetric channel performance when erasure properties are considered.

C. Binary Gaussian Channel (BAWGN)

The authors extend their technique to the Binary Additive White Gaussian Noise (BAWGN) channel.

They replace the union bound with a "sphere bound" and derive a threshold $\sigma^2_*(\lambda, \delta)$ for reliable communication.
Similar to the symmetric channel case, assuming both minimum distance and good erasure performance yields strictly better bounds than assuming minimum distance alone.

4. Key Results and Theorems

Theorem 1 (General Codes): Establishes that $(p, L)$ -list decodability implies vanishing error probability on $q$ SC $_{p'}$ for general codes, provided the minimum distance grows logarithmically with the list size.
Theorem 2 (Weight Distribution Bound): Provides a bound on the weight distribution $A_w(x)$ based on list decodability:
$A_w(x) \cdot \nu_q(n, t_1, t_2, w) \leq \binom{n}{t_1}(q-1)^{t_1}L$
where $\nu_q$ is the size of the intersection of two Hamming spheres.
Theorem 6 (Linear Codes & Erasure): If a linear code family has relative distance $\delta$ and vanishing error on $q$ EC $_\lambda$ , it has vanishing error on $q$ SC $_p$ for all $p < p^*_q(\lambda, \delta)$ .
Theorem 7 (Improvement over Johnson): For $q \geq 4$ $q \geq 4$ and large $\delta$ $δ$ , the derived bound $p^*_q(\frac{q\delta}{q-1}, \delta)$ $p_{q}^{*} (\frac{q δ}{q - 1}, δ)$ is strictly greater than the Johnson radius $J_q(\delta)$ $J_{q} (δ)$ .
- Visual Evidence: Figures 1 and 8 in the paper illustrate this improvement for $q=9, 17$ and other values, showing the new bound surpassing the Johnson curve in the high- $\delta$ regime.

5. Significance

Unification of Models: The paper successfully bridges the gap between worst-case (list decoding) and average-case (Shannon) models for general codes, showing that list decodability is a sufficient condition for reliable communication on symmetric channels.
Breaking the Johnson Barrier: For linear codes with large alphabets ( $q \geq 4$ ) and high relative distances, the authors prove that the Johnson bound is not the tightest possible limit for symmetric channel performance. By incorporating erasure channel properties, they achieve a strictly better lower bound on the achievable crossover probability.
New Proof Technique: The shift from "sharp threshold" arguments to direct weight distribution bounding via double counting and intersection sizes offers a more flexible toolkit for analyzing code performance. This technique is applicable to various channels, including the Gaussian channel.
Practical Implications: The results suggest that code families designed to perform well on erasure channels (like LDPC codes or Polar codes) may inherently possess better-than-expected performance on symmetric channels, provided they maintain a sufficient minimum distance.

In summary, this work refines our understanding of the trade-offs between distance, list decoding, and channel capacity, providing tighter theoretical guarantees for the performance of error-correcting codes in noisy environments.