状态的演化：量子世界的时间箭头 | 量子门与酉变换

⏳

从薛定谔方程到矩阵乘法，量子态如何随时间流动？

---

引言：量子态不是静止的

在之前的文章中，我们学会了如何用态矢 (|\psi\rangle) 描述一个量子系统的状态。我们也知道量子可以同时处于多个状态的叠加------比如一个量子比特可以同时是 (|0\rangle) 和 (|1\rangle)。但一个自然而然的问题是：量子态会随时间变化吗？如果会，它是如何演化的？

在经典物理中，物体的状态（位置、速度）随时间的变化由牛顿定律支配。在量子世界，状态的演化由薛定谔方程 描述。但幸运的是，对于量子计算而言，我们并不需要求解偏微分方程------在封闭量子系统中，演化被简化为一个非常优雅的数学形式：酉变换。

本文将带你深入理解：

• 量子态演化的数学本质------酉矩阵
• 为什么演化必须是"酉"的（概率守恒）
• 量子门就是实现演化的酉矩阵
• 以X门为例，亲手计算态矢的变换
• 用Python模拟量子门的作用

---

一、封闭系统的演化：酉变换

1.1 基本假设

量子力学中有一条基本假设：封闭量子系统的演化由酉变换描述。所谓"封闭"，是指系统与外界没有相互作用，没有测量干扰。

具体地说，假设系统在 t0t_0t0 时刻处于状态 ∣ψ(t0)⟩|\psi(t_0)\rangle∣ψ(t0)⟩，经过一段时间后，在 ttt 时刻的状态为：
∣ψ(t)⟩=U(t,t0)∣ψ(t0)⟩ |\psi(t)\rangle = U(t, t_0) |\psi(t_0)\rangle ∣ψ(t)⟩=U(t,t0)∣ψ(t0)⟩

其中 (U(t, t_0)) 是一个只依赖于时间 (t) 和 (t_0) 的算符，它满足酉性条件 ：
U†U=UU†=I U^\dagger U = U U^\dagger = I U†U=UU†=I

这里 U†U^\daggerU† 是 UUU 的共轭转置（转置后再取每个元素的复共轭），III 是单位矩阵。

1.2 为什么必须是酉的？

酉性条件有两个核心物理要求：

1. 概率守恒 ：初始态 ∣ψ(t0)⟩|\psi(t_0)\rangle∣ψ(t0)⟩ 满足归一化 ⟨ψ(t0)∣ψ(t0)⟩=1\langle\psi(t_0)|\psi(t_0)\rangle = 1⟨ψ(t0)∣ψ(t0)⟩=1。演化后：

   $$

   \langle\psi(t)|\psi(t)\rangle = \langle\psi(t_0)| U^\dagger U |\psi(t_0)\rangle = \langle\psi(t_0)|\psi(t_0)\rangle = 1

   $4

   概率和始终为1，符合物理实际。

2. 可逆性 ：酉变换一定有逆变换 U−1=U†U^{-1} = U^\daggerU−1=U†，这意味着量子演化在理论上是可逆的（除非测量介入）。这与经典逻辑门（如AND门）的不可逆形成鲜明对比。

1.3 酉矩阵的性质

• 酉矩阵的行列式的模为1：∣det⁡U∣=1|\det U| = 1∣detU∣=1
• 酉矩阵的特征值的模为1
• 酉矩阵的列向量构成一组标准正交基

在量子计算中，所有合法的量子门都是酉矩阵。

---

二、量子门：酉矩阵的物理化身

2.1 什么是量子门？

量子门就是作用在量子比特上的基本操作，对应一个酉矩阵。它们可以改变量子比特的状态，但必须保持归一化和可逆性。

最简单的量子门是作用在单量子比特上的门，它们在计算基 {∣0⟩,∣1⟩}\{|0\rangle, |1\rangle\}{∣0⟩,∣1⟩} 下可以表示为 2×22 \times 22×2 酉矩阵。

2.2 泡利矩阵：基础中的基础

泡利矩阵是一组最重要的酉矩阵，它们构成了单量子比特门的基础：

$$

I = \begin{bmatrix} 1 & 0 \ 0 & 1 \end{bmatrix}, \quad

