对称信道容量怎么算？从BSC到弱对称的完整推导与Python验证-代码聚汇网

对称信道容量怎么算？从BSC到弱对称的完整推导与Python验证

冷君聊大片·2026-09-04·阅读 23 GEO检测（免费）

对称信道信道容量BSC

|难度：普通|阅读约 33 分钟

1. 先搞清楚：什么样的信道才配叫“对称”

学信息论与编码，前几周最磨人的地方不是熵，也不是互信息，而是突然冒出来一堆“带定语”的信道名字：无记忆信道、二进制对称信道、对称信道、弱对称信道。很多人背住了二元对称信道（BSC）的容量公式 C = 1 - H(p)，却不知道这个公式到底是从哪里来的；等题目里换成四元对称信道，或者换成一个看起来“左右对称”的删除信道，立刻不知道该怎么算容量。这篇文章要解决的，就是“对称信道”这个核心知识点。

先说清楚这件事适合谁看。如果你是正在学《信息论与编码》的学生，想搞懂考试里“求对称信道容量”这一类题的底层逻辑；或者你是做通信、存储系统仿真的人，想弄清楚为什么 BSC 模型能简化问题、哪些地方能套用、哪些地方不能套用，这篇文章都适合你。下面我会从定义出发，把对称信道容量公式的来龙去脉拆开，再用 Python 做验证，最后聊聊这个模型和实际编码系统的关系。

1.1 容量问题的起点：信源、信道转移矩阵、互信息

信息论里研究一条离散无记忆信道（DMC），通常给定三样东西：输入符号集 X、输出符号集 Y、以及一组条件概率 P(y|x)。信道是否有记忆，看的是当前输出是否只依赖当前输入；DMC 的含义就是“无记忆”，也就是说每个符号独立地经过同一个条件概率模型。

信道容量定义为：

C = max_{p(x)} I(X;Y)

这里的 I(X;Y) 是输入和输出之间的互信息，衡量的是“看到输出之后，输入的不确定性减少了多少”。如果你还没有建立起感觉，可以把它理解成一个带宽上限：一段噪声信道能安全承载的信息率，最大不会超过这个 I。上课时老师会强调，容量只取决于信道本身，也就是只取决于 P(y|x)，和信源分布无关。但计算容量时，我们又必须去找一个让互信息最大的输入分布。这个“找最大值”的动作，正是对称信道能够简化计算的关键。

对一般信道，想用解析方法求这个最大值是相当困难的，因为互信息不是输入分布的线性函数，最大值处的输入分布往往没有简单表达式。实际计算通常是数值迭代，最常见的就是 Blahut-Arimoto 算法。然而，如果信道矩阵具有某种“对称性”，问题会变得非常干净：最优输入分布可以直接确定，容量也能写出闭式解。

1.2 行、列重排：既严格又直观的对称定义

“对称信道”在大多数教材里的正式定义是：如果信道转移矩阵的每一行都是第一行的某个排列，并且每一列也都是第一列的某个排列，就称该信道为对称信道。

这里要特别强调“排列”的含义。所谓“每一行是第一行的排列”，意思是如果把某一行的概率值重新排序，能得到第一行的概率序列。所以行与行之间拥有完全相同的概率集合，只是这些概率随机地摆到了不同的输出符号上。更进一步，列也要满足同样的条件——每一列都必须由第一列的同一组概率值重新排列而成。

这个定义看起来简简单单，但它给信道容量计算带来了两个极其有用的结论：

第一，因为行之间互为排列，每一行对应的条件熵都是一样的。对于任意一行，它的条件熵是 H(Y|x)，可以写成：

H(Y|x) = -∑_y P(y|x) log P(y|x)

行概率集合相同，意味着每一行算出来的熵都相等。换句话说，H(Y|X) 不再依赖输入分布，它是个常数 H(row)。

第二，因为列之间互为排列，所有列的列和都相等。如果假设输入服从均匀分布，那么输出的分布也会是均匀的，也就是 H(Y) 能够达到理论最大值 log|Y|。

