第三章 量子计算基础

第三章 量子计算基础 (Foundations of Quantum Computing)

在前两章中，我们建立了理解量子计算所需的全部数学和物理工具。从复数、希尔伯特空间、线性代数到量子力学的五条公设、自旋$1/2$、布洛赫球和测量理论——所有这些准备都指向同一个目标：量子计算 (Quantum Computing)。本章将把这些碎片拼接成一幅完整的图景，从最基本的量子比特出发，逐步构建到量子算法的核心思想。每一节都会反复回顾前两章的内容，让读者看到那些抽象概念如何在量子计算中焕发实际的生命力。

---

3.1 量子比特 (Qubits)

量子比特的定义

量子比特 (Quantum Bit, Qubit) 是量子计算的基本信息单元，对应于经典计算中的比特 (bit)。但与只能取0或1的经典比特不同，量子比特可以处于0和1的叠加态 (Superposition)。

一个单量子比特的量子态可以表示为：

$\lvert\psi\rangle = \alpha\lvert0\rangle + \beta\lvert1\rangle$

其中 $\alpha, \beta \in \mathbb{C}$ 是复数概率幅 (Probability Amplitudes)，满足归一化条件：

$\lvert\alpha\rvert^2 + \lvert\beta\rvert^2 = 1$

这里 $\lvert0\rangle$ 和 $\lvert1\rangle$ 构成计算基 (Computational Basis)，对应于二维希尔伯特空间 $\mathbb{C}^2$ 的一组标准正交基。回顾我们在1.2节学习的bra-ket记号：$\lvert0\rangle = \begin{pmatrix}1\\0\end{pmatrix}$，$\lvert1\rangle = \begin{pmatrix}0\\1\end{pmatrix}$。这两个基矢对应自旋$1/2$粒子的向上和向下自旋态，是量子力学中最简单的非平凡量子系统。

还记得2.4节的自旋$1/2$吗？ 量子比特就是自旋$1/2$的抽象化。在Stern-Gerlach实验中，电子的自旋态恰好生活在二维复向量空间中，向上自旋$\lvert\uparrow\rangle$对应$\lvert0\rangle$，向下自旋$\lvert\downarrow\rangle$对应$\lvert1\rangle$。量子比特借用了这个数学结构，但不再限定于具体的物理实现——它可以是自旋、能级、光子偏振等任何具有两个正交态的量子系统。这种抽象化的力量在于，无论底层物理实现如何，量子比特的数学描述都是统一的。

布洛赫球表示

每个量子比特都可以表示为布洛赫球面上的点。 回顾2.5节的内容，利用全局相位的不相关性，我们可以将任意单量子比特态参数化为：

$\lvert\psi\rangle = \cos\frac{\theta}{2}\lvert0\rangle + e^{i\phi}\sin\frac{\theta}{2}\lvert1\rangle$

其中 $\theta \in [0, \pi]$，$\phi \in [0, 2\pi)$。这一参数化直接来自2.5节的布洛赫球坐标：

$\vec{n} = (\sin\theta\cos\phi, \sin\theta\sin\phi, \cos\theta)$

球面上的每一点对应一个纯态 (Pure State)。特别地：

• 北极 ($\theta = 0$)：$\lvert0\rangle$
• 南极 ($\theta = \pi$)：$\lvert1\rangle$
• 赤道 ($\theta = \pi/2$)：等概率叠加态，如 $\lvert+\rangle = (\lvert0\rangle + \lvert1\rangle)/\sqrt{2}$ ($\phi = 0$) 和 $\lvert-\rangle = (\lvert0\rangle - \lvert1\rangle)/\sqrt{2}$ ($\phi = \pi$)

球面上的点是纯态，球内的点是混态 (Mixed State)。 这一区分至关重要，我们将在后文反复使用。布洛赫球是可视化单量子比特态的强大工具：态的演化对应球面上的轨迹，门操作对应旋转，测量对应投影。

经典比特 vs 量子比特

经典比特要么确定地是0，要么确定地是1。量子比特则通过概率幅实现叠加。但必须强调：叠加态不是概率混合。

考虑一个经典概率混合：以概率 $p$ 取0，以概率 $1-p$ 取1。对应的密度矩阵为：

$\rho_{\text{classical}} = p\lvert0\rangle\langle0\rvert + (1-p)\lvert1\rangle\langle1\rvert = \begin{pmatrix}p&0\\0&1-p\end{pmatrix}$

这与量子叠加态 $\lvert\psi\rangle = \alpha\lvert0\rangle + \beta\lvert1\rangle$ 的密度矩阵 $\rho = \lvert\psi\rangle\langle\psi\rvert$ 完全不同。经典混合对应布洛赫球内部的点（$z$轴上），而量子纯态对应球表面的点。2.5节中我们已经看到，混态的布洛赫向量长度小于1，丢失了相干性。这个区别是量子计算优势的根本来源：叠加态保留了概率幅之间的相对相位，而经典混合完全丢失了相位信息。

量子比特的物理实现

量子比特不是纯数学构造，它对应真实的物理系统。主要的物理实现包括：

1. 自旋$1/2$粒子：电子或原子核的自旋向上/向下（2.4节）。这是量子比特最直观的物理图像。核磁共振量子计算就是利用原子核自旋的量子态进行计算，通常需要在低温强磁场环境下操作。

2. 离子阱 (Ion Trap)：囚禁离子的两个内部能级（通常是超精细结构基态的两个子能级）编码$\lvert0\rangle$和$\lvert1\rangle$。通过激光精确操控能级跃迁。离子阱量子比特的相干时间较长，但门操作速度相对较慢。

3. 超导量子比特 (Superconducting Qubit)：利用约瑟夫森结 (Josephson Junction) 构建的非谐振电路。电荷量子比特、磁通量子比特和Transmon是主要类型。目前在许多量子计算平台中占主导地位，因为可以利用现有的半导体制造工艺，且门操作速度快。

4. 光子偏振 (Photon Polarization)：光子的水平/垂直偏振（或圆偏振）作为$\lvert0\rangle$和$\lvert1\rangle$。光子在室温下稳定，适合量子通信，但两光子相互作用困难，因此实现两比特门具有挑战性。

5. 拓扑量子比特 (Topological Qubit)：利用马约拉纳零能模等拓扑保护的状态。理论上具有极强的抗噪声能力，但目前仍处于早期研究阶段。

读者不需要深入每种实现的细节，但应该知道：量子比特是真实的物理系统，受量子力学五条公设支配。 无论选择哪种物理实现，量子比特的数学结构都是统一的，这正是量子计算理论的优美之处。

多个量子比特

当我们考虑多个量子比特时，1.6节的张量积成为核心工具。两个量子比特的态空间是各自空间的张量积：

$\mathbb{C}^2 \otimes \mathbb{C}^2 = \mathbb{C}^4$

一般地，$n$个量子比特的态空间维度为：

$\dim(\mathbb{C}^2)^{\otimes n} = 2^n$

这意味着$n$个量子比特需要$2^n$个复数概率幅来描述其态。这是量子计算指数优势的根本来源。例如，50个量子比特需要$2^{50} \approx 10^{15}$个复数来描述，这已经超过了许多经典计算机的内存容量。300个量子比特需要$2^{300} \approx 10^{90}$个复数，这个数字比可观测宇宙中的原子总数还多——这暗示了量子系统模拟经典不可行的深刻事实。

对于两个量子比特，计算基由四个正交态组成：

$\lvert00\rangle = \lvert0\rangle \otimes \lvert0\rangle, \quad \lvert01\rangle = \lvert0\rangle \otimes \lvert1\rangle$ $\lvert10\rangle = \lvert1\rangle \otimes \lvert0\rangle, \quad \lvert11\rangle = \lvert1\rangle \otimes \lvert1\rangle$

一般两比特态为：

$\lvert\psi\rangle = \alpha_{00}\lvert00\rangle + \alpha_{01}\lvert01\rangle + \alpha_{10}\lvert10\rangle + \alpha_{11}\lvert11\rangle$

满足 $\sum_{i,j} |\alpha_{ij}|^2 = 1$。

如果态可以写成 $\lvert\psi\rangle = \lvert\psi_1\rangle \otimes \lvert\psi_2\rangle$ 的形式，称为可分离态 (Separable State)；否则称为纠缠态 (Entangled State)，这是3.3节的核心主题。纠缠态的存在是量子计算超越经典计算的关键：它意味着系统的信息不能分解为各个子系统的信息之和。

小结 (Summary)： 量子比特是量子计算的信息单元，由二维希尔伯特空间中的单位向量描述，对应布洛赫球面上的点。它与经典比特的本质区别在于叠加态和相位相干性——叠加不是概率混合，而是保留相位信息的量子相干叠加。多个量子比特通过张量积组合，态空间维度指数增长，为量子并行性提供了指数级大的工作空间。

与量子计算的连接 (Connection to Quantum Computing)： 量子比特是所有量子算法的起点。$n$量子比特的$2^n$维态空间提供了指数级大的”工作空间”，而叠加态允许同时处理多个计算路径。从自旋$1/2$到抽象量子比特的跃迁，标志着我们从量子力学自然现象走向人工量子信息处理。理解量子比特的数学结构和物理实现，是进入量子算法世界的第一步。

---

3.2 单量子比特门 (Single-Qubit Gates)

量子门 = 酉算子

在经典计算中，门（如AND、OR、NOT）对比特进行确定性变换。在量子计算中，量子门 (Quantum Gate) 对应于酉算子 (Unitary Operator) $U$，满足：

$U^\dagger U = UU^\dagger = I$

回顾1.3节中关于酉矩阵的讨论：酉变换保持向量的模长不变。因此，若$\lvert\psi\rangle$满足归一化条件，则$U\lvert\psi\rangle$也满足：

$\langle\psi\rvert U^\dagger U\lvert\psi\rangle = \langle\psi\rvert\psi\rangle = 1$

这意味着量子门保持概率守恒——1.3节的酉矩阵正是量子门数学化的体现。 量子门的可逆性（酉性）是量子计算与经典计算的根本区别之一：经典门如AND和OR是不可逆的（多个输入映射到同一输出），而量子门必须是可逆的。

由于任意酉变换都可以分解为$2\times 2$酉矩阵的序列，单量子比特门构成了所有量子门的基础构件。1.3节中学习的矩阵运算和性质，现在是操作量子态的直接工具。

泡利门 (Pauli Gates)

1.3节中我们已经完整介绍了泡利矩阵。现在它们作为量子门重新登场，成为最基础的量子操作：

$X$门（量子非门，Quantum NOT）：

$X = \begin{pmatrix}0&1\\1&0\end{pmatrix}$

$X\lvert0\rangle = \lvert1\rangle, \quad X\lvert1\rangle = \lvert0\rangle$

$X$门翻转计算基，类比经典NOT门。在布洛赫球上，$X$对应绕$x$轴旋转$\pi$角度（$180°$）。它将北极移到南极，南极移到北极，而赤道上的点保持在赤道上但翻转$\phi$坐标。

$Z$门（相位翻转门，Phase Flip）：

$Z = \begin{pmatrix}1&0\\0&-1\end{pmatrix}$

$Z\lvert0\rangle = \lvert0\rangle, \quad Z\lvert1\rangle = -\lvert1\rangle$

$Z$门不改变$\lvert0\rangle$，但给$\lvert1\rangle$添加$\pi$相位。在布洛赫球上，$Z$对应绕$z$轴旋转$\pi$。它将赤道上的$\lvert+\rangle$变为$\lvert-\rangle$，而$\lvert-\rangle$变为$\lvert+\rangle$。

$Y$门：

$Y = \begin{pmatrix}0&-i\\i&0\end{pmatrix} = iXZ$

$Y\lvert0\rangle = i\lvert1\rangle, \quad Y\lvert1\rangle = -i\lvert0\rangle$

$Y$是$X$和$Z$的组合（相差一个全局相位$i$）。在布洛赫球上，$Y$对应绕$y$轴旋转$\pi$。三个泡利门分别对应三个坐标轴的$\pi$旋转，构成了布洛赫球旋转的基础。

下表总结了泡利门对关键态的作用：

门	$\lvert0\rangle$	$\lvert1\rangle$	$\lvert+\rangle$
$X$	$\lvert1\rangle$	$\lvert0\rangle$	$\lvert+\rangle$
$Z$	$\lvert0\rangle$	$-\lvert1\rangle$	$\lvert-\rangle$
$Y$	$i\lvert1\rangle$	$-i\lvert0\rangle$	$-i\lvert-\rangle$

注意$X\lvert+\rangle = \lvert+\rangle$和$Z\lvert+\rangle = \lvert-\rangle$——$X$门在$\lvert\pm\rangle$基下是对角的（本征值为$\pm 1$），而$Z$门在$\lvert0/1\rangle$基下是对角的。这揭示了不同门在不同基下的作用方式，也暗示了基变换在量子计算中的重要性。

阿达马门 (Hadamard Gate)

阿达马门 (Hadamard Gate) $H$ 是量子计算中最重要的单比特门之一：

$H = \frac{1}{\sqrt{2}}\begin{pmatrix}1&1\\1&-1\end{pmatrix}$

它的作用是将计算基变为叠加基：

$H\lvert0\rangle = \frac{1}{\sqrt{2}}(\lvert0\rangle + \lvert1\rangle) = \lvert+\rangle$ $H\lvert1\rangle = \frac{1}{\sqrt{2}}(\lvert0\rangle - \lvert1\rangle) = \lvert-\rangle$

反之亦然：

$H\lvert+\rangle = \lvert0\rangle, \quad H\lvert-\rangle = \lvert1\rangle$

$H$门将计算基变为$X$基，这对测量和算法至关重要。 例如，在$Z$基下测量$\lvert+\rangle$会以等概率得到0或1；但如果先施加$H$门再测量，就能确定性地得到0。这种基变换的能力是许多量子算法的核心。

阿达马门的重要性质：

• 自逆性：$H^2 = I$，即两次$H$门等价于恒等操作
• 共轭关系：$HXH = Z$，$HZH = X$

第一条性质意味着$H$是它自己的逆。第二条性质说明$H$门可以”交换”$X$和$Z$的作用——在量子纠错和算法设计中经常使用。例如，如果你想在$X$基下测量一个态，可以先施加$H$门（将$X$基转到$Z$基），然后在$Z$基下测量。

在布洛赫球上，$H$对应绕轴$(\hat{x} + \hat{z})/\sqrt{2}$旋转$\pi$角度。它将$z$轴转到$x$轴，$x$轴转到$z$轴，直观地展示了计算基和$X$基之间的对称性。

相位门 (Phase Gates)

$S$门（相位门，Phase Gate）：

$S = \begin{pmatrix}1&0\\0&i\end{pmatrix}$

$S\lvert0\rangle = \lvert0\rangle, \quad S\lvert1\rangle = i\lvert1\rangle$

$S$门给$\lvert1\rangle$添加$\pi/2$相位。注意$S^2 = Z$。$S$门在布洛赫球上对应绕$z$轴旋转$\pi/2$，将赤道上的态沿$z$方向旋转四分之一圆周。

$T$门（$\pi/8$门，$\pi/8$ Gate）：

$T = \begin{pmatrix}1&0\\0&e^{i\pi/4}\end{pmatrix}$

$T\lvert0\rangle = \lvert0\rangle, \quad T\lvert1\rangle = e^{i\pi/4}\lvert1\rangle$

$T$门添加$\pi/4$相位，且$T^2 = S$，$T^4 = Z$。$T$门对应绕$z$轴旋转$\pi/4$，是实现任意单比特旋转的关键门之一。与$H$门和CNOT门组合，$T$门构成了通用量子计算的完备门集。

通用门集

一个量子门集被称为通用 (Universal) 的，如果任意酉变换都可以被该集合中的门近似到任意精度。Solovay-Kitaev定理保证了这种近似的效率：用大小为$O(\log^c(1/\epsilon))$的电路可以以精度$\epsilon$近似任意$n$比特酉变换。

重要的事实是：

• $\{H, S, T, \text{CNOT}\}$ 是通用的单比特+双比特门集
• $\{H, T, \text{CNOT}\}$ 也是通用的（因为$S = T^2$）

这意味着仅使用$H$、$T$和CNOT门（3.3节），我们就可以实现任意量子算法。通用门集的存在是量子计算机可编程性的理论基础：不需要为每个算法设计专门的硬件，只需组合少量基本门即可。

布洛赫球上的旋转

回顾2.5节：任意单比特酉变换都可以写成

$U = e^{i\alpha} R_{\hat{n}}(\theta) = e^{i\alpha} e^{-i\frac{\theta}{2}\vec{\sigma}\cdot\hat{n}}$

其中$\vec{\sigma} = (X, Y, Z)$是泡利向量，$\hat{n}$是单位旋转轴，$\theta$是旋转角度。这一分解是1.5节谱定理的直接推论。

具体地：

• $X = -iR_x(\pi)$，绕$x$轴转$\pi$
• $Y = -iR_y(\pi)$，绕$y$轴转$\pi$
• $Z = -iR_z(\pi)$，绕$z$轴转$\pi$
• $H = -iR_{(\hat{x}+\hat{z})/\sqrt{2}}(\pi)$
• $S = e^{i\pi/4}R_z(\pi/2)$

这种几何视角直观地展示了每个门如何移动布洛赫球上的态。例如，任意单比特态都可以通过适当的$R_z$和$R_y$旋转从$\lvert0\rangle$制备出来，这是量子态制备的基本方法。

小结 (Summary)： 单量子比特门是$2\times 2$酉矩阵，保持态的归一化。泡利门实现比特翻转和相位翻转，对应布洛赫球上的$\pi$旋转。阿达马门在计算基和$X$基之间变换，是创造叠加态的关键工具。相位门$S$和$T$提供连续的相位控制。通用门集的存在意味着少量基本门可以实现任意量子计算。

与量子计算的连接 (Connection to Quantum Computing)： 单比特门是量子电路的基本构建块。阿达马门在创建叠加态（量子并行性的前提）中不可或缺。通用门集的存在意味着我们只需要少量基本门就能实现任意量子计算，这是量子计算机可编程性的基础。理解每个门在布洛赫球上的几何作用，是直观理解量子态演化的关键。

---

3.3 多量子比特门与纠缠 (Multi-Qubit Gates & Entanglement)

张量积回顾

在讨论多量子比特门之前，我们先回顾1.6节的张量积。若$A$作用于第一个量子比特，$B$作用于第二个量子比特，则联合操作是它们的张量积$A \otimes B$，作用在复合态$\lvert a\rangle \otimes \lvert b\rangle$上：

$(A \otimes B)(\lvert a\rangle \otimes \lvert b\rangle) = A\lvert a\rangle \otimes B\lvert b\rangle$

对于$2\times 2$矩阵$A = \begin{pmatrix}a_{11}&a_{12}\\a_{21}&a_{22}\end{pmatrix}$和$B$，有：

$A \otimes B = \begin{pmatrix}a_{11}B & a_{12}B\\a_{21}B & a_{22}B\end{pmatrix}$

这是一个$4\times 4$矩阵。关键性质：$(A \otimes B)(C \otimes D) = AC \otimes BD$，$(A \otimes B)^\dagger = A^\dagger \otimes B^\dagger$。这些性质保证了张量积的酉性：若$A$和$B$都是酉矩阵，则$A \otimes B$也是酉矩阵。

CNOT门

受控非门 (Controlled-NOT, CNOT) 是最重要的两量子比特门，也是产生纠缠的关键。没有CNOT门，多量子比特系统就无法实现真正的量子优势。

CNOT门的矩阵表示为：

$\text{CNOT} = \begin{pmatrix}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{pmatrix}$

在计算基$\{\lvert00\rangle, \lvert01\rangle, \lvert10\rangle, \lvert11\rangle\}$下，这个矩阵的含义是：

• 当控制比特为$\lvert0\rangle$时，目标比特不变
• 当控制比特为$\lvert1\rangle$时，目标比特翻转（$X$门作用）

形式上：

$\text{CNOT}\lvert c\rangle\lvert t\rangle = \lvert c\rangle\lvert t \oplus c\rangle$

其中$\oplus$是模2加法（经典XOR）。CNOT门与经典XOR门类似，但作用在量子叠加态上时产生完全不同的效果。

让我们验证几个关键作用：

$\text{CNOT}\lvert00\rangle = \lvert00\rangle$ $\text{CNOT}\lvert01\rangle = \lvert01\rangle$ $\text{CNOT}\lvert10\rangle = \lvert11\rangle$ $\text{CNOT}\lvert11\rangle = \lvert10\rangle$

注意CNOT将可分离态$\lvert1\rangle(\lvert0\rangle + \lvert1\rangle)/\sqrt{2}$变为纠缠态——这是下一小节的内容。这个简单的例子已经展示了量子门如何将可分离态转化为纠缠态。

贝尔态：最大纠缠态

贝尔态 (Bell States) 是两量子比特的四个最大纠缠态，构成两比特希尔伯特空间的一个正交基。它们是量子信息中最基本的纠缠资源。