X = \begin{bmatrix} 0 & 1 \ 1 & 0 \end{bmatrix}, \quad

Y = \begin{bmatrix} 0 & -i \ i & 0 \end{bmatrix}, \quad

Z = \begin{bmatrix} 1 & 0 \ 0 & -1 \end{bmatrix}

$4

容易验证它们都是酉矩阵：

• X†=XX^\dagger = XX†=X，且 KaTeX parse error: Can't use function '\)' in math mode at position 8: X^2 = I\̲)̲，所以 \(X^\dagger...
• 其他类似

2.3 X门：量子非门

X门的作用类似于经典的非门：它将 ∣0⟩|0\rangle∣0⟩ 变成 ∣1⟩|1\rangle∣1⟩，将 ∣1⟩|1\rangle∣1⟩ 变成 ∣0⟩|0\rangle∣0⟩。让我们用矩阵乘法验证：

X∣0⟩=011010=01=∣1⟩ X|0\rangle = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} \begin{bmatrix} 1 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 \\ 1 \end{bmatrix} = |1\rangle X∣0⟩=011010=01=∣1⟩
X∣1⟩=011001=10=∣0⟩ X|1\rangle = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} \begin{bmatrix} 0 \\ 1 \end{bmatrix} = \begin{bmatrix} 1 \\ 0 \end{bmatrix} = |0\rangle X∣1⟩=011001=10=∣0⟩

对于叠加态，X门会交换概率幅：
X(α∣0⟩+β∣1⟩)=αX∣0⟩+βX∣1⟩=α∣1⟩+β∣0⟩ X(\alpha|0\rangle + \beta|1\rangle) = \alpha X|0\rangle + \beta X|1\rangle = \alpha|1\rangle + \beta|0\rangle X(α∣0⟩+β∣1⟩)=αX∣0⟩+βX∣1⟩=α∣1⟩+β∣0⟩

这正是线性性的体现：量子门作用在叠加态上，等于分别作用在每个基态上再叠加。

由于X门与经典非门在功能上的相似性，它常被称为量子非门（quantum NOT gate）。

---

三、动手实践：用Python模拟X门

下面我们用NumPy来模拟X门对量子态的作用，直观感受态矢的变换。

import numpy as np

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

# 定义X门
X = np.array([[0, 1], [1, 0]])

# 验证X门是酉矩阵
print("X^† X = \n", X.conj().T @ X)
print("是否等于单位矩阵？", np.allclose(X.conj().T @ X, np.eye(2)))

# 作用在基态上
print("X|0> = \n", X @ ket0)
print("X|1> = \n", X @ ket1)

# 作用在叠加态 |+> = (|0> + |1>)/√2
plus = (ket0 + ket1) / np.sqrt(2)
print("|+> = \n", plus)

X_plus = X @ plus
print("X|+> = \n", X_plus)

# 验证结果应为 |+> 本身（因为 X|+> = (|1>+|0>)/√2 = |+>）
print("是否等于 |+>？", np.allclose(X_plus, plus))

运行输出：

X^† X = 
 [[1. 0.]
 [0. 1.]]
是否等于单位矩阵？ True
X|0> = 
 [[0.]
 [1.]]
X|1> = 
 [[1.]
 [0.]]
|+> = 
 [[0.70710678]
 [0.70710678]]
X|+> = 
 [[0.70710678]
 [0.70710678]]
是否等于 |+>？ True

可见，X门确实交换了 ∣0⟩|0\rangle∣0⟩ 和 ∣1⟩|1\rangle∣1⟩，并且作用于 ∣+⟩|+\rangle∣+⟩ 时保持不变（因为 ∣+⟩|+\rangle∣+⟩ 是X门的本征态，本征值为+1）。

---

四、更多单量子比特门

除了泡利门，常用的单量子比特门还有：

4.1 Hadamard门

H=12111−1 H = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} H=2 1111−1

作用：
H∣0⟩=∣0⟩+∣1⟩2=∣+⟩,H∣1⟩=∣0⟩−∣1⟩2=∣−⟩ H|0\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}} = |+\rangle, \quad H|1\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}} = |-\rangle H∣0⟩=2 ∣0⟩+∣1⟩=∣+⟩,H∣1⟩=2 ∣0⟩−∣1⟩=∣−⟩