把这两条放到互信息的表达式里，就能推出对称信道的容量公式，下一节我会仔细走一遍这个推导。

1.3 教科书上绕不开的三个例子

很多初学者看到“对称信道”四个字，脑海里自动浮现的可能是物理上看起来对称的“两端口”模型，比如二进制对称信道。这个直觉不算错，但不够精确。

最常见的三个例子分别是：

二元对称信道（BSC）：输入 X∈{0,1}，输出 Y∈{0,1}，每一位以概率 1-p 正确接收，以概率 p 翻转。转移矩阵写出来是 [[1-p, p], [p, 1-p]]。它的行是第一行 [1-p, p] 重排，列是第一列 [1-p, p] 的重排，所以它是典型的对称信道。
q 元均匀对称信道：输入输出都是 q 个符号，以概率 1-p 正确传输，以概率 p 等可能地错成其他 q-1 个符号。转移矩阵的对角线全是 1-p，非对角线全是 p/(q-1)。这个矩阵的行和列都满足重排条件，也是对称信道。注意它比 BSC 更一般，BSC 只是 q=2 的特例。
模 q 加性噪声信道：输入 X 和噪声 Z 独立，输出 Y = X + Z mod q。如果噪声分布给定，转移矩阵是一个“循环矩阵”，每一行都是上一行向右平移一位得到的。循环矩阵天然满足行重排和列重排条件，因此它也是对称信道。

这三个例子将是我后面计算容量时的“演员”。其中第三个例子尤其重要，因为很多通信系统的等价离散模型都可以归约成“模加法噪声”的形式。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 对称信道为什么能“一算到底”：容量公式的来龙去脉

对称信道最大的价值，在于它能避开通用的数值迭代，直接写出容量闭式解。但你如果只是背下公式，不理解每一步条件在哪里起作用，很容易在题目稍作变形时踩坑。这里我把推导拆开讲清楚。

2.1 一般 DMC 容量为什么难算

先看一般离散无记忆信道。给定输入分布 p(x)，互信息可以写成：

I(X;Y) = H(Y) - H(Y|X)

其中 H(Y) 是输出分布的熵，H(Y|X) 是在已知输入情况下输出剩余的不确定性。对于每个固定的输入符号 x，信道会给出一个“输出分布” P(y|x)，这个分布本身算出的熵就是 H(Y|X=x)。于是:

H(Y|X) = ∑_x p(x) H(Y|X=x)

也就是各输入符号对应的条件熵的加权平均。这里的权重就是输入分布。麻烦在于：输入分布如果变了，H(Y) 会变，H(Y|X) 这个加权平均也会变。两个量都在变，最大值就不容易直接手算。

教材里讲信道容量时，一般会先证明一个结论：容量函数是输入分布的上凸函数，所以最大点存在且唯一。这个结论保证了问题有解，但没有给我们一个普通学生能在考试时间里手算的办法。真正在一般信道上求容量，需要做迭代；这也是为什么信息论课程里要讲 Blahut-Arimoto 算法。

2.2 行重排解决条件熵，列条件解决输出熵

对称信道的巧妙之处，就是让上面两个“都在变”的量分别被控制住。

先看 H(Y|X)。由于信道矩阵各行互为排列，所以不论输入符号是什么，信道给出输出的条件熵都是同一个值：

H(Y|X=x1) = H(Y|X=x2) = ... = H(row)

不管输入分布怎么取，加权平均都等于 H(row)。于是第二个变化量变成了常数，互信息简化为：

I(X;Y) = H(Y) - H(row)

这时只要让 H(Y) 最大，I 就最大。而 H(Y) 最大不超过 log|Y|，如果输出能达到均匀分布，等式就能取到。对称信道的列条件保证能做到这一点：当输入取均匀分布时，输出符号 y 的概率是：

P(y) = ∑_x P(X=x) P(y|x) = (1/|X|) ∑_x P(y|x)

这里的 ∑_x P(y|x) 就是第 y 列的列和。既然各列互为排列，列和全部相等，所以所有 P(y) 都相等，输出就是均匀分布。