$\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert00\rangle + \lvert11\rangle)$ $\lvert\Phi^-\rangle = \frac{1}{\sqrt{2}}(\lvert00\rangle - \lvert11\rangle)$ $\lvert\Psi^+\rangle = \frac{1}{\sqrt{2}}(\lvert01\rangle + \lvert10\rangle)$ $\lvert\Psi^-\rangle = \frac{1}{\sqrt{2}}(\lvert01\rangle - \lvert10\rangle)$

这些态不能被写成两个单比特态的张量积。例如，假设$\lvert\Phi^+\rangle = (a\lvert0\rangle + b\lvert1\rangle) \otimes (c\lvert0\rangle + d\lvert1\rangle)$，展开后比较系数会发现$ad = bc = 1/\sqrt{2}$但$bd = ac = 0$，矛盾。这个矛盾证明了纠缠态的非经典性。

贝尔态制备电路是最基本的量子电路之一：

|0⟩ —H—•—    →    |Φ⁺⟩
|0⟩ ———⊕—          

推导过程：

1. 初始态：$\lvert00\rangle$
2. 对第一比特施加$H$：$H\lvert0\rangle \otimes \lvert0\rangle = \frac{1}{\sqrt{2}}(\lvert0\rangle + \lvert1\rangle) \otimes \lvert0\rangle = \frac{1}{\sqrt{2}}(\lvert00\rangle + \lvert10\rangle)$
3. 施加CNOT：$\frac{1}{\sqrt{2}}(\text{CNOT}\lvert00\rangle + \text{CNOT}\lvert10\rangle) = \frac{1}{\sqrt{2}}(\lvert00\rangle + \lvert11\rangle) = \lvert\Phi^+\rangle$

类似地，改变第一比特的输入或添加$Z$门可以制备其他三个贝尔态。贝尔态制备电路虽然简单，但它揭示了量子电路的核心能力：通过简单的门组合创造复杂的纠缠态。

纠缠的度量

如何量化纠缠？一个概念性的方法是使用约化密度矩阵 (Reduced Density Matrix)，我们在2.6节中已学习。

对贝尔态$\lvert\Phi^+\rangle$求部分迹（对第二个系统求迹）：

$\rho_A = \text{Tr}_B(\lvert\Phi^+\rangle\langle\Phi^+\rvert) = \frac{1}{2}(\lvert0\rangle\langle0\rvert + \lvert1\rangle\langle1\rvert) = \frac{I}{2}$

这是完全混态，对应布洛赫球的球心！这意味着如果我们只看第一个量子比特，我们对它的态完全无知——没有任何测量能给我们关于这个单比特的信息。纠缠 = “子系统的信息不完全”。

对比可分离态$\lvert00\rangle$：$\rho_A = \lvert0\rangle\langle0\rvert$，纯态，完全确定。纠缠态的子系统处于最大不确定性状态，而整个系统却处于完全确定的纯态——这是量子力学最反直觉的特征之一。

不可克隆定理

不可克隆定理 (No-Cloning Theorem) 是量子信息的基本限制，也是量子密码学安全性的基础。

定理：不存在酉算子$U$使得对所有态$\lvert\psi\rangle$满足：

$U(\lvert\psi\rangle \otimes \lvert0\rangle) = \lvert\psi\rangle \otimes \lvert\psi\rangle$

证明：假设这样的$U$存在。取两个不同的态$\lvert\psi\rangle$和$\lvert\phi\rangle$：

$U(\lvert\psi\rangle \otimes \lvert0\rangle) = \lvert\psi\rangle \otimes \lvert\psi\rangle$ $U(\lvert\phi\rangle \otimes \lvert0\rangle) = \lvert\phi\rangle \otimes \lvert\phi\rangle$

考虑叠加态$\lvert\xi\rangle = (\lvert\psi\rangle + \lvert\phi\rangle)/\sqrt{2}$。由线性性：

$U(\lvert\xi\rangle \otimes \lvert0\rangle) = \frac{1}{\sqrt{2}}U(\lvert\psi\rangle \otimes \lvert0\rangle) + \frac{1}{\sqrt{2}}U(\lvert\phi\rangle \otimes \lvert0\rangle) = \frac{1}{\sqrt{2}}(\lvert\psi\rangle\otimes\lvert\psi\rangle + \lvert\phi\rangle\otimes\lvert\phi\rangle)$

但如果$U$能克隆$\lvert\xi\rangle$，则应有：

$U(\lvert\xi\rangle \otimes \lvert0\rangle) = \lvert\xi\rangle \otimes \lvert\xi\rangle = \frac{1}{2}(\lvert\psi\rangle + \lvert\phi\rangle) \otimes (\lvert\psi\rangle + \lvert\phi\rangle)$

两者不相等（除非$\langle\psi\rvert\phi\rangle = 1$即两态相同），矛盾！因此完美通用克隆机不存在。

意义：经典信息可以被完美复制，但量子信息不能。这意味着窃听者无法通过”复制”量子通信来获取信息而不被发现——这是量子密码学的核心安全保证。不可克隆定理既是量子计算的约束（我们不能像经典计算那样随意复制中间结果），也是量子通信的安全基础。

小结 (Summary)： CNOT门是最重要的双比特门，能将可分离态变为纠缠态。贝尔态是最大纠缠态，制备只需$H$加CNOT。约化密度矩阵为完全混态是纠缠的标志——子系统信息完全丢失，但整体系统信息完整。不可克隆定理禁止完美复制未知量子态，奠定了量子密码学的安全基础。

与量子计算的连接 (Connection to Quantum Computing)： 纠缠是量子计算超越经典计算的关键资源。没有纠缠，量子计算可以被经典计算机有效模拟。CNOT门与单比特门一起构成通用量子计算。不可克隆定理既限制了量子信息处理（不能复制中间结果），也保护了量子通信的安全——这种双刃剑特性是量子信息科学的核心主题。

---

3.4 量子电路 (Quantum Circuits)

电路约定

量子电路 (Quantum Circuit) 是描述量子计算过程的图形化语言。它类似于经典电路图，但遵循量子力学的特殊规则。其基本约定如下：

• 水平线：代表量子比特，时间从左到右流动
• 方格/带字母的方框：单量子比特门（如$H$、$X$、$Z$、$S$、$T$）
• 实心圆点$\bullet$：CNOT门的控制比特
• 带$\oplus$的圆圈：CNOT门的目标比特
• 仪表符号：测量操作
• 双线：测量后的经典比特

图例：
|ψ⟩ ——     量子比特线（初始态|ψ⟩）
——H——     单比特门（H门）
——•——     CNOT控制比特
——⊕——     CNOT目标比特
——[M]—►  测量，输出经典比特
═══       经典比特线（双线）

量子电路的阅读顺序很重要：门按照从左到右的顺序依次作用。数学上，如果电路从左到右依次是门$U_1, U_2, \ldots, U_n$，则总演化算子是$U_n \cdots U_2 U_1$（注意逆序，因为最右边的门最后作用）。

示例电路1：贝尔态制备

|0⟩ —H—•—    →    |Φ⁺⟩
|0⟩ ———⊕—          

逐步演化：

1. 初始态：$\lvert\psi_0\rangle = \lvert00\rangle$
2. 第一比特$H$门：$\lvert\psi_1\rangle = (H \otimes I)\lvert00\rangle = \lvert+\rangle\lvert0\rangle = \frac{1}{\sqrt{2}}(\lvert00\rangle + \lvert10\rangle)$
3. CNOT门：$\lvert\psi_2\rangle = \text{CNOT}\lvert\psi_1\rangle = \frac{1}{\sqrt{2}}(\lvert00\rangle + \lvert11\rangle) = \lvert\Phi^+\rangle$

注意电路的时间顺序：门按照从左到右的顺序依次作用。数学上，最右边的门最先作用于态（如果我们将电路写成矩阵乘积，需要逆序相乘）。

示例电路2：量子隐形传态

量子隐形传态的电路在3.6节详细解释，此处先展示电路结构：

|ψ⟩ ————•—H—[M]—►─────┐
        |              │
|Φ⁺⟩₁——⊕————[M]—►────┼──► 经典通信 → Bob的修正
        │              │
|Φ⁺⟩₂————————————XⁿZᵐ─┘

这里$\lvert\psi\rangle$是Alice要传输的未知态，$\lvert\Phi^+\rangle$是Alice和Bob共享的贝尔态。Alice对她的两个比特进行测量，将2比特经典结果传给Bob，Bob根据结果应用$X$和$Z$修正门。这个电路展示了量子计算中最神奇的现象之一：利用纠缠和经典通信传输量子态。

示例电路3：GHZ态制备

GHZ态 (Greenberger-Horne-Zeilinger State) 是多比特最大纠缠态的推广：

$\lvert\text{GHZ}\rangle = \frac{1}{\sqrt{2}}(\lvert000\rangle + \lvert111\rangle)$

制备电路：

|0⟩ —H—•——————    →    |GHZ⟩
|0⟩ ———⊕—•————          
|0⟩ —————⊕————          

演化过程：

1. 初始态：$\lvert000\rangle$
2. 第一比特$H$门：$\frac{1}{\sqrt{2}}(\lvert000\rangle + \lvert100\rangle)$
3. CNOT(1→2)：$\frac{1}{\sqrt{2}}(\lvert000\rangle + \lvert110\rangle)$
4. CNOT(2→3)：$\frac{1}{\sqrt{2}}(\lvert000\rangle + \lvert111\rangle) = \lvert\text{GHZ}\rangle$

三个比特纠缠在一起：任何一个比特的测量都会瞬间确定其他两个比特的状态。GHZ态是贝尔态在三比特系统中的自然推广，展示了多体纠缠的复杂性。

电路深度和宽度

量子电路的复杂度由两个量刻画：

• 电路宽度 (Width) $n$：量子比特的数量
• 电路深度 (Depth) $d$：电路中最长的门操作路径（从左到右的门层数）

例如，GHZ制备电路的宽度为3，深度为3（三层门：$H$、CNOT、CNOT）。电路的**大小 (Size)**是门的总数。一个有$n$个量子比特、深度为$d$的电路，其大小通常为$O(nd)$。

电路深度直接影响算法的运行时间：在量子计算机上，同一层的门可以并行执行，因此深度（而非总门数）决定了时间复杂度。减少电路深度是量子算法优化的重要目标。

测量符号

测量用仪表符号表示：

——[M]—►

测量后，量子比特坍缩到经典结果（0或1），量子线变为经典双线：

——[M]—►═══

经典信息可以用于条件操作 (Conditional Operation)——例如，在隐形传态中，Bob根据收到的经典比特决定施加$X$和$Z$门。条件操作是量子-经典混合计算的基础。

小结 (Summary)： 量子电路是量子算法的图形表示，时间从左到右流动。基本元素包括量子线、单比特门、CNOT门和测量。电路复杂度由宽度（比特数）和深度（门层数）刻画。贝尔态、隐形传态和GHZ态是展示电路能力的典型例子。

与量子计算的连接 (Connection to Quantum Computing)： 量子电路是量子算法的标准描述语言。任何量子计算都可以表示为量子电路，电路深度直接影响算法的运行时间。理解电路图是阅读量子算法论文和实现量子程序的基础技能。从简单的贝尔态制备到复杂的量子算法，电路图提供了直观的算法描述方式。

---

3.5 量子测量与读取 (Quantum Measurement & Readout)

计算基测量回顾

量子测量的数学框架在2.6节和2.2节的公设4中已经建立。对于单量子比特态$\lvert\psi\rangle = \alpha\lvert0\rangle + \beta\lvert1\rangle$，在计算基（$Z$基）下测量：

• 得到结果0的概率：$p(0) = \lvert\alpha\rvert^2 = \langle\psi\rvert\lvert0\rangle\langle0\rvert\lvert\psi\rangle$
• 得到结果1的概率：$p(1) = \lvert\beta\rvert^2 = \langle\psi\rvert\lvert1\rangle\langle1\rvert\lvert\psi\rangle$

测量后，态坍缩 (Collapse) 到对应的本征态：

$\lvert\psi\rangle \xrightarrow{\text{测得0}} \lvert0\rangle, \quad \lvert\psi\rangle \xrightarrow{\text{测得1}} \lvert1\rangle$

这正是**2.2节公设4（投影公设）**的直接应用。测量的概率性不是由于我们的无知（如经典概率），而是量子力学的内禀随机性——即使我们完全知道量子态，也无法预测单次测量的结果。

$X$基下的测量

计算基不是唯一的测量基。$X$基由$\lvert+\rangle$和$\lvert-\rangle$组成，是$X$算子的本征态：

$X\lvert+\rangle = +1\cdot\lvert+\rangle, \quad X\lvert-\rangle = -1\cdot\lvert-\rangle$

要在$X$基下测量一个态，有两种等价方法：

方法1：先施加$H$门，再在$Z$基下测量（因为$H\lvert+\rangle = \lvert0\rangle$，$H\lvert-\rangle = \lvert1\rangle$）

方法2：直接投影到$\lvert+\rangle\langle+\rvert$和$\lvert-\rangle\langle-\rvert$

以$\lvert+\rangle$态在$Z$基下测量为例：

$p(0) = |\langle0\rvert+\rangle|^2 = \left|\frac{1}{\sqrt{2}}\right|^2 = \frac{1}{2}$ $p(1) = |\langle1\rvert+\rangle|^2 = \left|\frac{1}{\sqrt{2}}\right|^2 = \frac{1}{2}$

虽然$\lvert+\rangle$在$X$基下是确定性的（总是测得$+1$），但在$Z$基下却是完全随机的——这再次说明了测量依赖于所选基。不同的测量基揭示量子态的不同方面，这是量子力学的互补性原理在量子计算中的体现。

期望值

量子力学中的期望值 (Expectation Value) 对应多次测量的统计平均。

对于$Z$算子：

$\langle Z \rangle = \langle\psi\rvert Z\lvert\psi\rangle = (\alpha^*\langle0\rvert + \beta^*\langle1\rvert)(\alpha\lvert0\rangle - \beta\lvert1\rangle) = |\alpha|^2 - |\beta|^2$

几何上，$\langle Z \rangle$正是布洛赫球上态的**$z$坐标**。例如：

• $\lvert0\rangle$：$\langle Z \rangle = 1$（北极）
• $\lvert1\rangle$：$\langle Z \rangle = -1$（南极）
• $\lvert+\rangle$：$\langle Z \rangle = 0$（赤道）

类似地，$X$期望值为：

$\langle X \rangle = \langle\psi\rvert X\lvert\psi\rangle = \alpha^*\beta + \alpha\beta^* = 2\text{Re}(\alpha^*\beta)$

这是布洛赫球的$x$坐标。对于$\lvert+\rangle$，$\langle X \rangle = 1$；对于$\lvert-\rangle$，$\langle X \rangle = -1$。

统计解释与测量精度

单次量子测量结果是随机的。要估计期望值，需要制备多个相同的副本并统计测量结果。

设进行$N$次$Z$基测量，得到$N_0$个0和$N_1$个1。则$\langle Z \rangle$的估计为：

$\hat{Z} = \frac{N_0 - N_1}{N} \approx \langle Z \rangle$

由大数定律，估计误差随$N$增大而减小，精度为$1/\sqrt{N}$（标准量子极限）。这是量子计算中采样复杂度的基础。例如，要估计$\langle Z \rangle$到精度$0.01$，大约需要$N \approx 10000$次测量。

先测量后验概率更新示例：假设我们有一个未知态，先验认为是$\lvert0\rangle$或$\lvert+\rangle$各50%概率。如果在$Z$基下测得0：

• 若态为$\lvert0\rangle$，测得0的概率为1
• 若态为$\lvert+\rangle$，测得0的概率为$1/2$

由贝叶斯公式，测得0后态为$\lvert0\rangle$的后验概率：

$p(\lvert0\rangle | \text{测得0}) = \frac{1 \times 0.5}{1 \times 0.5 + 0.5 \times 0.5} = \frac{2}{3}$

测量与坍缩的物理意义

测量不仅是获取信息的手段，它还不可逆地改变了量子态。这一特性赋予量子计算独特的”一次性”特征：

• 一旦测量，叠加态坍缩到基态，原始信息（概率幅之间的相对相位）丢失
• 因此量子计算通常将测量放在最后（除非中间测量用于特定算法）
• 这也是量子纠错困难的原因：我们不能随意”检查”量子态而不破坏它

2.6节的密度矩阵框架可以统一描述测量：测量算子$M_m$作用后，未归一化态为$M_m\rho M_m^\dagger$，概率为$\text{Tr}(M_m^\dagger M_m \rho)$。这一框架比纯态描述更一般，可以处理混合态和更一般的测量（POVM）。

小结 (Summary)： 量子测量在计算基下以概率$|\alpha|^2$和$|\beta|^2$得到0和1。不同测量基给出不同统计结果，体现了量子力学的互补性。期望值对应布洛赫球坐标，需要通过多次测量统计估计。测量导致不可逆坍缩，是量子计算的关键约束。

与量子计算的连接 (Connection to Quantum Computing)： 测量是量子算法提取经典结果的唯一途径。由于单次测量随机，许多量子算法（如变分量子本征求解器VQE）需要大量采样来估计期望值。测量基的选择直接影响算法设计（如BB84中的基对比）。理解测量的统计特性，是分析量子算法复杂度和实际可行性的基础。

---

3.6 量子算法导引 (Quantum Algorithm Primer)

本章前五节构建了理解量子计算的全部工具箱。现在，我们将这些工具汇聚到具体的量子算法中，展示它们如何协同工作解决实际问题。本节的重点是概念理解，而非技术细节——我们的目标是让读者看到，那些看似抽象的数学和物理概念，如何在算法层面产生惊人的实际效果。

量子隐形传态 (Quantum Teleportation)

问题：Alice有一个未知量子态$\lvert\psi\rangle = \alpha\lvert0\rangle + \beta\lvert1\rangle$，她想将这个态”传”给远方的Bob。根据不可克隆定理（3.3节），她不能复制这个态。但她可以通过共享纠缠和经典通信实现传输——这就是量子隐形传态。

资源：Alice和Bob预先共享一个贝尔对$\lvert\Phi^+\rangle_{AB} = (\lvert00\rangle + \lvert11\rangle)/\sqrt{2}$。Alice持有第一比特，Bob持有第二比特。

电路：

|ψ⟩ ————•—H—[M]—►─────┐
        |              │
|Φ⁺⟩₁——⊕————[M]—►────┼──► 经典信道(2比特) → Bob
        │              │
|Φ⁺⟩₂————————————XⁿZᵐ─┘

步骤（Alice的操作在左，Bob在右）：

1. Alice对她的两个比特施加CNOT：控制是$\lvert\psi\rangle$，目标是她的贝尔态半边。

   三比特初始态：$\lvert\psi\rangle_A \otimes \lvert\Phi^+\rangle_{AB} = (\alpha\lvert0\rangle + \beta\lvert1\rangle) \otimes \frac{1}{\sqrt{2}}(\lvert00\rangle + \lvert11\rangle)$

2. Alice对第一比特施加$H$门：产生叠加，为测量做准备。

3. Alice测量她的两个比特，得到两位经典结果$(m, n)$，其中$m, n \in \{0, 1\}$。

4. Alice通过经典信道将$(m, n)$告诉Bob。这是关键：只传经典信息，不传量子态。

5. Bob根据$(m, n)$对他的比特施加修正门：

   • 若$m=1$，施加$X$门
   • 若$n=1$，施加$Z$门

   即Bob施加$X^m Z^n$。

结果：Bob的比特精确地变为$\lvert\psi\rangle$。

关键洞察：纠缠 + 经典通信 = 量子信息传输。Alice的测量使她的未知态”消失”（坍缩），而经典通信告诉Bob如何从他手中的纠缠比特重建原始态。没有共享纠缠，仅靠经典通信无法传输量子态；没有经典通信，仅有纠缠也无法传输（否则将违反相对论因果律）。隐形传态展示了量子力学最深刻的特征之一：纠缠可以实现超越经典通信的信息传输。

BB84量子密钥分发

问题：Alice和Bob如何通过不安全的信道建立只有他们知道的共享密钥？

BB84协议由Bennett和Brassard在1984年提出，是量子密码学的基石。

协议流程：

1. Alice随机选择基和比特：对每个量子比特，Alice随机选择$Z$基或$X$基，并随机准备$\lvert0\rangle$、$\lvert1\rangle$、$\lvert+\rangle$或$\lvert-\rangle$。她将量子比特发送给Bob。

2. Bob随机选择基测量：Bob对每个到达的量子比特，随机选择$Z$基或$X$基进行测量，记录结果。

3. 基对比（经典通信）：Alice和Bob通过公开信道宣布各自使用的基（但不公布测量结果）。

4. 保留匹配基的比特：只保留双方使用相同基的测量结果作为原始密钥。

5. 错误检测：双方公开对比部分比特，检测是否存在窃听导致的异常错误率。

基对比表示例：

