相位、纯态与混合态：量子世界的“身份”之谜

🎭

为什么概率相同，量子态却不同？从相位到密度矩阵，揭开量子相干性的面纱

引言：看不见的相位，看得见的概率

在之前的文章中，我们学习了量子比特的叠加态 $|\psi ⟩=\alpha |0⟩+\beta |1⟩$，其中 $\alpha$和 $\beta$是复数，满足$|\alpha {|}^2+|\beta {|}^2=1$。我们也知道测量得到 $|0⟩$ 的概率是 $|\alpha {|}^2$，得到 $|1⟩$ 的概率是 $|\beta {|}^2$。

但这里有一个关键问题：概率只依赖于模平方，丢失了相位的全部信息。例如，考虑两个不同的量子态：

$$|{\psi }_1⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩),|{\psi }_2⟩=\frac{1}{\sqrt{2}}(|0⟩-|1⟩)$$

它们在计算基 $\{|0⟩,|1⟩\}$ 下测量的概率完全相同：各1/2。然而，它们确实是不同的量子态——$|{\psi }_2⟩$ 带有一个相对相位 $-1$。这个相位在干涉实验中会显现出来，例如，在 $|\pm ⟩$ 基下测量，它们的结果完全不同：

• 对 $|{\psi }_1⟩=|+⟩$ 在 $\{|+⟩,|-⟩\}$ 基下测量，总是得到 $|+⟩$（概率1）。
• 对 $|{\psi }_2⟩=|-⟩$ 在相同基下测量，总是得到 $|-⟩$（概率1）。

这就引出了一个深刻的问题：仅凭测量概率，我们无法唯一确定一个量子态。我们需要更丰富的数学工具来描述量子态的全部信息，尤其是相位。更进一步，当系统不是处于一个确定的量子态，而是以一定概率混合多个量子态时，我们该如何描述？这就引出了纯态与混合态的概念。

本文将带你深入理解：

• 相位：量子相干性的灵魂
• 纯态：由态矢描述的“纯粹”量子态
• 混合态：经典概率混合，由密度矩阵描述
• 如何用密度矩阵统一处理纯态和混合态
• 通过实例和Python代码区分它们

一、相位：量子相干性的体现

1.1 相位的数学表示

任意单量子比特态可以写为：
$$|\psi ⟩=\cos \frac{\theta }{2}|0⟩+e^{i\varphi }\sin \frac{\theta }{2}|1⟩$$
其中 $\theta \in [0,\pi ]$，$\varphi \in [0,2\pi )$。这里的 $\varphi$ 就是相对相位。它决定了 $|0⟩$ 和 $|1⟩$ 之间的相位关系。

1.2 相位的作用

相位在量子干涉中起着决定性作用。考虑两个态：
$$|+⟩=\frac{|0⟩+|1⟩}{\sqrt{2}},|-⟩=\frac{|0⟩-|1⟩}{\sqrt{2}}$$
它们的区别仅在于相对相位：前者 $\varphi =0$，后者 $\varphi =\pi$。在计算基下测量，它们表现完全相同（各50%概率）。但在 $X$ 基（即 $\{|+⟩,|-⟩\}$）下测量，$|+⟩$ 总是给出 $|+⟩$，$|-⟩$ 总是给出 $|-⟩$。因此，相位可以通过在不同基下的测量来揭示。

1.3 为什么测量概率丢失相位？

测量概率 $p(i)=|⟨i|\psi ⟩{|}^2$ 是内积模的平方。对于 $|\psi ⟩=\alpha |0⟩+\beta |1⟩$，$|⟨0|\psi ⟩{|}^2=|\alpha {|}^2$ 只依赖于模长，不依赖于 $\alpha$的相位。同样，$|⟨1|\psi ⟩{|}^2=|\beta {|}^2$ 也只依赖于模长。因此，单次基测量无法获取相位信息。

要获取相位，需要进行干涉实验：将待测态与一个参考态叠加，通过测量干涉图样提取相位。

二、纯态：由态矢描述的量子态

纯态（pure state）是指可以用一个态矢 $|\psi ⟩$ 完全描述的量子态。它满足：

• 可以用希尔伯特空间中的向量表示。
• 具有确定的相位关系，即量子相干性。
• 测量概率由波恩规则给出，但相位信息隐含在态矢中。