于是容量公式水到渠成：

C = log|Y| - H(row)

注意 log 的底数。如果希望容量单位是比特，底数取 2；如果希望单位是奈特，则取自然对数。考试和仿真几乎都默认底数 2。

2.3 弱对称是公式可用的更短条件

有的教材或习题里会出现“弱对称信道”的概念。它和完全对称的定义差别在哪？

完全对称：行互为排列，列也互为排列。
弱对称：行互为排列，列不必互为排列，但每一列的列和相等。

为什么弱对称也够用？回头看刚才的推导，真正起作用的地方其实只有两点：一是各行熵相等，二是均匀输入能带来均匀输出。而“均匀输入能带来均匀输出”只需要各列列和相等就够了，不需要每一列都由第一列的概率值重排而成。列和相等更弱，也更容易在一些信道模型中验证。

所以弱对称信道的容量仍然是：

C = log|Y| - H(row)

输入分布同样取均匀分布。注意，这里“均匀输入”是达到容量的一种选择；如果题目问你“什么输入分布能达到容量”，答“等概率输入”通常不会错。但反过来要小心：并不是只有等概率输入能达到容量，在某些退化情况下可能还存在其他最优分布，只是均匀输入至少是一个确定可行的答案。

为什么还要强调完全对称？因为完全对称是更直观、更容易构造的一类信道；弱对称则是把条件放宽，让更多信道也能使用同一个容量公式。两者最重要的共同点是行之间的条件熵相等，这一点才是容量的“定海神针”。

2.4 最容易被误用的例子：二元删除信道不是对称信道

这里必须单独提醒一句，因为我在很多学生的作业里反复看到同一个错误：把“输入输出看起来左右对称”的二元删除信道（BEC）当成对称信道，然后套公式。

二元删除信道输入 X∈{0,1}，输出 Y∈{0,1,e}，其中 e 表示删除符号。当传输符号为 0 时，输出 0 的概率是 1-p，输出 e 的概率是 p；当传输符号为 1 时，输出 1 的概率是 1-p，输出 e 的概率是 p。把转移矩阵写成：

[ 1-p p 0 ]
[ 0 p 1-p ]

这里我把三列分别对应输出 0、e、1。我们检查一下第一列 [1-p, 0] 和第二列 [p, p]，它们显然不是同一组概率值的排列，因为第一列有一个元素是 0，另一个是 1-p；第二列两个元素都是 p。列和也不相等：第一列列和是 1-p，第二列列和是 2p。所以 BEC 既不是完全对称信道，也不是弱对称信道。

那么 BEC 的容量是多少？它是 C = 1-p，这个结果经常和经验公式混淆。它确实要求等概率输入，但推导方法和对称信道公式不同。计算过程可以这样看：取等概率输入，输出中收到 0 或 1 的概率各为 (1-p)/2，收到删除符号 e 的概率为 p。于是输出熵 H(Y) = (1-p) + h(p)，条件熵 H(Y|X) = h(p)，相减得到 I = 1-p。这个结果对 p 在 [0,1] 上都成立，而且它就是容量。

所以，当你看到“删除”两个字时，天然要警惕它是否满足对称信道的数学定义。BEC 的名字里有“二元”，也有一种“对称”的味道，但它不是“对称信道”大家族里可以直接套用 log|Y| - H(row) 的那类。真正的 q 元均匀对称信道里，行与行、列与列之间的概率结构是完全一致的重排关系。

3. 手动推导：BSC、q元对称信道的容量

理论知识再多，最终还是要落到会做题、会算数。这里我挑两个有代表性的信道，把从信道矩阵到容量最终数值的完整过程走一遍。

3.1 BSC：容量 1 减去二元熵函数

二元对称信道是最简单的强对称信道。转移矩阵：

P = [[1-p, p],
[p, 1-p]]

输入和输出符号集大小都是 2，所以 |Y| = 2，log|Y| = 1 bit。

任取一行，例如第一行 [1-p, p]，计算它的行熵：

