量子相对熵的数学原理与Python数值实现-代码聚汇网

量子相对熵的数学原理与Python数值实现

樱桃小公举·2026-08-29·阅读 22 GEO检测（免费）

量子相对熵密度矩阵特征值分解

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

做量子信息、矩阵分析或者量子热力学方向的同学，应该没少跟“相对熵”这个概念打交道。我最初接触矩阵算子 A 和矩阵算子 B 的相对熵，是在研究量子态区分问题的时候。当时需要刻画两个量子态之间的差异，最自然的想法就是把经典信息论里的 Kullback-Leibler 散度搬到矩阵世界里来。真正动手才发现，这个看似简单的量，背后牵扯到非对易性、矩阵对数计算、数值稳定性，还有一大串听起来很有分量的不等式性质。写这篇文章，是想把这几个月踩过的坑、补过的证明、调过的代码一次性讲清楚。

这个项目解决的核心问题非常明确：当 A 和 B 都是厄米算子（尤其是密度矩阵）时，如何用相对熵 S(A||B)=Tr(A(log A - log B)) 严谨、可计算地度量两者之间的差异。它不像普通范数那样满足对称性和三角不等式，却拥有信息处理不等式（Data Processing Inequality）这种极其实用的性质。所以它非常适合用来做纠缠检测、信道容量估计、量子热力学自由能差分析，以及各种需要“带方向地比较两个量子态”的任务。无论你是刚进入量子信息领域的研究生，还是做矩阵理论数值计算的工程师，这篇内容都能帮你把相对熵的定义、性质、代码实现和避坑经验一次理清。

1. 项目背景与整体思路

1.1 从经典相对熵到算子相对熵的跨越

经典信息论里的相对熵（KL 散度）定义在两个概率分布 p(x) 和 q(x) 之间：KL(p||q)=Σ p(x) log(p(x)/q(x))。它的直观含义是：如果用真实分布 q 去编码来自分布 p 的样本，平均会多浪费多少比特。这个量在信息论里极其重要，原因就在于它把“编码效率”和“分布差异”统一在了一起。

把概率分布换成密度矩阵后，事情就变得微妙了。矩阵 A 和 B 一般来说不对易，AB 不等于 BA，log A 和 log B 也不一定满足简单的关系。经典情况下对数的除法可以直接写成 log(p/q)，矩阵世界里没有“矩阵除法”这种干净操作，只能写成 log A - log B。这个形式上的变化实际上是本质性的：它让相对熵成为了一个违反直觉但非常有深度的算子函数。

我一开始的处理方式是直接把 A 和 B 特征分解，然后当成经典概率分布算 KL 散度。后来发现这并不行，尤其是 A 和 B 不对易时，相同的特征值谱并不能决定同样的相对熵，特征向量方向的差异会被相对熵捕捉到。这恰恰是量子信息里所谓的“非交换性带来的量子效应”。

1.2 为什么要给两个矩阵定义“熵差”

从应用角度看，相对熵最大的价值在于它是量子态区分理论的基石。比如说我们要判断一个未知量子态到底是落在集合 M1 还是集合 M2 里，最优的判别误差指数就与两个集合的相对熵有关。Stein 引理在量子场景下的表述直接用到 S(A||B) 作为指数率。

另一个绕不开的场景是纠缠检测。相对熵纠缠度 E_R(ρ) = min_{σ∈分离态} S(ρ||σ) 定义非常简洁，直觉上就是问“这个态离最近的分离态有多远”。这个定义比常见的部分转置判据更精细，因为它不仅回答“是不是纠缠”，还能给出一个纠缠程度的量化值。代价是需要在一个很大的凸集上做优化，数值实现上比线性判据麻烦得多，但结果的分辨率也高得多。

所以说，这个项目值得做，不是因为相对熵的公式多优美，而是因为它是连接信息论、矩阵论和量子物理的关键接口。理解了它，很多别的概念，比如量子互信息、信道容量、量子热力学中的自由能差，都会跟着通起来。

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

2. 数学定义与核心性质解析

2.1 定义式拆解：S(A||B)=Tr(A log A − A log B)

严格来说，量子相对熵定义在正半定算子 A 和正定算子 B 上：

S(A||B) = Tr(A log A) − Tr(A log B)

这里 log 是矩阵主对数。如果 A 有零特征值，约定 0 log 0 = 0，这个约定在谱分解的框架下非常自然，本质上就是只对正特征值的子空间取对数。如果 A 的支撑集（support）不完全包含在 B 的支撑集里，那么 S(A||B) 直接定义为 +∞。这一点和经典 KL 散度完全一致：如果某个事件在 p 下概率非零但在 q 下概率为零，KL 就发散。