例如，$|0⟩$、$|1⟩$、$|+⟩$、$|-⟩$ 都是纯态。纯态也可以写成密度算符的形式：
$$\rho =|\psi ⟩⟨\psi |$$
这是一个秩为1的投影算符，满足 ${\rho }^2=\rho$，且 $\mathrm{Tr}({\rho }^2)=1$。

三、混合态：经典概率混合

3.1 从比喻说起

让我们回到用户提供的比喻：

假设左手抓着一个袋子，这个袋子里面有无数的量子态，它们全都是 $|\psi ⟩=\frac{|0⟩+|1⟩}{\sqrt{2}}$ 这种叠加态。另外，有一个机器可以在 $Z$ 方向（计算基）上测量。每次拿出一个态，对它进行测量，不管它是 $|0⟩$ 还是 $|1⟩$，都扔到右手边的另一个袋子里面。如此反复，右边袋子里面的态越来越多了。由于测量结果对于这两种情况是等概率的，所以袋子里面约有一半的态是 $|0⟩$，另一半是 $|1⟩$。

现在，从右边的袋子里取出一个量子态。我们能说它和左边袋子里的态一样都是 $|+⟩$ 吗？

答案是不能。左边袋子里的每个态都是 $|+⟩$——一个纯态，具有确定的相位关系（$\varphi =0$）。右边袋子里的态，实际上是一半 $|0⟩$ 和一半 $|1⟩$ 的经典混合，就像一袋红球和白球一样。这种混合不包含任何相位信息，我们无法知道这些 $|0⟩$ 和 $|1⟩$ 原本是从 $|+⟩$ 测量得来的。它只能表示为：
$$\{\begin{array}{l}\text{以概率 }1/2\text{ 处于 }|0⟩\\ \text{以概率 }1/2\text{ 处于 }|1⟩\end{array}$$
这种描述就是混合态（mixed state）。

3.2 混合态的数学表示：密度矩阵

混合态不能用一个态矢表示，但可以用密度算符（density operator）统一描述。对于一个以概率 $p_i$ 处于纯态 $|{\psi }_i⟩$ 的系综，密度算符定义为：
$$\rho =\sum _i{p}_i|{\psi }_i⟩⟨{\psi }_i|$$
其中 $p_i>0$，${\sum }_i{p}_i=1$。

对于上述例子：
$$\rho =\frac{1}{2}|0⟩⟨0|+\frac{1}{2}|1⟩⟨1|=\frac{1}{2}\left[\begin{array}{cc}1& 0\\ 0& 0\end{array}\right]+\frac{1}{2}\left[\begin{array}{cc}0& 0\\ 0& 1\end{array}\right]=\left[\begin{array}{cc}\frac{1}{2}& 0\\ 0& \frac{1}{2}\end{array}\right]$$
这就是完全混合态，也称为最大混合态。

3.3 密度矩阵的性质

• 厄米性：${\rho }^{†}=\rho$
• 迹为1：$\mathrm{Tr}(\rho )=1$
• 半正定性：对任意态 $|\varphi ⟩$，$⟨\varphi |\rho |\varphi ⟩\ge 0$
• 对于纯态：${\rho }^2=\rho$，且 $\mathrm{Tr}({\rho }^2)=1$
• 对于混合态：$\mathrm{Tr}({\rho }^2)<1$（等于1当且仅当纯态）

$\mathrm{Tr}({\rho }^2)$ 称为纯度（purity），是衡量一个态“混合程度”的指标。

四、纯态与混合态的对比

重要区别：量子相干性

纯态具有量子相干性，这意味着它们可以产生干涉现象。混合态则没有这种相干性，因为不同分量之间的相位关系是随机的或丢失的。

例如，考虑两个态：

• 纯态 $|+⟩=\frac{|0⟩+|1⟩}{\sqrt{2}}$
• 混合态 $\rho =\frac{1}{2}(|0⟩⟨0|+|1⟩⟨1|)$

在计算基下测量，它们都给出50%概率0和50%概率1。但在 $X$ 基下测量：

• $|+⟩$ 总是给出 $|+⟩$（概率1）
• 混合态 $\rho$ 在 $X$ 基下测量，得到 $|+⟩$ 和 $|-⟩$ 的概率各1/2（因为 $\rho =\frac{1}{2}I$ 在任何基下都是均匀分布）

因此，通过在不同基下的测量，我们可以区分纯态和混合态。

五、密度矩阵的物理意义

密度矩阵不仅可以描述混合态，也可以描述复合系统的子系统。例如，一个两比特纠缠态的部分迹（partial trace）得到的就是混合态。这在量子信息中非常重要。

5.1 部分迹与约化密度矩阵

对于两比特纠缠态 $|{\Phi }^{+}⟩=\frac{|00⟩+|11⟩}{\sqrt{2}}$，如果我们只关心第一个比特，它的状态由对第二个比特求部分迹得到：
$${\rho }_A={\mathrm{Tr}}_B(|{\Phi }^{+}⟩⟨{\Phi }^{+}|)=\frac{1}{2}(|0⟩⟨0|+|1⟩⟨1|)$$
这正是完全混合态！这说明，尽管整体系统处于纯态，但每个子系统却处于混合态——这是纠缠的重要特征。

六、动手实践：用Python区分纯态与混合态

下面我们用NumPy构造纯态和混合态，计算它们的纯度，并模拟在不同基下的测量。

import numpy as np

# 基态
ket0 = np.array([[1], [0]])
ket1 = np.array([[0], [1]])

# 定义纯态 |+>
plus = (ket0 + ket1) / np.sqrt(2)
rho_pure = plus @ plus.conj().T # 密度矩阵

# 定义混合态 (最大混合态)
rho_mixed = 0.5 * (ket0 @ ket0.conj().T + ket1 @ ket1.conj().T)

# 计算纯度
purity_pure = np.trace(rho_pure @ rho_pure).real
purity_mixed = np.trace(rho_mixed @ rho_mixed).real

print("纯态 ρ = \\n", rho_pure)
print("纯度 Tr(ρ^2) =", purity_pure)
print("\\n混合态 ρ = \\n", rho_mixed)
print("纯度 Tr(ρ^2) =", purity_mixed)

# 定义 X 基的投影算符
ket_plus = plus
ket_minus = (ket0 – ket1) / np.sqrt(2)
P_plus = ket_plus @ ket_plus.conj().T
P_minus = ket_minus @ ket_minus.conj().T

# 在 X 基下测量纯态
prob_plus_pure = np.trace(P_plus @ rho_pure).real
prob_minus_pure = np.trace(P_minus @ rho_pure).real
print("\\n纯态在 X 基下测量:")
print("p(+) =", prob_plus_pure, "p(-) =", prob_minus_pure)

# 在 X 基下测量混合态
prob_plus_mixed = np.trace(P_plus @ rho_mixed).real
prob_minus_mixed = np.trace(P_minus @ rho_mixed).real
print("\\n混合态在 X 基下测量:")
print("p(+) =", prob_plus_mixed, "p(-) =", prob_minus_mixed)

输出：

纯态 ρ =
[[0.5 0.5]
[0.5 0.5]]
纯度 Tr(ρ^2) = 1.0

混合态 ρ =
[[0.5 0. ]
[0. 0.5]]
纯度 Tr(ρ^2) = 0.5

纯态在 X 基下测量:
p(+) = 1.0 p(-) = 0.0

混合态在 X 基下测量:
p(+) = 0.5 p(-) = 0.5

完美验证了我们的讨论：纯态在 X 基下测量结果确定，混合态则完全随机。

七、总结

纯态与混合态的根本区别在于量子相干性。纯态保留了相位信息，可以产生干涉；混合态则相当于经典统计混合，丢失了相位。密度矩阵是统一描述两者的强大工具，也是处理子系统、纠缠和开放量子系统的必备语言。

理解这些概念，对于深入学习量子信息、量子热力学和量子退相干至关重要。

思考题

欢迎在评论区分享你的思考和答案！

参考：[1] Nielsen & Chuang, Quantum Computation and Quantum Information [2] 本系列前文

🔮 量子门与量子电路：用矩阵操控量子态，实现最简单的量子算法

从线性代数到量子计算——一次函数查询如何区分全局性质？

引言：操控量子态的艺术

在经典计算机中，我们通过逻辑门（与门、或门、非门）处理比特，这些门对应着布尔函数。在量子计算机中，我们用量子门操控量子比特，而量子门的数学本质是酉矩阵——一种保持向量内积的线性变换。通过将一系列量子门组合成量子电路，我们可以实现复杂的量子算法，利用叠加和干涉解决经典计算机难以处理的问题。

本文将带你从线性代数视角重新认识量子门，并实现量子计算史上第一个展示量子优势的算法——Deutsch算法。你将看到：

• 量子态如何表示为向量
• 量子门如何用矩阵作用改变量子态
• 如何用H门、X门、CNOT门构建电路
• Deutsch算法的完整数学推导与Python代码实现
• 从Deutsch到Deutsch-Jozsa的推广

一、量子态的数学表示：态矢

在量子力学中，一个量子系统的状态由希尔伯特空间中的态矢（state vector）描述。对于量子比特，两个基态通常记为：
$$|0⟩=\left[\begin{array}{c}1\\ 0\end{array}\right],|1⟩=\left[\begin{array}{c}0\\ 1\end{array}\right]$$
任意单量子比特态可以表示为这两个基的线性组合：
$$|\psi ⟩=\alpha |0⟩+\beta |1⟩=\left[\begin{array}{c}\alpha \\ \beta \end{array}\right]$$
其中 $\alpha ,\beta$ 是复数，满足归一化条件 $|\alpha {|}^2+|\beta {|}^2=1$。$|\alpha {|}^2$ 和 $|\beta {|}^2$ 分别是测量得到 $|0⟩$ 和 $|1⟩$ 的概率。

二、量子门：酉矩阵的作用

2.1 酉矩阵的定义

量子门对应酉矩阵 $U$，满足 $U^{†}U=U{U}^{†}=I$，其中 $U^{†}$ 是 $U$ 的共轭转置。酉矩阵的作用是将一个归一化的量子态映射到另一个归一化的量子态，保持概率总和为1。量子门是可逆的（因为酉矩阵可逆），这与许多经典逻辑门（如AND）的不可逆形成鲜明对比。

2.2 常用单量子比特门

这些单比特门是构成量子电路的基本单元。

2.3 两量子比特门：CNOT

两量子比特门中最重要的当属CNOT门（受控非门）。它的矩阵表示为：
CNOT=[1000010000010010]
\\text{CNOT} = \\begin{bmatrix}
1 & 0 & 0 & 0 \\\\
0 & 1 & 0 & 0 \\\\
0 & 0 & 0 & 1 \\\\
0 & 0 & 1 & 0
\\end{bmatrix}
CNOT=​1000​0100​0001​0010​​
作用：如果控制比特（第一个）为 $|1⟩$，则翻转目标比特（第二个）；否则保持不变。用计算基表示为：
$$\text{CNOT}|00⟩=|00⟩,\text{CNOT}|01⟩=|01⟩,\text{CNOT}|10⟩=|11⟩,\text{CNOT}|11⟩=|10⟩$$

CNOT门可以产生纠缠，是量子计算中不可或缺的组件。

三、量子电路的构建

3.1 门的并行：张量积

当多个门同时作用在不同量子比特上时，整体矩阵由它们的张量积给出。例如，对第一个比特应用H门，同时对第二个比特应用X门，整体矩阵为 $H\otimes X$。张量积的规则：$(A\otimes B)(|\psi ⟩\otimes |\varphi ⟩)=(A|\psi ⟩)\otimes (B|\varphi ⟩)$。

3.2 门的顺序：矩阵乘法

当门依次作用时，整体演化由矩阵乘积描述，但顺序要反过来：先作用的门在乘积的右边。例如，电路先应用 $U_1$，再应用 $U_2$，最后应用 $U_3$，则整体矩阵为 $U_3{U}_2{U}_1$。

3.3 测量

测量是量子电路的最后一步，它将量子信息转化为经典信息。测量结果是一个概率分布，由波恩规则给出：对态 $|\psi ⟩$ 测量得到 $|i⟩$ 的概率为 $|⟨i|\psi ⟩{|}^2$。测量后，量子态坍缩到 $|i⟩$。

四、最简单的量子算法：Deutsch算法

4.1 问题描述

我们有一个未知的黑箱函数 $f:\{0,1\}\to \{0,1\}$，它要么是常数函数（$f(0)=f(1)$），要么是平衡函数（$f(0)\ne f(1)$）。我们需要用最少的查询次数判断它是常数还是平衡。

经典解法：需要分别查询 $f(0)$ 和 $f(1)$，然后比较——需要两次查询。

量子解法：Deutsch算法仅需一次查询！它展示了量子并行性的威力。

4.2 电路设计

Deutsch算法的量子电路如下：

q0: |0> ── H ── U_f ── H ── M
q1: |1> ── H ───────────

其中 $U_f$ 是量子预言机，实现：
$$U_f|x⟩|y⟩=|x⟩|y\oplus f(x)⟩$$
$\oplus$ 是模2加法（异或）。

4.3 数学推导

我们一步步推导量子态的变化。

初始化：
$$|{\psi }_0⟩=|0⟩\otimes |1⟩=|01⟩$$

第一步：对两个比特应用H门：
$$|{\psi }_1⟩=(H\otimes H)|01⟩=H|0⟩\otimes H|1⟩$$
因为 $H|0⟩=\frac{|0⟩+|1⟩}{\sqrt{2}}$，$H|1⟩=\frac{|0⟩-|1⟩}{\sqrt{2}}$，所以：
$$|{\psi }_1⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)\otimes \frac{1}{\sqrt{2}}(|0⟩-|1⟩)=\frac{1}{2}\left[|0⟩(|0⟩-|1⟩)+|1⟩(|0⟩-|1⟩)\right]$$