比特序号	Alice的基	Alice的态	Bob的基	Bob的测量	基相同？	保留？
1	$Z$	$\lvert0\rangle$	$Z$	0	是	0
2	$Z$	$\lvert1\rangle$	$X$	+或-	否	丢弃
3	$X$	$\lvert+\rangle$	$X$	+	是	+
4	$X$	$\lvert-\rangle$	$Z$	0或1	否	丢弃
5	$Z$	$\lvert1\rangle$	$Z$	1	是	1

安全原理：

若窃听者Eve截获量子比特并测量，由于她不知道Alice使用的基，有50%概率选择错误基。错误基测量会扰动量子态（3.5节的测量坍缩），引入约25%的错误率。Alice和Bob通过检测错误率即可发现窃听。

**不可克隆定理（3.3节）**保证Eve不能复制量子比特来避免扰动——她必须立即测量，从而必然留下痕迹。这是BB84安全性的量子力学保证。

Deutsch-Jozsa算法

问题：给定一个函数$f: \{0,1\}^n \to \{0,1\}$，判定它是常数函数（对所有输入输出相同）还是平衡函数（恰好一半输入输出0，一半输出1）。

经典复杂度：最坏情况需要$2^{n-1}+1$次查询（检查超过一半输入才能确定）。

量子复杂度：只需1次查询！

核心思想：量子并行性。通过阿达马门将所有输入叠加起来，一次查询同时评估所有$2^n$个输入。然后通过干涉提取全局性质（常数vs平衡）。

具体地，算法将输入寄存器制备为所有$2^n$个计算基的等幅叠加：

$\lvert\psi\rangle = \frac{1}{\sqrt{2^n}}\sum_{x=0}^{2^n-1}\lvert x\rangle$

然后应用量子预言机（实现函数$f$的酉变换），再通过干涉测量提取信息。虽然Deutsch-Jozsa算法判定的函数类型过于特殊，不具有实际应用价值，但它是展示量子并行性原理的经典教学案例。

Grover搜索算法

问题：在$N = 2^n$个未排序的数据库项中搜索目标项。

经典复杂度：平均需要$N/2$次查询，最坏情况$N$次。

量子复杂度：$O(\sqrt{N})$次查询。

核心思想：振幅放大 (Amplitude Amplification)。Grover算法通过迭代地”标记”目标项（翻转其相位）并”扩散”（将所有态向目标态旋转），逐步放大目标态的概率幅。

对于$N$个项，约$\frac{\pi}{4}\sqrt{N}$次迭代后，测量以高概率得到目标项。这对于大数据库搜索有二次加速。

算法	经典复杂度	量子复杂度	加速
搜索$N$项	$O(N)$	$O(\sqrt{N})$	二次

虽然加速只是二次的（而非指数），但Grover算法适用于任何未结构化搜索问题，且已被证明是最优的量子搜索算法——不存在更快的量子搜索算法。

Shor算法

问题：大整数$N$的因子分解。

意义：现代RSA加密的安全性基于”大整数因子分解在经典计算上困难”的假设。Shor算法在量子计算机上可以高效分解大整数，从而威胁RSA加密。

核心思想：将因子分解转化为周期发现问题，然后用量子傅里叶变换 (Quantum Fourier Transform, QFT) 加速周期发现。

回顾1.8节的DFT。量子傅里叶变换是DFT的量子实现，可以在$O((\log N)^2)$时间内完成经典需要$O(N\log N)$的操作。这种指数级的加速来自量子并行性：QFT同时处理所有频率分量。

复杂度对比：

算法	经典复杂度	量子复杂度	加速
因子分解$N$	$O(\exp((\log N)^{1/3}))$（最佳经典算法）	$O((\log N)^3)$	指数

Shor算法的指数加速使其成为量子计算最受关注的算法，也是推动量子计算研究的主要动力之一。它展示了量子计算机在特定数学问题上的惊人能力，同时也提醒我们：量子计算不仅是科学好奇，还关乎信息安全的基础。

小结 (Summary)： 量子隐形传态利用纠缠和经典通信传输量子态，展示了纠缠的非经典能力；BB84通过基对比和不可克隆定理实现安全密钥分发，是量子密码学的基石；Deutsch-Jozsa展示量子并行性——一次操作评估所有输入；Grover提供搜索的二次加速，且已被证明最优；Shor算法通过QFT实现因子分解的指数加速，威胁RSA加密。

与量子计算的连接 (Connection to Quantum Computing)： 这五个算法展示了量子计算的核心优势来源：叠加态实现并行计算、纠缠提供非经典关联、量子干涉提取全局信息。从密钥分发到数据库搜索，从因子分解到量子通信，这些算法奠定了量子信息科学的实用基础。我们已经积累了足够的数学和物理工具来理解它们——这正是前两章全部内容的价值所在。量子计算不是神秘的魔法，而是量子力学原理的系统化应用。

3.7 量子优势演示 (Quantum Advantage Demonstrations)

什么是量子优势：量子优势（Quantum Advantage，曾称”量子霸权”）是指量子计算机在特定任务上超越最先进经典计算机的能力。注意，这不是通用计算能力的超越（通用量子计算机还未实现），而是在精心设计的特定问题上的计算速度超越。量子优势的演示不一定是实用的（如随机电路采样的输出本身没有商业价值），其意义在于实验上验证量子系统的计算能力突破了经典模拟的极限。

Google Sycamore 2019：

• 53 量子比特超导处理器，使用随机电路采样（Random Circuit Sampling, RCS）任务
• 任务：从一个随机量子电路中采样输出位串的概率分布
• 经典模拟估计：当今最强经典超级计算机（Summit）需要约 10,000 年
• Sycamore 运行：约 200 秒完成 100 万次采样
• 争议与讨论：IBM 提出经典模拟可在 2.5 天内完成（使用更优算法和Summit的存储层次）。无论具体数字，Sycamore 标志着量子计算首次在明确定义的任务上明显超越经典
• 关键工程细节：53 个比特中实际上只有 53 个可用（其中 1 个故障），门保真度约 99.5% 双门
• 线性交叉熵保真度（XEB fidelity）约 0.2%——验证了量子电路的正确运行

中国九章 / 祖冲之：

• 九章 2020（USTC 潘建伟、陆朝阳团队）：光量子高斯玻色采样（Gaussian Boson Sampling），76 个光子模式，经典模拟需要 6 亿年，九章 200 秒完成
• 祖冲之 2021（USTC 朱晓波团队）：66 量子比特超导处理器，RCS 任务比 Sycamore 快 2-3 个数量级
• 九章 2.0 2021：113 个光子模式，高斯玻色采样的经典模拟时间估计为 $10^{24}$ 年，九章约 2 小时
• 2023 年关键转折：这两个实验表明中美同时在超导和光量子两条路线上实现了量子优势

经典模拟的反击：

• 2023-2024 年：新的张量网络算法（基于边界 MPS，boundary MPS）将 Sycamore 级电路的经典模拟时间从数天降至数小时——在 GPU 集群上
• 2024 年 10 月：Google 的 67 比特 Sycamore 升级版 RCS 实验重新拉开与经典模拟的差距
• 这一”军备竞赛”的动态表明：量子优势不是一次性的成就，而是一个持续的过程——量子硬件在进步，经典模拟算法也在进步

Willow 2024 的 RCS 演示：

• Willow 处理器在 RCS 任务上展示了更强的量子优势：估计经典模拟需要 $10^{25}$ 年，Willow 约 5 分钟
• 与 2019 年相比，Willow 的优势来自：更多比特（105）、更高保真度（99.85% 双门）、更低串扰
• 更重要的是：Willow 的 RCS 是在”纠错模式下”运行的——虽然 RCS 本身不需要纠错，但并行运行的纠错电路证明处理器可以在纠错的同时保持量子优势

量子优势的局限与争议：

1. 非实用性：RCS 和高斯玻色采样的输出没有实际应用价值——它们是”计算能力的基准测试”，而非”有用计算”
2. 经典模拟的渐进性：每次量子优势演示后，经典社区通常会在几个月内找到更高效的模拟算法——因此量子优势不是一次性”获胜”
3. 从优势到实用：真正具有商业价值的量子优势需要在以下领域实现：量子化学模拟（肥料生产、电池设计）、组合优化（物流、金融）、机器学习（药物发现）
4. 验证问题：当量子计算机足够大时，其输出本身无法被经典计算机完全验证——信任问题由此产生

小结 (Summary)： 量子优势演示（Sycamore 2019、九章 2020、Willow 2024）在精心设计的采样任务上展示了量子计算超越经典模拟的能力。这些演示是验证量子硬件能力的必要步骤，但距离实用的量子加速还有距离。RCS 和高斯玻色采样是”计算能力基准”，而非”有用计算”。真正的量子优势需要在量子化学、优化或机器学习等应用领域实现。

与量子计算的连接 (Connection to Quantum Computing)： 量子优势演示是量子计算领域的”能力证明”——它回答了”量子计算机真的能超越经典计算机吗”这一根本问题。每次演示都推动了硬件工程（更多比特、更高保真度、更低噪声）和经典模拟算法（张量网络、近似算法）的双向进步。理解量子优势的现状（它做了什么、没做什么），对于评估量子计算的整体发展态势和技术路线选择至关重要。

---

第三章总结

本章将前两章的数学（线性代数、概率论、傅里叶变换）和物理（量子力学公设、自旋、布洛赫球、测量理论）凝聚为量子计算的核心框架：

• 3.1 量子比特 = 自旋$1/2$的抽象，生活在布洛赫球上
• 3.2 单比特门 = 酉矩阵 = 布洛赫球旋转，$H$门创造叠加
• 3.3 CNOT + 纠缠 = 量子计算的”灵魂”，不可克隆定理保护安全
• 3.4 量子电路 = 算法的图形语言
• 3.5 测量 = 提取经典结果的唯一途径，但有不可逆代价
• 3.6 算法 = 上述所有工具的综合运用

量子计算不是神秘的魔法，而是量子力学原理的系统化应用。当你理解量子比特、门、纠缠和测量时，你已经掌握了理解这个领域所需的全部基础概念。接下来的学习将是在这个框架上添加更复杂的电路、更精妙的算法和更深入的物理实现——但核心思想，已经在这里了。

附录

第三部分 量子计算基础 — 费曼学习法习题集

配套教程：《量子计算前置教程——从第一性原理出发》第三部分（3.1–3.6）

方法：费曼学习法（Feynman Technique）—— 教是最好的学。每节 4 题，覆盖计算、推导、讲解、洞察四个层次。

难度：⭐（基础）→ ⭐⭐（进阶）→ 🗣️（费曼讲解）→ 💭（深度洞察）

---

目录

• 3.1 量子比特
• 3.2 单量子比特门
• 3.3 多量子比特门与纠缠
• 3.4 量子电路
• 3.5 量子测量与读取
• 3.6 量子算法导引
• 参考答案
• 开放性问题

---

3.1 量子比特

---

习题 3.1.1 ⭐ 三态归一化

将下列态归一化，并求各测量结果的概率：

$\lvert\psi\rangle = 2\lvert0\rangle + i\lvert1\rangle - (1+i)\lvert0\rangle$

提示：先化简表达式，再归一化。

---

习题 3.1.2 ⭐⭐ 从振幅到布洛赫坐标

给定 $\lvert\psi\rangle = \frac{1}{\sqrt{3}}\lvert0\rangle + \frac{1+i}{\sqrt{6}}\lvert1\rangle$，求其布洛赫球坐标 $(\theta,\phi)$ 和对应的三维向量 $\vec{n} = (n_x, n_y, n_z)$。

---

习题 3.1.3 🗣️ 费曼：给外婆讲量子比特

你的外婆问：“你说量子比特可以同时是0和1，那它是不是就像薛定谔的猫一样半死不活？”

用不超过 8 句话（不使用任何公式），向外婆解释：

1. 量子比特的”叠加”和”半杯水”有什么本质不同
2. 为什么测量会”破坏”叠加态
3. 类比古典音乐的”和弦”（多个音符同时响）与量子叠加的区别

---

习题 3.1.4 💭 洞察：维度灾难

$n$ 个量子比特的态空间维度是 $2^n$。对 $n=100$ 的量子处理器，需要 $2^{100} \approx 10^{30}$ 个复参数描述其态。

(a) 这个数字意味着什么？与经典计算机的模拟能力有什么关系？ (b) 但是——我们真的能”利用”这 $2^n$ 维空间吗？测量只能得到 $n$ 个经典比特，那么这巨大的态空间在多大程度上是”可访问的”？ (c) 这个”维度爆炸”是量子优势的唯一来源吗？如果不是，还有什么其他关键因素？

---

3.2 单量子比特门

---

习题 3.2.1 ⭐ $H$-$T$ 序列计算

计算下列门序列作用在 $\lvert0\rangle$ 后的最终态：

$T \cdot H \cdot T \cdot H \lvert0\rangle$

将结果表示为布洛赫球上的 $(\theta, \phi)$ 坐标。提示：$T = \begin{pmatrix}1&0\\0&e^{i\pi/4}\end{pmatrix}$。

---

习题 3.2.2 ⭐⭐ 任意旋转的分解

证明：任意单量子比特酉算子 $U$ 可以分解为

$U = e^{i\alpha} R_z(\beta) R_y(\gamma) R_z(\delta)$

其中 $R_y(\theta) = e^{-i\theta Y/2}$，$R_z(\theta) = e^{-i\theta Z/2}$。

提示：回忆布洛赫球上的参数化形式 $U = e^{i\alpha} R_{\hat{n}}(\theta)$，并利用 $Y$ 和 $Z$ 生成元的对易关系。

---

习题 3.2.3 🗣️ 费曼：给程序员讲量子门

你是一名经验丰富的后端工程师，你的同事看到量子门后说：“这不就是矩阵乘法吗？我写个 numpy 也能算这些东西。”

用不超过 6 句话，从物理信息的角度解释：为什么量子门不只是矩阵乘法？量子态上运行的”门”和经典 CPU 上运行的”指令”有哪两个本质区别？

---

习题 3.2.4 💭 洞察：$T$ 门的特殊地位

在 $\{H, T, \text{CNOT}\}$ 门集中，$T$ 门是唯一一个不是”克利福德门”的。克利福德门（$H$, $S$, CNOT）可以将泡利矩阵映射到泡利矩阵，但 $T$ 门不能。

(a) 为什么量子计算的通用门集必须包含一个非克利福德门？ (b) 这对实现容错量子计算意味着什么？为什么 $T$ 门在表面码中的”magic state distillation”成本远高于其他门？ (c) 如果 $T$ 门这么贵，为什么我们不换个通用门集？

---

3.3 多量子比特门与纠缠

---

习题 3.3.1 ⭐ 纠缠态上的门作用

给定态 $\lvert\Phi^+\rangle = (\lvert00\rangle + \lvert11\rangle)/\sqrt{2}$，依次施加下列操作（按顺序）：

1. 第一个量子比特上施加 $H$ 门
2. CNOT（控制=第一个比特，目标=第二个比特）
3. 第一个量子比特上施加 $Z$ 门

求最终态。

---

习题 3.3.2 ⭐⭐ 乘积态不可能产生纠缠

假设我们有一个两量子比特门 $U$ 可以写成张量积形式：

$U = A \otimes B$

其中 $A$ 和 $B$ 是单比特酉算子。证明：如果输入态是可分离的，$U(A \otimes B)$ 的输出一定是可分离的。这意味着什么？

---

习题 3.3.3 🗣️ 费曼：给科幻迷解释纠缠

你的朋友说：“量子纠缠我懂，就是两个粒子不管隔多远，一个变了另一个马上跟着变，爱因斯坦说的’幽灵般的超距作用’嘛！”

用不超过 7 句话（不使用任何公式），纠正这个误解。你需要讲清楚：

1. 纠缠在数学上意味着什么（不是”心灵感应”，而是”关联”）
2. 为什么纠缠不能用来超光速通信（“测量坍缩”是局域的）
3. 纠缠到底有什么用（举一个具体例子）

---

习题 3.3.4 💭 洞察：纠缠是”资源”

纠缠常被称为量子计算的”资源”，就像能量是热力学中的资源一样。

(a) 为什么纠缠是非经典的？不用纠缠的量子计算可以用经典计算机高效模拟吗？ (b) 如果纠缠是资源，它”消耗”了什么？制备贝尔对需要什么代价？ (c) “纠缠蒸馏”和”纠缠交换”告诉我们纠缠可以被提纯和路由。这意味着什么？纠缠是否能像电力一样被”传输”？

---

3.4 量子电路

---

习题 3.4.1 ⭐ 电路跟踪

写出下列电路中每个步骤后的量子态（从最左边开始跟踪）：

|0⟩ —H—•——H—•—
|0⟩ ———⊕——H—⊕—
|0⟩ ————————⊕—

电路宽度 = 3，深度 = 5。最终态是什么？

---

习题 3.4.2 ⭐⭐ CNOT 门等价性证明

证明下列两个电路是等价的（即对任意输入态给出相同输出）：

电路 A：

—•—     —X—
  |   =   |
—⊕—     —•—

电路 B：

—⊕—     —•—
  |   =   |
—•—     —⊕—

也就是说，CNOT 在交换控制和目标比特后，再在两侧施加 $H$ 门，与原来的 CNOT 相同。即：

$(H \otimes H) \cdot \text{CNOT}_{1\to2} \cdot (H \otimes H) = \text{CNOT}_{2\to1}$

---

习题 3.4.3 🗣️ 费曼：给硬件工程师讲”可逆性”

你的同事是一名硬件工程师，她看到量子电路后很不解：“经典电路里 NAND 门只需要 4 个晶体管，量子门看起来好复杂。为什么量子门必须是可逆的？这不是浪费吗？”

用不超过 6 句话解释：

1. 从量子力学公设出发说明为什么必须酉（可逆）
2. 一个经典不可逆门（如 AND）如果用在量子计算机上会发生什么
3. 使用经典可逆门（如 Toffoli）的代价是什么

---

习题 3.4.4 💭 洞察：电路深度 vs 量子优势

量子电路的深度决定了算法的实际运行时间。当前 NISQ（含噪中等规模量子）设备的典型约束是：

• 量子比特数：50–1000
• 电路深度：< 100（超过此值噪声淹没有用信号）

(a) 一个 100 量子比特、深度 50 的电路能实现什么？不能实现什么？ (b) 为什么深度受限比量子比特数受限更致命？举例说明。 (c) 量子体积（Quantum Volume）指标同时考虑比特数和深度，这告诉了我们什么？

---

3.5 量子测量与读取

---

习题 3.5.1 ⭐ 期望值计算

态 $\lvert\psi\rangle = \frac{1}{\sqrt{2}}(\lvert0\rangle - e^{i\pi/3}\lvert1\rangle)$，求其在 $X$、$Y$、$Z$ 三个方向的期望值 $\langle X\rangle, \langle Y\rangle, \langle Z\rangle$，并验证 $\langle X\rangle^2 + \langle Y\rangle^2 + \langle Z\rangle^2 = 1$。

---

习题 3.5.2 ⭐⭐ 测量的”反直觉”性

考虑一个二比特态 $\lvert\Psi^-\rangle = (\lvert01\rangle - \lvert10\rangle)/\sqrt{2}$。

(a) 证明在单个比特上的任何测量结果都是完全随机的（$P(0) = P(1) = 1/2$）。 (b) 但如果你测量两个比特，结果一定相反（一个 0 一个 1）。 (c) 用一个类比解释这种”全局确定、局部随机”的现象。

---

习题 3.5.3 🗣️ 费曼：给统计学家讲量子概率

你的朋友（统计学教授）说：“你那个测量概率不就是经典条件概率吗？一个粒子有 60% 的概率是 0、40% 的概率是 1，跟我抛一枚不均匀的硬币有什么不同？”

用不超过 8 句话讲解两者的根本区别。需要包括：

1. “概率幅”的干涉效应（相位的作用）
2. 测量后坍缩 vs 经典概率的条件更新
3. 举个例子：对 $\lvert+\rangle$ 在 $X$ 基和 $Z$ 基下测量结果的不同——为什么经典硬币做不到

---

习题 3.5.4 💭 洞察：量子层析的成本

要确定一个未知量子比特的态，我们需要对多个副本在不同基下测量——这就是量子态层析。

(a) 对一个单比特纯态，理论上需要最少多少次测量才能确定它？为什么？ (b) 对于一个 $n$ 比特的未知纯态，需要的测量次数随 $n$ 如何增长？这代表了什么根本限制？ (c) 经典估计中，$N$ 次采样的精度是 $O(1/\sqrt{N})$（标准量子极限）。有没有办法超越这个极限（如量子增强传感）？这意味着什么？

---

3.6 量子算法导引

---

习题 3.6.1 ⭐ BB84 窃听概率分析

在 BB84 协议中，假设窃听者 Eve 有以下策略：对每个截获的量子比特，以概率 $p$ 测量、以概率 $1-p$ 直接转发（不测量）。

(a) 如果 Alice 和 Bob 随机选择基（$Z$ 或 $X$ 各 50%），Eve 的测量会导致多少错误率？ (b) 如果 Alice 和 Bob 要求错误率不超过 5% 才认为信道安全，Eve 的最大 $p$ 是多少而不被检测？