H门在量子计算中极为重要，用于创造叠加态。

4.2 相位门S

S=100i S = \begin{bmatrix} 1 & 0 \\ 0 & i \end{bmatrix} S=100i

作用：保持 ∣0⟩|0\rangle∣0⟩ 不变，将 ∣1⟩|1\rangle∣1⟩ 的相位旋转 π/2\pi/2π/2。

4.3 T门

T=100eiπ/4 T = \begin{bmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{bmatrix} T=100eiπ/4

作用：π/4\pi/4π/4 相位门。

4.4 旋转门

更一般的单比特门可以实现绕布洛赫球任意轴的旋转：
Rx(θ)=cos⁡θ2I−isin⁡θ2X R_x(\theta) = \cos\frac{\theta}{2} I - i\sin\frac{\theta}{2} X Rx(θ)=cos2θI−isin2θX

等等。

所有这些都是酉矩阵，因此都是合法的量子门。

---

五、量子门的组合：从单门到电路

当多个量子门依次作用时，整体演化由它们的矩阵乘积给出，但顺序要反过来 ：先作用的门在乘法中位于右边。例如，先应用H门，再应用X门，整体矩阵为：
U=X⋅H U = X \cdot H U=X⋅H

对于多量子比特系统，我们需要用张量积 组合单比特门。例如，对第一个比特应用H门，第二个比特应用X门，整体为 H⊗XH \otimes XH⊗X。

将这些门按一定顺序排列，就构成了量子电路------量子算法的骨架。

---

六、总结

概念	数学描述	物理意义
状态演化	∣ψ(t)⟩=U∣ψ(0)⟩|\psi(t)\rangle = U|\psi(0)\rangle∣ψ(t)⟩=U∣ψ(0)⟩	封闭系统的时间演化
酉矩阵	U†U=IU^\dagger U = IU†U=I	保持概率和可逆性
量子门	具体的酉矩阵	量子计算的基本操作
X门	0110\begin{bmatrix}0&1\\1&0\end{bmatrix}0110	量子非门，交换 ∣0⟩|0\rangle∣0⟩ 和 ∣1⟩|1\rangle∣1⟩
门组合	矩阵乘积（注意顺序）	构建复杂变换

量子态的演化本质上就是矩阵乘法。通过选择不同的酉矩阵（量子门），我们可以精确操控量子态，实现从简单的翻转到复杂的量子算法。

在下一篇文章中，我们将把这些单门组合起来，构建真正的量子电路，并运行第一个完整的量子算法------Deutsch算法。

---

思考题

1. 验证Y门是否满足酉性条件，并计算 Y∣0⟩Y|0\rangleY∣0⟩ 和 Y∣1⟩Y|1\rangleY∣1⟩。
2. 证明 HXH=ZH X H = ZHXH=Z。（提示：用矩阵乘法）
3. 如果一个量子门不是酉矩阵，会发生什么物理后果？

欢迎在评论区分享你的计算和思考！

---

下期预告：量子电路入门------从Hadamard到CNOT，构建你的第一个量子算法

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

⚡ 量子电路入门：从Hadamard到CNOT，构建你的第一个量子算法

像搭积木一样搭建量子电路，用Deutsch算法感受量子并行性的魅力

---

引言：量子计算的核心------量子电路

经典计算机由逻辑门（与门、或门、非门）构成的电路组成，这些门处理经典的0和1。同样，量子计算机的核心是量子电路 ------由量子门连接而成的网络，负责对量子比特（qubit）进行操控。

在之前的文章中，我们学习了单量子比特门（如H门、X门）的矩阵表示，也知道了两量子比特门（如CNOT）可以产生纠缠。现在，是时候把这些"积木"组合起来，搭建第一个真正的量子电路，并运行一个简单的量子算法------Deutsch算法。

通过本文，你将亲手体验：

• 如何用H门创造叠加态
• 如何用CNOT门实现纠缠（虽然不是Deutsch算法必需，但为后续铺垫）
• 如何组合这些门形成一个完整的量子电路
• 如何用数学推导和Python代码验证Deutsch算法的正确性

---

一、单量子比特门：基础积木

1.1 回顾：量子门就是酉矩阵

任何合法的量子门都可以用一个酉矩阵 UUU 表示，满足 U†U=IU^\dagger U = IU†U=I。对于单量子比特，门是 2×22\times22×2 矩阵，作用在态矢 ∣ψ⟩|\psi\rangle∣ψ⟩ 上得到新态 U∣ψ⟩U|\psi\rangleU∣ψ⟩。

1.2 Hadamard门：创造叠加的魔法师

H门是最重要的单比特门之一，它的矩阵为：
H=12111−1 H = \frac{1}{\sqrt{2}}\begin{bmatrix}1 & 1 \\ 1 & -1\end{bmatrix} H=2 1111−1

作用效果：
H∣0⟩=∣0⟩+∣1⟩2≡∣+⟩,H∣1⟩=∣0⟩−∣1⟩2≡∣−⟩ H|0\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}} \equiv |+\rangle,\quad H|1\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}} \equiv |-\rangle H∣0⟩=2 ∣0⟩+∣1⟩≡∣+⟩,H∣1⟩=2 ∣0⟩−∣1⟩≡∣−⟩