第二步：应用预言机 $U_f$：

预言机的作用是将 $|x⟩|y⟩$ 变为 $|x⟩|y\oplus f(x)⟩$。注意当 $y$ 处于 $|0⟩-|1⟩$ 时，这个变换会引入一个相位：
$$U_f|x⟩(|0⟩-|1⟩)=|x⟩(|f(x)⟩-|1\oplus f(x)⟩)=(-1{)}^{f(x)}|x⟩(|0⟩-|1⟩)$$
因为若 $f(x)=0$，则 $|0⟩-|1⟩$ 不变；若 $f(x)=1$，则 $|1⟩-|0⟩=-(|0⟩-|1⟩)$。

因此，应用 $U_f$ 后：
$$|{\psi }_2⟩=\frac{1}{2}\left[(-1{)}^{f(0)}|0⟩(|0⟩-|1⟩)+(-1{)}^{f(1)}|1⟩(|0⟩-|1⟩)\right]$$
提取公因子 $\frac{|0⟩-|1⟩}{\sqrt{2}}$，并将系数归一化：
$$|{\psi }_2⟩=\left[\frac{(-1{)}^{f(0)}|0⟩+(-1{)}^{f(1)}|1⟩}{\sqrt{2}}\right]\otimes \frac{|0⟩-|1⟩}{\sqrt{2}}$$