H(row) = -p log2 p - (1-p) log2(1-p)

这个式子就是二元熵函数，通常记为 H(p)。因此 BSC 容量：

C = 1 - H(p)

这个公式背后有几个值得注意的端点情况。当 p=0 时，信道无噪声，H(0)=0，容量为 1 bit，也就是说每发一个比特都能被可靠地收到。当 p=1 时，每个比特必然翻转，容量仍然为 1 bit，因为只要把输出取反就能恢复原来的比特。所以哪怕“完全错误”的信道，理论上也不损失容量，它只是把你所有比特都翻转了，而这种翻转是确定性的、可逆的。当 p=0.5 时，输出和输入完全独立，H(0.5)=1，容量为 0，这时候信道已经不再传递任何信息，无论你怎么编码都是白费。

一个常见的误解是从 p=1 到 p=0.5，容量持续下降；从 p=0.5 到 p=1，容量又会上升。所以 BSC 容量在 [0, 1] 上不是单调函数。如果题目给你一个“翻转概率 0.8”的 BSC，你算容量时应该先考虑等效错误概率 min(p, 1-p) = 0.2，因为我们可以通过把输出比特全部取反，把翻转概率 0.8 变成 0.2。这个直觉在信道编码设计中也很有用：如果知道信道有系统性倾向翻转，先做一次固定映射就能改善信道。

3.2 q元对称信道：容量随着“错误摊得越散”而变化

现在把 BSC 推广到 q 元字符表。考虑 q 元均匀对称信道：发送某个符号时，以概率 1-p 保持正确，以总概率 p 等可能地错到其他 q-1 个符号上。

转移矩阵第 i 行中，对角线位置的元素是 1-p，另外 q-1 个位置都是 p/(q-1)。因为每行的非零概率集合相同，列也相同，所以这是强对称信道。输出符号数 |Y| = q，于是：

C = log2 q - H(row)

行熵按定义：

H(row) = -(1-p) log2(1-p) - (q-1) * [p/(q-1)] log2[p/(q-1)]

化简后：

H(row) = -(1-p) log2(1-p) - p log2[p/(q-1)]

一个直观的结论是：在错误总概率 p 固定的情况下，如果错误被均匀摊给更多符号，单个错误概率 p/(q-1) 更小，听起来似乎更好？但注意熵项里还带着 log2[p/(q-1)]，当 q 增大时，log2[p/(q-1)] 会更负，乘上 p 后是更大的正值，所以 H(row) 会增大，容量会下降。原因其实好理解：q 越大时，每次错误的“不确定方向”更多，接收端看到错误符号后更难以猜测原始符号，所以信道传递有效信息的能力被进一步削弱。

举个例子：q=4，p=0.12。此时：

H(row) = -0.88 * log2(0.88) - 0.12 * log2(0.04)

逐项算，约等于 0.162 + 0.557 = 0.719 bit。容量就是：

C = 2 - 0.719 = 1.281 bit

如果 q=4 且 p=0，容量是 2 bit；如果 p=0.75，也就是错误概率被均匀摊到 3 个错误符号上，每个错误符号概率 0.25，此时行熵达到 2 bit，容量为 0。这个边界正好符合直觉：当发送任意符号，接收符号等概率地出现在 4 个符号中时，信道已经完全没有信息量了。

3.3 模 q 加性噪声信道：对称信道的一个“底层模板”

除了上面那种教科书常见的“正确+错误”模型，另一个更接近通信本质的对称信道是模 q 加性噪声信道。

设输入 X 和噪声 Z 都取值于 {0,1,...,q-1}，二者独立，输出为：

Y = (X + Z) mod q

噪声概率分布为 P(Z=k)=p_k。这个信道的转移矩阵特点是：给定了输入 x，输出 y 的条件概率只取决于 y-x 在模 q 意义下的差值，即 P(y|x) = p_{y-x}。于是转移矩阵每一行都是上一行的循环移位，它是一个循环矩阵。

循环矩阵天然满足“行重排、列重排”的对称条件，所以它是对称信道。它的行熵不依赖具体输入，等于噪声熵 H(Z)：

