跳到正文
EN

9.6

密集编码

提前共享一对 Bell 态，寄一个 qubit 就能捎上两个经典比特：四个 Pauli 门把一对纠缠调到四个正交的 Bell 态上，与隐形传态互为镜像。

建议先掌握

学完本节你应该能

  • 完整推演密集编码协议：四种编码操作、四个 Bell 态、解码线路，全程手算
  • 解释「只动自己这一半，就能到达全部四个 Bell 态」为什么可行
  • 说明 2 比特是上限：没有预共享纠缠时 1 个 qubit 至多带 1 比特（Holevo）
  • 把密集编码与隐形传态的资源等式并排写出，看出对偶关系

上一节结尾我们把隐形传态的交易单倒过来念： 预共享 1 个 ebit，再寄出 1 个 qubit，能兑换几个经典比特？ 9.1 节的 Holevo 论证说一个 qubit 至多读出 1 比特， 这一节却要合法地读出 2 比特。看纠缠怎么把邮费砍半。

具体问题：一次只能寄一个粒子，想说四句话

Alice 要给 Bob 发一条两比特消息——00、01、10、11 四选一 （比如「买入 / 卖出 / 持有 / 清仓」）。但信道昂贵，本月额度只剩一个 qubit。

没有纠缠时，一个 qubit 只值一比特

先看朴素方案的天花板。Alice 把消息编进单个 qubit 的态里寄出， Bob 收到后测量。9.1 节讲过：一次测量只有两个出口， 且不同的非正交态无法被可靠区分。要可靠传 2 比特， Bob 得把四个态无歧义地分开，这需要四个两两正交的态—— 可单个 qubit 的 Hilbert 空间只有二维，至多塞下 2 个正交态。 死路。（这正是 Holevo 定理的特例：无辅助资源时，nn 个 qubit ≤ nn 个经典比特。）

出路在于：Bob 手里可以提前有点东西。只要两人事先分好一对 Bell 态， Alice 手里那一半的「操作余地」就翻倍了。

协议全程手算

事先：两人共享 ∣Φ+⟩=∣00⟩+∣11⟩2\ket{\Phi^+}=\frac{\ket{00}+\ket{11}}{\sqrt2}， 粒子 A 在 Alice 处，粒子 B 在 Bob 处。

            编码（Alice 本地）      寄出 A          解码（Bob 本地）
 A ────────[ I / X / Z / ZX ]────────────────●──[H]──[测量]→ m₁
   ╲                                         │
    Φ⁺                                       │
   ╱                                         │
 B ──────────────────────────────────────────⊕──────[测量]→ m₂
四个 Pauli 门调出四个 Bell 态基础~7 min

第 1 步：编码。 Alice 按要发的消息对自己那一半施加一个门：

  • 消息 00：什么都不做（II）。态不变：
(I⊗I)∣Φ+⟩=∣00⟩+∣11⟩2=∣Φ+⟩(9.6.1)(I\otimes I)\ket{\Phi^+}=\frac{\ket{00}+\ket{11}}{\sqrt2}=\ket{\Phi^+}\tag{9.6.1}
  • 消息 01：施加 XX（翻转 A）。逐项作用在第一位上：
(X⊗I) ∣00⟩+∣11⟩2=∣10⟩+∣01⟩2=∣Ψ+⟩(9.6.2)(X\otimes I)\,\frac{\ket{00}+\ket{11}}{\sqrt2} =\frac{\ket{10}+\ket{01}}{\sqrt2}=\ket{\Psi^+}\tag{9.6.2}
  • 消息 10：施加 ZZ（给 A 的 ∣1⟩\ket{1} 添负号）：
(Z⊗I) ∣00⟩+∣11⟩2=∣00⟩−∣11⟩2=∣Φ−⟩(9.6.3)(Z\otimes I)\,\frac{\ket{00}+\ket{11}}{\sqrt2} =\frac{\ket{00}-\ket{11}}{\sqrt2}=\ket{\Phi^-}\tag{9.6.3}
  • 消息 11：先 XX 后 ZZ：
(ZX⊗I)∣Φ+⟩=(Z⊗I) ∣10⟩+∣01⟩2=∣01⟩−∣10⟩2=∣Ψ−⟩(9.6.4)(ZX\otimes I)\ket{\Phi^+} =(Z\otimes I)\,\frac{\ket{10}+\ket{01}}{\sqrt2} =\frac{\ket{01}-\ket{10}}{\sqrt2}=\ket{\Psi^-}\tag{9.6.4}

四条消息 ↦\mapsto 四个 Bell 态，而 Bell 态两两正交—— 可靠区分所需的正交性凑齐了，只是它长在两比特空间里。

第 2 步：寄出。 Alice 把粒子 A 寄给 Bob。现在两个粒子都在 Bob 手里。