H门将基态变成等幅叠加态，是量子并行性的起点。注意两次应用H门会回到原态：H2=IH^2 = IH2=I。

1.3 泡利门：X、Y、Z

• X门 （量子非门）：X=0110X = \begin{bmatrix}0&1\\1&0\end{bmatrix}X=0110，交换 ∣0⟩|0\rangle∣0⟩ 和 ∣1⟩|1\rangle∣1⟩。
• Z门 ：Z=100−1Z = \begin{bmatrix}1&0\\0&-1\end{bmatrix}Z=100−1，给 ∣1⟩|1\rangle∣1⟩ 引入相位 −1-1−1。
• Y门 ：Y=0−ii0Y = \begin{bmatrix}0&-i\\i&0\end{bmatrix}Y=0i−i0，组合了比特翻转和相位翻转。

在电路中，X门常用作翻转操作，Z门用于调整相位。

---

二、两量子比特门：引入关联

单比特门只能独立操作每个量子比特。要让比特之间产生相互作用，我们需要多比特门 。最基本的双比特门是CNOT门（受控非门）。

2.1 CNOT门的定义

CNOT门有两个输入：控制比特 （control qubit）和目标比特 （target qubit）。如果控制比特是 ∣1⟩|1\rangle∣1⟩，则翻转目标比特；否则保持不变。用计算基表示为：

CNOT∣00⟩=∣00⟩,CNOT∣01⟩=∣01⟩,CNOT∣10⟩=∣11⟩,CNOT∣11⟩=∣10⟩ \text{CNOT}|00\rangle = |00\rangle,\quad \text{CNOT}|01\rangle = |01\rangle,\quad \text{CNOT}|10\rangle = |11\rangle,\quad \text{CNOT}|11\rangle = |10\rangle CNOT∣00⟩=∣00⟩,CNOT∣01⟩=∣01⟩,CNOT∣10⟩=∣11⟩,CNOT∣11⟩=∣10⟩

它的矩阵形式（4×4，按 ∣00⟩,∣01⟩,∣10⟩,∣11⟩|00\rangle,|01\rangle,|10\rangle,|11\rangle∣00⟩,∣01⟩,∣10⟩,∣11⟩ 顺序）为：
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= 1000010000010010

2.2 CNOT与纠缠

CNOT的魔力在于，当控制比特处于叠加态时，它可以产生纠缠 。例如，从 ∣00⟩|00\rangle∣00⟩ 开始，先对第一个比特应用H门：
∣ψ⟩=(H⊗I)∣00⟩=∣00⟩+∣10⟩2 |\psi\rangle = (H\otimes I)|00\rangle = \frac{|00\rangle + |10\rangle}{\sqrt{2}} ∣ψ⟩=(H⊗I)∣00⟩=2 ∣00⟩+∣10⟩