要小心的是 Tr(A log A) 和 Tr(A log B) 这两项都不能随便交换顺序。虽然迹的循环性允许 Tr(A log B) = Tr(log B A)，但 log B 和 A 不对易时，我们不能把 log 单独拆出来作用到 A 的期望值上。也就是说，Tr(A log B) 不等于 Σ p_i log q_i，后者的成立需要 A 和 B 同时对角化。这一点在理解相对熵的物理含义时很容易被忽略。

我在项目里习惯先把 A 和 B 都做特征分解：A = U_A D_A U_A†，B = U_B D_B U_B†，然后 Tr(A log A) = Σ λ_Ai log λ_Ai，而 Tr(A log B) = Σ_{ij} λ_Ai (log μ_Bj) |<a_i|b_j>|²。这里 λ_Ai 是 A 的特征值，μ_Bj 是 B 的特征值，|<a_i|b_j>|² 是两个特征基之间的转换矩阵元素模平方。这个表达式清晰地展示了相对熵如何同时编码特征值差异和特征基差异，是写数值代码时最常用的形式。

2.2 四大“看家”性质

相对熵之所以在理论推导中如此可靠，靠的是一组漂亮的不等式性质：

第一是非负性：S(A||B) ≥ 0，当且仅当 A=B 时取等。这个结论由 Klein 不等式保证，本质上利用了 −log x 在正半轴上是严格凸函数这一性质。放到经典情形，就是 Gibbs 不等式。

第二是信息处理不等式：对任意完全正迹保持映射（量子信道）Λ，有 S(Λ(A)||Λ(B)) ≤ S(A||B)。这句话的意思是，任何物理上可行的操作，都不会增加两个量子态的相对熵。这跟经典数据处理不等式的地位一样，是量子信息论里少数几个“铁律”之一。很多可达到性定理的证明都建立在它之上。

第三是联合凸性：S(A||B) 关于 (A,B) 是联合凸函数，即 S(λA1+(1−λ)A2 || λB1+(1−λ)B2) ≤ λS(A1||B1)+(1−λ)S(A2||B2)。这个性质比普通凸性强得多，是证明相对熵纠缠度可计算性和各种变分公式的基础。

第四是发散条件：如果 supp(A) ⊄ supp(B)，则 S(A||B)=+∞，这保证了相对熵作为随机序的严格性，也让很多优化问题可以通过约束支撑集来避免病态情况。

这四个性质组合在一起，让相对熵成为一个“有方向、不对称、但拥有最强排序能力”的度量工具。实际项目中，它不满足对称性也可能算一个优点：A 到 B 的差异和 B 到 A 的差异本来就该不同，比如从混合态到纯态的距离和从纯态到混合态的距离在物理上并不是同一件事。

2.3 相对熵与常用度量对比

度量方式	定义	对称性	三角不等式	信息处理不等式	适用场景
算子相对熵 S(A		B)	Tr(A(log A − log B))	不满足	不满足
迹距离	½ Tr\|A−B\|	满足	满足	满足	量子态保真度估计
保真度 F(A,B)	(Tr√(√A B √A))²	满足	不直接满足	满足	量子重叠度
Hilbert-Schmidt 距离	√Tr((A−B)²)	满足	满足	不满足	矩阵逼近

从表里能直观看出，相对熵是唯一一个牺牲对称性和三角不等式、但保留信息处理不等式的度量。在很多物理问题里，信息处理不等式才是更本质的要求。比如做数据压缩时，只要经过了信道，区分难度只可能下降，不可能上升，这正是熵差的核心意义。因此在需要“沿信道单调递减”的场景，选相对熵几乎是不二之选。

3. 物理内涵与应用场景

3.1 量子态区分：带方向的差异指标

量子态区分是量子信息里最经典的问题之一。给定一个未知态，它要么是 A 要么是 B，我们希望通过测量来猜。当实验次数 n 很大时，最优判别误差的衰减率由量子 Chernoff 界描述，而其中一个特别常用的上界就来自相对熵。具体来说，如果假设检验是 H0: ρ=A 对 H1: ρ=B，那么错误概率的指数率与 S(A||B) 有直接联系。

