VQE 和 QAOA 变分量子算法教程¶

本教程详细介绍 Qibo 中最重要的两种混合量子-经典算法。

目录¶

1. 变分量子算法概述
2. VQE：变分量子特征值求解器
3. QAOA：量子近似优化算法
4. 算法对比与选择
5. 实战示例
6. 练习题

---

变分量子算法概述¶

什么是变分量子算法？¶

变分量子算法是一类混合量子-经典算法，结合了：

• 量子部分：准备参数化量子态，计算期望值
• 经典部分：优化参数，最小化目标函数

通用框架¶

# 伪代码
initialize_parameters(θ)
while not converged:
    # 量子部分
    state = quantum_circuit(θ)
    expectation = calculate_expectation(state, hamiltonian)
    
    # 经典部分
    θ = classical_optimizer(expectation, θ)

优势¶

• NISQ 友好：适合当前量子硬件
• 容错性强：对噪声有一定鲁棒性
• 应用广泛：化学、优化、机器学习

---

In [ ]:

# 导入必要的库
import numpy as np
import matplotlib.pyplot as plt
from qibo import Circuit, gates, hamiltonians, models
from qibo.models import VQE, QAOA

# 设置图形
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

print("VQE 和 QAOA 教程")
print(f"当前后端已准备就绪")

# 导入必要的库 import numpy as np import matplotlib.pyplot as plt from qibo import Circuit, gates, hamiltonians, models from qibo.models import VQE, QAOA # 设置图形 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False print("VQE 和 QAOA 教程") print(f"当前后端已准备就绪")

VQE：变分量子特征值求解器¶

核心思想¶

VQE 用于寻找哈密顿量 $H$ 的基态能量：

$$ E(\theta) = \langle \psi(\theta) | H | \psi(\theta) \rangle $$

目标： $$ \theta^* = \arg\min_\theta E(\theta) $$

应用场景¶

• 量子化学：分子基态能量
• 凝聚态物理：多体系统基态
• 材料科学：晶体结构预测

VQE 工作流程¶

In [ ]:

# 步骤 1：创建变分电路（Ansatz）
def create_vqe_circuit(nqubits, nlayers):
    """
    创建变分量子电路
    
    参数:
        nqubits: 量子比特数
        nlayers: 电路层数
    """
    circuit = Circuit(nqubits)
    
    for l in range(nlayers):
        # 第一层：RY 门（参数化）
        circuit.add(gates.RY(q, theta=0) for q in range(nqubits))
        
        # 第二层：CZ 门（纠缠）
        circuit.add(gates.CZ(q, q + 1) for q in range(0, nqubits - 1, 2))
        
        # 第三层：RY 门
        circuit.add(gates.RY(q, theta=0) for q in range(nqubits))
        
        # 第四层：CZ 门（交错模式）
        circuit.add(gates.CZ(q, q + 1) for q in range(1, nqubits - 2, 2))
        circuit.add(gates.CZ(0, nqubits - 1))
    
    # 最后的 RY 层
    circuit.add(gates.RY(q, theta=0) for q in range(nqubits))
    
    return circuit

# 创建示例电路
nqubits = 4
nlayers = 2
circuit_vqe = create_vqe_circuit(nqubits, nlayers)

print(f"VQE 电路创建完成：")
print(f"量子比特数：{nqubits}")
print(f"电路层数：{nlayers}")
print(f"参数数量：{2 * nqubits * nlayers + nqubits}")