第 3 步：解码 = Bell 测量。 用 9.5 节末尾的线路反着读： CNOT（A 控 B）再对 A 打 HH，把四个 Bell 态映回四个计算基态。 逐一验证（以 ∣Ψ−⟩\ket{\Psi^-} 为例，其余同法）：

∣Ψ−⟩→ CNOT ∣01⟩−∣11⟩2=∣0⟩−∣1⟩2⊗∣1⟩→ H⊗I ∣1⟩⊗∣1⟩=∣11⟩(9.6.5)\ket{\Psi^-}\xrightarrow{\ \mathrm{CNOT}\ } \frac{\ket{01}-\ket{11}}{\sqrt2} =\frac{\ket{0}-\ket{1}}{\sqrt2}\otimes\ket{1} \xrightarrow{\ H\otimes I\ }\ket{1}\otimes\ket{1}=\ket{11}\tag{9.6.5}

四种情形的完整对照：

消息Alice 的门信道里的态测量读数 m1m2m_1m_2
00II∣Φ+⟩\ket{\Phi^+}00
01XX∣Ψ+⟩\ket{\Psi^+}01
10ZZ∣Φ−⟩\ket{\Phi^-}10
11ZXZX∣Ψ−⟩\ket{\Psi^-}11

Bob 确定性地读出两比特。没有概率、没有猜测——因为四个候选态正交。

物理图像

与隐形传态互为镜像。 两个协议消耗同一种燃料（1 个 ebit）， 方向恰好相反：

  • 隐形传态：花 2 个经典比特，运 1 个 qubit；
  • 密集编码：花 1 个 qubit，运 2 个经典比特。

一个用经典信道扛量子货，一个用量子信道扛经典货。 这对镜像说明 qubit 与 cbit 之间没有固定汇率—— 汇率由手头的纠缠储备决定。 「纠缠是一种可消耗的通信资源」这个观念， 正是从这两个 1992/1993 年的协议开始确立的。

数学形式

资源等式并排（箭头左边是消耗，右边是产出）：

1 ebit+2 cbit ⟶ 1 qubit(9.6.6)1\ \text{ebit}+2\ \text{cbit}\ \longrightarrow\ 1\ \text{qubit}\tag{9.6.6}1 ebit+1 qubit ⟶ 2 cbit(9.6.7)1\ \text{ebit}+1\ \text{qubit}\ \longrightarrow\ 2\ \text{cbit}\tag{9.6.7}

两式都不能反推出「白送」：把第二式代入第一式， 左右各消掉一轮，得 2 ebit+往返信道→2\,\text{ebit} + \text{往返信道} \to 原样—— 纠缠只会越用越少，从不凭空增值（LOCC 不增纠缠，9.3 节）。

本节关键公式

  • 编码

    (σ⊗I)∣Φ+⟩,σ∈{I,X,Z,ZX}(\sigma\otimes I)\ket{\Phi^+},\quad \sigma\in\{I,X,Z,ZX\}

    四个 Pauli 操作 ↦ 四个两两正交的 Bell 态

  • 解码

    (H⊗I) CNOT: ∣Bm1m2⟩↦∣m1m2⟩(H\otimes I)\,\mathrm{CNOT}:\ \ket{B_{m_1m_2}}\mapsto\ket{m_1m_2}

    Bell 测量线路，确定性读出

  • 资源等式

    1 ebit+1 qubit→2 cbit1\ \text{ebit}+1\ \text{qubit}\to 2\ \text{cbit}

    与隐形传态 1 ebit + 2 cbit → 1 qubit 对偶

  • Holevo 上限

    χ≤n bit (无纠缠),2n bit (预共享纠缠)\chi\le n\ \text{bit}\ (\text{无纠缠}),\quad 2n\ \text{bit}\ (\text{预共享纠缠})

    密集编码恰好顶格，不存在「更密集」编码

自测共 4 题

  1. 1.

    Alice 想发消息 10，她应对自己的粒子施加哪个门？

  2. 2.

    窃听者 Eve 在途中截获了 Alice 寄出的粒子 A（但拿不到 B）。她能读出多少消息？

  3. 3.

    两人共享 3 对 Bell 态，Alice 共寄出 3 个 qubit。用密集编码最多能可靠传送多少个经典比特？

    bit允许 0% 相对误差
  4. 4.

    关于密集编码与隐形传态的关系，正确的是？（多选）

    多选题

接下来

到目前为止，纠缠帮我们搬运信息：传态、捎话。 下一个问题更有野心：量子力学能不能帮我们计算得更快？ 1992 年的 Deutsch–Jozsa 算法给出第一个干净的「能」—— 一个经典要问指数多次的问题，量子问一次就够。 下一节看叠加与干涉如何变成算力。

全站第 70 / 106 节 · 用 ← → 翻页