这里的“方向性”要特别提一下。S(A||B) 大说明“如果真实态是 A，但模型假设是 B，代价很高”；反过来 S(B||A) 可能很小。这在假设检验中非常合理：我们关注的通常是虚警率还是漏警率，两个方向的代价本来就不对称。我在实际计算中经常利用这个性质来判定“哪个态更难被其他态冒充”，即比较 S(A||B) 和 S(B||A) 的大小关系。

从数值角度看，只要算出两个密度矩阵的特征谱和转换矩阵，S(A||B) 的精度就基本由矩阵对角化的精度决定。对于常见的 2 量子比特系统（4×4 矩阵），一次相对熵计算在微秒量级，哪怕是几千次蒙特卡洛采样也毫无压力。

3.2 纠缠检测与相对熵纠缠度

相对熵纠缠度 E_R(ρ) 的定义很自然：在全体分离态集合 S 中，找一个离 ρ 最近的分离态 σ，然后取最小相对熵。这个量满足纠缠度量的基本要求：当 ρ 可分时 E_R(ρ)=0，当 ρ 纠缠时 E_R(ρ)>0。和负性（negativity）之类的判据不同，相对熵纠缠度是 LOCC（局域操作与经典通信）下的单调量，这意味着它在理论上更有权威性。

实现 E_R 的最大难度在于优化。分离态集合是一个非常大的凸集，而且无法用一组线性约束简单刻画。我试过两种方案：第一种是梯度下降 + 投影，每次迭代把矩阵投影到分离态集合上；第二种是把 σ 参数化成若干纯积态的凸组合，再用随机优化逼近。经验是，对小系统（比如 2×2 或 2×3），第二种方案更快且更稳；对高维系统，两种方案都容易陷入局部最优，通常需要配合模拟退火或多次随机重启。

一个实用技巧：如果只是为了判断纠缠，还是先算部分转置判据。只有部分转置判据不充分（比如在高维系统中出现束缚纠缠态）时，才值得动用相对熵纠缠度。这类态通常表现为部分转置后仍然正定，但相对熵纠缠度严格大于零。

3.3 量子热力学中的自由能差

在量子热力学里，相对熵经常扮演“非平衡自由能差”的角色。对于热平衡态 γ = exp(−βH)/Z，任意态 ρ 的相对熵 S(ρ||γ) 可以写成：

S(ρ||γ) = β(F(ρ) − F(γ))

其中 F(ρ) = Tr(ρH) − (1/β)S(ρ) 是非平衡自由能，S(ρ) = −Tr(ρ log ρ) 是冯诺依曼熵。这个公式简洁地说明了：非平衡态偏离平衡态越远，相对熵越大，能够提取的“自由能代价”也就越高。

我在做这类计算时，最常被问的问题是“为什么不用直接算 F(ρ) 而要用相对熵”。原因是数值稳定性：F(ρ) 里包含冯诺依曼熵，当 ρ 接近纯态时熵趋近于 0，而 −(1/β)S(ρ) 的绝对值很大，容易引起数值误差。但写成 S(ρ||γ) 之后，对数项同时受到 ρ 和 γ 的约束，配合正则化处理，反而能获得更稳定的结果。

这个表达式的另一个妙处是天然满足涨落定理。比如在量子淬火过程中，体系从 γ1 演化到 ρ，然后由 ρ 弛豫到 γ2，其不可逆功与 ΔS = S(ρ||γ2) − S(ρ||γ1) 直接相关。计算上只需要准备初始平衡态和最终平衡态两个密度矩阵，再求中间态的相对熵即可。

4. 数值计算与代码实现

4.1 核心算法：特征值分解法

计算 S(A||B) 最直接的算法就是特征值分解。对单独的 A 来说，S(A) = −Tr(A log A) 可以完全通过对角化实现：先求 A 的特征值 λ_i，再计算 −Σ λ_i log λ_i。问题主要集中在 Tr(A log B) 这一项，因为 A 和 B 不一定能同时对角化。

我采用的算法分三步：

对 B 做特征分解：B = U_B D_B U_B†，得到特征值 μ_j 和特征向量 |b_j>；
计算矩阵 M_{ij} = <a_i|b_j>，其中 |a_i> 是 A 的特征向量；
计算 Tr(A log B) = Σ_{i,j} λ_Ai log μ_Bj · |M_{ij}|²。

这个算法比直接调用 scipy.linalg.logm(B) 再算迹要稳得多。直接算 logm 时，若 B 有接近零的特征值，矩阵对数的条件数会爆炸，误差会在后来的矩阵乘法中被放大。而特征值分解法把对数操作完全限制在特征值层面，只要 μ_j 不低于某阈值，结果就是可靠的。