---

习题 3.6.2 ⭐⭐ Grover 迭代的几何解释

在 Grover 搜索中，初始态 $\lvert s\rangle$ 和目标态 $\lvert \omega\rangle$ 之间的夹角用 $\sin\theta = 1/\sqrt{N}$ 表示。

(a) 证明一次 Grover 迭代将 $\lvert s\rangle$ 向 $\lvert \omega\rangle$ 旋转 $2\theta$ 角度。 (b) 证明最优迭代次数约为 $\frac{\pi}{4}\sqrt{N}$。 (c) 对 $N=10^6$ 的数据库，经典和量子查询次数分别是多少？

---

习题 3.6.3 🗣️ 费曼：给 CEO 讲”量子计算机做了什么”

你的 CEO 看了新闻后兴奋地说：“我明白了，量子计算机就是’同时尝试所有可能性’的超级计算机！以后加密、密码、搜索全都完蛋了！我们要马上投资！”

用不超过 10 句话，冷静地解释为什么这个理解有问题。需要包括：

1. “同时尝试”的比喻为什么错（中间测量/坍缩问题）
2. 量子计算机不是在所有问题上都快——举一个它不快的例子
3. 目前（2026年）量子计算机的真实状态（多少比特、多少噪声、能做什么不能做什么）

---

习题 3.6.4 💭 洞察：后量子密码学

Shor 算法威胁 RSA 和 ECC，但 Grover 算法对对称加密（如 AES）只有二次加速（将 128 位密钥的有效强度降至 64 位）。

(a) 如果 2040 年 10000 逻辑量子比特的量子计算机可用，AES-256 是否还安全？ (b) 后量子密码学（PQC）的标准化正在进行中。NIST 选中的候选方案（如 Kyber、Dilithium）基于什么样的困难问题？为什么这些问题被认为能抵抗量子攻击？ (c) 你认为从现在到 2040 年，量子计算机更可能先实现量子优势（展示有用计算），还是先破解 RSA？为什么？

---

参考答案

---

3.1 量子比特

3.1.1 三态归一化

化简：$2\lvert0\rangle + i\lvert1\rangle - (1+i)\lvert0\rangle = (2 - 1 - i)\lvert0\rangle + i\lvert1\rangle = (1 - i)\lvert0\rangle + i\lvert1\rangle$

模长：$\|(1-i)\|^2 + \|i\|^2 = (1^2 + 1^2) + 1 = 3$

归一化态：$\lvert\hat\psi\rangle = \frac{1-i}{\sqrt{3}}\lvert0\rangle + \frac{i}{\sqrt{3}}\lvert1\rangle$

概率：$P(0) = |(1-i)/\sqrt{3}|^2 = 2/3$，$P(1) = |i/\sqrt{3}|^2 = 1/3$

---

3.1.2 从振幅到布洛赫坐标

振幅：$\alpha = 1/\sqrt{3}$，$\beta = (1+i)/\sqrt{6}$

$|\alpha|^2 = 1/3$，$|\beta|^2 = (1^2 + 1^2)/6 = 2/6 = 1/3$（好，归一化正确）

$\cos\frac{\theta}{2} = \sqrt{1/3}$，$\theta = 2\arccos(1/\sqrt{3}) \approx 1.9106$ rad

$\beta$ 的相位：$\arg(1+i) = \pi/4$

$\alpha$ 是正实数（相位为 0），所以 $\phi = \pi/4$

布洛赫向量：$\vec{n} = (\sin\theta\cos\phi,\ \sin\theta\sin\phi,\ \cos\theta)$

$\sin\frac{\theta}{2} = \sqrt{2/3}$，$\sin\theta = 2\sin\frac{\theta}{2}\cos\frac{\theta}{2} = 2\sqrt{2/9} = 2\sqrt{2}/3$

$\cos\theta = \cos^2\frac{\theta}{2} - \sin^2\frac{\theta}{2} = 1/3 - 2/3 = -1/3$

$\vec{n} = (2\sqrt{2}/3 \cdot \sqrt{2}/2,\ 2\sqrt{2}/3 \cdot \sqrt{2}/2,\ -1/3) = (2/3,\ 2/3,\ -1/3)$

验算：$|\vec{n}| = \sqrt{4/9 + 4/9 + 1/9} = 1$。纯态。

---

3.1.3 🗣️ 参考答案要点

关键点（不必全部使用，选择适合听众的）：

• 类比 1（和弦 vs 单音）：一个和弦由多个音符同时发声组成，但这不是”不确定该弹哪个音”——它是有意为之的叠加，比单独的音符包含更多信息。量子比特就像千位音乐家同时演奏的和弦，不是”半杯水”样式的折中。
• 类比 2（硬币 vs 箭头）：经典比特像一枚静态硬币（要么正面要么反面）。量子比特像一个旋转的硬币——它处于一种动态叠加，包含相位信息（它朝哪个方向旋转？转速多少？）。测量就像用手按住旋转的硬币，你只得到”正面”或”反面”，却丢失了旋转的方向信息。
• 为什么测量会破坏：因为测量要求量子态和我们宏观的测量设备相互作用。这个相互作用过于”暴力”，等价于询问”你到底是 0 还是 1？“——量子态只能被迫选择一个答案，而原始的叠加信息就丢失了。就像你问一个正在想复杂问题的人”你饿不饿？“，这个简单的二元问题打断了他的深层思考。

---

3.1.4 💭 洞察参考答案

(a) $2^{100}$ 个复参数，如果用双精度浮点数存储，大约需要 $2^{100} \times 16$ 字节 $\approx 1.6 \times 10^{31}$ 字节。这远远超过地球上所有存储设备的总和。所以经典计算机不可能模拟 100 量子比特的任意态——这就是”量子霸权”实验的根本逻辑。

(b) 关键限制：我们只能通过测量提取 $n$ 个经典比特的信息。所以这 $2^n$ 维空间中有用信息的提取效率是有限的。这引出了量子计算的核心问题：如何巧妙设计算法让干涉效应”放大”正确答案的概率幅，同时”抑制”错误答案？换句话说，量子计算机不是可以任意访问巨大态空间，而是需要精心编排干涉模式来提取全局信息。

(c) 维度爆炸不是唯一来源。熵和干涉同样重要。如果没有纠缠（仅用可分离态），经典计算机可以高效模拟。如果没有干涉，叠加态无法产生信号增强。所以量子优势 = 叠加（维度） + 纠缠（关联） + 干涉（信号提取），三者缺一不可。

---

3.2 单量子比特门

3.2.1 $H$-$T$ 序列计算

$H\lvert0\rangle = \frac{1}{\sqrt{2}}(\lvert0\rangle + \lvert1\rangle)$

$T\cdot H\lvert0\rangle = \frac{1}{\sqrt{2}}(\lvert0\rangle + e^{i\pi/4}\lvert1\rangle)$

$H\cdot T\cdot H\lvert0\rangle$：$H\lvert0\rangle = \lvert+\rangle$，$H\lvert e^{i\pi/4}\rangle$ 需计算

更简单的方法：用矩阵乘法。

$H = \frac{1}{\sqrt{2}}\begin{pmatrix}1&1\\1&-1\end{pmatrix},\quad T = \begin{pmatrix}1&0\\0&e^{i\pi/4}\end{pmatrix}$

$TH = \frac{1}{\sqrt{2}}\begin{pmatrix}1&1\\e^{i\pi/4}&-e^{i\pi/4}\end{pmatrix}$

$HTH = \frac12\begin{pmatrix}1&1\\1&-1\end{pmatrix}\begin{pmatrix}1&1\\e^{i\pi/4}&-e^{i\pi/4}\end{pmatrix} = \frac12\begin{pmatrix}1+e^{i\pi/4} & 1-e^{i\pi/4}\\ 1-e^{i\pi/4} & 1+e^{i\pi/4}\end{pmatrix}$

所以：$HTH\lvert0\rangle = \frac12\begin{pmatrix}1+e^{i\pi/4}\\ 1-e^{i\pi/4}\end{pmatrix}$

注意 $1+e^{i\pi/4} = \sqrt{2+\sqrt{2}}\cdot e^{i\pi/8}$，$1-e^{i\pi/4} = \sqrt{2-\sqrt{2}}\cdot e^{i3\pi/8}$

最终施加 $T$：$T(HTH\lvert0\rangle) = \frac12\begin{pmatrix}1+e^{i\pi/4}\\ e^{i\pi/4}(1-e^{i\pi/4})\end{pmatrix}$

简化：$e^{i\pi/4}(1-e^{i\pi/4}) = e^{i\pi/4} - e^{i\pi/2} = e^{i\pi/4} - i$

最终态 $(\theta, \phi)$ 可通过计算 $|\alpha|^2$ 和相位差得到。

---

3.2.2 任意旋转分解证明

任意 $U \in SU(2)$ 可以写为 $U = e^{i\alpha}R_{\hat{n}}(\theta) = e^{i\alpha}e^{-i\frac{\theta}{2}\vec{\sigma}\cdot\hat{n}}$

将 $\hat{n}$ 用球坐标表示：$\hat{n} = (\sin\Theta\cos\Phi,\ \sin\Theta\sin\Phi,\ \cos\Theta)$

由恒等式：$e^{-i\frac{\theta}{2}\vec{\sigma}\cdot\hat{n}} = \cos\frac{\theta}{2}I - i\sin\frac{\theta}{2}(\hat{n}\cdot\vec{\sigma})$

构造 $R_z(\beta)R_y(\gamma)R_z(\delta)$：

$R_z(\beta) = \begin{pmatrix}e^{-i\beta/2}&0\\0&e^{i\beta/2}\end{pmatrix}$ $R_y(\gamma) = \begin{pmatrix}\cos(\gamma/2)&-\sin(\gamma/2)\\\sin(\gamma/2)&\cos(\gamma/2)\end{pmatrix}$

乘积得：

$R_z(\beta)R_y(\gamma)R_z(\delta) = \begin{pmatrix}e^{-i(\beta+\delta)/2}\cos(\gamma/2) & -e^{-i(\beta-\delta)/2}\sin(\gamma/2)\\ e^{i(\beta-\delta)/2}\sin(\gamma/2) & e^{i(\beta+\delta)/2}\cos(\gamma/2)\end{pmatrix}$

这是一个一般 $SU(2)$ 矩阵（对角元互为复共轭，反对角元为另一个复共轭对）。这正是任意单比特酉变换除去全局相位后的形式。几何意义：先用 $R_z(\delta)$ 将态转到合适经度，用 $R_y(\gamma)$ 调整纬度，再用 $R_z(\beta)$ 调整最终相位。这就是量子态制备的”欧拉角”分解。

---

3.2.3 🗣️ 参考答案要点

1. 量子门是物理过程，不只是一次计算：当你对量子态施加门时，你实际上在操控物理系统——用微波脉冲轰击超导电路，或用激光照射离子——这个物理过程遵循薛定谔方程，不是简单的数组运算。你的 numpy 代码模拟的是这个物理过程，而不是物理过程本身。

2. 测量不可逆性：经典 CPU 的每条指令都是确定性的——你可以随意复制、检查中间值。但量子门操作后的中间态一旦测量就坍缩了。你不能在运行到一半时”偷偷看一眼”而不破坏计算。这意味着调试量子程序与调试经典程序有本质区别。

3. 并行有代价：你可以在量子叠加上并行操作，但读出结果时会坍缩。真正的问题是：你不是在”同时尝试所有可能性”，而是通过精心设计的干涉让正确答案的概率幅增强、错误答案的衰减。这更像编排水波干涉，而不是开多个 CPU 线程。

---

3.2.4 💭 洞察参考答案

(a) 克利福德门集（$H, S, CNOT$\）可以通过 Gottesman-Knill 定理被经典计算机高效模拟——纯克利福德电路没有量子优势。必须插入非克利福德门（如 $T$）才能突破这个限制。所以通用量子计算 = 克利福德 + 非克利福德。$T$ 门提供了克利福德门无法复制的相位旋转精度。

(b) 在容错量子计算中，克利福德门可以通过稳定子编码（如表面码）以非常低的资源成本实现。但 $T$ 门不能直接容错实现，需要通过 magic state distillation——一个高开销的过程（可能需要 100 多个物理 $T$ 门来合成一个高保真度的逻辑 $T$ 门）。$T$ 门”贵”，不是因为物理实现难，而是因为它不在稳定子规范内。所以在估算量子计算资源时，通常只看”需要多少个 $T$ 门”。

(c) 换个门集不会帮太多。任何通用门集都必须包含一个非克利福德门，而任何非克利福德门在表面码中都有类似的高昂成本。这是容错通用量子计算的本质限制，不是换个门集能绕过的。

---

3.3 多量子比特门与纠缠

3.3.1 纠缠态上的门作用

初始：$\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert00\rangle + \lvert11\rangle)$

1. 第一比特 $H$ 门： $\lvert\psi_1\rangle = \frac{1}{\sqrt{2}}(H\lvert0\rangle \otimes \lvert0\rangle + H\lvert1\rangle \otimes \lvert1\rangle)$ $= \frac{1}{2}[(\lvert0\rangle+\lvert1\rangle)\lvert0\rangle + (\lvert0\rangle-\lvert1\rangle)\lvert1\rangle]$ $= \frac{1}{2}(\lvert00\rangle + \lvert10\rangle + \lvert01\rangle - \lvert11\rangle)$

2. CNOT（控制=1，目标=2）： 反转第二比特当第一比特为 $|1\rangle$： $\lvert\psi_2\rangle = \frac{1}{2}(\lvert00\rangle + \lvert11\rangle + \lvert01\rangle - \lvert10\rangle)$

3. 第一比特 $Z$ 门： $Z\lvert\psi_2\rangle = \frac{1}{2}(\lvert00\rangle - \lvert11\rangle + \lvert01\rangle + \lvert10\rangle)$

最终态：$\frac{1}{2}(\lvert00\rangle + \lvert01\rangle + \lvert10\rangle - \lvert11\rangle)$

这不是贝尔态（振幅不是均匀的 $1/\sqrt{2}$）。它等于 $\frac{1}{\sqrt{2}}(\lvert0+\rangle - \lvert1-\rangle)$。

---

3.3.2 乘积态保持可分离性证明

输入可分离态：$\lvert\psi_{in}\rangle = \lvert\phi_1\rangle \otimes \lvert\phi_2\rangle$

施加 $U = A \otimes B$：

$\lvert\psi_{out}\rangle = (A \otimes B)(\lvert\phi_1\rangle \otimes \lvert\phi_2\rangle) = (A\lvert\phi_1\rangle) \otimes (B\lvert\phi_2\rangle)$

这显然也是可分离的（两个单比特态的张量积）。

意义：仅仅使用张量积形式的门无法产生纠缠。要创造纠缠，必须使用类似 CNOT 的非张量积门。这正是 CNOT 如此重要的原因——它是能产生纠缠的最简单门。没有 CNOT 或等价的两比特门，量子计算就没有真正的”量子性”。

---

3.3.3 🗣️ 参考答案要点

1. 纠缠是关于相关性的，不是关于信号的：纠缠不意味着两个粒子之间有一个”信息通道”。它意味着两个粒子的测量结果之间存在统计关联——当你测到第一个是 0，第二个必然是 1（对 $\lvert\Psi^-\rangle$ 而言）。但这种关联只能在事后对比数据时看到，不能用来实时传递信息。

2. 为什么不能超光速通信：假设 Alice 和 Bob 共享一个纠缠对，Alice 先测量她的粒子得到 0 或 1（各 50% 概率）。Bob 的粒子现在”知道”了 Alice 的结果——但 Bob 自己无法知道，因为他的测量结果也是随机的。Alice 的测量没有向 Bob 发送任何信号，Bob 无法区分他的粒子是否已经被测量。这保证了相对论因果律不被破坏。

3. 纠缠的真正用途：纠缠可用于量子隐形传态——传输一个量子态（不是超光速，需要经典通信配合）。也可用于量子密钥分发——如果有人在信道上窃听，纠缠会被破坏，从而被发现。

一个比喻：纠缠就像两个人各自拿着一个手套箱里的两只手套。一个人打开箱子发现是左手套，就”知道”另一个人必然有右手套——但他们各自打开箱子前都不知道自己有什么。这不是超光速通信，只是关联。

---

3.3.4 💭 洞察参考答案

(a) 是的！没有纠缠的量子态（即可分离态）可以被经典计算机高效模拟。具体来说，用 $n$ 个单比特态的张量积描述一个 $n$ 比特可分离态只需要 $O(n)$ 个参数，而不是 $2^n$。所以纠缠是真正的”量子性”来源——没有纠缠就没有量子优势。

(b) 纠缠”消耗”了可分离性。制备贝尔对需要 $H$ 门和 CNOT 门，而 CNOT 需要物理上两个量子比特之间的相互作用（如超导芯片上的电容耦合）。这是有代价的：两比特门的保真度通常低于单比特门，而且纠缠会随退相干而衰减（纠缠”死亡”）。维持高质量纠缠是当前量子计算的核心工程挑战。

(c) 纠缠可以在不同系统之间”传输”（纠缠交换）。两个从未相互作用的粒子通过中间粒子可以建立纠缠——这为量子网络和量子中继器奠定了基础。想象一个”量子互联网”：通过纠缠交换和纠缠蒸馏，我们可以跨越远距离建立高质量纠缠链路。这与电力传输不同（电力传输能量，而纠缠传输关联），但在拓扑意义上，纠缠确实是一种可以路由和提纯的资源。

---

3.4 量子电路

3.4.1 电路跟踪

电路：

|0⟩ —H—•——H—•—
|0⟩ ———⊕——H—⊕—
|0⟩ ————————⊕—

逐步跟踪：

1. 初始：$\lvert000\rangle$
2. 第一比特 $H$：$\frac{1}{\sqrt{2}}(\lvert000\rangle + \lvert100\rangle)$
3. CNOT$_{1\to2}$：$\frac{1}{\sqrt{2}}(\lvert000\rangle + \lvert110\rangle)$
4. 第二比特 $H$：$\frac{1}{\sqrt{2}}(\lvert000\rangle + \frac{1}{\sqrt{2}}(\lvert100\rangle - \lvert110\rangle))$？注意 $H(\lvert110\rangle) = \lvert1\rangle \otimes \frac{1}{\sqrt{2}}(\lvert0\rangle + \lvert1\rangle) \otimes \lvert0\rangle = \frac{1}{\sqrt{2}}(\lvert100\rangle + \lvert110\rangle)$

更正：$H$ 只作用于第二比特： $\frac{1}{\sqrt{2}}(\lvert000\rangle + \lvert110\rangle) \xrightarrow{H_2} \frac{1}{\sqrt{2}}[\lvert0\rangle \otimes H\lvert0\rangle \otimes \lvert0\rangle + \lvert1\rangle \otimes H\lvert1\rangle \otimes \lvert0\rangle]$ $= \frac{1}{2}[(\lvert000\rangle + \lvert010\rangle) + (\lvert100\rangle - \lvert110\rangle)]$ $= \frac{1}{2}(\lvert000\rangle + \lvert010\rangle + \lvert100\rangle - \lvert110\rangle)$

5. CNOT$_{1\to2}$：当第一比特为 $|1\rangle$ 时翻转第二比特： $\frac{1}{2}(\lvert000\rangle + \lvert010\rangle + \lvert110\rangle - \lvert100\rangle)$

6. CNOT$_{2\to3}$：当第二比特为 $|1\rangle$ 时翻转第三比特：

• $\lvert000\rangle \to \lvert000\rangle$
• $\lvert010\rangle \to \lvert011\rangle$
• $\lvert110\rangle \to \lvert111\rangle$
• $\lvert100\rangle \to \lvert100\rangle$

最终态：$\frac{1}{2}(\lvert000\rangle + \lvert011\rangle + \lvert111\rangle - \lvert100\rangle)$

这是一个四分量纠缠态，不是 GHZ 态。

---

3.4.2 CNOT 门等价性证明

需要证明：$(H \otimes H) \cdot \text{CNOT}_{1\to2} \cdot (H \otimes H) = \text{CNOT}_{2\to1}$

左端作用在计算基上：

先对两个比特施加 $H$：$\lvert00\rangle \to \frac{1}{2}(\lvert00\rangle + \lvert01\rangle + \lvert10\rangle + \lvert11\rangle)$

CNOT$_{1\to2}$ 后： $\frac{1}{2}(\lvert00\rangle + \lvert01\rangle + \lvert11\rangle + \lvert10\rangle)$ = 没有变化！因为输入对称。

等等，需要更仔细地逐基矢计算。

对 $\lvert00\rangle$： $(H\otimes H)\lvert00\rangle = \frac{1}{2}(\lvert00\rangle + \lvert01\rangle + \lvert10\rangle + \lvert11\rangle)$ $\text{CNOT}_{1\to2}$ 后：$\frac{1}{2}(\lvert00\rangle + \lvert01\rangle + \lvert11\rangle + \lvert10\rangle)$ = $\frac{1}{2}(\lvert00\rangle + \lvert01\rangle + \lvert10\rangle + \lvert11\rangle)$ = $\lvert++\rangle$ 再 $(H\otimes H)\lvert++\rangle = \lvert00\rangle$。