# 步骤 1：创建变分电路（Ansatz） def create_vqe_circuit(nqubits, nlayers): """ 创建变分量子电路 参数: nqubits: 量子比特数 nlayers: 电路层数 """ circuit = Circuit(nqubits) for l in range(nlayers): # 第一层：RY 门（参数化） circuit.add(gates.RY(q, theta=0) for q in range(nqubits)) # 第二层：CZ 门（纠缠） circuit.add(gates.CZ(q, q + 1) for q in range(0, nqubits - 1, 2)) # 第三层：RY 门 circuit.add(gates.RY(q, theta=0) for q in range(nqubits)) # 第四层：CZ 门（交错模式） circuit.add(gates.CZ(q, q + 1) for q in range(1, nqubits - 2, 2)) circuit.add(gates.CZ(0, nqubits - 1)) # 最后的 RY 层 circuit.add(gates.RY(q, theta=0) for q in range(nqubits)) return circuit # 创建示例电路 nqubits = 4 nlayers = 2 circuit_vqe = create_vqe_circuit(nqubits, nlayers) print(f"VQE 电路创建完成：") print(f"量子比特数：{nqubits}") print(f"电路层数：{nlayers}") print(f"参数数量：{2 * nqubits * nlayers + nqubits}")

In [ ]:

# 步骤 2：创建哈密顿量
# 这里使用 XXZ 模型作为示例

hamiltonian = hamiltonians.XXZ(nqubits=nqubits, delta=0.5)

print(f"哈密顿量：XXZ 模型")
print(f"量子比特数：{hamiltonian.nqubits}")
print(f"\n矩阵形状：{hamiltonian.matrix.shape}")

# 步骤 2：创建哈密顿量 # 这里使用 XXZ 模型作为示例 hamiltonian = hamiltonians.XXZ(nqubits=nqubits, delta=0.5) print(f"哈密顿量：XXZ 模型") print(f"量子比特数：{hamiltonian.nqubits}") print(f"\n矩阵形状：{hamiltonian.matrix.shape}")

In [ ]:

# 步骤 3：初始化 VQE 模型
vqe = VQE(circuit_vqe, hamiltonian)

print("VQE 模型初始化完成")
print(f"\n电路：{vqe.circuit}")
print(f"哈密顿量：{type(vqe.hamiltonian).__name__}")

# 步骤 3：初始化 VQE 模型 vqe = VQE(circuit_vqe, hamiltonian) print("VQE 模型初始化完成") print(f"\n电路：{vqe.circuit}") print(f"哈密顿量：{type(vqe.hamiltonian).__name__}")

In [ ]:

# 步骤 4：初始化参数并优化
import numpy as np

# 计算参数数量
nparams = 2 * nqubits * nlayers + nqubits

# 随机初始化参数
np.random.seed(42)
initial_params = np.random.uniform(0, 2 * np.pi, nparams)

print(f"参数数量：{nparams}")
print(f"初始参数范围：[{initial_params.min():.2f}, {initial_params.max():.2f}]")

# 步骤 4：初始化参数并优化 import numpy as np # 计算参数数量 nparams = 2 * nqubits * nlayers + nqubits # 随机初始化参数 np.random.seed(42) initial_params = np.random.uniform(0, 2 * np.pi, nparams) print(f"参数数量：{nparams}") print(f"初始参数范围：[{initial_params.min():.2f}, {initial_params.max():.2f}]")

In [ ]:

# 步骤 5：执行优化
# 注意：实际运行可能需要一些时间

# 配置优化器选项
options = {
    "disp": True,      # 显示优化过程
    "maxiter": 100,    # 最大迭代次数
}

# 执行优化（已注释，实际运行时取消注释）
# best_energy, best_params, extra = vqe.minimize(
#     initial_params,
#     method="Powell",  # 优化方法：Powell, BFGS, L-BFGS-B 等
#     options=options
# )

print("VQE 优化（实际运行已注释）")
print("\n预期输出：")
print("- 最优能量（基态能量）")
print("- 最优参数")
print("- 优化历史")

# 步骤 5：执行优化 # 注意：实际运行可能需要一些时间 # 配置优化器选项 options = { "disp": True, # 显示优化过程 "maxiter": 100, # 最大迭代次数 } # 执行优化（已注释，实际运行时取消注释） # best_energy, best_params, extra = vqe.minimize( # initial_params, # method="Powell", # 优化方法：Powell, BFGS, L-BFGS-B 等 # options=options # ) print("VQE 优化（实际运行已注释）") print("\n预期输出：") print("- 最优能量（基态能量）") print("- 最优参数") print("- 优化历史")