不过要提醒一点，直接用特征值分解法要求 A 和 B 都是正规算子。好消息是量子信息里我们处理的密度矩阵都是厄米的，天然满足这个条件。如果 A 或 B 是更一般的非正规矩阵，那就得老老实实走积分表示或者 Jordan 标准形了，那种情况在工程项目里很少见。

4.2 Python 实现与精度对比

我用 NumPy 和 SciPy 写了一个相对熵的计算模块，核心函数如下：

python复制import numpy as np
from scipy.linalg import eigh

def quantum_relative_entropy(A, B, tol=1e-12):
    """
    计算 S(A||B) = Tr(A (log A - log B))
    A, B: Hermitian positive semidefinite matrices
    tol: 特征值截断阈值
    """
    # 检查合法性
    if not np.allclose(A, A.conj().T, atol=tol):
        raise ValueError("A 必须是厄米矩阵")
    if not np.allclose(B, B.conj().T, atol=tol):
        raise ValueError("B 必须是厄米矩阵")

    # A 的特征分解
    evals_A, evecs_A = eigh(A)
    # 截断极小特征值，避免 log(0)
    mask_A = evals_A > tol
    evals_A_pos = evals_A[mask_A]
    evecs_A_pos = evecs_A[:, mask_A]

    # 第一项 Tr(A log A)
    term1 = np.sum(evals_A_pos * np.log(evals_A_pos))

    # B 的特征分解
    evals_B, evecs_B = eigh(B)
    if np.min(evals_B) <= tol:
        # 检查支撑集是否包含
        overlap = evecs_A_pos.conj().T @ evecs_B
        for i in range(evals_A_pos.shape[0]):
            idx_zero = evals_B <= tol
            if np.any(np.abs(overlap[i, idx_zero]) > tol):
                return np.inf
    mask_B = evals_B > tol
    evals_B_pos = evals_B[mask_B]
    evecs_B_pos = evecs_B[:, mask_B]

    # 重叠矩阵 M_ij = <a_i|b_j>
    M = evecs_A_pos.conj().T @ evecs_B_pos
    overlap_sq = np.abs(M) ** 2

    # 第二项 Tr(A log B)
    term2 = 0.0
    for i in range(evals_A_pos.shape[0]):
        log_B_diag = np.log(evals_B_pos)
        term2 += evals_A_pos[i] * np.dot(overlap_sq[i], log_B_diag)

    return term1 - term2

这段代码有两个细节值得说明。第一，特征值截断阈值 tol 不能设得太小，也不能设得太大。太小会把数值噪声当成真实特征值，导致 log 爆炸；太大则会把真实的低权重信息丢掉。我一般取 1e-12 到 1e-14，具体取决于输入矩阵的尺度。第二，检查支撑集时，不能只看 B 是否有零特征值，还要看 A 的对应特征向量是否落在 B 的零空间上。只有两者同时成立，相对熵才是有限的。这个检查缺失时，程序会在算 term2 时静默地给出错误的结果，非常坑。

4.3 数值稳定性与正则化处理

密度矩阵在实验中不可避免地带有噪声，特征值可能会变成极小正数甚至小数负数。数值上最常见的问题是 B 的某个特征值接近零，导致 log μ_j 变成很大的负数，让 term2 变得异常巨大。

我的建议是两步走：先用谱裁剪（spectral clipping）把特征值限制在 [ε, 1] 范围内，再做归一化。比如：

python复制def regularize_density_matrix(rho, eps=1e-10):
    evals, evecs = eigh(rho)
    evals_clipped = np.clip(evals, eps, None)
    evals_clipped = evals_clipped / np.sum(evals_clipped)
    return (evecs * evals_clipped) @ evecs.conj().T

这个操作等价于给密度矩阵混入了一点白噪声：ρ → (1−δ)ρ + δ I/d。在物理上，这相当于考虑了有限温度或去极化信道的效果，在很多场景下反而是更贴近实际的模型。代价是它会让相对熵从无穷大变成有限值，因此在需要判断支撑集发散的场景中，不能直接使用正则化，必须先做支撑集检查。

我实测过不同 ε 对结果的影响：对于 4×4 密度矩阵，ε 从 1e-12 到 1e-8 变化，S(A||B) 在非发散区间的波动基本在 1e-8 以内。这说明只要不触发支撑集不匹配，正则化对相对熵的影响非常小，可以放心使用。

5. 常见问题与排查技巧

5.1 矩阵“长得像”密度矩阵但不是合法输入