对 $\lvert01\rangle$： $(H\otimes H)\lvert01\rangle = \frac{1}{2}(\lvert00\rangle - \lvert01\rangle + \lvert10\rangle - \lvert11\rangle)$ $\text{CNOT}_{1\to2}$ 后：$\frac{1}{2}(\lvert00\rangle - \lvert01\rangle + \lvert11\rangle - \lvert10\rangle)$ = $\frac{1}{2}(\lvert00\rangle - \lvert01\rangle - \lvert10\rangle + \lvert11\rangle)$ 再 $(H\otimes H)$ 后：$\frac{1}{2}[(H\otimes H)(\lvert00\rangle - \lvert01\rangle - \lvert10\rangle + \lvert11\rangle)]$ $(H\otimes H)\lvert00\rangle = \lvert++\rangle = \frac{1}{2}(\lvert00\rangle + \lvert01\rangle + \lvert10\rangle + \lvert11\rangle)$ $(H\otimes H)\lvert01\rangle = \lvert+-\rangle = \frac{1}{2}(\lvert00\rangle - \lvert01\rangle + \lvert10\rangle - \lvert11\rangle)$ $(H\otimes H)\lvert10\rangle = \lvert-+\rangle = \frac{1}{2}(\lvert00\rangle + \lvert01\rangle - \lvert10\rangle - \lvert11\rangle)$ $(H\otimes H)\lvert11\rangle = \lvert--\rangle = \frac{1}{2}(\lvert00\rangle - \lvert01\rangle - \lvert10\rangle + \lvert11\rangle)$

所以上式中： $\frac{1}{2}[\lvert++\rangle - \lvert+-\rangle - \lvert-+\rangle + \lvert--\rangle]$ $= \frac{1}{2}[\lvert++\rangle - \lvert+-\rangle - \lvert-+\rangle + \lvert--\rangle]$

计算 $\lvert01\rangle$ 在这组基下的表示… 更简单的方法是用矩阵直接验证。

直接矩阵验证：$\text{CNOT}_{1\to2} = \begin{pmatrix}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{pmatrix}$

$(H\otimes H) = \frac12\begin{pmatrix}1&1&1&1\\1&-1&1&-1\\1&1&-1&-1\\1&-1&-1&1\end{pmatrix}$

$(H\otimes H)\cdot\text{CNOT}_{1\to2}\cdot(H\otimes H)$ 计算得到：

$\begin{pmatrix}1&0&0&0\\0&0&0&1\\0&0&1&0\\0&1&0&0\end{pmatrix} = \text{CNOT}_{2\to1}$

得证。几何意义：$H$ 门将 $Z$ 基和 $X$ 基互换。在 $X$ 基下，CNOT 的控制和目标关系反转。

---

3.4.3 🗣️ 参考答案要点

1. 酉性来自公设：量子力学要求时间演化算子是酉的（保持内积），这是公设3的直接要求。如果使用不可逆门，系统会丢失信息，破坏概率守恒——这在量子力学中不允许。

2. 不可逆门的灾难：如果我们试图用 AND 门（不可逆，输入 00/01/10/11 → 输出 0/0/0/1，丢失 2 比特信息），在量子力学中这意味着信息被”泄露”到环境中，也就是退相干。退相干会破坏量子叠加，使量子计算退化为经典计算。

3. 可逆的代价：经典可逆门（如 Toffoli）需要更多物理资源——Toffoli 门在量子实现中需要约 8 个基础门（CNOT + 单比特门）。作为对比，经典 NAND 只需要 4 个晶体管。量子计算的”可逆性”是一把双刃剑：它保护了量子相干性，但付出了更大的门实现成本。

---

3.4.4 💭 洞察参考答案

(a) 100 比特、深度 50 的电路——这大致描述了当前最先进量子处理器的能力。能做什么：某些变分量子算法（VQE）的简单问题、小规模量子化学模拟（如 H2 分子）、随机电路采样（验证量子优势）。不能做什么：Shor 算法分解大数（需要深度 $10^9+$）、Grover 搜索大型数据库。

(b) 深度受限更致命，因为：你可以通过增加比特数来利用更多并行性，但深度限制意味着你无法执行复杂算法。比如 Shor 算法需要的电路深度随输入长度多项式增长（约 $O((\log N)^3)$），对于 2048 位 RSA，深度约为 $10^9$——远超过当前设备 100 深度的能力。增加比特数解决不了深度问题。

(c) 量子体积 $V_Q = \min[n, d]^2$，其中 $n$ 是比特数，$d$ 是最大深度。它反映了量子处理器的综合能力：一个 1000 比特但深度只有 5 的设备（$V_Q = 25$）不一定比 50 比特深度 50 的设备（$V_Q = 2500$）更有用。这个指标告诉我们：比特数不是一切，质量和深度同样重要。

---

3.5 量子测量与读取

3.5.1 期望值计算

$\lvert\psi\rangle = \frac{1}{\sqrt{2}}(\lvert0\rangle - e^{i\pi/3}\lvert1\rangle)$，其中 $\alpha = 1/\sqrt{2}$，$\beta = -e^{i\pi/3}/\sqrt{2}$

$\langle Z\rangle = |\alpha|^2 - |\beta|^2 = \frac12 - \frac12 = 0$

$\langle X\rangle = \alpha^*\beta + \alpha\beta^* = \frac{1}{\sqrt{2}}\cdot\frac{-e^{i\pi/3}}{\sqrt{2}} + \frac{1}{\sqrt{2}}\cdot\frac{-e^{-i\pi/3}}{\sqrt{2}} = -\frac12(e^{i\pi/3} + e^{-i\pi/3}) = -\cos(\pi/3) = -\frac12$

$\langle Y\rangle = i(\alpha\beta^* - \alpha^*\beta) = i\left[\frac{1}{\sqrt{2}}\cdot\frac{-e^{-i\pi/3}}{\sqrt{2}} - \frac{1}{\sqrt{2}}\cdot\frac{-e^{i\pi/3}}{\sqrt{2}}\right] = \frac{i}{2}(-e^{-i\pi/3} + e^{i\pi/3}) = \frac{i}{2}\cdot 2i\sin(\pi/3) = -\sin(\pi/3) = -\frac{\sqrt{3}}{2}$

验证：$\langle X\rangle^2 + \langle Y\rangle^2 + \langle Z\rangle^2 = \frac14 + \frac34 + 0 = 1$。是纯态。

---

3.5.2 测量的”反直觉”性证明

(a) $\lvert\Psi^-\rangle = \frac{1}{\sqrt{2}}(\lvert01\rangle - \lvert10\rangle)$

对第一个比特在计算基下测量：

$P_1(0) = \text{Tr}[(\lvert0\rangle\langle0\rvert \otimes I) \lvert\Psi^-\rangle\langle\Psi^-\rvert]$

$\langle\Psi^-\rvert(\lvert0\rangle\langle0\rvert \otimes I)\lvert\Psi^-\rangle = \frac12(\langle01\rvert - \langle10\rvert)(\lvert0\rangle\langle0\rvert \otimes I)(\lvert01\rangle - \lvert10\rangle)$

$= \frac12\langle01\rvert(\lvert0\rangle\langle0\rvert \otimes I)\lvert01\rangle + \frac12\langle10\rvert(\lvert0\rangle\langle0\rvert \otimes I)\lvert10\rangle$（交叉项为 0）

$= \frac12\langle1\rvert I\lvert1\rangle\langle0\rvert0\rangle\langle0\rvert0\rangle + \frac12\langle0\rvert I\lvert0\rangle\langle1\rvert0\rangle\langle0\rvert1\rangle$

$= \frac12 \cdot 1 \cdot 1 \cdot 1 + \frac12 \cdot 1 \cdot 0 = \frac12$

同理 $P_1(1) = 1/2$。由对称性，第二个比特也一样。

(b) 两比特同时测量：$P(00) = P(11) = 0$，$P(01) = P(10) = 1/2$。所以两个比特结果总相反。

(c) 类比：想象两个魔术球，每个球单独看时，红/蓝完全随机。但如果你同时看两个球，它们颜色一定不同。这不是因为球之间有”通信”，而是它们被制作时就被设定为”配对”——一个总是红，另一个总是蓝，但我们不知道哪个是哪个。量子纠缠比这个类比更强（涉及基的选择、相位等），但”全局确定、局部随机”的核心特征是类似的。

---

3.5.3 🗣️ 参考答案要点

1. 概率幅有相位，经典概率没有：经典概率只有幅度（0.6 vs 0.4），但量子概率幅是复数，包含相位信息。相位会产生干涉效应：$\lvert+\rangle = (\lvert0\rangle + \lvert1\rangle)/\sqrt{2}$ 和 $\lvert-\rangle = (\lvert0\rangle - \lvert1\rangle)/\sqrt{2}$ 具有完全相同的测量概率（$P(0)=P(1)=0.5$），但在 $X$ 基下会产生完全不同的结果。经典硬币做不到这一点——你不会找到两枚不同的硬币，它们抛出正面的概率一样，但在另一种”测量”下表现完全不同。

2. 坍缩不是条件更新：经典条件概率是信息更新——如果你抛一枚不均匀硬币但没看结果，条件概率只反映你认知的改变，硬币本身没变。但量子测量后的坍缩是物理变化——量子态真的被改变了，不仅仅是你不知道它。测量 $\lvert+\rangle$ 在 $Z$ 基下，得到 0 后态变为 $\lvert0\rangle$，再测量 $Z$ 基又会得到 0（确定性）。但经典概率更新后再测，得到同样结果，两者表面相似——区别在于，如果你在测量后改测 $X$ 基，$\lvert0\rangle$ 的 $X$ 测量结果是随机的（$P(+)=P(-)=0.5$），而经典不均匀硬币在任何”基”下的表现都一样。

3. 举例：对 $\lvert+\rangle$ 在 $Z$ 基测，$P(0)=P(1)=0.5$；在 $X$ 基测，$P(+)=1$。同一个态在不同”测量方向”下给出完全不同的统计。没有任何经典概率分布能做到这一点。这就证明了量子概率不是经典概率。

---

3.5.4 💭 洞察参考答案

(a) 理论上，单比特纯态需要 $\infty$ 次测量才能确定（因为单次测量给出随机结果，只有统计足够多次才能精确估计）。但实际上，从信息论角度，一个单比特纯态有 2 个实参数（$\theta, \phi$），理论上最少需要 2 比特的信息就能编码——但提取这 2 比特需要多次测量（因为每次测量只产生 1 比特，且有统计噪声）。

(b) $n$ 比特纯态有 $2^{n+1} - 2$ 个实参数。标准量子态层析的样本复杂度是 $O(2^n)$，随 $n$ 指数增长。这是量子态层析不可扩展的根本原因——即使我们制备了这些态，测量它们来确认代价也太高。这推动了”量子验证”的研究——不需要完整层析就能确认量子态性质。

(c) 标准量子极限 $1/\sqrt{N}$ 可以通过使用纠缠初始态（如 GHZ 态）来突破，达到海森堡极限 $1/N$——这就是量子增强传感。例如，使用 $N$ 个纠缠粒子的干涉仪，相位估计精度可以达到 $1/N$，比经典极限 $1/\sqrt{N}$ 提升了 $\sqrt{N}$ 倍。这是量子计量学的核心优势，也是量子计算”干涉”能力的直接体现。

---

3.6 量子算法导引

3.6.1 BB84 窃听概率分析

(a) Eve 截获并测量时，有 50% 概率选错基。选错基会以 50% 概率得到错误结果，所以每次测量引入 $0.5 \times 0.5 = 25\%$ 错误率。但如果 Eve 以概率 $p$ 测量，以 $1-p$ 转发，总体错误率 = $p \times 25\%$。

简洁推导：

• Eve 测量概率：$p$
• Eve 选错基概率：$1/2$
• Eve 选错基时测量错误概率：$1/2$
• 每比特错误率 = $p \cdot \frac12 \cdot \frac12 = \frac{p}{4}$

(b) 令 $p/4 < 0.05$，得 $p < 0.2$。即如果 Eve 截获超过 20% 的量子比特，就会被检测到。

---

3.6.2 Grover 迭代的几何解释

(a) 定义初始态 $\lvert s\rangle = \frac{1}{\sqrt{N}}\sum_x \lvert x\rangle$。将其分解为目标分量和正交分量：

$\lvert s\rangle = \sin\theta\lvert \omega\rangle + \cos\theta\lvert \omega^\perp\rangle$

其中 $\sin\theta = 1/\sqrt{N}$。

Grover 迭代 $G = U_s U_\omega$，其中：

• $U_\omega = I - 2\lvert\omega\rangle\langle\omega\rvert$（标记，相对于 $\lvert \omega^\perp\rangle,\lvert\omega\rangle$ 的反射）
• $U_s = 2\lvert s\rangle\langle s\rvert - I$（扩散，相对于 $\lvert s\rangle$ 的反射）

两个反射的复合 = $2\theta$ 的旋转。每次迭代将 $\lvert s\rangle$ 向 $\lvert\omega\rangle$ 旋转 $2\theta$。

(b) 需要旋转总角度 $\pi/2$（从初始 $\theta$ 到 $\pi/2$，即指向 $\lvert\omega\rangle$）。

迭代次数 $k$：$k \cdot 2\theta + \theta = \pi/2$，得 $k = \frac{\pi}{4\theta} - \frac12$

由于 $\sin\theta \approx \theta = 1/\sqrt{N}$（对大的 $N$）， $k \approx \frac{\pi}{4}\sqrt{N} - \frac12 \approx \frac{\pi}{4}\sqrt{N}$

(c) $N = 10^6$，经典最坏情况 $N = 10^6$ 次，平均 $5\times 10^5$ 次。 量子：$k \approx \frac{\pi}{4}\sqrt{10^6} = \frac{\pi}{4} \cdot 1000 \approx 785$ 次。 加速因子：约 $10^6/785 \approx 1274$ 倍。

---

3.6.3 🗣️ 参考答案要点

1. “同时尝试”是不可能的：如果量子计算机真的”同时尝试所有可能性”，测量时会得到所有可能结果的叠加——但测量只能得到一个结果。所以”同时尝试所有”这个比喻最大的问题在于：你只能取出一个结果。

2. 干涉是关键：量子算法的秘密不在于并行，而在于干涉。以 Grover 搜索为例：我们并不是列出所有可能性然后挑出正确的一个——我们通过振幅放大，让正确项的概率幅变大、错误项变小。这更像潮汐波汇聚能量到一点，而不是同时读取多个文件夹。

3. 量子计算机不是在所有问题上都快：经典计算机在一般任务上（排序、数据库管理、办公软件）可能永远比量子计算机快。量子计算机只对特定问题有优势：因子分解（Shor）、搜索（Grover）、模拟量子系统。它不会取代你的笔记本电脑。

4. 2026年真实状态：当前最先进的量子处理器有 1000+ 物理量子比特（如 IBM Condor），但逻辑量子比特（纠错后的有效比特）仍然是个位数。噪声水平限制了电路深度到约 50–100 层。我们能展示”量子霸权”的随机电路采样（Google 2019, 53 比特），也能运行小规模的变分算法，但还没有一个公认的、有商业价值的”量子优势”演示。破解 RSA-2048 需要几百万逻辑量子比特，按当前进展速度估计还需 10–20 年。

---

3.6.4 💭 洞察参考答案

(a) AES-256 对 Grover 搜索的有效密钥强度降至 128 位——仍然是经典计算意义上安全的（$2^{128}$ 次操作远超任何可行攻击）。但如果未来有更快的量子算法出现（不仅限 Grover），情况可能改变。目前学界认为 AES-256 是后量子安全的，但 AES-128 可能有风险。

(b) NIST 已选中的 PQC 标准主要基于：

• 格密码 (Lattice-based)：Kyber (KEM)、Dilithium (签名)。安全性基于”带错误学习的最近向量问题”（Learning With Errors, LWE），目前没有已知的量子算法能高效求解。
• 哈希签名：SPHINCS+，基于哈希函数的不可逆性，Grover 只能提供二次加速。

这些问题的困难性对抗量子攻击的根源在于：它们不依赖结构化的代数结构（如 RSA 的循环群），而依赖”噪声”和”随机性”，使得量子傅里叶变换无法像对付 RSA 那样有效。

(c) 这个问题没有确定答案，但有三种主流观点：

1. 先有量子优势（乐观派）：5–10 年内，量子模拟（材料科学、化学）将展示有商业价值的优势，比如更高效的催化剂或电池材料设计。
2. 先破解 RSA（悲观派/密码学视角）：虽然需要更多量子比特，但密码学是攻击者的问题——攻击者只需要一次成功，而防御者需要永远安全。因此即使 2040 年才出现量子 RSA 破解，我们现在就应该迁移到 PQC。
3. 同时发生但不同领域：量子优势在模拟中更早实现（2028–2032），而 RSA 破解需要更长的时间（2035–2045）。两者的实现路径完全不同——模拟需要更少的逻辑量子比特但更高的精度，而 RSA 破解需要大量的逻辑量子比特但精度要求不高。

我最赞同第三种观点：量子计算的优势将先在科学计算领域展现，密码学威胁是更长期但更严峻的挑战。

---

开放性问题

这部分问题没有标准答案，适合课堂讨论、辩论或深度思考。每个问题都涉及技术、社会或哲学的交叉点。

---

1. 量子优势的”杀手级应用”在哪里？

Shor 算法威胁密码学，Grover 搜索加速搜索，VQE 模拟量子化学。但哪个才是量子计算机的”杀手级应用”？或者说，量子计算是否需要像经典计算一样的”杀手级应用”（如电子表格、网页浏览）才能证明其价值？量子优势是否可能分散在许多窄领域，而没有单一的杀手级应用？

---

2. 量子计算会加剧还是缓解数字不平等？

量子计算机的建造成本预计在数十亿美元级别，初期可能只有少数几个组织（Google、IBM、政府）能够使用。考虑到云量子服务的商业模式，这会加重大型科技公司对计算资源的垄断，还是会通过云服务让更多人受益？量子计算时代的”数字鸿沟”会是什么样子？

---

3. 如果 PQC 提前部署，Shor 算法还有工程上的意义吗？

如果全世界在 2030 年之前完成 PQC 迁移（NIST 已经发布标准），量子破解 RSA 就失去了实际意义——没有重要的加密数据还在使用 RSA。那么研发大规模容错量子计算机的主要动机是什么？纯粹的科学研究？模拟量子系统？还是我们仍然需要警惕未知的密码学突破？

---

4. 量子随机性是真随机吗？

量子测量结果是概率性的——这是否意味着量子计算机是”真正的随机数生成器”？经典计算机只能生成伪随机数（依赖算法和种子），而量子计算机可以基于测量结果生成随机数。这是否在哲学上”更随机”？这对密码学、蒙特卡洛模拟和彩票等行业意味着什么？

---

5. “量子霸权”这个概念合理吗？

2019 年 Google 宣布”量子霸权”（使用 53 量子比特的 Sycamore 处理器在 200 秒内完成了一个经典超级计算机需 10000 年才能完成的计算任务）。但随后 IBM 质疑这个结论，指出经典算法可以更高效地模拟这个特定电路。这个争议引出了一个更深层的问题：“量子霸权”这个术语是否有意义？我们是否应该用更有建设性的指标（如有用的计算任务上的优势）来取代它？什么才是一个令人信服的”量子优势”演示？

---

文件信息：6 节 × 4 题 = 24 基础题 + 5 开放性问题

难度分布：⭐ 6 题 · ⭐⭐ 6 题 · 🗣️ 6 题 · 💭 6 题

总行数：约 850 行

量子计算前置教程 —— 代码验证补充

配套教程：《量子计算前置教程——从第一性原理出发》

用途：本文件提供 Python + NumPy + Qiskit 代码块，用于验证教程中的关键数学推导和演示量子计算概念。 所有代码均可复制粘贴直接运行。

运行环境要求：

• Python ≥ 3.9
• pip install numpy qiskit qiskit-aer
• 如需打印彩色矩阵，可安装 pip install rich（非必须）

---

安装与导入

## ============================================================
## 环境准备：安装依赖
## ============================================================
## 在终端执行：
##   pip install numpy qiskit qiskit-aer
#
## 如果 Qiskit 版本为 1.x，请确保使用 AerSimulator：
##   from qiskit_aer import AerSimulator
## ============================================================

import numpy as np

## ---------- Qiskit 1.x 兼容导入 ----------
try:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator
    from qiskit.visualization import plot_histogram
    HAS_QISKIT = True
except ImportError:
    HAS_QISKIT = False
    print("⚠️  Qiskit 未安装。仅 NumPy 部分可执行。")
    print("   安装命令: pip install qiskit qiskit-aer")

---

第一部分：数学基础验证

对应教程 1.1 – 1.8 节

---

1.1 复数运算与欧拉公式

对应教程：1.1.2 四则运算与共轭、1.1.4 欧拉公式的推导