VQE 完整运行示例¶

让我们用一个更小的系统来完整演示 VQE。

In [ ]:

# 创建一个简单的 2 量子比特 VQE 示例

# 1. 创建简单电路
circuit_simple = Circuit(2)
circuit_simple.add(gates.RY(0, theta=0))
circuit_simple.add(gates.RY(1, theta=0))
circuit_simple.add(gates.CZ(0, 1))

# 2. 创建哈密顿量
ham_simple = hamiltonians.XXZ(2, delta=0.5)

# 3. 创建 VQE
vqe_simple = VQE(circuit_simple, ham_simple)

# 4. 优化
initial_params_simple = np.random.uniform(0, 2*np.pi, 2)

print("简单 VQE 示例（2 量子比特）")
print(f"参数数量：{len(initial_params_simple)}")
print(f"\n可以运行：")
print("best_energy, best_params, _ = vqe_simple.minimize(initial_params_simple)")

# 创建一个简单的 2 量子比特 VQE 示例 # 1. 创建简单电路 circuit_simple = Circuit(2) circuit_simple.add(gates.RY(0, theta=0)) circuit_simple.add(gates.RY(1, theta=0)) circuit_simple.add(gates.CZ(0, 1)) # 2. 创建哈密顿量 ham_simple = hamiltonians.XXZ(2, delta=0.5) # 3. 创建 VQE vqe_simple = VQE(circuit_simple, ham_simple) # 4. 优化 initial_params_simple = np.random.uniform(0, 2*np.pi, 2) print("简单 VQE 示例（2 量子比特）") print(f"参数数量：{len(initial_params_simple)}") print(f"\n可以运行：") print("best_energy, best_params, _ = vqe_simple.minimize(initial_params_simple)")

QAOA：量子近似优化算法¶

核心思想¶

QAOA 用于解决组合优化问题，如 MaxCut、TSP 等。

哈密顿量形式：

• 问题哈密顿量 $H_P$：编码优化目标
• 混合哈密顿量 $H_M$：驱动量子态探索

QAOA 态： $$ |\beta, \gamma\rangle = \prod_{k=1}^p e^{-i\beta_k H_M} e^{-i\gamma_k H_P} |s\rangle $$

其中：

• $|s\rangle = |+\rangle^{\otimes n}$ 是初始态
• $p$ 是 QAOA 层数（深度）

---

In [ ]:

# QAOA 示例 1：MaxCut 问题

# 步骤 1：创建 MaxCut 哈密顿量
nqubits = 5

# 定义邻接矩阵（图）
adj_matrix = np.array([
    [0, 1, 1, 0, 1],
    [1, 0, 1, 1, 0],
    [1, 1, 0, 1, 1],
    [0, 1, 1, 0, 1],
    [1, 0, 1, 1, 0]
])

ham_maxcut = hamiltonians.MaxCut(nqubits=nqubits, adj_matrix=adj_matrix)

print(f"MaxCut 哈密顿量创建完成")
print(f"节点数：{nqubits}")
print(f"边数：{int(np.sum(adj_matrix) / 2)}")

# QAOA 示例 1：MaxCut 问题 # 步骤 1：创建 MaxCut 哈密顿量 nqubits = 5 # 定义邻接矩阵（图） adj_matrix = np.array([ [0, 1, 1, 0, 1], [1, 0, 1, 1, 0], [1, 1, 0, 1, 1], [0, 1, 1, 0, 1], [1, 0, 1, 1, 0] ]) ham_maxcut = hamiltonians.MaxCut(nqubits=nqubits, adj_matrix=adj_matrix) print(f"MaxCut 哈密顿量创建完成") print(f"节点数：{nqubits}") print(f"边数：{int(np.sum(adj_matrix) / 2)}")

In [ ]:

# 步骤 2：创建 QAOA 模型
nlayers = 2  # QAOA 层数（p）

qaoa = QAOA(ham_maxcut, n_layers=nlayers)