这是新手最容易踩的坑。很多人从一个较大的量子态取部分迹得到约化密度矩阵，然后直接扔进计算函数。结果发现特征值有负数，或者特征向量不正交。查了半天才发现，是因为前面少了一步归一化，或者浮点误差让矩阵失去了精确的厄米性。

排查建议：在函数入口处强制检查以下三项：

np.allclose(A, A.conj().T)：厄米性；
np.trace(A) > 1 - tol and np.trace(A) < 1 + tol：迹为 1；
np.min(np.linalg.eigvalsh(A)) > -tol：半正定性。

其中第二项尤其重要。很多实验数据重建出来的矩阵迹并不严格等于 1，经验做法是重新归一化：A = A / np.trace(A)。这一步看起来简单，却能让后续所有计算都稳定下来。我在项目里把这个检查封装成了装饰器，每次调用计算函数都会自动验证，省了不少调试时间。

5.2 `logm` 返回复数结果或警告

SciPy 的 scipy.linalg.logm 在输入矩阵有非正特征值时会返回复数矩阵并抛出警告。量子信息里严格合法的密度矩阵特征值都非负，但数值构造的不合法矩阵（比如干涉项过大导致极小特征值为负）会触发这条路径。

我建议不要依赖 logm 去处理相对熵计算，而是直接用特征值分解法。如果确实需要 logm，一个可行的修复是强制对称化：B_sym = (B + B.conj().T) / 2，然后再算。这个操作在物理上可以理解为“扔掉非厄米部分的噪声”，对最终结果的修正通常是二阶小量。

顺带一提，logm 在矩阵尺度相差悬殊时很容易报“矩阵对数主分支不连续”的警告。这种情况在相对熵里其实对应物理上的发散，与其强行压制，不如输出 +∞ 并在文档里标注原因。

5.3 支撑集不匹配导致结果无穷大

相对熵发散是数学上合法的结果，但在工程代码里出现 inf 时，排查过程往往会让人困惑。我遇到过的情况是：A 是纯态 |0><0|，B 是一个均匀混合态 I/d。此时 supp(A) ⊂ supp(B)，相对熵有限，等于 log d。但如果 A 是 |0><0|，B 是 |1><1|，支撑集完全不重叠，S(A||B)=+∞，而 S(B||A) 同样是 +∞。

要避免这类问题，最有效的做法是在函数返回 inf 前打出一条详细日志，指出：

A 的哪个特征向量落在了 B 的零空间上；
对应特征值的权重是多少；
建议是否使用正则化。

我在实际计算中就是这么做的，因为相对熵的 inf 往往不是 bug，而是物理条件变化导致的相变信号。比如在量子相变点附近，相对熵对支撑集变化非常敏感，明确输出 inf 反而能帮助定位临界行为。

5.4 大规模矩阵的计算性能优化

当矩阵维度超过几百时，完整的特征分解开始成为瓶颈。特别是在纠缠度优化这类需要反复调用相对熵的场景，计算量会爆炸。

我的优化策略有三个方向。第一个是降维：很多问题是低秩的，A 的有效秩远小于维度，可以先用随机 SVD 降维再计算。第二个是缓存：在优化迭代中，B 往往只在一个小邻域内变化，可以对 B 的特征分解做热启动，用上一次的特征向量作为初值。第三个是换公式：如果只需要比较相对熵大小而不需要绝对值，可以用 S(A||B) + S(B||A) 这种对称化组合，然后通过矩阵不等式做一些近似化简。

还有一个小技巧：对于张量积结构的输入，比如多量子比特系统的密度矩阵，可以用密度矩阵的重构形式避免显式构造大矩阵。这样可以把 2^n × 2^n 的计算降为若干个 2×2 或 4×4 的局域计算。这类技巧在量子多体数值模拟里非常实用，能撑到 n=20 左右而不至于内存爆炸。

6. 写在最后

我实际用这个模块跑了大概两个月，最深的感受是相对熵这个量“越用越顺手”。一开始总觉得它不如迹距离那样直观，毕竟不满足对称性很反直觉。但真到了纠缠检测和热力学自由能差这种场景，才发现不对称才是优点，它能区分“谁偏离谁”的方向，能捕捉到信道作用下信息损失的单调变化。如果你也在做量子态比较、信道容量估计或者纠缠度计算，建议先在自己的项目里写一个类似上文的函数，再逐渐加正则化、支撑集检查和性能优化。这个量虽然定义简单，但它背后那套矩阵不等式体系，值回票价。