再应用CNOT（控制为第一个比特，目标为第二个）：
CNOT∣ψ⟩=CNOT∣00⟩+CNOT∣10⟩2=∣00⟩+∣11⟩2 \text{CNOT}|\psi\rangle = \frac{\text{CNOT}|00\rangle + \text{CNOT}|10\rangle}{\sqrt{2}} = \frac{|00\rangle + |11\rangle}{\sqrt{2}} CNOT∣ψ⟩=2 CNOT∣00⟩+CNOT∣10⟩=2 ∣00⟩+∣11⟩

这正是贝尔态 ∣Φ+⟩|\Phi^+\rangle∣Φ+⟩，两个比特完全纠缠。

纠缠是量子计算的重要资源，虽然Deutsch算法不需要纠缠，但它是后续复杂算法（如量子隐形传态、Shor算法）的基础。

2.3 其他常用双比特门

• CZ门 （受控Z门）：当控制为 ∣1⟩|1\rangle∣1⟩ 时对目标应用Z门。
• SWAP门：交换两个比特的状态。

---

三、量子电路基础：组合的艺术

3.1 门的并行：张量积

当多个门同时作用在不同比特上时，整体效果由它们的张量积 描述。例如，对第一个比特应用H门，同时对第二个比特应用X门，整体矩阵为 H⊗XH \otimes XH⊗X。这个矩阵作用在双比特态上。

3.2 门的顺序：矩阵乘法

当门依次作用时，整体矩阵是各门矩阵的乘积 ，但顺序要反过来 ：先作用的门在乘积的右边。例如，先应用 U1U_1U1，再应用 U2U_2U2，最后应用 U3U_3U3，整体为 U3U2U1U_3 U_2 U_1U3U2U1。

这是因为态矢从右向左演化：
∣ψfinal⟩=U3(U2(U1∣ψinitial⟩)) |\psi_{\text{final}}\rangle = U_3 (U_2 (U_1 |\psi_{\text{initial}}\rangle)) ∣ψfinal⟩=U3(U2(U1∣ψinitial⟩))

3.3 测量：从量子到经典

电路末端通常有测量 操作，它将量子态坍缩为经典比特（0或1）。测量结果是一个概率分布，由波恩规则给出：对态 ∣ψ⟩|\psi\rangle∣ψ⟩ 测量基 ∣i⟩|i\rangle∣i⟩ 的概率为 ∣⟨i∣ψ⟩∣2|\langle i|\psi\rangle|^2∣⟨i∣ψ⟩∣2。

在电路图中，测量用"仪表"符号表示。

3.4 电路可视化

量子电路通常从左到右绘制，水平线代表量子比特，方框代表量子门。例如：

q0: ┤ H ├──■───────
         ┌─┴─┐
q1: ─────┤ X ├─┤M├
         └───┘ └─┘

这个电路表示：对q0应用H门，然后以q0为控制、q1为目标的CNOT门，最后测量q1。

---

四、第一个量子算法：Deutsch算法

4.1 问题描述

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

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

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

4.2 量子电路

Deutsch算法的电路如下：

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

其中 UfU_fUf 是量子预言机（oracle），它实现变换：
Uf∣x⟩∣y⟩=∣x⟩∣y⊕f(x)⟩ U_f |x\rangle|y\rangle = |x\rangle |y \oplus f(x)\rangle Uf∣x⟩∣y⟩=∣x⟩∣y⊕f(x)⟩

这里 ⊕\oplus⊕ 是模2加法（异或）。

4.3 数学推导

初始化 ：
∣ψ0⟩=∣0⟩⊗∣1⟩=∣01⟩ |\psi_0\rangle = |0\rangle \otimes |1\rangle = |01\rangle ∣ψ0⟩=∣0⟩⊗∣1⟩=∣01⟩

第一步：对两个比特应用H门 ：
∣ψ1⟩=(H⊗H)∣01⟩=H∣0⟩⊗H∣1⟩=∣0⟩+∣1⟩2⊗∣0⟩−∣1⟩2 |\psi_1\rangle = (H\otimes H)|01\rangle = H|0\rangle \otimes H|1\rangle = \frac{|0\rangle+|1\rangle}{\sqrt{2}} \otimes \frac{|0\rangle-|1\rangle}{\sqrt{2}} ∣ψ1⟩=(H⊗H)∣01⟩=H∣0⟩⊗H∣1⟩=2 ∣0⟩+∣1⟩⊗2 ∣0⟩−∣1⟩