print(f"QAOA 模型创建完成")
print(f"层数：{nlayers}")
print(f"参数数量：{2 * nlayers}")  # 每层有 γ 和 β 两个参数

# 步骤 2：创建 QAOA 模型 nlayers = 2 # QAOA 层数（p） qaoa = QAOA(ham_maxcut, n_layers=nlayers) print(f"QAOA 模型创建完成") print(f"层数：{nlayers}") print(f"参数数量：{2 * nlayers}") # 每层有 γ 和 β 两个参数

In [ ]:

# 步骤 3：初始化参数
np.random.seed(42)
initial_params_qaoa = np.random.uniform(0, 0.1, 2 * nlayers)

print(f"初始参数：{initial_params_qaoa}")
print("\n参数说明：")
print("- 前 p 个参数：γ₁, γ₂, ..., γₚ（问题哈密顿量角度）")
print("- 后 p 个参数：β₁, β₂, ..., βₚ（混合哈密顿量角度）")

# 步骤 3：初始化参数 np.random.seed(42) initial_params_qaoa = np.random.uniform(0, 0.1, 2 * nlayers) print(f"初始参数：{initial_params_qaoa}") print("\n参数说明：") print("- 前 p 个参数：γ₁, γ₂, ..., γₚ（问题哈密顿量角度）") print("- 后 p 个参数：β₁, β₂, ..., βₚ（混合哈密顿量角度）")

In [ ]:

# 步骤 4：执行优化
options = {
    "disp": True,
    "maxiter": 100,
}

# 执行优化（已注释）
# best_energy, best_params, extra = qaoa.minimize(
#     initial_params_qaoa,
#     method="Powell",
#     options=options
# )

print("QAOA 优化（实际运行已注释）")
print("\n预期输出：")
print("- 最优能量（对应 MaxCut 的最大割值）")
print("- 最优参数 [γ₁, γ₂, β₁, β₂]")

# 步骤 4：执行优化 options = { "disp": True, "maxiter": 100, } # 执行优化（已注释） # best_energy, best_params, extra = qaoa.minimize( # initial_params_qaoa, # method="Powell", # options=options # ) print("QAOA 优化（实际运行已注释）") print("\n预期输出：") print("- 最优能量（对应 MaxCut 的最大割值）") print("- 最优参数 [γ₁, γ₂, β₁, β₂]")

In [ ]:

# 步骤 5：分析解
# 假设我们已经得到了最优参数

# 从最优参数获得解
def analyze_qaoa_solution(qaoa, params):
    """
    分析 QAOA 的解
    """
    # 执行电路
    circuit = qaoa.circuit(params)
    result = circuit()
    
    # 获得测量结果
    frequencies = result.frequencies()
    
    # 找到出现次数最多的解
    most_common = frequencies.most_common(5)
    
    return most_common

# 使用示例（假设有最优参数）
# best_params = np.array([0.5, 0.3, 0.2, 0.4])
# solutions = analyze_qaoa_solution(qaoa, best_params)

print("解的分析函数已定义")
print("\n使用方法：")
print("solutions = analyze_qaoa_solution(qaoa, best_params)")

# 步骤 5：分析解 # 假设我们已经得到了最优参数 # 从最优参数获得解 def analyze_qaoa_solution(qaoa, params): """ 分析 QAOA 的解 """ # 执行电路 circuit = qaoa.circuit(params) result = circuit() # 获得测量结果 frequencies = result.frequencies() # 找到出现次数最多的解 most_common = frequencies.most_common(5) return most_common # 使用示例（假设有最优参数） # best_params = np.array([0.5, 0.3, 0.2, 0.4]) # solutions = analyze_qaoa_solution(qaoa, best_params) print("解的分析函数已定义") print("\n使用方法：") print("solutions = analyze_qaoa_solution(qaoa, best_params)")

算法对比与选择¶

VQE vs QAOA¶

In [ ]:

# 创建对比表格
comparison_data = {
    "特性": ["目标", "应用领域", "哈密顿量", "电路结构", "典型深度", "优化难度"],
    "VQE": ["基态能量", "量子化学、凝聚态", "物理哈密顿量", "自定义 Ansatz", "深（10+层）", "中等"],
    "QAOA": ["最优解", "组合优化", "问题哈密顿量", "固定结构（QAOA 层）", "浅（2-5层）", "较低"]
}

import pandas as pd
df = pd.DataFrame(comparison_data)
print("\nVQE vs QAOA 对比：")
print(df.to_string(index=False))

# 创建对比表格 comparison_data = { "特性": ["目标", "应用领域", "哈密顿量", "电路结构", "典型深度", "优化难度"], "VQE": ["基态能量", "量子化学、凝聚态", "物理哈密顿量", "自定义 Ansatz", "深（10+层）", "中等"], "QAOA": ["最优解", "组合优化", "问题哈密顿量", "固定结构（QAOA 层）", "浅（2-5层）", "较低"] } import pandas as pd df = pd.DataFrame(comparison_data) print("\nVQE vs QAOA 对比：") print(df.to_string(index=False))

如何选择？¶

In [ ]:

# 决策树
print("""算法选择指南：

1. 你的问题是什么？
   ├─ 量子化学/材料科学 → VQE
   └─ 组合优化 → QAOA

2. 哈密顿量是什么？
   ├─ 物理系统哈密顿量 → VQE
   └─ 优化问题编码的哈密顿量 → QAOA

3. 量子资源限制？
   ├─ 可以使用深电路 → VQE
   └─ 只能用浅电路 → QAOA

4. 需要精确解还是近似解？
   ├─ 需要高精度 → VQE
   └─ 可以接受近似 → QAOA
""")

# 决策树 print("""算法选择指南： 1. 你的问题是什么？ ├─ 量子化学/材料科学 → VQE └─ 组合优化 → QAOA 2. 哈密顿量是什么？ ├─ 物理系统哈密顿量 → VQE └─ 优化问题编码的哈密顿量 → QAOA 3. 量子资源限制？ ├─ 可以使用深电路 → VQE └─ 只能用浅电路 → QAOA 4. 需要精确解还是近似解？ ├─ 需要高精度 → VQE └─ 可以接受近似 → QAOA """)

实战示例¶

示例 1：VQE 求解分子基态¶

In [ ]:

# VQE 求解 H2 分子的基态能量（简化模型）

# 使用简化的哈密顿量（实际分子需要更复杂的模型）
nqubits = 2

# 创建电路（模拟分子轨道）
circuit_h2 = Circuit(nqubits)
circuit_h2.add(gates.RY(0, theta=0))
circuit_h2.add(gates.RY(1, theta=0))
circuit_h2.add(gates.CNOT(0, 1))
circuit_h2.add(gates.RY(1, theta=0))

# 创建哈密顿量（简化版）
# H = g0*I + g1*Z0 + g2*Z1 + g3*Z0Z1 + g4*X0X1 + g5*Y0Y1
# 这里使用 XXZ 作为近似
ham_h2 = hamiltonians.XXZ(nqubits, delta=1.0)

# 创建 VQE
vqe_h2 = VQE(circuit_h2, ham_h2)

print("H2 分子 VQE 模型创建完成")
print("\n注意：这是一个简化示例")
print("实际分子基态计算需要：")
print("1. Jordan-Wigner 或 Bravyi-Kitaev 变换")
print("2. 更精确的哈密顿量")
print("3. 更深的 Ansatz 电路")