验证目标：复数四则运算、共轭、模的计算，以及欧拉公式的数值验证

## ============================================================
## 示例 1：复数基本运算 —— 验证教程 1.1.2 节
## ============================================================

## 使用 Python 内置复数类型
z1 = 1 + 2j   # 对应教程例 1.1 的分子
z2 = 3 - 1j   # 对应教程例 1.1 的分母

## --- 加减法 ---
print("=== 复数加减法 ===")
print(f"z1 = {z1}")
print(f"z2 = {z2}")
print(f"z1 + z2 = {z1 + z2}")   # 期望: (4+1j)
print(f"z1 - z2 = {(1+2j) - (3-1j)}")  # 期望: (-2+3j)

## --- 乘法 (教程公式) ---
## (a+bi)(c+di) = (ac-bd) + (ad+bc)i
print("\n=== 复数乘法 ===")
print(f"z1 * z2 = {z1 * z2}")   # 期望: (5+5j)
## 验证: (1+2j)(3-1j) = 3 -1j + 6j -2j² = 3+5j+2 = 5+5j ✓

## --- 共轭 ---
print("\n=== 复共轭 (教程 1.1.2) ===")
print(f"z1 的共轭 conj(z1) = {z1.conjugate()}")   # 期望: (1-2j)
print(f"z2 的共轭 conj(z2) = {z2.conjugate()}")   # 期望: (3+1j)

## --- 除法 (示例 1.1 的验证) ---
print("\n=== 复数除法 (教程例 1.1) ===")
result = (1 + 2j) / (3 - 1j)
print(f"(1+2j)/(3-1j) = {result}")
print(f"期望值: 0.1 + 0.7j")
print(f"验证: 结果 × 分母 = {result * (3-1j)} (应为 1+2j)")

## --- 模的计算 ---
print("\n=== 模 (教程 1.1.3) ===")
z3 = 1 + 1j
print(f"|{z3}| = {abs(z3):.4f}")   # 期望: sqrt(2) ≈ 1.4142
print(f"验证: sqrt(1²+1²) = {np.sqrt(1**2 + 1**2):.4f}")

## ============================================================
## 示例 2：欧拉公式的数值验证 —— 验证教程 1.1.4 节
## ============================================================

print("=== 欧拉公式 e^(iθ) = cosθ + i sinθ 数值验证 ===")

thetas = [0, np.pi/4, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi]
labels = ["0", "π/4", "π/2", "π", "3π/2", "2π"]

for theta, label in zip(thetas, labels):
    euler = np.exp(1j * theta)          # e^(iθ)
    trig  = np.cos(theta) + 1j * np.sin(theta)  # cosθ + i sinθ
    diff  = abs(euler - trig)
    print(f"θ={label:6s}: e^(iθ)={euler:8.4f}, cos+isin={trig:8.4f}, 差值={diff:.2e}")
    assert diff < 1e-15, "欧拉公式数值验证失败！"

print("\n✅ 欧拉公式验证通过：所有差值为 ~10^-16 量级（浮点精度）")

## ---------- 特别验证：欧拉恒等式 e^(iπ) + 1 = 0 ----------
print("\n=== 欧拉恒等式 e^(iπ) + 1 = 0 ===")
val = np.exp(1j * np.pi) + 1
print(f"e^(iπ) + 1 = {val}")
print(f"实部={val.real:.2e}, 虚部={val.imag:.2e}")
assert abs(val) < 1e-15, "欧拉恒等式验证失败！"
print("✅ 欧拉恒等式验证通过！")

## ============================================================
## 示例 3：复数乘法的几何意义 —— 验证教程 1.1.5 节
## ============================================================
## 教程核心结论：复数乘法 = 模长相乘 + 辐角相加

print("=== 复数乘法的几何意义 ===")

z = 1 + 1j   # 模 = √2, 辐角 = π/4
w = np.sqrt(2) * np.exp(1j * np.pi/4)  # 模 = √2, 辐角 = π/4

product = z * w
r_product = abs(product)
theta_product = np.angle(product)

print(f"z = {z}, |z|={abs(z):.4f}, arg(z)={np.angle(z):.4f}")
print(f"w = √2·e^(iπ/4), |w|={abs(w):.4f}, arg(w)={np.angle(w):.4f}")
print(f"z·w = {product}")
print(f"|z·w| = {r_product:.4f} (期望: 2.0)")
print(f"arg(z·w) = {theta_product:.4f} (期望: π/2 ≈ {np.pi/2:.4f})")
print(f"验证: 模长相乘 √2·√2=2, 辐角相加 π/4+π/4=π/2")

## 验证教程中的例子：乘以 i 相当于旋转 90°
print("\n=== 乘以 i = 旋转 90° ===")
v = 2 + 0j
print(f"v = {v}")
print(f"v × i = {v * 1j}")     # 期望: 2i (逆时针旋转 90°)
print(f"v × i² = {v * 1j * 1j}")  # 期望: -2 (旋转 180°)
print(f"v × i⁴ = {v * (1j**4)}")   # 期望: 2 (旋转 360°，回到原位)

---

1.2 向量空间与 bra-ket 符号

对应教程：1.2.3 bra-ket 符号、1.2.5 C² 量子比特空间

验证目标：用 NumPy 实现狄拉克符号的矩阵表示、内积计算

## ============================================================
## 示例 4：bra-ket 符号的 NumPy 实现 —— 验证教程 1.2.3 节
## ============================================================

print("=== bra-ket 符号的矩阵表示 ===")

## 定义 |0⟩ 和 |1⟩ (教程 1.2.5)
ket0 = np.array([[1], [0]])  # |0⟩
ket1 = np.array([[0], [1]])  # |1⟩

## bra = ket 的共轭转置
bra0 = ket0.conj().T          # ⟨0|
bra1 = ket1.conj().T          # ⟨1|

print("|0⟩ =")
print(ket0)
print("\n⟨0| =")
print(bra0)

## 验证正交归一性
print("\n=== 正交归一性验证 ===")
print(f"⟨0|0⟩ = {bra0 @ ket0}")   # 期望: 1
print(f"⟨1|1⟩ = {bra1 @ ket1}")   # 期望: 1
print(f"⟨0|1⟩ = {bra0 @ ket1}")   # 期望: 0
print(f"⟨1|0⟩ = {bra1 @ ket0}")   # 期望: 0

## ---------- 验证教程例 1.2 ----------
print("\n=== 教程例 1.2 的验证 ===")
psi = np.array([[1], [1j]])       # |ψ⟩ = (1, i)^T
phi = np.array([[2], [1+1j]])     # |φ⟩ = (2, 1+i)^T

bra_psi = psi.conj().T            # ⟨ψ|
bra_phi = phi.conj().T            # ⟨φ|

## 计算内积
ip_phi_psi = bra_phi @ psi        # ⟨φ|ψ⟩
ip_psi_phi = bra_psi @ phi        # ⟨ψ|φ⟩

print(f"|ψ⟩ = \n{psi}")
print(f"|φ⟩ = \n{phi}")
print(f"⟨φ|ψ⟩ = {ip_phi_psi[0,0]}")          # 期望: 3+i
print(f"⟨ψ|φ⟩ = {ip_psi_phi[0,0]}")          # 期望: 3-i
print(f"⟨ψ|φ⟩ = ⟨φ|ψ⟩*? {ip_psi_phi[0,0] == ip_phi_psi[0,0].conjugate()}")

## ---------- 验证 |+⟩ 的归一化 (教程例 1.3) ----------
print("\n=== 教程例 1.3：|+⟩ 归一化验证 ===")
ket_plus = (ket0 + ket1) / np.sqrt(2)   # |+⟩
bra_plus = ket_plus.conj().T
norm_plus = (bra_plus @ ket_plus)[0, 0]
print(f"|+⟩ = 1/√2 (|0⟩ + |1⟩)")
print(f"⟨+|+⟩ = {norm_plus:.4f}")   # 期望: 1
assert abs(norm_plus - 1) < 1e-15, "归一化验证失败"
print("✅ 归一化验证通过！")

---

1.3 线性算子与泡利矩阵

对应教程：1.3.4 泡利矩阵、1.3.5 矩阵运算、反交换关系

验证目标：泡利矩阵的酉性、厄米性、反交换关系、代数性质

## ============================================================
## 示例 5：泡利矩阵及其性质验证 —— 验证教程 1.3.4 & 1.3.5 节
## ============================================================

print("=== 泡利矩阵的定义 ===")
I = np.array([[1, 0], [0, 1]], dtype=complex)
X = np.array([[0, 1], [1, 0]], dtype=complex)
Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
Z = np.array([[1, 0], [0, -1]], dtype=complex)

paulis = {"I": I, "X": X, "Y": Y, "Z": Z}
for name, mat in paulis.items():
    print(f"\n{name} =")
    print(mat)

## ---------- 验证酉性: U†U = I ----------
print("\n=== 酉性验证 (U†U = I) ===")
for name, mat in paulis.items():
    u_dag_u = mat.conj().T @ mat
    is_unitary = np.allclose(u_dag_u, I)
    print(f"{name}†·{name} = I? {is_unitary}")
    if not is_unitary:
        print(f"差值:\n{u_dag_u - I}")

## ---------- 验证厄米性: H† = H ----------
print("\n=== 厄米性验证 (H† = H) ===")
for name, mat in paulis.items():
    is_hermitian = np.allclose(mat.conj().T, mat)
    print(f"{name}† = {name}? {is_hermitian}")

## ---------- 验证平方恒等: X² = Y² = Z² = I ----------
print("\n=== 平方恒等验证 (Pauli² = I) ===")
for name, mat in paulis.items():
    sq = mat @ mat
    is_id = np.allclose(sq, I)
    print(f"{name}² = I? {is_id}")

## ---------- 验证反交换关系: XY = -YX ----------
print("\n=== 反交换关系验证 (教程 1.3.5) ===")
xy = X @ Y
yx = Y @ X
print(f"XY = \n{xy}")
print(f"YX = \n{yx}")
print(f"XY = -YX? {np.allclose(xy, -yx)}")

## ---------- 验证对易关系: XY = iZ ----------
print(f"\n=== 泡利代数关系 (教程 1.3.5) ===")
print(f"XY = iZ? {np.allclose(X @ Y, 1j * Z)}")
print(f"YZ = iX? {np.allclose(Y @ Z, 1j * X)}")
print(f"ZX = iY? {np.allclose(Z @ X, 1j * Y)}")

## ---------- 验证 XY ≠ YX (非交换性) ----------
print(f"\n=== 矩阵乘法非交换性 ===")
print(f"XY == YX? {np.allclose(xy, yx)}")  # 期望: False

---

1.4 内积、范数与投影算子

对应教程：1.4 内积与投影算子

验证目标：内积性质、柯西-施瓦茨不等式、投影算子的构造

## ============================================================
## 示例 6：内积、范数与投影算子 —— 验证教程 1.4 节
## ============================================================

print("=== 范数计算 (教程 1.4 范数与距离) ===")
v = np.array([[1], [1j]])   # |v⟩ = (1, i)^T
norm_v = np.sqrt((v.conj().T @ v)[0, 0])
print(f"|v⟩ = \n{v}")
print(f"||v⟩|| = sqrt(⟨v|v⟩) = {norm_v:.4f}")   # 期望: √2 ≈ 1.4142

## 归一化
v_norm = v / norm_v
print(f"\n归一化后: ⟨v̂|v̂⟩ = {(v_norm.conj().T @ v_norm)[0,0]:.4f}")  # 期望: 1

## ---------- 柯西-施瓦茨不等式验证 ----------
print("\n=== 柯西-施瓦茨不等式 |⟨v|w⟩| ≤ ||v||·||w|| ===")
psi = np.array([[1], [0]], dtype=complex)     # |0⟩
phi = np.array([[1], [1]], dtype=complex) / np.sqrt(2)  # |+⟩
ip = (psi.conj().T @ phi)[0, 0]
norm_psi = np.sqrt((psi.conj().T @ psi)[0, 0])
norm_phi = np.sqrt((phi.conj().T @ phi)[0, 0])
lhs = abs(ip)
rhs = norm_psi * norm_phi
print(f"|⟨ψ|φ⟩| = {lhs:.4f}")
print(f"||ψ||·||φ|| = {rhs:.4f}")
print(f"不等式成立? {lhs <= rhs + 1e-15}")

## ---------- 投影算子构造 ----------
print("\n=== 投影算子 P₀ = |0⟩⟨0| (教程 1.4) ===")
ket0 = np.array([[1], [0]], dtype=complex)
bra0 = ket0.conj().T
P0 = ket0 @ bra0
print("P0 =")
print(P0)
print(f"P0² = P0? {np.allclose(P0 @ P0, P0)}")   # 幂等性验证

## 完备性关系
ket1 = np.array([[0], [1]], dtype=complex)
bra1 = ket1.conj().T
P1 = ket1 @ bra1
print(f"\nP0 + P1 = I? {np.allclose(P0 + P1, np.eye(2))}")   # 完备性验证

## 投影计算概率
psi_plus = (ket0 + ket1) / np.sqrt(2)  # |+⟩
p0 = (psi_plus.conj().T @ P0 @ psi_plus)[0, 0]
p1 = (psi_plus.conj().T @ P1 @ psi_plus)[0, 0]
print(f"\n测量 |+⟩：P(0) = {p0:.2f}, P(1) = {p1:.2f}")
print(f"概率和 = {p0 + p1:.2f}")  # 期望: 1.0

---

1.5 特征值与谱定理

对应教程：1.5 特征值与特征向量、泡利矩阵的谱分解

验证目标：NumPy 特征值分解、谱定理的数值验证

## ============================================================
## 示例 7：特征值与谱分解 —— 验证教程 1.5 节
## ============================================================

print("=== 泡利 Z 矩阵特征值 (教程 1.5 显式计算) ===")
Z = np.array([[1, 0], [0, -1]], dtype=complex)
eigvals_Z, eigvecs_Z = np.linalg.eigh(Z)  # eigh 专为对称/厄米矩阵优化
print(f"Z 矩阵:")
print(Z)
print(f"特征值: {eigvals_Z}")   # 期望: [-1, 1]
print(f"特征向量(列):\n{eigvecs_Z}")
print(f"验证迹=特征值和: tr(Z)={np.trace(Z):.0f}, sum(λ)={sum(eigvals_Z):.0f}")
print(f"验证 det=特征值积: det(Z)={np.linalg.det(Z):.0f}, prod(λ)={np.prod(eigvals_Z):.0f}")

## ---------- 泡利 X 矩阵谱分解验证 ----------
print("\n=== 泡利 X 矩阵谱分解 (教程 1.5) ===")
X = np.array([[0, 1], [1, 0]], dtype=complex)
eigvals_X, eigvecs_X = np.linalg.eigh(X)

## 谱分解: X = Σ λᵢ |vᵢ⟩⟨vᵢ|
X_reconstructed = np.zeros((2, 2), dtype=complex)
for i in range(2):
    vec = eigvecs_X[:, [i]]
    proj = vec @ vec.conj().T
    X_reconstructed += eigvals_X[i] * proj

print(f"X 原始矩阵:\n{X}")
print(f"X 谱分解重建:\n{X_reconstructed}")
print(f"验证一致? {np.allclose(X, X_reconstructed)}")

## ---------- 教程中的非泡利例子 ----------
print("\n=== 教程中 H = [[3,1],[1,3]] 的特征值 ===")
H = np.array([[3, 1], [1, 3]], dtype=complex)
eigvals_H, eigvecs_H = np.linalg.eigh(H)
print(f"H 矩阵:\n{H}")
print(f"特征值: {eigvals_H}")   # 期望: [2, 4]
print(f"特征向量:\n{eigvecs_H}")

## ---------- 酉算子特征值验证 ----------
print("\n=== 酉算子特征值模为 1 验证 (教程 1.5 末) ===")
## 相位门 P(θ) = diag(1, e^(iθ))
theta = np.pi/3
P = np.array([[1, 0], [0, np.exp(1j * theta)]], dtype=complex)
eigvals_P = np.linalg.eigvals(P)
print(f"P(π/3) = diag(1, e^(iπ/3))")
print(f"特征值: {eigvals_P}")
print(f"特征值模长: {[abs(v) for v in eigvals_P]}")  # 期望: [1, 1]

---

1.6 张量积与 CNOT 门

对应教程：1.6 张量积与多体系统、CNOT 门矩阵

验证目标：克罗内克积、双量子比特基、CNOT 门矩阵构造

## ============================================================
## 示例 8：张量积与克罗内克积 —— 验证教程 1.6 节
## ============================================================

print("=== 双量子比特基向量 (教程 1.6) ===")
ket0 = np.array([[1], [0]], dtype=complex)
ket1 = np.array([[0], [1]], dtype=complex)

## 张量积构造 |ij⟩ = |i⟩ ⊗ |j⟩
ket00 = np.kron(ket0, ket0)
ket01 = np.kron(ket0, ket1)
ket10 = np.kron(ket1, ket0)
ket11 = np.kron(ket1, ket1)

print(f"|00⟩ = \n{ket00}")
print(f"|01⟩ = \n{ket01}")
print(f"|10⟩ = \n{ket10}")
print(f"|11⟩ = \n{ket11}")

## ---------- 验证教程中的 Z⊗X ----------
print("\n=== Z ⊗ X 计算 (教程 1.6) ===")
Z = np.array([[1, 0], [0, -1]], dtype=complex)
X = np.array([[0, 1], [1, 0]], dtype=complex)
Z_kron_X = np.kron(Z, X)
print("Z ⊗ X =")
print(Z_kron_X)
print(f"形状: {Z_kron_X.shape} (期望: 4×4)")

## 验证作用于 |0⟩⊗|+⟩
ket_plus = (ket0 + ket1) / np.sqrt(2)
state_in = np.kron(ket0, ket_plus)
state_out = Z_kron_X @ state_in
print(f"\n(Z⊗X) · |0+⟩ = \n{state_out}")
print(f"验证: 与 |0+⟩ 相同? {np.allclose(state_out, state_in)}")
print("(因为 Z|0⟩=|0⟩, X|+⟩=|+⟩，所以 |0+⟩ 是特征向量，特征值 +1)")

## ---------- CNOT 门矩阵构造 (教程公式) ----------
print("\n=== CNOT 门矩阵构造 (教程 1.6) ===")
P0 = np.array([[1, 0], [0, 0]], dtype=complex)  # |0⟩⟨0|
P1 = np.array([[0, 0], [0, 1]], dtype=complex)  # |1⟩⟨1|
I2 = np.eye(2, dtype=complex)
CNOT_from_formula = np.kron(P0, I2) + np.kron(P1, X)
print("CNOT = P₀⊗I + P₁⊗X =")
print(CNOT_from_formula)

## 验证 CNOT 对计算基的作用
print("\n=== CNOT 作用于计算基 ===")
for i, label in enumerate(["|00⟩", "|01⟩", "|10⟩", "|11⟩"]):
    basis_states = [ket00, ket01, ket10, ket11]
    result = CNOT_from_formula @ basis_states[i]
    print(f"CNOT·{label} = \n{result}")

## ---------- 贝尔态：证明不可分解 ----------
print("\n=== 贝尔态纠缠验证 (教程 1.6) ===")
bell = (ket00 + ket11) / np.sqrt(2)
print(f"|Φ⁺⟩ = (|00⟩ + |11⟩)/√2 = \n{bell}")
## 尝试因式分解检查
## 如果 |Φ⁺⟩ = (a|0⟩+b|1⟩) ⊗ (c|0⟩+d|1⟩) = ac|00⟩ + ad|01⟩ + bc|10⟩ + bd|11⟩
## 则 ad = 0 且 bc = 0，但同时 ac = bd = 1/√2，矛盾
print("不能写成 |a⟩⊗|b⟩ 形式 (ad=0 与 ac=1/√2 矛盾)")
print("✅ 确认 |Φ⁺⟩ 是纠缠态")

---

1.7 概率幅与干涉

对应教程：1.7.5 经典概率 vs 量子概率

验证目标：概率幅叠加产生的干涉项

## ============================================================
## 示例 9：量子干涉 —— 验证教程 1.7.5 节
## ============================================================

print("=== 量子干涉: |ψ₁+ψ₂|² ≠ |ψ₁|² + |ψ₂|² ===")

## 定义两个复数概率幅
psi1 = 0.6 + 0.0j
psi2 = 0.0 + 0.8j

## 经典概率：直接相加
P_classical = abs(psi1)**2 + abs(psi2)**2

## 量子概率：先加再模平方
psi_total = psi1 + psi2
P_quantum = abs(psi_total)**2

print(f"ψ₁ = {psi1}")
print(f"ψ₂ = {psi2}")
print(f"经典概率 P_classical = |ψ₁|² + |ψ₂|² = {P_classical:.4f}")
print(f"量子概率 P_quantum = |ψ₁+ψ₂|² = {P_quantum:.4f}")
print(f"干涉项 = P_quantum - P_classical = {P_quantum - P_classical:.4f}")
print(f"P_classical ≠ P_quantum? {abs(P_classical - P_quantum) > 1e-10}")