第三步：对第一个比特再次应用H门：

H门作用在第一个比特的态上：
$$H\left(\frac{(-1{)}^{f(0)}|0⟩+(-1{)}^{f(1)}|1⟩}{\sqrt{2}}\right)$$

• 若 $f(0)=f(1)$（常数函数），则两个系数符号相同，设为 $s$，那么态为 $s\frac{|0⟩+|1⟩}{\sqrt{2}}$，经过H门后：
  $$H\left(s\frac{|0⟩+|1⟩}{\sqrt{2}}\right)=s|0⟩$$
• 若 $f(0)\ne f(1)$（平衡函数），则两个系数符号相反，设为 $s|0⟩-s|1⟩$（其中 $s=\pm 1$），那么态为 $s\frac{|0⟩-|1⟩}{\sqrt{2}}$，经过H门后：
  $$H\left(s\frac{|0⟩-|1⟩}{\sqrt{2}}\right)=s|1⟩$$

因此，第一个比特的最终状态为：

• 常数函数：$|0⟩$
• 平衡函数：$|1⟩$

第四步：测量第一个比特：

测量结果直接告诉我们函数类型：若测得0，则为常数；若测得1，则为平衡。

4.4 关键洞察

• 预言机在一次调用中同时处理了 $x=0$ 和 $x=1$ 的信息，并将结果编码在相位中。
• 最后的H门和测量将相位信息转化为计算基下的确定性结果。
• 整个过程只用了一次函数查询，实现了经典算法需要两次查询才能完成的任务。