H(row) = -∑_k p_k log2 p_k

容量公式：

C = log2 q - H(Z)

这个结论有非常强的直觉：模 q 加法信道中，信息遭受的是“加性噪声干扰”，信道的不可靠性完全由噪声 Z 的不确定性决定。如果 Z 恒等于 0，H(Z)=0，容量是 log2 q，不多不少正好是无噪声 q 进制信道的容量。如果 Z 是在 q 个符号上均匀分布的，H(Z)=log2 q，容量归零，噪声把输入完全淹没了。

这个模型在编码领域极其常见。比如在 q 进制 LDPC 码的仿真里，如果采用 q 进制调制并假设噪声是模 q 加性的，就可以把实际信道抽象成这个模型，从而快速得到一个对称的、可解析分析的信道矩阵。理解这个“底层模板”，比单纯背 BSC 公式要有用得多。

4. 用Python把容量跑出来：别再只背公式

学信息论的人容易陷入一种状态：公式推导全都懂，但让写一个实验验证就无从下手。网上关于“信息论与编码 python”的搜索热度一直很高，说明很多人都想用代码把抽象概念落地。这一节我就用 Python 做一个小而完整的练习：先从信道矩阵出发，用互信息定义精确计算 BSC 容量，再用蒙特卡洛模拟做交叉验证。

4.1 从信道矩阵出发的精确计算

我们不需要调用任何高级库，只用 NumPy 就能完成。核心思路很简单：对于给定的输入分布 p_x 和信道矩阵 W，先算联合分布 P(x,y)，然后分别算 H(Y)、H(Y|X)，最后得到 I(X;Y)。为了求容量，还需要对输入分布做搜索；不过对 BSC，理论上已经知道最优分布是等概率输入，所以直接验证等概率输入下的互信息即可。

下面这段代码同时实现了二元熵函数和 BSC 容量公式：

python复制import numpy as np

def binary_entropy(p):
    p = np.clip(p, 1e-12, 1 - 1e-12)
    return -p * np.log2(p) - (1 - p) * np.log2(1 - p)

def bsc_capacity(p):
    return 1.0 - binary_entropy(p)

# 用互信息定义直接计算 BSC 给定 p 下的 I(X;Y)，输入为均匀分布
def bsc_mutual_info_uniform(p):
    W = np.array([
        [1 - p, p],
        [p, 1 - p]
    ])
    # 均匀输入
    px = np.array([0.5, 0.5])
    # 联合分布 P(x,y) = P(x) * W(y|x)
    joint = px[:, None] * W
    # 输出分布
    py = joint.sum(axis=0)
    # H(Y)
    hy = -np.sum(py * np.log2(np.clip(py, 1e-12, 1)))
    # H(Y|X) 的加权平均
    hy_given_x = 0.0
    for i in range(W.shape[0]):
        row = W[i]
        h_row = -np.sum(row * np.log2(np.clip(row, 1e-12, 1)))
        hy_given_x += px[i] * h_row
    return hy - hy_given_x

for p in [0.0, 0.1, 0.2, 0.5, 0.9]:
    formula = bsc_capacity(p)
    direct = bsc_mutual_info_uniform(p)
    print(f"p={p:.2f}, capacity_formula={formula:.6f}, mutual_info_uniform={direct:.6f}")

运行这段代码会看到一个现象：在 p=0.0、0.1、0.2、0.5 时，公式结果和均匀输入下的互信息完全一致。这正是对称信道定理的体现——均匀输入已经是最优输入，所以它对应的互信息就是容量。到 p=0.9 时，capacity_formula 和 direct 仍然相等，容量等于约 0.531 bit，对应前面说过的等效翻转概率 0.1 的情况。

4.2 模拟抽样验证，反过来理解互信息

精确计算联合分布当然可靠，但它容易让人误以为互信息只需要“算一算”。如果你真的在一套通信系统中估计容量，往往只有输入数据和输出数据，没有显式的转移矩阵。此时可以用蒙特卡洛方法做估计。