## ---------- 演示相长干涉与相消干涉 ----------
print("\n=== 相长干涉 vs 相消干涉 ===")

## 相长干涉：同相位
a = 0.5 + 0.0j
b = 0.5 + 0.0j
constructive = abs(a + b)**2
separate = abs(a)**2 + abs(b)**2
print(f"同相位: ψ₁={a}, ψ₂={b}")
print(f"  |ψ₁|²+|ψ₂|² = {separate:.4f}, |ψ₁+ψ₂|² = {constructive:.4f} (加强)")

## 相消干涉：反相位
c = 0.5 + 0.0j
d = -0.5 + 0.0j
destructive = abs(c + d)**2
print(f"反相位: ψ₁={c}, ψ₂={d}")
print(f"  |ψ₁|²+|ψ₂|² = {abs(c)**2+abs(d)**2:.4f}, |ψ₁+ψ₂|² = {destructive:.4f} (抵消)")

---

1.8 离散傅里叶变换

对应教程：1.8 傅里叶分析、DFT 矩阵

验证目标：2×2 和 4×4 DFT 矩阵、与阿达玛门的关系

## ============================================================
## 示例 10：DFT 矩阵 —— 验证教程 1.8.3 节
## ============================================================

print("=== 2×2 DFT 矩阵 (教程 1.8) ===")
## N=2, ω₂ = e^(2πi/2) = -1
N2 = 2
omega2 = np.exp(2j * np.pi / N2)
F2 = np.array([[omega2**(j*k) for k in range(N2)] for j in range(N2)])
print(f"F₂ = \n{F2}")
print(f"验证: F₂ = [[1,1],[1,-1]]? {np.allclose(F2, [[1,1],[1,-1]])}")

## 归一化后就是阿达玛门
H = F2 / np.sqrt(2)
print(f"\nF₂/√2 = 阿达玛门 H = \n{H}")

## ---------- 4×4 DFT 矩阵 ----------
print("\n=== 4×4 DFT 矩阵 (教程 1.8.3) ===")
N4 = 4
omega4 = np.exp(2j * np.pi / N4)
F4 = np.array([[omega4**(j*k) for k in range(N4)] for j in range(N4)])
print(f"F₄ =")
print(np.array2string(F4, precision=2, suppress_small=True))
print(f"\n期望值 (来自教程):")
print("[[1,  1,    1,    1  ]")
print(" [1,  i,   -1,   -i ]")
print(" [1, -1,   1,   -1 ]")
print(" [1, -i,  -1,    i ]]")

## 验证行向量正交性
print(f"\nF₄ 列向量正交? ", end="")
for i in range(N4):
    for j in range(i+1, N4):
        dot = F4[:, i].conj().T @ F4[:, j]
        if abs(dot) > 1e-10:
            print(f"第{i}列与第{j}列不正交 (内积={dot:.4f})")
            break
    else:
        continue
    break
else:
    print("是 (所有列两两正交)")

## 验证归一化为酉
print(f"(F₄/2)†(F₄/2) = I? {np.allclose((F4/2).conj().T @ (F4/2), np.eye(N4))}")

---

第二部分：物理基础验证

对应教程 2.1 – 2.6 节

---

2.2 量子公设：态初始化与酉演化

对应教程：2.2 五条公设

验证目标：态制备 (公设1)、酉演化 (公设2)、测量概率 (公设4)

## ============================================================
## 示例 11：量子态制备与酉演化 —— 验证教程 2.2 节
## ============================================================

print("=== 公设 1：态空间 ===")
## 初始态 |0⟩
psi0 = np.array([[1], [0]], dtype=complex)
print(f"初始态 |0⟩ = \n{psi0}")
print(f"⟨0|0⟩ = {(psi0.conj().T @ psi0)[0,0]:.0f}")  # 归一化

print("\n=== 公设 2：酉演化 ===")
## 阿达玛门
H = np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)
psi1 = H @ psi0  # H|0⟩ = |+⟩
print(f"H|0⟩ = |+⟩ = \n{psi1}")
print(f"⟨ψ₁|ψ₁⟩ = {(psi1.conj().T @ psi1)[0,0]:.4f}")  # 保持归一化

print("\n=== 公设 4：玻恩规则 ===")
## 在 Z 基下测量 |+⟩ 的概率
ket0 = np.array([[1], [0]], dtype=complex)
ket1 = np.array([[0], [1]], dtype=complex)
P0 = abs((ket0.conj().T @ psi1)[0,0])**2
P1 = abs((ket1.conj().T @ psi1)[0,0])**2
print(f"在 |+⟩ 态下测量 Z 基:")
print(f"  P(0) = |⟨0|+⟩|² = {P0:.4f}")   # 期望: 0.5
print(f"  P(1) = |⟨1|+⟩|² = {P1:.4f}")   # 期望: 0.5
print(f"  P(0) + P(1) = {P0+P1:.4f}")     # 期望: 1.0

print("\n=== 公设 3：可观测量 (期望值) ===")
Z = np.array([[1, 0], [0, -1]], dtype=complex)
exp_Z = (psi1.conj().T @ Z @ psi1)[0, 0]
print(f"⟨+|Z|+⟩ = {exp_Z:.4f} (期望为 0)")

---

2.3 无限深势阱波函数

对应教程：2.3 波函数与薛定谔方程、无限深势阱

验证目标：波函数的归一化、正交性、可视化

## ============================================================
## 示例 12：无限深势阱波函数 —— 验证教程 2.3 节
## ============================================================

import numpy as np

## 势阱参数
L = 1.0      # 势阱宽度
N = 1000     # 采样点数
x = np.linspace(0, L, N)
dx = L / N

## 波函数: ψₙ(x) = √(2/L) · sin(nπx/L)
def psi_n(n, x, L):
    return np.sqrt(2/L) * np.sin(n * np.pi * x / L)

print("=== 无限深方势阱波函数验证 ===")
for n in [1, 2, 3]:
    psi = psi_n(n, x, L)
    # 数值积分验证归一化 ∫|ψ|²dx = 1
    norm = np.sum(np.abs(psi)**2) * dx
    print(f"n={n}: ∫|ψₙ|² dx = {norm:.6f} (期望 1.0)")
    assert abs(norm - 1) < 0.01

## 验证正交性 ∫ψₘ*·ψₙ dx = 0 (m ≠ n)
print("\n=== 正交性验证 ===")
for m, n in [(1, 2), (1, 3), (2, 3)]:
    psi_m = psi_n(m, x, L)
    psi_n_val = psi_n(n, x, L)
    overlap = np.sum(psi_m.conj() * psi_n_val) * dx
    print(f"∫ψₘ*·ψₙ dx (m={m}, n={n}) = {overlap:.6f} (期望 0)")

## 绘制波函数 (需要 matplotlib)
try:
    import matplotlib.pyplot as plt
    plt.figure(figsize=(8, 5))
    for n in [1, 2, 3, 4]:
        psi = psi_n(n, x, L)
        plt.plot(x, psi, label=f"n={n}")
    plt.xlabel("x")
    plt.ylabel("ψₙ(x)")
    plt.title("无限深势阱波函数 ψₙ(x) = √(2/L)·sin(nπx/L)")
    plt.legend()
    plt.grid(alpha=0.3)
    plt.savefig("infinite_well_wavefunctions.png", dpi=150)
    print("\n📊 波函数图已保存为 infinite_well_wavefunctions.png")
except ImportError:
    print("\n(未安装 matplotlib，跳过绘图)")

---

2.4 自旋与泡利矩阵测量

对应教程：2.4 二能级系统与自旋

验证目标：自旋算子的期望值、本征值 ±1

## ============================================================
## 示例 13：自旋测量与期望值 —— 验证教程 2.4 节
## ============================================================

print("=== 自旋 1/2 算子的期望值 ===")

## 泡利矩阵
sigma_x = np.array([[0, 1], [1, 0]], dtype=complex)
sigma_y = np.array([[0, -1j], [1j, 0]], dtype=complex)
sigma_z = np.array([[1, 0], [0, -1]], dtype=complex)

## 自旋算子 Sᵢ = (ℏ/2)·σᵢ，这里取 ℏ=1
hbar = 1
Sx = hbar/2 * sigma_x
Sy = hbar/2 * sigma_y
Sz = hbar/2 * sigma_z

## 几种量子态
ket0 = np.array([[1], [0]], dtype=complex)
ket1 = np.array([[0], [1]], dtype=complex)
ket_plus = (ket0 + ket1) / np.sqrt(2)
ket_minus = (ket0 - ket1) / np.sqrt(2)
ket_plus_i = (ket0 + 1j * ket1) / np.sqrt(2)

states = {
    "|0⟩": ket0,
    "|1⟩": ket1,
    "|+⟩": ket_plus,
    "|-⟩": ket_minus,
    "|+i⟩": ket_plus_i,
}

ops = {"Sx": Sx, "Sy": Sy, "Sz": Sz}

print(f"{'态':8s} {'⟨Sx⟩':10s} {'⟨Sy⟩':10s} {'⟨Sz⟩':10s}")
print("-" * 40)
for name, state in states.items():
    exps = []
    for op_name, op in ops.items():
        exp = (state.conj().T @ op @ state)[0, 0].real
        exps.append(f"{exp:8.3f}")
    print(f"{name:8s} {exps[0]:10s} {exps[1]:10s} {exps[2]:10s}")

## 验证 Stern-Gerlach：自旋在任何方向只取 ±ℏ/2
print("\n=== Stern-Gerlach：特征值验证 ===")
for name, op in [("Sx", Sx), ("Sy", Sy), ("Sz", Sz)]:
    eigvals = np.linalg.eigvalsh(op)  # eigh 返回排序后的实数特征值
    print(f"{name} 特征值: {eigvals} (应为 ±{hbar/2})")

---

2.5 布洛赫球坐标

对应教程：2.5 布洛赫球

验证目标：参数化 (θ, φ) → (x,y,z) 坐标、布洛赫矢量

## ============================================================
## 示例 14：布洛赫球坐标 —— 验证教程 2.5 节
## ============================================================

print("=== 布洛赫球坐标计算 (教程 2.5) ===")

## 任意纯态参数化: |ψ⟩ = cos(θ/2)|0⟩ + e^(iφ)sin(θ/2)|1⟩
## 布洛赫矢量: (x,y,z) = (sinθ cosφ, sinθ sinφ, cosθ)

def bloch_coords(theta, phi):
    """从 (θ, φ) 计算布洛赫球坐标"""
    x = np.sin(theta) * np.cos(phi)
    y = np.sin(theta) * np.sin(phi)
    z = np.cos(theta)
    # 验证在单位球面上
    r = np.sqrt(x**2 + y**2 + z**2)
    return x, y, z, r

def state_vector(theta, phi):
    """从 (θ, φ) 构造量子态向量"""
    return np.array([[np.cos(theta/2)],
                     [np.exp(1j * phi) * np.sin(theta/2)]], dtype=complex)

## ---------- 验证教程表：标准状态在球面上的位置 ----------
test_cases = [
    ("|0⟩",    0,       0),
    ("|1⟩",    np.pi,   0),
    ("|+⟩",    np.pi/2, 0),
    ("|-⟩",    np.pi/2, np.pi),
    ("|+i⟩",   np.pi/2, np.pi/2),
    ("|-i⟩",   np.pi/2, 3*np.pi/2),
]

print(f"{'态':8s} {'θ':8s} {'φ':8s} {'x':8s} {'y':8s} {'z':8s} {'在球面?':10s}")
print("-" * 60)
for name, theta, phi in test_cases:
    x, y, z, r = bloch_coords(theta, phi)
    print(f"{name:8s} {theta:8.2f} {phi:8.2f} {x:+8.3f} {y:+8.3f} {z:+8.3f} {r==1}")

## ---------- 验证布洛赫矢量 = (⟨X⟩, ⟨Y⟩, ⟨Z⟩) ----------
print("\n=== 布洛赫矢量 = (⟨X⟩, ⟨Y⟩, ⟨Z⟩) 验证 (教程 2.5) ===")
X = np.array([[0, 1], [1, 0]], dtype=complex)
Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
Z = np.array([[1, 0], [0, -1]], dtype=complex)

theta, phi = np.pi/3, np.pi/4  # 任选一个态
psi = state_vector(theta, phi)

x_exp = (psi.conj().T @ X @ psi)[0, 0].real
y_exp = (psi.conj().T @ Y @ psi)[0, 0].real
z_exp = (psi.conj().T @ Z @ psi)[0, 0].real
x_geo, y_geo, z_geo, _ = bloch_coords(theta, phi)

print(f"态: θ={theta:.4f}, φ={phi:.4f}")
print(f"布洛赫矢量 (几何):  ({x_geo:.4f}, {y_geo:.4f}, {z_geo:.4f})")
print(f"布洛赫矢量 (期望):  ({x_exp:.4f}, {y_exp:.4f}, {z_exp:.4f})")
print(f"一致? {np.allclose([x_geo, y_geo, z_geo], [x_exp, y_exp, z_exp])}")

---

2.6 密度矩阵与纯度

对应教程：2.6 测量理论与密度矩阵

验证目标：纯态 vs 混态密度矩阵、纯度、约化密度矩阵

## ============================================================
## 示例 15：密度矩阵与纯度 —— 验证教程 2.6 节
## ============================================================

print("=== 纯态密度矩阵 ===")
## 纯态 |+⟩
ket_plus = np.array([[1], [1]], dtype=complex) / np.sqrt(2)
rho_pure = ket_plus @ ket_plus.conj().T
print(f"ρ_pure = |+⟩⟨+| = \n{rho_pure}")
print(f"Tr(ρ) = {np.trace(rho_pure):.4f}")      # 期望: 1
print(f"Tr(ρ²) = {np.trace(rho_pure @ rho_pure):.4f}")  # 纯态: 1

print("\n=== 混态密度矩阵 ===")
## 50% |0⟩ + 50% |1⟩ (经典混合)
ket0 = np.array([[1], [0]], dtype=complex)
ket1 = np.array([[0], [1]], dtype=complex)
rho_mixed = 0.5 * (ket0 @ ket0.conj().T) + 0.5 * (ket1 @ ket1.conj().T)
print(f"ρ_mixed = 0.5|0⟩⟨0| + 0.5|1⟩⟨1| = \n{rho_mixed}")
print(f"Tr(ρ) = {np.trace(rho_mixed):.4f}")      # 期望: 1
print(f"Tr(ρ²) = {np.trace(rho_mixed @ rho_mixed):.4f}")  # 混态: < 1

## ---------- 关键检验：⟨X⟩ ----------
print("\n=== 关键检验：⟨X⟩ (教程 2.6) ===")
X = np.array([[0, 1], [1, 0]], dtype=complex)
exp_X_pure = np.trace(rho_pure @ X)
exp_X_mixed = np.trace(rho_mixed @ X)
print(f"纯态 ⟨X⟩ = Tr(ρ_pure·X) = {exp_X_pure:.4f}")   # 期望: 1
print(f"混态 ⟨X⟩ = Tr(ρ_mixed·X) = {exp_X_mixed:.4f}")  # 期望: 0

## 两个态在 Z 测量下统计相同，但在 X 测量下完全不同！
Z = np.array([[1, 0], [0, -1]], dtype=complex)
print(f"\n两种态在 Z 基测量:")
print(f"  纯态 P(0) = {rho_pure[0,0]:.2f}, P(1) = {rho_pure[1,1]:.2f}")
print(f"  混态 P(0) = {rho_mixed[0,0]:.2f}, P(1) = {rho_mixed[1,1]:.2f}")

## ---------- 约化密度矩阵：贝尔态 ----------
print("\n=== 贝尔态的约化密度矩阵 (教程 2.6) ===")
ket00 = np.kron(ket0, ket0)
ket11 = np.kron(ket1, ket1)
bell = (ket00 + ket11) / np.sqrt(2)   # |Φ⁺⟩
rho_bell = bell @ bell.conj().T       # 整体密度矩阵 (纯态)

print(f"整体 Tr(ρ²) = {np.trace(rho_bell @ rho_bell):.4f} (纯态 = 1)")

## 对第二个比特求偏迹
## ρ_A = Tr_B(ρ_AB) = Σ_j ⟨j_B|ρ_AB|j_B⟩
rho_A = np.zeros((2, 2), dtype=complex)
basis_B = [ket0, ket1]
for j, b in enumerate(basis_B):
    # ⟨j|ρ_AB|j⟩ (对 B 的部分)
    # rho_bell 是 4×4 矩阵，我们需要在 B 子空间上收缩
    proj = np.kron(np.eye(2), b @ b.conj().T)
    rho_A += proj @ rho_bell @ proj.conj().T

## 更简洁的方式：直接数值迹
rho_A_simple = np.zeros((2, 2), dtype=complex)
for j, b in enumerate(basis_B):
    # 构造 ⟨j| 作用于 B 部分
    inner = np.kron(np.eye(2), b.conj().T) @ rho_bell @ np.kron(np.eye(2), b)
    rho_A_simple += inner

print(f"\n约化密度矩阵 ρ_A = Tr_B(|Φ⁺⟩⟨Φ⁺|) = \n{rho_A_simple}")
print(f"ρ_A 的 Tr(ρ_A²) = {np.trace(rho_A_simple @ rho_A_simple):.4f} (混态 < 1)")
print("✅ 纠缠纯态的子系统是混态！")

---

第三部分：量子计算实例

对应教程 3.1 – 3.6 节

以下示例需要 Qiskit。如未安装，请执行 pip install qiskit qiskit-aer

---

3.1–3.2 单量子比特门模拟 (Qiskit)

对应教程：3.1 量子比特、3.2 单量子比特门

验证目标：Qiskit 模拟 X, Z, H, S, T 门对 |0⟩ 的作用

## ============================================================
## 示例 16：单量子比特门模拟 —— 验证教程 3.2 节
## ============================================================

if HAS_QISKIT:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator
    import numpy as np

    print("=== 单量子比特门模拟 ===")

    # 辅助函数：运行电路并获取态向量
    def run_and_get_statevec(qc):
        """编译并模拟电路，返回状态向量"""
        simulator = AerSimulator()
        qc.save_statevector()
        compiled = transpile(qc, simulator)
        result = simulator.run(compiled).result()
        return result.get_statevector()

    # 测试各种门对 |0⟩ 的作用
    for gate_name, gate_cmd in [("I (恒等)", 'id'), ("X (非门)", 'x'),
                                 ("Z (相位翻转)", 'z'), ("H (阿达玛)", 'h'),
                                 ("S (相位π/2)", 's'), ("T (π/8门)", 't')]:
        qc = QuantumCircuit(1)
        eval(f"qc.{gate_cmd}(0)")  # 在 qubit 0 上施加门
        sv = run_and_get_statevec(qc)
        print(f"  {gate_name:14s}: {sv}")

    # 验证自逆性: H² = I
    print("\n=== 自逆性验证 ===")
    qc = QuantumCircuit(1)
    qc.h(0)
    qc.h(0)  # 两次 H 门
    sv = run_and_get_statevec(qc)
    print(f"H·H|0⟩ = {sv} (应为 |0⟩ = [1+0j, 0+0j])")
    assert np.allclose(sv, [1, 0]), "H² 验证失败！"
    print("✅ H² = I 验证通过！")

    # 验证 HXH = Z
    print("\n=== HXH = Z 验证 ===")
    qc = QuantumCircuit(1)
    qc.h(0)
    qc.x(0)
    qc.h(0)
    sv = run_and_get_statevec(qc)
    # HXH|0⟩ = Z|0⟩ = |0⟩
    print(f"HXH|0⟩ = {sv}")

    qc2 = QuantumCircuit(1)
    qc2.z(0)
    sv2 = run_and_get_statevec(qc2)
    print(f"Z|0⟩   = {sv2}")
    print(f"一致? {np.allclose(sv, sv2)}")
else:
    print("⚠️  需要 Qiskit。使用纯 NumPy 近似:")
    H = np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)
    X = np.array([[0, 1], [1, 0]], dtype=complex)
    Z = np.array([[1, 0], [0, -1]], dtype=complex)
    ket0 = np.array([[1], [0]], dtype=complex)
    print(f"H·H|0⟩ = {H @ H @ ket0}")
    print(f"HXH|0⟩ = {H @ X @ H @ ket0}")
    print(f"Z|0⟩   = {Z @ ket0}")

---

3.3 贝尔态制备与纠缠验证 (Qiskit)

对应教程：3.3 多量子比特门与纠缠

验证目标：贝尔态制备电路、CNOT 门、纠缠验证

## ============================================================
## 示例 17：贝尔态制备与纠缠验证 —— 验证教程 3.3 节
## ============================================================

