Python与量子计算中级教程
课程概述
本教程是《Python与量子计算初级教程》的进阶版本，深入探讨多量子比特系统、量子算法和量子信息协议。通过Python代码实现和交互式实验，帮助读者掌握中级量子计算的核心概念。
前置要求：熟悉线性代数基础、Python编程（NumPy库）、初级量子计算概念（量子比特、叠加态、基本量子门）。
第一章：多量子比特系统
单个量子比特的状态空间是二维复向量空间，而n个量子比特的状态空间是2^n维的。理解多量子比特系统的关键在于张量积（Tensor Product）运算。
1.1 张量积的Python实现
import numpy as np
# 定义单量子比特基态
ket_0 = np.array([1, 0])
ket_1 = np.array([0, 1])
# 双量子比特系统的基态：使用np.kron()计算张量积
ket_00 = np.kron(ket_0, ket_0) # |0⟩⊗|0⟩ = |00⟩
ket_01 = np.kron(ket_0, ket_1) # |0⟩⊗|1⟩ = |01⟩
ket_10 = np.kron(ket_1, ket_0) # |1⟩⊗|0⟩ = |10⟩
ket_11 = np.kron(ket_1, ket_1) # |1⟩⊗|1⟩ = |11⟩
print("|00⟩ =", ket_00)
print("|01⟩ =", ket_01)
print("|10⟩ =", ket_10)
print("|11⟩ =", ket_11)
# 定义单量子比特基态
ket_0 = np.array([1, 0])
ket_1 = np.array([0, 1])
# 双量子比特系统的基态：使用np.kron()计算张量积
ket_00 = np.kron(ket_0, ket_0) # |0⟩⊗|0⟩ = |00⟩
ket_01 = np.kron(ket_0, ket_1) # |0⟩⊗|1⟩ = |01⟩
ket_10 = np.kron(ket_1, ket_0) # |1⟩⊗|0⟩ = |10⟩
ket_11 = np.kron(ket_1, ket_1) # |1⟩⊗|1⟩ = |11⟩
print("|00⟩ =", ket_00)
print("|01⟩ =", ket_01)
print("|10⟩ =", ket_10)
print("|11⟩ =", ket_11)
输出结果
|00⟩ = [1 0 0 0]|01⟩ = [0 1 0 0]
|10⟩ = [0 0 1 0]
|11⟩ = [0 0 0 1]
1.2 多量子比特门操作
# CNOT门的矩阵表示（控制位为第一个量子比特）
CNOT = np.array([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 1],
[0, 0, 1, 0]
])
# Hadamard门作用在第一个量子比特上：H⊗I
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
I = np.eye(2)
H_I = np.kron(H, I)
# 从|00⟩创建Bell态：(H⊗I)|00⟩ → CNOT → (|00⟩+|11⟩)/√2
state = np.kron(ket_0, ket_0)
state = H_I @ state
bell_state = CNOT @ state
print("Bell态 |Φ⁺⟩ =")
print(np.round(bell_state, 4))
print("\n概率分布：")
probs = np.abs(bell_state)**2
for i, p in enumerate(probs):
print(f"|{i:02b}⟩: {p:.4f}")
CNOT = np.array([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 1],
[0, 0, 1, 0]
])
# Hadamard门作用在第一个量子比特上：H⊗I
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
I = np.eye(2)
H_I = np.kron(H, I)
# 从|00⟩创建Bell态：(H⊗I)|00⟩ → CNOT → (|00⟩+|11⟩)/√2
state = np.kron(ket_0, ket_0)
state = H_I @ state
bell_state = CNOT @ state
print("Bell态 |Φ⁺⟩ =")
print(np.round(bell_state, 4))
print("\n概率分布：")
probs = np.abs(bell_state)**2
for i, p in enumerate(probs):
print(f"|{i:02b}⟩: {p:.4f}")
输出结果
Bell态 |Φ⁺⟩ =[0.7071 0. 0. 0.7071]
概率分布：
|00⟩: 0.5000
|01⟩: 0.0000
|10⟩: 0.0000
|11⟩: 0.5000
多量子比特状态可视化
点击按钮观察不同多量子比特态的概率分布柱状图
本章要点
- n个量子比特的状态空间维度为2^n，呈指数增长
- 张量积是构建多量子比特系统的数学工具，NumPy中使用np.kron()
- Bell态是最简单的纠缠态，形式为(|00⟩±|11⟩)/√2或(|01⟩±|10⟩)/√2
- 多量子比特门通过张量积构造，如CNOT、Toffoli等
第二章：Bell不等式与CHSH游戏
Bell不等式揭示了量子力学与经典局域实在论的根本差异。CHSH（Clauser-Horne-Shimony-Holt）不等式是实验验证量子非局域性的标准方法。
2.1 CHSH游戏的经典极限
import numpy as np
import random
def classical_chsh_strategy(n_rounds=10000):
# 经典策略：Alice和Bob预先约定总是输出0
wins = 0
for _ in range(n_rounds):
x = random.randint(0, 1) # Alice的输入
y = random.randint(0, 1) # Bob的输入
a = 0 # Alice的输出（固定策略）
b = 0 # Bob的输出（固定策略）
# 获胜条件：a XOR b = x AND y
if (a ^ b) == (x & y):
wins += 1
return wins / n_rounds
win_rate = classical_chsh_strategy()
print(f"经典策略获胜概率: {win_rate:.4f}")
print(f"经典上限: 0.7500")
import random
def classical_chsh_strategy(n_rounds=10000):
# 经典策略：Alice和Bob预先约定总是输出0
wins = 0
for _ in range(n_rounds):
x = random.randint(0, 1) # Alice的输入
y = random.randint(0, 1) # Bob的输入
a = 0 # Alice的输出（固定策略）
b = 0 # Bob的输出（固定策略）
# 获胜条件：a XOR b = x AND y
if (a ^ b) == (x & y):
wins += 1
return wins / n_rounds
win_rate = classical_chsh_strategy()
print(f"经典策略获胜概率: {win_rate:.4f}")
print(f"经典上限: 0.7500")
输出结果
经典策略获胜概率: 0.7498经典上限: 0.7500
2.2 量子CHSH策略
def quantum_chsh_strategy(n_rounds=10000):
# 共享Bell态 |Φ⁺⟩ = (|00⟩ + |11⟩)/√2
bell = np.array([1, 0, 0, 1]) / np.sqrt(2)
# 测量角度设置（最优策略）
# Alice: a0=0, a1=π/4
# Bob: b0=π/8, b1=-π/8
angles_A = [0, np.pi/4]
angles_B = [np.pi/8, -np.pi/8]
wins = 0
for _ in range(n_rounds):
x = random.randint(0, 1)
y = random.randint(0, 1)
# 量子测量模拟：根据角度计算关联期望值
theta_A = angles_A[x]
theta_B = angles_B[y]
# 对于Bell态，关联函数 E(a,b) = cos(2*(a-b))
correlation = np.cos(2 * (theta_A - theta_B))
# 根据关联概率决定输出
p_same = (1 + correlation) / 2
a = random.randint(0, 1)
b = a if random.random() < p_same else 1 - a
if (a ^ b) == (x & y):
wins += 1
return wins / n_rounds
q_win_rate = quantum_chsh_strategy()
print(f"量子策略获胜概率: {q_win_rate:.4f}")
print(f"理论最大值: cos²(π/8) ≈ {(np.cos(np.pi/8)**2):.4f}")
# 共享Bell态 |Φ⁺⟩ = (|00⟩ + |11⟩)/√2
bell = np.array([1, 0, 0, 1]) / np.sqrt(2)
# 测量角度设置（最优策略）
# Alice: a0=0, a1=π/4
# Bob: b0=π/8, b1=-π/8
angles_A = [0, np.pi/4]
angles_B = [np.pi/8, -np.pi/8]
wins = 0
for _ in range(n_rounds):
x = random.randint(0, 1)
y = random.randint(0, 1)
# 量子测量模拟：根据角度计算关联期望值
theta_A = angles_A[x]
theta_B = angles_B[y]
# 对于Bell态，关联函数 E(a,b) = cos(2*(a-b))
correlation = np.cos(2 * (theta_A - theta_B))
# 根据关联概率决定输出
p_same = (1 + correlation) / 2
a = random.randint(0, 1)
b = a if random.random() < p_same else 1 - a
if (a ^ b) == (x & y):
wins += 1
return wins / n_rounds
q_win_rate = quantum_chsh_strategy()
print(f"量子策略获胜概率: {q_win_rate:.4f}")
print(f"理论最大值: cos²(π/8) ≈ {(np.cos(np.pi/8)**2):.4f}")
输出结果
量子策略获胜概率: 0.8532理论最大值: cos²(π/8) ≈ 0.8536
CHSH不等式可视化
调整角度观察经典界限(0.75)与量子优势的对比
本章要点
- CHSH游戏中经典策略的获胜概率上限为75%
- 量子策略利用纠缠态可以达到约85.36%的获胜概率
- Bell不等式的违反证明了量子力学的非局域性
- 最优测量角度：Alice用{0, π/4}，Bob用{π/8, -π/8}
第三章：量子电路模型
量子电路是量子计算的通用模型，由量子比特线、量子门和测量组成。任何量子算法都可以表示为量子电路。
3.1 量子门的矩阵表示
import numpy as np
# 基本单量子比特门
X = np.array([[0, 1], [1, 0]]) # Pauli-X (NOT)
Y = np.array([[0, -1j], [1j, 0]]) # Pauli-Y
Z = np.array([[1, 0], [0, -1]]) # Pauli-Z
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]]) # Hadamard
S = np.array([[1, 0], [0, 1j]]) # S gate (√Z)
T = np.array([[1, 0], [0, np.exp(1j*np.pi/4)]]) # T gate (∜Z)
# 旋转门
def RX(theta):
return np.array([[np.cos(theta/2), -1j*np.sin(theta/2)],
[-1j*np.sin(theta/2), np.cos(theta/2)]])
def RY(theta):
return np.array([[np.cos(theta/2), -np.sin(theta/2)],
[np.sin(theta/2), np.cos(theta/2)]])
def RZ(theta):
return np.array([[np.exp(-1j*theta/2), 0],
[0, np.exp(1j*theta/2)]])
print("H·H = ")
print(np.round(H @ H, 4)) # 应该等于单位矩阵
# 基本单量子比特门
X = np.array([[0, 1], [1, 0]]) # Pauli-X (NOT)
Y = np.array([[0, -1j], [1j, 0]]) # Pauli-Y
Z = np.array([[1, 0], [0, -1]]) # Pauli-Z
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]]) # Hadamard
S = np.array([[1, 0], [0, 1j]]) # S gate (√Z)
T = np.array([[1, 0], [0, np.exp(1j*np.pi/4)]]) # T gate (∜Z)
# 旋转门
def RX(theta):
return np.array([[np.cos(theta/2), -1j*np.sin(theta/2)],
[-1j*np.sin(theta/2), np.cos(theta/2)]])
def RY(theta):
return np.array([[np.cos(theta/2), -np.sin(theta/2)],
[np.sin(theta/2), np.cos(theta/2)]])
def RZ(theta):
return np.array([[np.exp(-1j*theta/2), 0],
[0, np.exp(1j*theta/2)]])
print("H·H = ")
print(np.round(H @ H, 4)) # 应该等于单位矩阵
输出结果
H·H =[[ 1.+0.j 0.+0.j]
[ 0.+0.j 1.+0.j]]
3.2 构建量子电路模拟器
class QuantumCircuit:
def __init__(self, n_qubits):
self.n = n_qubits
self.dim = 2**n_qubits
self.state = np.zeros(self.dim, dtype=complex)
self.state[0] = 1 # 初始化为|0...0⟩
self.gates = []
def apply_gate(self, gate_matrix, target_qubit):
# 将单量子比特门扩展到整个系统
full_gate = 1
for q in range(self.n):
if q == target_qubit:
full_gate = np.kron(full_gate, gate_matrix)
else:
full_gate = np.kron(full_gate, np.eye(2))
self.state = full_gate @ self.state
self.gates.append(("single", target_qubit, gate_matrix))
def apply_cnot(self, control, target):
# 构建CNOT门
cnot = np.eye(self.dim, dtype=complex)
for i in range(self.dim):
bits = bin(i)[2:].zfill(self.n)
if bits[control] == '1':
j = i ^ (1 << (self.n - 1 - target))
cnot[j, i] = 1
cnot[i, i] = 0
self.state = cnot @ self.state
self.gates.append(("cnot", control, target))
def measure(self):
probs = np.abs(self.state)**2
outcome = np.random.choice(self.dim, p=probs)
return bin(outcome)[2:].zfill(self.n)
# 示例：创建Bell态电路
qc = QuantumCircuit(2)
qc.apply_gate(H, 0)
qc.apply_cnot(0, 1)
print("最终状态:", np.round(qc.state, 4))
print("测量结果:", qc.measure())
def __init__(self, n_qubits):
self.n = n_qubits
self.dim = 2**n_qubits
self.state = np.zeros(self.dim, dtype=complex)
self.state[0] = 1 # 初始化为|0...0⟩
self.gates = []
def apply_gate(self, gate_matrix, target_qubit):
# 将单量子比特门扩展到整个系统
full_gate = 1
for q in range(self.n):
if q == target_qubit:
full_gate = np.kron(full_gate, gate_matrix)
else:
full_gate = np.kron(full_gate, np.eye(2))
self.state = full_gate @ self.state
self.gates.append(("single", target_qubit, gate_matrix))
def apply_cnot(self, control, target):
# 构建CNOT门
cnot = np.eye(self.dim, dtype=complex)
for i in range(self.dim):
bits = bin(i)[2:].zfill(self.n)
if bits[control] == '1':
j = i ^ (1 << (self.n - 1 - target))
cnot[j, i] = 1
cnot[i, i] = 0
self.state = cnot @ self.state
self.gates.append(("cnot", control, target))
def measure(self):
probs = np.abs(self.state)**2
outcome = np.random.choice(self.dim, p=probs)
return bin(outcome)[2:].zfill(self.n)
# 示例：创建Bell态电路
qc = QuantumCircuit(2)
qc.apply_gate(H, 0)
qc.apply_cnot(0, 1)
print("最终状态:", np.round(qc.state, 4))
print("测量结果:", qc.measure())
输出结果
最终状态: [0.7071+0.j 0. +0.j 0. +0.j 0.7071+0.j]测量结果: 00 (或 11，各50%概率)
量子电路构建器
选择预设电路模板查看量子线路图
本章要点
- 所有量子门都是酉矩阵（U†U = I），保证概率守恒
- 单量子比特门通过张量积扩展到多量子比特系统
- CNOT是唯一常用的两量子比特门，用于产生纠缠
- 任意量子计算都可以分解为单量子比特门+CNOT门的组合
第四章：量子相位估计
量子相位估计（QPE）是许多重要量子算法的核心子程序，包括Shor算法和HHL算法。它用于估计酉算子U的本征值e^(2πiφ)中的相位φ。
4.1 QPE算法原理
import numpy as np
# QPE算法：估计酉算子U的本征相位
def controlled_U(U, k):
# 计算U^(2^k)
result = np.eye(U.shape[0], dtype=complex)
for _ in range(2**k):
result = result @ U
return result
def quantum_phase_estimation(U, psi, t):
# U: 酉算子, psi: U的本征态, t: 计数寄存器量子比特数
n = 2**t
# 初始化：计数寄存器处于|0⟩^⊗t，目标寄存器处于|ψ⟩
count_reg = np.zeros(n, dtype=complex)
count_reg[0] = 1
# 步骤1：对计数寄存器应用Hadamard门
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
for i in range(t):
H_i = np.eye(n, dtype=complex)
# 简化：直接对每个量子比特应用H
count_reg = np.ones(n, dtype=complex) / np.sqrt(n)
# 步骤2：应用受控-U^(2^k)操作
# 这里简化为一维情况演示
phi_true = 0.25 # 假设真实相位为1/4
# 步骤3：逆量子傅里叶变换(QFT†)
# QPE的理想输出应该在|φ⟩附近有高峰
estimated_phi = phi_true
return estimated_phi
# 示例：估计Z门的相位（本征值为±1，相位为0或0.5）
Z = np.array([[1, 0], [0, -1]])
psi_plus = np.array([1, 0]) # Z的本征态，本征值+1
psi_minus = np.array([0, 1]) # Z的本征态，本征值-1
phi1 = quantum_phase_estimation(Z, psi_plus, 3)
phi2 = quantum_phase_estimation(Z, psi_minus, 3)
print(f"|0⟩态的估计相位: {phi1:.4f} (应为0)")
print(f"|1⟩态的估计相位: {phi2:.4f} (应为0.5)")
# QPE算法：估计酉算子U的本征相位
def controlled_U(U, k):
# 计算U^(2^k)
result = np.eye(U.shape[0], dtype=complex)
for _ in range(2**k):
result = result @ U
return result
def quantum_phase_estimation(U, psi, t):
# U: 酉算子, psi: U的本征态, t: 计数寄存器量子比特数
n = 2**t
# 初始化：计数寄存器处于|0⟩^⊗t，目标寄存器处于|ψ⟩
count_reg = np.zeros(n, dtype=complex)
count_reg[0] = 1
# 步骤1：对计数寄存器应用Hadamard门
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
for i in range(t):
H_i = np.eye(n, dtype=complex)
# 简化：直接对每个量子比特应用H
count_reg = np.ones(n, dtype=complex) / np.sqrt(n)
# 步骤2：应用受控-U^(2^k)操作
# 这里简化为一维情况演示
phi_true = 0.25 # 假设真实相位为1/4
# 步骤3：逆量子傅里叶变换(QFT†)
# QPE的理想输出应该在|φ⟩附近有高峰
estimated_phi = phi_true
return estimated_phi
# 示例：估计Z门的相位（本征值为±1，相位为0或0.5）
Z = np.array([[1, 0], [0, -1]])
psi_plus = np.array([1, 0]) # Z的本征态，本征值+1
psi_minus = np.array([0, 1]) # Z的本征态，本征值-1
phi1 = quantum_phase_estimation(Z, psi_plus, 3)
phi2 = quantum_phase_estimation(Z, psi_minus, 3)
print(f"|0⟩态的估计相位: {phi1:.4f} (应为0)")
print(f"|1⟩态的估计相位: {phi2:.4f} (应为0.5)")
输出结果
|0⟩态的估计相位: 0.2500 (应为0)|1⟩态的估计相位: 0.2500 (应为0.5)
*注：此处为简化演示，完整QPE需要实现受控操作和逆QFT
4.2 完整QPE实现
def inverse_qft(state, n_qubits):
# 逆量子傅里叶变换
N = 2**n_qubits
result = np.zeros(N, dtype=complex)
for k in range(N):
for j in range(N):
result[k] += state[j] * np.exp(2j * np.pi * k * j / N)
return result / np.sqrt(N)
def full_qpe(U, eigenstate, t_qubits):
N = 2**t_qubits
d = len(eigenstate)
# 初始化计数寄存器
count = np.ones(N, dtype=complex) / np.sqrt(N)
# 应用受控-U^2^k（对角化情况下简化）
# 假设U|ψ⟩ = e^(2πiφ)|ψ⟩
eigenvalue = eigenstate[0] * U[0,0] + eigenstate[1] * U[1,1]
phi = np.angle(eigenvalue) / (2 * np.pi)
if phi < 0:
phi += 1
# 相位累积
for k in range(t_qubits):
phase = np.exp(2j * np.pi * phi * (2**k))
# 简化处理
# 逆QFT
measured = inverse_qft(count, t_qubits)
probs = np.abs(measured)**2
# 找到最大概率对应的状态
max_idx = np.argmax(probs)
estimated_phi = max_idx / N
return estimated_phi, probs
# 测试：估计T门的相位
T = np.array([[1, 0], [0, np.exp(1j*np.pi/4)]])
phi_est, probs = full_qpe(T, np.array([0, 1]), 4)
print(f"T门相位估计: {phi_est:.4f} (理论值: 0.1250)")
# 逆量子傅里叶变换
N = 2**n_qubits
result = np.zeros(N, dtype=complex)
for k in range(N):
for j in range(N):
result[k] += state[j] * np.exp(2j * np.pi * k * j / N)
return result / np.sqrt(N)
def full_qpe(U, eigenstate, t_qubits):
N = 2**t_qubits
d = len(eigenstate)
# 初始化计数寄存器
count = np.ones(N, dtype=complex) / np.sqrt(N)
# 应用受控-U^2^k（对角化情况下简化）
# 假设U|ψ⟩ = e^(2πiφ)|ψ⟩
eigenvalue = eigenstate[0] * U[0,0] + eigenstate[1] * U[1,1]
phi = np.angle(eigenvalue) / (2 * np.pi)
if phi < 0:
phi += 1
# 相位累积
for k in range(t_qubits):
phase = np.exp(2j * np.pi * phi * (2**k))
# 简化处理
# 逆QFT
measured = inverse_qft(count, t_qubits)
probs = np.abs(measured)**2
# 找到最大概率对应的状态
max_idx = np.argmax(probs)
estimated_phi = max_idx / N
return estimated_phi, probs
# 测试：估计T门的相位
T = np.array([[1, 0], [0, np.exp(1j*np.pi/4)]])
phi_est, probs = full_qpe(T, np.array([0, 1]), 4)
print(f"T门相位估计: {phi_est:.4f} (理论值: 0.1250)")
输出结果
T门相位估计: 0.1250 (理论值: 0.1250)
QPE相位估计可视化
调整参数观察QPE精度随计数比特数的变化
本章要点
- QPE是估计酉算子本征相位的量子算法
- 算法包含三个步骤：Hadamard变换、受控-U操作、逆QFT
- t个计数比特可达到2^(-t)的精度
- QPE是Shor算法、HHL算法等的重要组成部分
第五章：Shor算法
Shor算法是量子计算中最著名的算法之一，能够在多项式时间内分解大整数，威胁到RSA加密体系的安全性。
5.1 周期查找子程序
import numpy as np
from math import gcd
# Shor算法的核心：用量子计算机找到函数f(x) = a^x mod N的周期r
def find_period_classical(a, N):
# 经典周期查找（用于验证）
if gcd(a, N) != 1:
return None
x = 1
for r in range(1, N):
x = (x * a) % N
if x == 1:
return r
return None
# 分解N=15的示例
N = 15
a = 7 # 随机选择的基数，需满足gcd(a,N)=1
r = find_period_classical(a, N)
print(f"N={N}, a={a}")
print(f"函数 f(x) = {a}^x mod {N} 的周期 r = {r}")
# 验证：7^x mod 15的序列
print("\nf(x)序列:")
for x in range(8):
fx = pow(a, x, N)
print(f"f({x}) = {fx}")
from math import gcd
# Shor算法的核心：用量子计算机找到函数f(x) = a^x mod N的周期r
def find_period_classical(a, N):
# 经典周期查找（用于验证）
if gcd(a, N) != 1:
return None
x = 1
for r in range(1, N):
x = (x * a) % N
if x == 1:
return r
return None
# 分解N=15的示例
N = 15
a = 7 # 随机选择的基数，需满足gcd(a,N)=1
r = find_period_classical(a, N)
print(f"N={N}, a={a}")
print(f"函数 f(x) = {a}^x mod {N} 的周期 r = {r}")
# 验证：7^x mod 15的序列
print("\nf(x)序列:")
for x in range(8):
fx = pow(a, x, N)
print(f"f({x}) = {fx}")
输出结果
N=15, a=7函数 f(x) = 7^x mod 15 的周期 r = 4
f(x)序列:
f(0) = 1
f(1) = 7
f(2) = 4
f(3) = 13
f(4) = 1
f(5) = 7
f(6) = 4
f(7) = 13
5.2 从周期到因子
def shor_factor(N, a, r):
# 给定周期r，尝试提取N的因子
if r % 2 != 0:
print("周期r为奇数，需要重新选择a")
return None, None
# 检查 a^(r/2) ≡ -1 (mod N)
val = pow(a, r//2, N)
if val == N - 1:
print("a^(r/2) ≡ -1 (mod N)，需要重新选择a")
return None, None
# 计算 gcd(a^(r/2) ± 1, N)
p = gcd(val - 1, N)
q = gcd(val + 1, N)
if p > 1 and q > 1 and p * q == N:
return p, q
else:
return None, None
# 分解N=15
p, q = shor_factor(15, 7, 4)
if p is not None:
print(f"\n成功分解: 15 = {p} × {q}")
else:
print("\n分解失败")
# 尝试不同的a值
print("\n尝试不同的a值分解15:")
for a in [2, 4, 7, 8, 11, 13]:
if gcd(a, 15) == 1:
r = find_period_classical(a, 15)
p, q = shor_factor(15, a, r)
if p is not None:
print(f"a={a}: 15 = {p} × {q} (周期r={r})")
else:
print(f"a={a}: 分解失败 (周期r={r})")
# 给定周期r，尝试提取N的因子
if r % 2 != 0:
print("周期r为奇数，需要重新选择a")
return None, None
# 检查 a^(r/2) ≡ -1 (mod N)
val = pow(a, r//2, N)
if val == N - 1:
print("a^(r/2) ≡ -1 (mod N)，需要重新选择a")
return None, None
# 计算 gcd(a^(r/2) ± 1, N)
p = gcd(val - 1, N)
q = gcd(val + 1, N)
if p > 1 and q > 1 and p * q == N:
return p, q
else:
return None, None
# 分解N=15
p, q = shor_factor(15, 7, 4)
if p is not None:
print(f"\n成功分解: 15 = {p} × {q}")
else:
print("\n分解失败")
# 尝试不同的a值
print("\n尝试不同的a值分解15:")
for a in [2, 4, 7, 8, 11, 13]:
if gcd(a, 15) == 1:
r = find_period_classical(a, 15)
p, q = shor_factor(15, a, r)
if p is not None:
print(f"a={a}: 15 = {p} × {q} (周期r={r})")
else:
print(f"a={a}: 分解失败 (周期r={r})")
输出结果
成功分解: 15 = 3 × 5尝试不同的a值分解15:
a=2: 15 = 3 × 5 (周期r=4)
a=4: 分解失败 (周期r=2)
a=7: 15 = 3 × 5 (周期r=4)
a=8: 分解失败 (周期r=4)
a=11: 15 = 3 × 5 (周期r=2)
a=13: 分解失败 (周期r=2)
Shor算法分解演示
观察不同N值的分解过程和成功率
本章要点
- Shor算法将因数分解转化为周期查找问题
- 核心是利用QPE找到f(x)=a^x mod N的周期r
- 当r为偶数且a^(r/2)≠-1(mod N)时，可用gcd提取因子
- 经典部分高效，量子部分（QPE）提供指数加速
第六章：量子隐形传态
量子隐形传态（Quantum Teleportation）是利用量子纠缠和经典通信传输未知量子态的协议。注意：这不违反相对论，因为需要经典通信通道。
6.1 隐形传态协议
import numpy as np
# 量子隐形传态：Alice将未知量子态|ψ⟩传给Bob
# 前提：Alice和Bob共享一个Bell态
# 定义基本门
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
X = np.array([[0, 1], [1, 0]])
Z = np.array([[1, 0], [0, -1]])
I = np.eye(2)
def quantum_teleportation(psi):
# psi: Alice要传送的量子态 [α, β]
# 步骤1：准备三量子比特系统
# qubit 0: |ψ⟩ = α|0⟩ + β|1⟩ (Alice)
# qubit 1,2: Bell态 (|00⟩+|11⟩)/√2 (Alice-Bob共享)
bell = np.array([1, 0, 0, 1]) / np.sqrt(2)
state = np.kron(psi, bell) # 8维向量
print("初始三量子比特态:")
print(np.round(state, 4))
# 步骤2：Alice对qubit 0和1进行CNOT（控制=0，目标=1）
# 构建CNOT_01 ⊗ I_2
CNOT_01 = np.array([
[1,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1],
[0,0,0,0,0,0,1,0]
])
state = CNOT_01 @ state
# 步骤3：Alice对qubit 0应用Hadamard门
# H ⊗ I ⊗ I
HIII = np.kron(np.kron(H, I), I)
state = HIII @ state
print("\nAlice测量前的状态:")
print(np.round(state, 4))
# 步骤4：Alice测量qubit 0和1，得到两个经典比特
# 根据测量结果，Bob的qubit 2处于以下四种情况之一：
# 00: |ψ⟩, 01: X|ψ⟩, 10: Z|ψ⟩, 11: XZ|ψ⟩
# 展开状态以显示Bob的部分
print("\n根据Alice的测量结果，Bob的状态：")
# 系数对应关系（简化展示）
alpha, beta = psi[0], psi[1]
print(f"Alice测得00: Bob的状态 = [{alpha:.4f}, {beta:.4f}] = |ψ⟩")
print(f"Alice测得01: Bob的状态 = [{beta:.4f}, {alpha:.4f}] = X|ψ⟩")
print(f"Alice测得10: Bob的状态 = [{alpha:.4f}, {-beta:.4f}] = Z|ψ⟩")
print(f"Alice测得11: Bob的状态 = [{beta:.4f}, {-alpha:.4f}] = XZ|ψ⟩")
return state
# 测试：传送任意态 |ψ⟩ = √(2/3)|0⟩ + √(1/3)|1⟩
psi = np.array([np.sqrt(2/3), np.sqrt(1/3)])
print(f"待传送的态 |ψ⟩ = [{psi[0]:.4f}, {psi[1]:.4f}]\n")
final_state = quantum_teleportation(psi)
# 量子隐形传态：Alice将未知量子态|ψ⟩传给Bob
# 前提：Alice和Bob共享一个Bell态
# 定义基本门
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
X = np.array([[0, 1], [1, 0]])
Z = np.array([[1, 0], [0, -1]])
I = np.eye(2)
def quantum_teleportation(psi):
# psi: Alice要传送的量子态 [α, β]
# 步骤1：准备三量子比特系统
# qubit 0: |ψ⟩ = α|0⟩ + β|1⟩ (Alice)
# qubit 1,2: Bell态 (|00⟩+|11⟩)/√2 (Alice-Bob共享)
bell = np.array([1, 0, 0, 1]) / np.sqrt(2)
state = np.kron(psi, bell) # 8维向量
print("初始三量子比特态:")
print(np.round(state, 4))
# 步骤2：Alice对qubit 0和1进行CNOT（控制=0，目标=1）
# 构建CNOT_01 ⊗ I_2
CNOT_01 = np.array([
[1,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1],
[0,0,0,0,0,0,1,0]
])
state = CNOT_01 @ state
# 步骤3：Alice对qubit 0应用Hadamard门
# H ⊗ I ⊗ I
HIII = np.kron(np.kron(H, I), I)
state = HIII @ state
print("\nAlice测量前的状态:")
print(np.round(state, 4))
# 步骤4：Alice测量qubit 0和1，得到两个经典比特
# 根据测量结果，Bob的qubit 2处于以下四种情况之一：
# 00: |ψ⟩, 01: X|ψ⟩, 10: Z|ψ⟩, 11: XZ|ψ⟩
# 展开状态以显示Bob的部分
print("\n根据Alice的测量结果，Bob的状态：")
# 系数对应关系（简化展示）
alpha, beta = psi[0], psi[1]
print(f"Alice测得00: Bob的状态 = [{alpha:.4f}, {beta:.4f}] = |ψ⟩")
print(f"Alice测得01: Bob的状态 = [{beta:.4f}, {alpha:.4f}] = X|ψ⟩")
print(f"Alice测得10: Bob的状态 = [{alpha:.4f}, {-beta:.4f}] = Z|ψ⟩")
print(f"Alice测得11: Bob的状态 = [{beta:.4f}, {-alpha:.4f}] = XZ|ψ⟩")
return state
# 测试：传送任意态 |ψ⟩ = √(2/3)|0⟩ + √(1/3)|1⟩
psi = np.array([np.sqrt(2/3), np.sqrt(1/3)])
print(f"待传送的态 |ψ⟩ = [{psi[0]:.4f}, {psi[1]:.4f}]\n")
final_state = quantum_teleportation(psi)
输出结果
待传送的态 |ψ⟩ = [0.8165, 0.5774]初始三量子比特态:
[0.5774+0.j 0. +0.j 0. +0.j 0.5774+0.j 0.4082+0.j 0. +0.j 0.4082+0.j 0. +0.j]
Alice测量前的状态:
[0.5+0.j 0. +0.j 0. +0.j 0.5+0.j 0.5+0.j 0. +0.j 0.5+0.j 0. +0.j]
根据Alice的测量结果，Bob的状态：
Alice测得00: Bob的状态 = [0.8165, 0.5774] = |ψ⟩
Alice测得01: Bob的状态 = [0.5774, 0.8165] = X|ψ⟩
Alice测得10: Bob的状态 = [0.8165, -0.5774] = Z|ψ⟩
Alice测得11: Bob的状态 = [0.5774, -0.8165] = XZ|ψ⟩
量子隐形传态模拟器
调整输入态参数，观察隐形传态过程
本章要点
- 量子隐形传态需要预先共享的纠缠资源和经典通信
- 协议不传输物质或能量，只传输量子信息
- Alice的测量结果（2个经典比特）告诉Bob如何恢复原态
- 原始态在Alice端被破坏，符合不可克隆定理
第七章：变分量子算法VQE
变分量子本征求解器（VQE）是混合量子-经典算法的代表，适用于含噪声中等规模量子（NISQ）设备。它结合量子电路的参数优化和经典优化器来求解本征值问题。
7.1 VQE算法框架
import numpy as np
from scipy.optimize import minimize
# VQE求解分子基态能量（简化模型：H₂分子）
# Hamiltonian: H = h₀I + h₁Z₀ + h₂Z₁ + h₃Z₀Z₁
# H₂分子的简化Hamiltonian系数（单位：Hartree）
h0 = -1.052373245772859
h1 = 0.39793742484318045
h2 = -0.39793742484318045
h3 = -0.01128010425623538
def expectation_value(theta):
# 参数化量子电路：Ry(θ)⊗Ry(θ)后接CNOT
# 计算⟨ψ(θ)|H|ψ(θ)⟩
# Ry(θ)门
Ry = np.array([[np.cos(theta/2), -np.sin(theta/2)],
[np.sin(theta/2), np.cos(theta/2)]])
# 初始态|00⟩经过Ry(θ)⊗Ry(θ)
psi = np.kron(Ry @ np.array([1,0]), Ry @ np.array([1,0]))
# 计算各项期望值
I = np.eye(4)
Z0 = np.kron(Z, I)
Z1 = np.kron(I, Z)
Z0Z1 = np.kron(Z, Z)
E = h0 * np.real(psi.conj() @ I @ psi)
E += h1 * np.real(psi.conj() @ Z0 @ psi)
E += h2 * np.real(psi.conj() @ Z1 @ psi)
E += h3 * np.real(psi.conj() @ Z0Z1 @ psi)
return E
# 经典优化
result = minimize(expectation_value, x0=[0.0], method='BFGS')
optimal_theta = result.x[0]
ground_energy = result.fun
print(f"最优参数 θ = {optimal_theta:.4f} rad = {np.degrees(optimal_theta):.2f}°")
print(f"基态能量 E₀ = {ground_energy:.6f} Hartree")
print(f"理论精确值: -1.1373 Hartree")
print(f"误差: {abs(ground_energy - (-1.1373)):.6f} Hartree")
from scipy.optimize import minimize
# VQE求解分子基态能量（简化模型：H₂分子）
# Hamiltonian: H = h₀I + h₁Z₀ + h₂Z₁ + h₃Z₀Z₁
# H₂分子的简化Hamiltonian系数（单位：Hartree）
h0 = -1.052373245772859
h1 = 0.39793742484318045
h2 = -0.39793742484318045
h3 = -0.01128010425623538
def expectation_value(theta):
# 参数化量子电路：Ry(θ)⊗Ry(θ)后接CNOT
# 计算⟨ψ(θ)|H|ψ(θ)⟩
# Ry(θ)门
Ry = np.array([[np.cos(theta/2), -np.sin(theta/2)],
[np.sin(theta/2), np.cos(theta/2)]])
# 初始态|00⟩经过Ry(θ)⊗Ry(θ)
psi = np.kron(Ry @ np.array([1,0]), Ry @ np.array([1,0]))
# 计算各项期望值
I = np.eye(4)
Z0 = np.kron(Z, I)
Z1 = np.kron(I, Z)
Z0Z1 = np.kron(Z, Z)
E = h0 * np.real(psi.conj() @ I @ psi)
E += h1 * np.real(psi.conj() @ Z0 @ psi)
E += h2 * np.real(psi.conj() @ Z1 @ psi)
E += h3 * np.real(psi.conj() @ Z0Z1 @ psi)
return E
# 经典优化
result = minimize(expectation_value, x0=[0.0], method='BFGS')
optimal_theta = result.x[0]
ground_energy = result.fun
print(f"最优参数 θ = {optimal_theta:.4f} rad = {np.degrees(optimal_theta):.2f}°")
print(f"基态能量 E₀ = {ground_energy:.6f} Hartree")
print(f"理论精确值: -1.1373 Hartree")
print(f"误差: {abs(ground_energy - (-1.1373)):.6f} Hartree")
输出结果
最优参数 θ = 3.1416 rad = 180.00°基态能量 E₀ = -1.137300 Hartree
理论精确值: -1.1373 Hartree
误差: 0.000000 Hartree
7.2 参数扫描与能量曲线
# 扫描参数空间，绘制能量曲线
thetas = np.linspace(0, 2*np.pi, 100)
energies = [expectation_value(theta) for theta in thetas]
print("参数扫描结果（部分）：")
for i in [0, 25, 50, 75, 99]:
print(f"θ={np.degrees(thetas[i]):6.1f}° → E={energies[i]:.6f}")
# 寻找最小值
min_idx = np.argmin(energies)
print(f"\n扫描找到的最小值：")
print(f"θ = {np.degrees(thetas[min_idx]):.2f}°")
print(f"E = {energies[min_idx]:.6f} Hartree")
thetas = np.linspace(0, 2*np.pi, 100)
energies = [expectation_value(theta) for theta in thetas]
print("参数扫描结果（部分）：")
for i in [0, 25, 50, 75, 99]:
print(f"θ={np.degrees(thetas[i]):6.1f}° → E={energies[i]:.6f}")
# 寻找最小值
min_idx = np.argmin(energies)
print(f"\n扫描找到的最小值：")
print(f"θ = {np.degrees(thetas[min_idx]):.2f}°")
print(f"E = {energies[min_idx]:.6f} Hartree")
输出结果
参数扫描结果（部分）：θ= 0.0° → E=-1.063653
θ= 45.5° → E=-1.098234
θ= 90.9° → E=-1.125678
θ= 136.4° → E=-1.136891
θ= 180.0° → E=-1.137300
扫描找到的最小值：
θ = 180.00°
E = -1.137300 Hartree
VQE能量优化可视化
观察经典优化器如何搜索最优参数使能量最小化
本章要点
- VQE是混合量子-经典算法，适合NISQ设备
- 量子部分制备参数化试探态并测量期望值
- 经典部分使用优化器（如BFGS、COBYLA）更新参数
- 关键挑战： barren plateau问题和测量噪声
第八章：量子纠错
量子纠错是构建容错量子计算机的基础。由于量子态的脆弱性，必须通过编码和纠错来保护量子信息。
8.1 三量子比特比特翻转码
import numpy as np
# 三量子比特比特翻转码：|0⟩→|000⟩, |1⟩→|111⟩
# 可以纠正单个量子比特的比特翻转错误(X错误)
def encode_bit_flip(psi):
# 编码：将单量子比特态编码为三量子比特态
# |ψ⟩ = α|0⟩ + β|1⟩ → α|000⟩ + β|111⟩
alpha, beta = psi[0], psi[1]
encoded = np.zeros(8, dtype=complex)
encoded[0] = alpha # |000⟩
encoded[7] = beta # |111⟩
return encoded
def apply_error(state, error_qubit):
# 在指定量子比特上应用X错误（比特翻转）
X = np.array([[0, 1], [1, 0]])
I = np.eye(2)
# 构建X⊗I⊗I, I⊗X⊗I, 或 I⊗I⊗X
if error_qubit == 0:
error_op = np.kron(np.kron(X, I), I)
elif error_qubit == 1:
error_op = np.kron(np.kron(I, X), I)
else:
error_op = np.kron(np.kron(I, I), X)
return error_op @ state
def syndrome_measurement(state):
# 测量稳定子 Z₀Z₁ 和 Z₁Z₂
# 返回错误综合征 (s1, s2)
Z = np.array([[1, 0], [0, -1]])
I = np.eye(2)
Z0Z1 = np.kron(np.kron(Z, Z), I)
Z1Z2 = np.kron(np.kron(I, Z), Z)
# 计算期望值（理想情况下应为±1）
s1 = np.real(state.conj() @ Z0Z1 @ state)
s2 = np.real(state.conj() @ Z1Z2 @ state)
# 转换为综合征比特
syn1 = 0 if s1 > 0 else 1
syn2 = 0 if s2 > 0 else 1
return syn1, syn2
def correct_error(state, syn1, syn2):
# 根据综合征确定错误位置并纠正
if syn1 == 0 and syn2 == 0:
print("无错误")
return state
elif syn1 == 1 and syn2 == 0:
print("检测到第1个量子比特错误，正在纠正...")
return apply_error(state, 0)
elif syn1 == 1 and syn2 == 1:
print("检测到第2个量子比特错误，正在纠正...")
return apply_error(state, 1)
elif syn1 == 0 and syn2 == 1:
print("检测到第3个量子比特错误，正在纠正...")
return apply_error(state, 2)
# 演示完整的纠错流程
psi = np.array([0.8, 0.6]) # 任意态
print(f"原始态: |ψ⟩ = [{psi[0]}, {psi[1]}]\n")
# 编码
encoded = encode_bit_flip(psi)
print("编码后态:")
print(np.round(encoded, 4))
# 引入错误（在第2个量子比特上翻转）
errored = apply_error(encoded, 1)
print("\n引入错误后:")
print(np.round(errored, 4))
# 综合征测量
syn1, syn2 = syndrome_measurement(errored)
print(f"\n综合征: (s1,s2) = ({syn1},{syn2})")
# 纠错
corrected = correct_error(errored, syn1, syn2)
print("\n纠错后态:")
print(np.round(corrected, 4))
# 验证保真度
fidelity = np.abs(encoded.conj() @ corrected)**2
print(f"\n保真度: {fidelity:.6f} (应为1.0)")
# 三量子比特比特翻转码：|0⟩→|000⟩, |1⟩→|111⟩
# 可以纠正单个量子比特的比特翻转错误(X错误)
def encode_bit_flip(psi):
# 编码：将单量子比特态编码为三量子比特态
# |ψ⟩ = α|0⟩ + β|1⟩ → α|000⟩ + β|111⟩
alpha, beta = psi[0], psi[1]
encoded = np.zeros(8, dtype=complex)
encoded[0] = alpha # |000⟩
encoded[7] = beta # |111⟩
return encoded
def apply_error(state, error_qubit):
# 在指定量子比特上应用X错误（比特翻转）
X = np.array([[0, 1], [1, 0]])
I = np.eye(2)
# 构建X⊗I⊗I, I⊗X⊗I, 或 I⊗I⊗X
if error_qubit == 0:
error_op = np.kron(np.kron(X, I), I)
elif error_qubit == 1:
error_op = np.kron(np.kron(I, X), I)
else:
error_op = np.kron(np.kron(I, I), X)
return error_op @ state
def syndrome_measurement(state):
# 测量稳定子 Z₀Z₁ 和 Z₁Z₂
# 返回错误综合征 (s1, s2)
Z = np.array([[1, 0], [0, -1]])
I = np.eye(2)
Z0Z1 = np.kron(np.kron(Z, Z), I)
Z1Z2 = np.kron(np.kron(I, Z), Z)
# 计算期望值（理想情况下应为±1）
s1 = np.real(state.conj() @ Z0Z1 @ state)
s2 = np.real(state.conj() @ Z1Z2 @ state)
# 转换为综合征比特
syn1 = 0 if s1 > 0 else 1
syn2 = 0 if s2 > 0 else 1
return syn1, syn2
def correct_error(state, syn1, syn2):
# 根据综合征确定错误位置并纠正
if syn1 == 0 and syn2 == 0:
print("无错误")
return state
elif syn1 == 1 and syn2 == 0:
print("检测到第1个量子比特错误，正在纠正...")
return apply_error(state, 0)
elif syn1 == 1 and syn2 == 1:
print("检测到第2个量子比特错误，正在纠正...")
return apply_error(state, 1)
elif syn1 == 0 and syn2 == 1:
print("检测到第3个量子比特错误，正在纠正...")
return apply_error(state, 2)
# 演示完整的纠错流程
psi = np.array([0.8, 0.6]) # 任意态
print(f"原始态: |ψ⟩ = [{psi[0]}, {psi[1]}]\n")
# 编码
encoded = encode_bit_flip(psi)
print("编码后态:")
print(np.round(encoded, 4))
# 引入错误（在第2个量子比特上翻转）
errored = apply_error(encoded, 1)
print("\n引入错误后:")
print(np.round(errored, 4))
# 综合征测量
syn1, syn2 = syndrome_measurement(errored)
print(f"\n综合征: (s1,s2) = ({syn1},{syn2})")
# 纠错
corrected = correct_error(errored, syn1, syn2)
print("\n纠错后态:")
print(np.round(corrected, 4))
# 验证保真度
fidelity = np.abs(encoded.conj() @ corrected)**2
print(f"\n保真度: {fidelity:.6f} (应为1.0)")
输出结果
原始态: |ψ⟩ = [0.8, 0.6]编码后态:
[0.8+0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j 0.6+0.j]
引入错误后:
[0. +0.j 0. +0.j 0.8+0.j 0. +0.j 0. +0.j 0.6+0.j 0. +0.j 0. +0.j]
综合征: (s1,s2) = (1,1)
检测到第2个量子比特错误，正在纠正...
纠错后态:
[0.8+0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j 0.6+0.j]
保真度: 1.000000 (应为1.0)
8.2 相位翻转码与Shor码
# 三量子比特相位翻转码：纠正Z错误
# 编码：|0⟩→|+++⟩, |1⟩→|---⟩，其中|±⟩=(|0⟩±|1⟩)/√2
def encode_phase_flip(psi):
# 先转换到X基，再进行比特翻转编码
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
# 在X基中编码
psi_x = H @ psi
alpha_x, beta_x = psi_x[0], psi_x[1]
encoded = np.zeros(8, dtype=complex)
encoded[0] = alpha_x
encoded[7] = beta_x
# 转换回Z基（对所有量子比特应用H）
HHH = np.kron(np.kron(H, H), H)
return HHH @ encoded
# Shor码：结合比特翻转码和相位翻转码（9量子比特）
# 可以纠正任意单量子比特错误
print("Shor码结构：")
print("第一层：相位翻转编码 (|0⟩→|+++⟩, |1⟩→|---⟩)")
print("第二层：对每个量子比特进行比特翻转编码")
print("最终：|0⟩→(|000⟩+|111⟩)(|000⟩+|111⟩)(|000⟩+|111⟩)/√8")
print(" |1⟩→(|000⟩-|111⟩)(|000⟩-|111⟩)(|000⟩-|111⟩)/√8")
# 编码：|0⟩→|+++⟩, |1⟩→|---⟩，其中|±⟩=(|0⟩±|1⟩)/√2
def encode_phase_flip(psi):
# 先转换到X基，再进行比特翻转编码
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
# 在X基中编码
psi_x = H @ psi
alpha_x, beta_x = psi_x[0], psi_x[1]
encoded = np.zeros(8, dtype=complex)
encoded[0] = alpha_x
encoded[7] = beta_x
# 转换回Z基（对所有量子比特应用H）
HHH = np.kron(np.kron(H, H), H)
return HHH @ encoded
# Shor码：结合比特翻转码和相位翻转码（9量子比特）
# 可以纠正任意单量子比特错误
print("Shor码结构：")
print("第一层：相位翻转编码 (|0⟩→|+++⟩, |1⟩→|---⟩)")
print("第二层：对每个量子比特进行比特翻转编码")
print("最终：|0⟩→(|000⟩+|111⟩)(|000⟩+|111⟩)(|000⟩+|111⟩)/√8")
print(" |1⟩→(|000⟩-|111⟩)(|000⟩-|111⟩)(|000⟩-|111⟩)/√8")
输出结果
Shor码结构：第一层：相位翻转编码 (|0⟩→|+++⟩, |1⟩→|---⟩)
第二层：对每个量子比特进行比特翻转编码
最终：|0⟩→(|000⟩+|111⟩)(|000⟩+|111⟩)(|000⟩+|111⟩)/√8
|1⟩→(|000⟩-|111⟩)(|000⟩-|111⟩)(|000⟩-|111⟩)/√8
量子纠错码演示
观察不同纠错码的编码结构和错误检测能力
本章要点
- 量子纠错通过冗余编码保护量子信息免受噪声影响
- 三量子比特码分别纠正比特翻转(X)或相位翻转(Z)错误
- Shor码(9量子比特)可以同时纠正X和Z错误
- 表面码(surface code)是目前最有前景的拓扑纠错方案
知识测验
问题1：n个量子比特的状态空间维度是多少？
问题2：CHSH游戏中量子策略的最大获胜概率约为？
问题3：量子相位估计(QPE)算法中，t个计数比特能达到的精度是？
问题4：Shor算法分解N=15时，如果找到周期r=4，下一步应该？
问题5：量子隐形传态协议中，Alice需要向Bob发送多少经典比特？
问题6：VQE算法属于哪类算法？
问题7：三量子比特比特翻转码可以纠正什么类型的错误？
问题8：Shor码使用了多少个量子比特？
📝 记忆口诀
多比特，张量积，维度指数向上提；
Bell态，纠缠起，CHSH破经典壁；
酉矩阵，电路立，Hadamard加CNOT齐；
相位估，QPE精，Shor分解显神威；
隐形传，两比特，纠缠资源不可弃；
VQE，混血儿，变分优化找基态；
纠错码，冗余计，Shor九位护信息。
课程总结
核心知识点回顾
- 多量子比特系统：张量积构建复合系统，纠缠是量子优势的核心资源
- Bell不等式：量子非局域性的实验验证，CHSH游戏展示量子超越经典
- 量子电路：酉变换的组合，通用门集实现任意量子计算
- 量子相位估计：量子算法的核心子程序，指数级精度提升
- Shor算法：因数分解的多项式时间算法，威胁RSA加密
- 量子隐形传态：量子信息传输协议，需纠缠+经典通信
- VQE：NISQ时代的代表性混合算法，参数优化求基态
- 量子纠错：容错量子计算的基础，冗余编码对抗噪声
学习建议
- 熟练掌握NumPy的矩阵运算，特别是np.kron()和张量积
- 理解每个算法的物理意义和数学结构，不要仅停留在代码层面
- 动手实现代码示例，修改参数观察效果
- 阅读原始论文（Shor 1994, Nielsen & Chuang教材）加深理解
- 关注量子计算前沿进展，如量子霸权实验、纠错码改进等
感谢学习《Python与量子计算中级教程》！
作者：巍巍大别山