模拟思路是：固定输入分布为均匀分布，生成大量输入符号，再按 BSC 的翻转概率生成输出符号，最后用经验分布近似联合分布，并计算出互信息的估计值。下面给出一个简单的实现：

python复制rng = np.random.default_rng(42)
p = 0.1
n = 200000

# 生成输入序列，均匀 0/1
x = rng.integers(0, 2, size=n)

# 生成噪声翻转标记，翻转概率 p
flip = rng.random(n) < p
y = np.where(flip, 1 - x, x)

# 估计联合分布 P(x, y)
total = n
p00 = np.sum((x == 0) & (y == 0)) / total
p01 = np.sum((x == 0) & (y == 1)) / total
p10 = np.sum((x == 1) & (y == 0)) / total
p11 = np.sum((x == 1) & (y == 1)) / total

joint = np.array([[p00, p01],
                  [p10, p11]])
px = joint.sum(axis=1)
py = joint.sum(axis=0)

def entropy_from_prob(probs):
    probs = np.clip(probs, 1e-12, 1.0)
    return -np.sum(probs * np.log2(probs))

mutual_info = entropy_from_prob(py) - sum(
    px[i] * entropy_from_prob(joint[i] / px[i])
    for i in range(2)
)

print(f"理论容量: {bsc_capacity(p):.6f} bit")
print(f"蒙特卡洛估计互信息: {mutual_info:.6f} bit")

当样本量足够大时，估计值会接近理论值 0.531。这个实验让我印象很深：信息论里的“互信息”不是一个抽象符号，它完全可以放在一个收发链路上通过统计频率估计出来。只是要注意，蒙特卡洛估计天然带有方差，样本量越小、真实互信息越接近 0，估计偏差就越明显。

4.3 一个容易忽略的实验细节

仿真对称信道时有一个典型的坑：不要把“信息速率”和“容量”混为一谈。容量是在输入分布经过充分优化之后得到的信道极限；你用均匀输入算出互信息，在对称信道中刚好等于容量，但如果你随机选了一个非均匀输入，算出来的互信息就会低于容量。

还有，用 np.random.random() < p 模拟 BSC 是正确的，因为 p 就是翻转概率。但有些同学在模拟时把 p 当成“正确概率”，逻辑反转，仿真结果曲线就会从 C=1-H(p) 变成 C=1-H(1-p)。由于二元熵函数满足 H(p)=H(1-p)，BSC 这个特例不容易暴露错误，但一旦推广到 q>2 的对称信道，这种混淆会让结果完全错掉。我的建议是：每次写仿真前，先把转移矩阵打印出来，用肉眼确认一下“当你输入 0 时，输出 1 的概率到底是多少”，再开始跑大样本实验。

5. 从对称信道到编码直觉：它到底有什么用

很多人学到“信道容量”这个位置时，会觉得它不过是又一个可以手算的题目。真正把视角拉远，对称信道模型的用途远不止考试。它是理解信道编码增益、设计仿真链路、解释复杂信道抽象的基础。

5.1 对称性让“最优输入”变得简单，也让编码设计有了基准

在一般信道上，达到容量的输入分布可能是个不太规则的分布，这对实际编码系统来说非常不友好。而在对称信道里，最优输入就是等概率输入，这意味着系统不需要做复杂的信号偏置或概率成形，直接把 0/1 码字以 50% 的概率送入信道即可。

这一点对信道编码设计的意义很大。编码定理告诉我们，只要码率 R < C，就存在足够长的码字使错误概率任意小。这个定理是对“存在性”的肯定，但它没有告诉我们码字长什么样。对 BSC 这类对称信道，我们还可以进一步知道：最大似然译码等价于最小汉明距离译码。因为在 BSC 中，错误是逐符号独立发生的，一个包含 d 个翻转错误的接收序列，它的概率随 d 增加而指数下降；要最大化解码正确概率，就要找离接收序列最近的那个码字。这个直觉是很多入门级编码课程解释“线性分组码纠错能力由最小距离决定”的出发点。