# VQE 求解 H2 分子的基态能量（简化模型） # 使用简化的哈密顿量（实际分子需要更复杂的模型） nqubits = 2 # 创建电路（模拟分子轨道） circuit_h2 = Circuit(nqubits) circuit_h2.add(gates.RY(0, theta=0)) circuit_h2.add(gates.RY(1, theta=0)) circuit_h2.add(gates.CNOT(0, 1)) circuit_h2.add(gates.RY(1, theta=0)) # 创建哈密顿量（简化版） # H = g0*I + g1*Z0 + g2*Z1 + g3*Z0Z1 + g4*X0X1 + g5*Y0Y1 # 这里使用 XXZ 作为近似 ham_h2 = hamiltonians.XXZ(nqubits, delta=1.0) # 创建 VQE vqe_h2 = VQE(circuit_h2, ham_h2) print("H2 分子 VQE 模型创建完成") print("\n注意：这是一个简化示例") print("实际分子基态计算需要：") print("1. Jordan-Wigner 或 Bravyi-Kitaev 变换") print("2. 更精确的哈密顿量") print("3. 更深的 Ansatz 电路")

示例 2：QAOA 求解 MaxCut¶

In [ ]:

# 完整的 MaxCut QAOA 示例

def solve_maxcut_with_qaoa(adj_matrix, nlayers=2):
    """
    使用 QAOA 求解 MaxCut 问题
    
    参数:
        adj_matrix: 图的邻接矩阵
        nlayers: QAOA 层数
    """
    nqubits = adj_matrix.shape[0]
    
    # 1. 创建哈密顿量
    ham = hamiltonians.MaxCut(nqubits=nqubits, adj_matrix=adj_matrix, dense=False)
    
    # 2. 创建 QAOA
    qaoa = QAOA(ham, n_layers=nlayers)
    
    # 3. 初始化参数
    np.random.seed(42)
    initial_params = np.random.uniform(0, 0.1, 2 * nlayers)
    
    # 4. 优化
    # best_energy, best_params, _ = qaoa.minimize(initial_params, method="Powell")
    
    # 5. 分析解
    # most_common = analyze_qaoa_solution(qaoa, best_params)
    
    return qaoa

# 测试图
test_adj = np.array([
    [0, 1, 1, 0],
    [1, 0, 1, 1],
    [1, 1, 0, 1],
    [0, 1, 1, 0]
])

qaoa_model = solve_maxcut_with_qaoa(test_adj, nlayers=2)

print(f"MaxCut QAOA 模型创建完成")
print(f"\n可以运行：")
print("best_energy, best_params, _ = qaoa_model.minimize(initial_params)")

# 完整的 MaxCut QAOA 示例 def solve_maxcut_with_qaoa(adj_matrix, nlayers=2): """ 使用 QAOA 求解 MaxCut 问题 参数: adj_matrix: 图的邻接矩阵 nlayers: QAOA 层数 """ nqubits = adj_matrix.shape[0] # 1. 创建哈密顿量 ham = hamiltonians.MaxCut(nqubits=nqubits, adj_matrix=adj_matrix, dense=False) # 2. 创建 QAOA qaoa = QAOA(ham, n_layers=nlayers) # 3. 初始化参数 np.random.seed(42) initial_params = np.random.uniform(0, 0.1, 2 * nlayers) # 4. 优化 # best_energy, best_params, _ = qaoa.minimize(initial_params, method="Powell") # 5. 分析解 # most_common = analyze_qaoa_solution(qaoa, best_params) return qaoa # 测试图 test_adj = np.array([ [0, 1, 1, 0], [1, 0, 1, 1], [1, 1, 0, 1], [0, 1, 1, 0] ]) qaoa_model = solve_maxcut_with_qaoa(test_adj, nlayers=2) print(f"MaxCut QAOA 模型创建完成") print(f"\n可以运行：") print("best_energy, best_params, _ = qaoa_model.minimize(initial_params)")

练习题¶

练习 1：VQE 基础¶

使用 VQE 计算 3 量子比特 TFIM 模型的基态能量（h=1.0）。

练习 2：QAOA MaxCut¶

使用 QAOA 求解一个 4 节点的完全图的 MaxCut 问题。

练习 3：QAOA 深度影响¶

研究 QAOA 层数（p=1, 2, 3）对 MaxCut 解质量的影响。

In [ ]:

# 练习 1 的框架
def exercise_vqe():
    """
    VQE 练习：计算 TFIM 基态能量
    """
    nqubits = 3
    h_field = 1.0
    
    # TODO: 创建 VQE 电路
    # circuit = create_vqe_circuit(nqubits, nlayers=2)
    
    # TODO: 创建 TFIM 哈密顿量
    # hamiltonian = hamiltonians.TFIM(nqubits, h=h_field)
    
    # TODO: 创建并优化 VQE
    # vqe = VQE(circuit, hamiltonian)
    # best_energy, best_params, _ = vqe.minimize(initial_params)
    
    print(f"TFIM 基态能量计算")
    print(f"量子比特数：{nqubits}")
    print(f"横向场强度：{h_field}")

exercise_vqe()

# 练习 1 的框架 def exercise_vqe(): """ VQE 练习：计算 TFIM 基态能量 """ nqubits = 3 h_field = 1.0 # TODO: 创建 VQE 电路 # circuit = create_vqe_circuit(nqubits, nlayers=2) # TODO: 创建 TFIM 哈密顿量 # hamiltonian = hamiltonians.TFIM(nqubits, h=h_field) # TODO: 创建并优化 VQE # vqe = VQE(circuit, hamiltonian) # best_energy, best_params, _ = vqe.minimize(initial_params) print(f"TFIM 基态能量计算") print(f"量子比特数：{nqubits}") print(f"横向场强度：{h_field}") exercise_vqe()

In [ ]:

# 练习 2 的框架
def exercise_qaoa_maxcut():
    """
    QAOA 练习：4 节点完全图 MaxCut
    """
    nqubits = 4
    
    # 创建完全图的邻接矩阵
    adj_matrix = np.ones((nqubits, nqubits)) - np.eye(nqubits)
    
    # TODO: 创建 QAOA
    # qaoa = QAOA(hamiltonians.MaxCut(nqubits, adj_matrix=adj_matrix))
    
    # TODO: 优化并分析
    # best_energy, best_params, _ = qaoa.minimize(initial_params)
    
    print(f"4 节点完全图 MaxCut")
    print(f"理论最优割值：{(nqubits**2 - nqubits) // 2}")  # 完全图的最大割

exercise_qaoa_maxcut()

# 练习 2 的框架 def exercise_qaoa_maxcut(): """ QAOA 练习：4 节点完全图 MaxCut """ nqubits = 4 # 创建完全图的邻接矩阵 adj_matrix = np.ones((nqubits, nqubits)) - np.eye(nqubits) # TODO: 创建 QAOA # qaoa = QAOA(hamiltonians.MaxCut(nqubits, adj_matrix=adj_matrix)) # TODO: 优化并分析 # best_energy, best_params, _ = qaoa.minimize(initial_params) print(f"4 节点完全图 MaxCut") print(f"理论最优割值：{(nqubits**2 - nqubits) // 2}") # 完全图的最大割 exercise_qaoa_maxcut()

总结¶

关键要点¶

1. VQE 核心要素：

   • 参数化电路（Ansatz）
   • 物理哈密顿量
   • 经典优化器
   • 目标：最小化期望值

2. QAOA 核心要素：

   • 固定电路结构（QAOA 层）
   • 问题哈密顿量 + 混合哈哈密顿量
   • 层数参数 p
   • 目标：寻找最优解

3. 优化方法：

   • Powell（无梯度）
   • BFGS/L-BFGS-B（拟牛顿）
   • CMA-ES（进化算法）

4. 应用场景：

   • VQE：量子化学、凝聚态物理
   • QAOA：组合优化、MaxCut、TSP

下一步学习¶

• 量子机器学习：量子分类器（教程 04）
• 量子优化：QAP、MVC（教程 05）
• 绝热演化：绝热量子计算（教程 06）

参考资源¶

• Qibo 示例：examples/benchmarks/vqe.py, examples/benchmarks/qaoa.py
• VQE 原论文：Peruzzo et al. (2014)
• QAOA 原论文：Farhi et al. (2014)

---

恭喜！ 你已经掌握了 VQE 和 QAOA 的基本用法。

继续探索量子算法的精彩世界吧！🚀