五、Python实现与模拟

我们使用NumPy模拟Deutsch算法的整个过程，验证四种可能的预言机。

import numpy as np

# 基态
ket0 = np.array([[1], [0]])
ket1 = np.array([[0], [1]])

# 门
H = 1/np.sqrt(2) * np.array([[1, 1], [1, –1]])
X = np.array([[0, 1], [1, 0]])
I = np.eye(2)

# CNOT矩阵 (4×4)
CNOT = np.array([
[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]
])

def deutsch_algorithm(oracle_type):
"""
模拟Deutsch算法
oracle_type: 'constant_0', 'constant_1', 'balanced_x', 'balanced_xnot'
"""
# 初始态 |01>
psi = np.kron(ket0, ket1)

# 第一步：H⊗H
H2 = np.kron(H, H)
psi = H2 @ psi

# 第二步：预言机 U_f
if oracle_type == 'constant_0':
# f(0)=0, f(1)=0: U_f = I⊗I
U_f = np.eye(4)
elif oracle_type == 'constant_1':
# f(0)=1, f(1)=1: U_f = I⊗X
U_f = np.kron(I, X)
elif oracle_type == 'balanced_x':
# f(0)=0, f(1)=1: 即 f(x)=x，实现为CNOT
U_f = CNOT
elif oracle_type == 'balanced_xnot':
# f(0)=1, f(1)=0: f(x)=x⊕1，先X再CNOT
X_on_second = np.kron(I, X)
U_f = CNOT @ X_on_second
else:
raise ValueError("Unknown oracle type")