换言之，对称信道给了编码理论一个干净的“试验场”。如果在一个非对称、有记忆、无规律的信道上研究编码，变量太多，很多结论根本推导不出来。通信研究者习惯于先弄清楚 BSC、BEC、AWGN 这几类基础信道下的极限，再逐步为复杂信道寻找近似模型。

5.2 实际链路里什么时候能近似成对称信道

工程中很少遇到教科书里那样完美的数学模型，但对称信道仍然很有用。

举个例子。一条加性高斯白噪声（AWGN）信道经过 BPSK 调制、相干解调、硬判决之后，比特错误概率可以写成 Q 函数形式。如果把每个比特的硬判决输出当作最终接收符号，这条链路就非常接近一个 BSC，翻转概率就等于误比特率。这时用 BSC 容量曲线可以快速估算当前信噪比下还有多少编码增益空间。

又比如，在只关心“外层纠错码性能”的仿真中，研究者常常把经过内层调制解调的真实信道压缩成一个等效的 BSC 或 BEC。这样做不是为了精确刻画物理过程，而是为了隔离问题：先把最核心的编码增益评估清楚，再回头考虑软信息损失、信道相关性等次要因素。工程上的“等效信道”思想，本质上就是对对称信道概念的延伸。

不过必须时刻提醒自己：近似只在有效范围内成立。BPSK + 硬判决的等效 BSC 会丢掉软判决信息，在低信噪比下，硬判决造成的容量损失可能相当可观。此时再用 BSC 容量去逼近真实系统的极限会偏保守，更好的做法是保留对数似然比信息，用二进制输入软输出信道建模。

5.3 学完这个知识点，下一步该怎么走

我个人在讲信息论与编码这门课的时候，经常看到学生把 BSC 容量公式背得滚瓜烂熟，但拿到模 q 加性噪声信道就不会了，或者一遇到 BEC 就习惯性套 C = log|Y| - H(row)。我自己也踩过这个坑。踩过几次之后，我的体会是：学对称信道不能停留在“能算题”，关键是抓住两条主线——行重排保证了 H(Y|X) 恒定，列和相等保证了均匀输入给出均匀输出。这两条主线哪怕没记住完整公式，碰到具体信道也能自己重新推导出来。

如果你后面准备深入信道编码，我建议下一步做几件小事：第一，用 Python 把 BSC、BEC、q 元均匀对称信道的容量曲线画在同一张图上，横轴是错误概率或删除概率，纵轴是容量，观察它们的差别；第二，研究一下 Blahut-Arimoto 算法，用它计算一个非对称小矩阵信道的容量，再和对称信道的结果对照，感受“对称性”到底把复杂度降到了哪里；第三，找一篇介绍 LDPC 码在 BEC 下迭代译码的文章，看看删除符号的软信息是如何传播的。

画曲线时，可以参考这段最简代码来出图：

python复制import numpy as np
import matplotlib.pyplot as plt

p = np.linspace(0.0, 1.0, 200)
C_bsc = 1.0 - binary_entropy(p)
C_bec = 1.0 - p

plt.plot(p, C_bsc, label="BSC")
plt.plot(p, C_bec, label="BEC")
plt.xlabel("error/erasure probability p")
plt.ylabel("capacity (bit/channel use)")
plt.legend()
plt.grid(True)
plt.show()

这张图能直观告诉你一件事：同样概率 p 下，BEC 的容量比 BSC 高，因为删除符号至少是“明确告知你这一位不可靠”，而 BSC 的错误则是“悄悄把 0 变成了 1”，接收端并不知道哪个位置错了。信息论里那种“坏消息里也有信息”的微妙感，在这里体现得淋漓尽致。

最后再分享一个学习技巧：遇到任何带“对称”二字的信道，先别急着背结论，先用 20 秒在纸上把转移矩阵写出来，然后检查它到底满足“行排列、列排列”，还是只满足“弱对称”，或者两者都不满足。这个动作只要坚持做，考试时就不容易翻车，做仿真时也会少走很多弯路。