if HAS_QISKIT:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator

    print("=== 贝尔态 |Φ⁺⟩ 制备 (教程 3.3) ===")
    qc = QuantumCircuit(2)
    qc.h(0)       # H 门
    qc.cx(0, 1)   # CNOT 门
    qc.save_statevector()

    simulator = AerSimulator()
    compiled = transpile(qc, simulator)
    result = simulator.run(compiled).result()
    sv = result.get_statevector()

    print(f"制备的态: {sv}")
    print(f"|Φ⁺⟩ = (|00⟩ + |11⟩)/√2 的振幅: {sv[0]:.4f}, {sv[-1]:.4f}")
    print(f"其他分量: {sv[1]:.4f}, {sv[2]:.4f} (应为 0)")

    # 验证纠缠：子系统在 Z 基下完全随机
    print("\n=== 纠缠验证：测量统计 ===")
    qc2 = QuantumCircuit(2, 2)
    qc2.h(0)
    qc2.cx(0, 1)
    qc2.measure(0, 0)
    qc2.measure(1, 1)

    compiled2 = transpile(qc2, simulator)
    result2 = simulator.run(compiled2, shots=4096).result()
    counts = result2.get_counts()
    print(f"测量结果统计 (4096 次):")
    for outcome, count in sorted(counts.items()):
        print(f"  |{outcome}⟩: {count:5d} 次 ({100*count/4096:.1f}%)")

    # 验证：只有 |00⟩ 和 |11⟩
    assert '01' not in counts or counts['01'] < 10, "纠缠制备失败！"
    assert '10' not in counts or counts['10'] < 10, "纠缠制备失败！"
    print("✅ 纠缠验证通过：仅观察到 |00⟩ 和 |11⟩")

    # ---------- 展示 4 个贝尔态 ----------
    print("\n=== 四个贝尔态 (教程 3.3) ===")
    bell_circuits = {
        "|Φ⁺⟩": lambda qc: (qc.h(0), qc.cx(0, 1)),
        "|Φ⁻⟩": lambda qc: (qc.h(0), qc.z(0), qc.cx(0, 1)),
        "|Ψ⁺⟩": lambda qc: (qc.h(0), qc.x(1), qc.cx(0, 1)),
        "|Ψ⁻⟩": lambda qc: (qc.x(0), qc.h(0), qc.cx(0, 1)),
    }
    for name, circuit_fn in bell_circuits.items():
        qc = QuantumCircuit(2)
        circuit_fn(qc)
        qc.save_statevector()
        compiled = transpile(qc, simulator)
        sv = simulator.run(compiled).result().get_statevector()
        print(f"  {name}: {sv}")

else:
    print("⚠️  需要 Qiskit 来运行此示例。")

---

3.4 GHZ 态制备电路 (Qiskit)

对应教程：3.4 量子电路、GHZ 态制备

验证目标：多比特纠缠、电路深度概念

## ============================================================
## 示例 18：GHZ 态制备电路 —— 验证教程 3.4 节
## ============================================================

if HAS_QISKIT:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator

    print("=== GHZ 态制备 (教程 3.4) ===")
    n = 4  # 4 个量子比特
    qc = QuantumCircuit(n)
    qc.h(0)
    for i in range(n-1):
        qc.cx(i, i+1)  # 级联 CNOT
    qc.save_statevector()

    simulator = AerSimulator()
    compiled = transpile(qc, simulator)
    result = simulator.run(compiled).result()
    sv = result.get_statevector()

    print(f"GHZ 态振幅 (仅 |0000⟩ 和 |1111⟩ 非零):")
    for i, amp in enumerate(sv):
        if abs(amp) > 1e-10:
            state_label = format(i, f'0{n}b')
            print(f"  |{state_label}⟩: {amp:.4f}")

    # 测量验证
    print(f"\n=== GHZ 测量 (4096 次) ===")
    qc2 = QuantumCircuit(n, n)
    qc2.h(0)
    for i in range(n-1):
        qc2.cx(i, i+1)
    qc2.measure_all()

    compiled2 = transpile(qc2, simulator)
    result2 = simulator.run(compiled2, shots=4096).result()
    counts = result2.get_counts()
    for outcome, count in sorted(counts.items()):
        if count > 10:
            print(f"  |{outcome}⟩: {count:5d} 次 ({100*count/4096:.1f}%)")

else:
    print("⚠️  需要 Qiskit 来运行此示例。")

---

3.5 量子测量与期望值

对应教程：3.5 量子测量与读取

验证目标：在不同基下测量、期望值估计

## ============================================================
## 示例 19：不同基下的测量 —— 验证教程 3.5 节
## ============================================================

if HAS_QISKIT:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator

    print("=== 在 Z 基和 X 基下测量 |+⟩ ===")
    simulator = AerSimulator()

    # Z 基测量 (直接测量)
    qc_z = QuantumCircuit(1, 1)
    qc_z.h(0)
    qc_z.measure(0, 0)
    compiled_z = transpile(qc_z, simulator)
    result_z = simulator.run(compiled_z, shots=4096).result()
    counts_z = result_z.get_counts()
    print(f"Z 基测量: {counts_z}")

    # X 基测量 (先 H 再测 Z)
    qc_x = QuantumCircuit(1, 1)
    qc_x.h(0)
    qc_x.h(0)  # 第二次 H 将 X 基转到 Z 基
    qc_x.measure(0, 0)
    compiled_x = transpile(qc_x, simulator)
    result_x = simulator.run(compiled_x, shots=4096).result()
    counts_x = result_x.get_counts()
    print(f"X 基测量: {counts_x}")

    # 注意：|+⟩ 在 X 基测量下是确定性的 (总是 +1)

    print("\n=== 期望值估计 (教程 3.5) ===")
    # 制备 |+⟩ 并测量 Z, 估计 ⟨Z⟩
    counts = result_z.get_counts()
    N = 4096
    n0 = counts.get('0', 0)
    n1 = counts.get('1', 0)
    exp_Z_est = (n0 - n1) / N
    exp_Z_exact = 0.0  # ⟨+|Z|+⟩ = 0
    print(f"⟨Z⟩ 估计值: {exp_Z_est:.4f} (精确值: {exp_Z_exact})")
    print(f"估计误差: {abs(exp_Z_est - exp_Z_exact):.4f} (∼ 1/√N ≈ {1/np.sqrt(N):.4f})")

else:
    print("⚠️  需要 Qiskit 来运行此示例。")

---

3.6 量子隐形传态模拟 (Qiskit)

对应教程：3.6 量子算法导引 —— 量子隐形传态

验证目标：完整隐形传态电路、纠缠+经典通信传输量子态

## ============================================================
## 示例 20：量子隐形传态 (Quantum Teleportation) —— 验证教程 3.6 节
## ============================================================

if HAS_QISKIT:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator

    print("=== 量子隐形传态模拟 ===")

    # ---- 步骤 1：Alice 准备要传输的未知态 ----
    # 这里我们使用一个已知态以便验证结果：|ψ⟩ = cos(θ/2)|0⟩ + e^(iφ)sin(θ/2)|1⟩
    # 选择 θ = π/3, φ = π/4 (任意态)
    theta, phi = np.pi/3, np.pi/4

    qc = QuantumCircuit(3, 3)  # q0=Alice的态, q1=Alice的贝尔对, q2=Bob的贝尔对

    # Alice 制备要传的态 |ψ⟩
    qc.ry(theta, 0)      # 绕 y 轴旋转 θ
    qc.rz(phi, 0)        # 绕 z 轴旋转 φ

    # ---- 步骤 2：共享纠缠对 |Φ⁺⟩ ----
    qc.h(1)
    qc.cx(1, 2)          # 在 q1, q2 之间创建贝尔态

    # ---- 步骤 3：Alice 的操作 ----
    qc.barrier()
    qc.cx(0, 1)          # CNOT: q0(控制), q1(目标)
    qc.h(0)              # 阿达玛门

    # ---- 步骤 4：Alice 测量并发送经典比特 ----
    qc.measure(0, 0)
    qc.measure(1, 1)

    # ---- 步骤 5：Bob 根据经典结果修正 ----
    qc.barrier()
    qc.cx(1, 2)          # 如果 q1=1 → X 门
    qc.cz(0, 2)          # 如果 q0=1 → Z 门

    # ---- 验证：Bob 的态是否等于原始态 ----
    # 通过对比：对 Bob 的态做逆向操作，如果传态成功应该得到 |0⟩
    qc.ry(-theta, 2)
    qc.rz(-phi, 2)
    qc.measure(2, 2)     # 如果结果为 0，传态成功

    simulator = AerSimulator()
    compiled = transpile(qc, simulator)
    result = simulator.run(compiled, shots=4096).result()
    counts = result.get_counts()

    # 统计成功/失败
    success = sum(count for outcome, count in counts.items() if outcome[-1] == '0')
    fail = 4096 - success
    print(f"隐形传态 {'成功' if success > 4000 else '失败'}:")
    print(f"  ✅ q2 回到 |0⟩: {success} 次 ({100*success/4096:.1f}%)")
    print(f"  ❌ 未回到 |0⟩: {fail} 次 ({100*fail/4096:.1f}%)")
    print(f"  容错阈值: 95% (噪声和非理想门会降低保真度)")
    if success / 4096 > 0.95:
        print("\n✅ 量子隐形传态仿真验证通过！")
    else:
        print("\n⚠️  传态保真度不足，请检查电路。")

else:
    print("⚠️  需要 Qiskit 来运行此示例。")

---

3.6 Grover 搜索算法模拟 (Qiskit)

对应教程：3.6 Grover 搜索算法

验证目标：振幅放大、二次加速概念

## ============================================================
## 示例 21：Grover 搜索算法 —— 验证教程 3.6 节
## ============================================================

if HAS_QISKIT:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator

    print("=== Grover 搜索算法 (2 量子比特, 搜索 |11⟩) ===")

    # ---- 设置 ----
    n = 2            # 2 个量子比特
    target = "11"    # 目标态
    oracle = QuantumCircuit(n)

    # ---- Oracle：标记 |11⟩ ----
    # 对 |11⟩ 翻转相位：应用 CZ 门
    oracle.cz(0, 1)

    # ---- 扩散算子 (振幅放大) ----
    def diffusion(n):
        qc = QuantumCircuit(n)
        qc.h(range(n))
        qc.x(range(n))
        qc.h(n-1)
        qc.mcx(list(range(n-1)), n-1)  # 多控 Z
        qc.h(n-1)
        qc.x(range(n))
        qc.h(range(n))
        return qc

    # ---- 完整 Grover 电路 ----
    qc = QuantumCircuit(n, n)

    # 1. 制备均匀叠加
    qc.h(range(n))

    # 2. 一次 Grover 迭代 (对于 2 比特，一次就够了)
    qc.append(oracle, range(n))
    qc.append(diffusion(n), range(n))

    # 3. 测量
    qc.measure(range(n), range(n))

    # ---- 模拟 ----
    simulator = AerSimulator()
    compiled = transpile(qc, simulator)
    result = simulator.run(compiled, shots=4096).result()
    counts = result.get_counts()

    print(f"测量结果:")
    for outcome, count in sorted(counts.items()):
        print(f"  |{outcome}⟩: {count:5d} 次 ({100*count/4096:.1f}%)")

    target_count = counts.get(target, 0)
    print(f"\n目标态 |{target}⟩ 概率: {100*target_count/4096:.1f}%")
    print(f"经典搜索随机概率: 25% (2 比特中 1 个目标)")
    print(f"Grover 搜索概率: {100*target_count/4096:.1f}%")
    if target_count / 4096 > 0.80:
        print("✅ Grover 振幅放大验证通过！")
    else:
        print("⚠️  概率较低，可增加迭代次数。")

else:
    print("⚠️  需要 Qiskit 来运行此示例。")

---

3.6 量子傅里叶变换 (Qiskit)

对应教程：1.8 傅里叶分析 + 3.6 QFT

验证目标：QFT 与 DFT 矩阵的关系

## ============================================================
## 示例 22：量子傅里叶变换 —— 验证 1.8 节与 3.6 节
## ============================================================

if HAS_QISKIT:
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator
    import numpy as np

    print("=== 量子傅里叶变换 QFT (3 量子比特) ===")

    def qft_rotations(qc, n):
        """QFT 子电路：受控旋转"""
        for qubit in range(n):
            qc.h(qubit)
            for other in range(qubit+1, n):
                angle = np.pi / (2**(other - qubit))
                qc.cp(angle, other, qubit)
        # 交换比特以纠正顺序
        for i in range(n // 2):
            qc.swap(i, n-1-i)
        return qc

    # ---- 计算 QFT 对 |001⟩ 的作用 ----
    n = 3
    qc = QuantumCircuit(n)
    qc.x(0)  # 制备 |001⟩ (最低位)
    qft_rotations(qc, n)
    qc.save_statevector()

    simulator = AerSimulator()
    compiled = transpile(qc, simulator)
    result = simulator.run(compiled).result()
    sv = result.get_statevector()

    print(f"QFT|001⟩ 的态向量:")
    for i, amp in enumerate(sv):
        if abs(amp) > 1e-10:
            state_label = format(i, f'0{n}b')
            print(f"  |{state_label}⟩: {amp:.4f}")

    # ---- NumPy 验证：直接 DFT ----
    N = 2**n
    omega = np.exp(2j * np.pi / N)
    # QFT 矩阵: (F_N)ⱼₖ = ω^(j·k) / √N
    QFT_matrix = np.array([[omega**(j*k) for k in range(N)]
                            for j in range(N)], dtype=complex) / np.sqrt(N)

    input_vec = np.zeros(N, dtype=complex)
    input_vec[1] = 1  # |001⟩ (索引 1)
    expected = QFT_matrix @ input_vec

    print(f"\nNumPy DFT 验证:")
    for i, amp in enumerate(expected):
        if abs(amp) > 1e-10:
            state_label = format(i, f'0{n}b')
            print(f"  |{state_label}⟩: {amp:.4f}")

    # 比较 Qiskit 与 NumPy 结果
    qiskit_result = np.array([sv[i] for i in range(N)])
    match = np.allclose(qiskit_result, expected, atol=1e-10)
    print(f"\nQiskit QFT 与 NumPy DFT 一致? {match}")
    if match:
        print("✅ QFT 验证通过！")
else:
    print("⚠️  需要 Qiskit 来运行此示例。")

---

附录：综合练习

以下综合练习将多个概念结合，验证教程中的核心衍生结论。

综合 1：不可克隆定理的演示

对应教程：3.3 不可克隆定理

验证思路：尝试构造”克隆”电路并观察它无法适用于任意态

## ============================================================
## 综合练习 1：不可克隆定理 —— 验证教程 3.3 节
## ============================================================

print("=== 不可克隆定理演示 ===")
print("假设有一个"量子克隆机"，对 |0⟩ 和 |1⟩ 都能工作...")

## 尝试构造一个酉算子 U 使得:
## U|00⟩ = |00⟩ (克隆 |0⟩)
## U|10⟩ = |11⟩ (克隆 |1⟩)
## 那么 U 对叠加态 (|0⟩+|1⟩)/√2 会怎样?

ket0 = np.array([[1], [0]], dtype=complex)
ket1 = np.array([[0], [1]], dtype=complex)
ket00 = np.kron(ket0, ket0)
ket10 = np.kron(ket1, ket0)

## 定义这个"克隆机"的矩阵形式
## 要求: U|00⟩ = |00⟩, U|10⟩ = |11⟩
## 在基 {|00⟩,|01⟩,|10⟩,|11⟩} 下
U = np.zeros((4, 4), dtype=complex)
U[:, 0] = ket00.flatten()     # U|00⟩ = |00⟩
U[:, 2] = np.kron(ket1, ket1).flatten()  # U|10⟩ = |11⟩
## 补充 |01⟩ 和 |11⟩ 的映射以保持酉性
U[:, 1] = np.kron(ket0, ket1).flatten()  # U|01⟩ = |01⟩
U[:, 3] = np.kron(ket1, ket0).flatten()  # U|11⟩ = |10⟩

## 验证酉性
is_unitary = np.allclose(U.conj().T @ U, np.eye(4))
print(f"U 是酉矩阵? {is_unitary}")

## 查看对叠加态的作用
psi = (ket0 + ket1) / np.sqrt(2)  # |+⟩
input_state = np.kron(psi, ket0)   # |+⟩⊗|0⟩
output_state = U @ input_state

print(f"\n输入: |+⟩⊗|0⟩ = \n{input_state}")
print(f"输出: U(|+⟩⊗|0⟩) = \n{output_state}")

## 真正的克隆应该得到: |+⟩⊗|+⟩
true_clone = np.kron(psi, psi)
print(f"真正的克隆: |+⟩⊗|+⟩ = \n{true_clone}")
print(f"\n两者相等? {np.allclose(output_state, true_clone)}")
print("❌ 不等！通用克隆机不存在 —— 不可克隆定理成立！")

综合 2：量子比特与经典比特的测量对比

对应教程：3.1 经典 vs 量子比特

验证目标：量子叠加态在布洛赫球赤道上，经典混合在 Z 轴上

## ============================================================
## 综合练习 2：量子比特 vs 经典比特 —— 验证 3.1 节
## ============================================================

print("=== 量子比特 vs 经典比特 ===")

## 制备三个状态，它们的 Z 基测量统计完全相同
## 但 X 基测量统计完全不同

## 状态 1: |+⟩ (量子叠加态)
ket_plus = np.array([[1], [1]], dtype=complex) / np.sqrt(2)

## 状态 2: 经典混态 50%|0⟩+50%|1⟩
rho_classical = np.array([[0.5, 0], [0, 0.5]], dtype=complex)

## 状态 3: 另一个叠加态 |+i⟩
ket_plus_i = np.array([[1], [1j]], dtype=complex) / np.sqrt(2)
rho_plus_i = ket_plus_i @ ket_plus_i.conj().T

X = np.array([[0, 1], [1, 0]], dtype=complex)
Z = np.array([[1, 0], [0, -1]], dtype=complex)

print(f"{'状态':20s} {'P(Z=0)':10s} {'P(Z=1)':10s} {'⟨X⟩':10s} {'⟨Z⟩':10s}")
print("-" * 60)

## |+⟩
p0_plus = abs(ket_plus[0])**2
p1_plus = abs(ket_plus[1])**2
expX_plus = (ket_plus.conj().T @ X @ ket_plus)[0,0].real
expZ_plus = (ket_plus.conj().T @ Z @ ket_plus)[0,0].real
print(f"{'|+⟩ (量子叠加)':20s} {p0_plus:10.2f} {p1_plus:10.2f} {expX_plus:10.2f} {expZ_plus:10.2f}")

## 经典混态
p0_class = rho_classical[0,0].real
p1_class = rho_classical[1,1].real
expX_class = np.trace(rho_classical @ X).real
expZ_class = np.trace(rho_classical @ Z).real
print(f"{'经典混态 (50/50)':20s} {p0_class:10.2f} {p1_class:10.2f} {expX_class:10.2f} {expZ_class:10.2f}")

## |+i⟩
p0_plus_i = abs(ket_plus_i[0])**2
p1_plus_i = abs(ket_plus_i[1])**2
expX_plus_i = np.trace(rho_plus_i @ X).real
expZ_plus_i = np.trace(rho_plus_i @ Z).real
print(f"{'|+i⟩ (量子叠加)':20s} {p0_plus_i:10.2f} {p1_plus_i:10.2f} {expX_plus_i:10.2f} {expZ_plus_i:10.2f}")

print("\n✅ 结论: Z 测量无法区分三种态，但 X 测量可以！")
print("   这就是量子比特与经典比特的本质区别：相位信息。")

---

总结对照表

示例编号	内容	对应教程	技术
1	复数四则运算与除法	1.1.2	Python complex
2	欧拉公式 e^(iθ) = cosθ + i sinθ	1.1.4	numpy.exp
3	复数的旋转与缩放	1.1.5	numpy.angle
4	bra-ket 符号与内积	1.2.3	numpy 矩阵运算
5	泡利矩阵性质验证	1.3.4–1.3.5	numpy.linalg
6	投影算子与概率	1.4	外积 ket @ bra
7	特征值/谱分解	1.5	numpy.linalg.eigh
8	张量积与 CNOT 构造	1.6	numpy.kron
9	量子干涉	1.7.5	复数模平方
10	DFT 矩阵	1.8.3	单位根 exp(2πi/N)
11	量子公设验证	2.2	矩阵模拟
12	无限深势阱波函数	2.3	数值积分
13	自旋期望值	2.4	泡利矩阵
14	布洛赫球坐标	2.5	参数化验证
15	密度矩阵与纯度	2.6	Tr(ρ), Tr(ρ²)
16	单量子比特门	3.2	Qiskit
17	贝尔态制备	3.3	Qiskit
18	GHZ 态制备	3.4	Qiskit
19	多基测量与期望值	3.5	Qiskit
20	量子隐形传态	3.6	Qiskit
21	Grover 搜索	3.6	Qiskit
22	量子傅里叶变换	1.8+3.6	Qiskit+NumPy
C1	不可克隆定理	3.3	NumPy 酉矩阵
C2	经典 vs 量子比特	3.1	密度矩阵对比

---

文件信息

• 配套教程：《量子计算前置教程——从第一性原理出发》
• 代码示例总数：24 个（22 个主示例 + 2 个综合练习）
• 更新日期：2026-05-28