展开为：
∣ψ1⟩=12∣0⟩(∣0⟩−∣1⟩)+∣1⟩(∣0⟩−∣1⟩) |\psi_1\rangle = \frac{1}{2}\left \|0\\rangle(\|0\\rangle-\|1\\rangle) + \|1\\rangle(\|0\\rangle-\|1\\rangle) \\right ∣ψ1⟩=21∣0⟩(∣0⟩−∣1⟩)+∣1⟩(∣0⟩−∣1⟩)

第二步：应用预言机 UfU_fUf：

预言机的作用是将 ∣x⟩∣y⟩|x\rangle|y\rangle∣x⟩∣y⟩变为 ∣x⟩∣y⊕f(x)⟩|x\rangle|y\oplus f(x)\rangle∣x⟩∣y⊕f(x)⟩。注意到当 yyy 处于 ∣0⟩−∣1⟩|0\rangle-|1\rangle∣0⟩−∣1⟩ 时，y⊕f(x)y\oplus f(x)y⊕f(x) 会引入一个相位：
Uf∣x⟩(∣0⟩−∣1⟩)=∣x⟩(∣f(x)⟩−∣1⊕f(x)⟩)=(−1)f(x)∣x⟩(∣0⟩−∣1⟩) U_f |x\rangle (|0\rangle-|1\rangle) = |x\rangle (|f(x)\rangle - |1\oplus f(x)\rangle) = (-1)^{f(x)} |x\rangle (|0\rangle-|1\rangle) Uf∣x⟩(∣0⟩−∣1⟩)=∣x⟩(∣f(x)⟩−∣1⊕f(x)⟩)=(−1)f(x)∣x⟩(∣0⟩−∣1⟩)

因为如果 f(x)=0f(x)=0f(x)=0，则 ∣f(x)⟩−∣1⊕f(x)⟩=∣0⟩−∣1⟩|f(x)\rangle-|1\oplus f(x)\rangle = |0\rangle-|1\rangle∣f(x)⟩−∣1⊕f(x)⟩=∣0⟩−∣1⟩；如果 f(x)=1f(x)=1f(x)=1，则 ∣1⟩−∣0⟩=−(∣0⟩−∣1⟩)|1\rangle-|0\rangle = -(|0\rangle-|1\rangle)∣1⟩−∣0⟩=−(∣0⟩−∣1⟩)。

因此，预言机作用后：
∣ψ2⟩=12(−1)f(0)∣0⟩(∣0⟩−∣1⟩)+(−1)f(1)∣1⟩(∣0⟩−∣1⟩) |\psi_2\rangle = \frac{1}{2}\left (-1)\^{f(0)}\|0\\rangle(\|0\\rangle-\|1\\rangle) + (-1)\^{f(1)}\|1\\rangle(\|0\\rangle-\|1\\rangle) \\right ∣ψ2⟩=21(−1)f(0)∣0⟩(∣0⟩−∣1⟩)+(−1)f(1)∣1⟩(∣0⟩−∣1⟩)

提取公因子 ∣0⟩−∣1⟩2\frac{|0\rangle-|1\rangle}{\sqrt{2}}2 ∣0⟩−∣1⟩，并将系数归一化：
∣ψ2⟩=(−1)f(0)∣0⟩+(−1)f(1)∣1⟩2⊗∣0⟩−∣1⟩2 |\psi_2\rangle = \left \\frac{(-1)\^{f(0)}\|0\\rangle + (-1)\^{f(1)}\|1\\rangle}{\\sqrt{2}} \\right \otimes \frac{|0\rangle-|1\rangle}{\sqrt{2}} ∣ψ2⟩=2 (−1)f(0)∣0⟩+(−1)f(1)∣1⟩⊗2 ∣0⟩−∣1⟩

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

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

计算：