psi = U_f @ psi

# 第三步：对第一个比特应用H门
H_on_first = np.kron(H, I)
psi = H_on_first @ psi

# 第四步：测量第一个比特
prob_0 = np.abs(psi[0,0])**2 + np.abs(psi[1,0])**2 # |00> 和 |01>
prob_1 = np.abs(psi[2,0])**2 + np.abs(psi[3,0])**2 # |10> 和 |11>

result = 0 if prob_0 > 0.5 else 1
return result

# 测试
print("常数函数 f(0)=f(1)=0 结果:", deutsch_algorithm('constant_0'))
print("常数函数 f(0)=f(1)=1 结果:", deutsch_algorithm('constant_1'))
print("平衡函数 f(x)=x 结果:", deutsch_algorithm('balanced_x'))
print("平衡函数 f(x)=x⊕1 结果:", deutsch_algorithm('balanced_xnot'))

运行输出：

常数函数 f(0)=f(1)=0 结果: 0
常数函数 f(0)=f(1)=1 结果: 0
平衡函数 f(x)=x 结果: 1
平衡函数 f(x)=x⊕1 结果: 1

这正是Deutsch算法的预期结果：常数函数测得0，平衡函数测得1。

六、从Deutsch到Deutsch-Jozsa

Deutsch算法处理的是单比特函数。它的推广——Deutsch-Jozsa算法——可以处理 $n$比特的函数，判断它是常数函数还是平衡函数（对于平衡函数，输出0和1的个数相等）。经典算法在最坏情况下需要 $2^{n-1}+1$ 次查询，而Deutsch-Jozsa算法仍然只需要一次查询！这是第一个展示指数级加速的量子算法。

Deutsch-Jozsa的电路结构与Deutsch类似，只是将单比特H门替换为 $n$ 比特的H门，预言机作用于 $n+1$ 个比特上。其核心思想同样是相位编码和干涉。

七、总结

量子门与量子电路是量子计算的“硬件”描述语言。通过矩阵乘法，我们可以精确预言量子态的演化，并设计出超越经典算法的解决方案。Deutsch算法虽小，却展示了量子计算的精髓——并行性与干涉的结合。掌握这些基础，你就能向更复杂的Grover搜索和Shor因式分解迈进。

思考题

欢迎在评论区分享你的思考和实验结果！

参考：[1] Nielsen & Chuang, Quantum Computation and Quantum Information [2] 本系列前文