• 若 f(0)=f(1)f(0)=f(1)f(0)=f(1)（常数函数），则两项系数符号相同，设为 sss，那么状态为 s∣0⟩+∣1⟩2s\frac{|0\rangle+|1\rangle}{\sqrt{2}}s2 ∣0⟩+∣1⟩，经过H门后：
  H(s∣0⟩+∣1⟩2)=s∣0⟩ H\left(s\frac{|0\rangle+|1\rangle}{\sqrt{2}}\right) = s|0\rangle H(s2 ∣0⟩+∣1⟩)=s∣0⟩
• 若 f(0)≠f(1)f(0)\neq f(1)f(0)=f(1)（平衡函数），则两项系数符号相反，设为 s∣0⟩−s∣1⟩s|0\rangle - s|1\rangles∣0⟩−s∣1⟩（其中 s=±1s = \pm 1s=±1），那么状态为 s∣0⟩−∣1⟩2s\frac{|0\rangle-|1\rangle}{\sqrt{2}}s2 ∣0⟩−∣1⟩，经过H门后：
  H(s∣0⟩−∣1⟩2)=s∣1⟩ H\left(s\frac{|0\rangle-|1\rangle}{\sqrt{2}}\right) = s|1\rangle H(s2 ∣0⟩−∣1⟩)=s∣1⟩

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

• 常数函数：∣0⟩|0\rangle∣0⟩
• 平衡函数：∣1⟩|1\rangle∣1⟩

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

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

4.4 关键点：为什么只查询一次？

在第二步中，预言机同时处理了 ∣x⟩=∣0⟩|x\rangle = |0\rangle∣x⟩=∣0⟩和 ∣x⟩=∣1⟩|x\rangle = |1\rangle∣x⟩=∣1⟩ 两种情况，并在 ∣y⟩|y\rangle∣y⟩ 的相位中编码了 f(0)f(0)f(0) 和 f(1)f(1)f(1) 的信息。最后的H门和测量将这些相位信息转化为计算结果。整个过程只调用了一次预言机，但同时获取了 f(0)f(0)f(0) 和 f(1)f(1)f(1) 的信息------这就是量子并行性的体现。

---

五、动手实践：用Python实现Deutsch算法

下面我们用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]])
I = np.eye(2)

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
    # 构造 U_f 矩阵 (4x4)
    # 根据 oracle_type 定义 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 = np.array([
            [1,0,0,0],
            [0,1,0,0],
            [0,0,0,1],
            [0,0,1,0]
        ])
    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
    
    psi = U_f @ psi
    
    # 第三步：对第一个比特应用H门
    H_on_first = np.kron(H, I)
    psi = H_on_first @ psi
    
    # 第四步：测量第一个比特
    # 测量得到0的概率为 |<0|ψ>|^2，其中 <0| 作用在第一个比特上
    # 需要将态矢投影到第一个比特为0的子空间
    prob_0 = 0
    # 两个基态 |00> 和 |01> 对应第一个比特为0
    prob_0 = np.abs(psi[0,0])**2 + np.abs(psi[1,0])**2
    prob_1 = 1 - prob_0
    
    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到Deutsch-Jozsa

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

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

---

七、总结与展望

通过本文，我们学会了：

• 如何用H门和CNOT门构建量子电路
• 量子门的组合方式：张量积和矩阵乘法
• 第一个量子算法------Deutsch算法的电路、数学推导和代码实现
• 量子并行性的本质：一次操作同时处理多个输入，通过干涉提取信息

Deutsch算法虽然简单，但它揭示了量子计算的灵魂：叠加 + 干涉 = 量子优势。在后续的文章中，我们将看到这些思想如何被放大，形成Grover搜索的二次加速和Shor因式分解的指数加速。

现在，你已经掌握了量子电路的基础。接下来，不妨动手尝试构建制备贝尔态的电路，或者用Qiskit等框架运行真实的量子模拟器。量子世界的大门已经敞开，等待你深入探索。

---

思考题

1. 在Deutsch算法中，如果初始态第二个比特不是 ∣1⟩|1\rangle∣1⟩ 而是 ∣0⟩|0\rangle∣0⟩，电路还能正常工作吗？为什么？
2. 尝试用Qiskit实现Deutsch算法，并在IBM量子模拟器上运行。
3. 查阅资料，了解Deutsch-Jozsa算法的电路，并思考它如何扩展到多比特情形。

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

---

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