VQE 求解 XY 模型¶
本 notebook 使用 DeepQuantum 实现变分量子本征求解器（VQE），求解 XY 模型的基态能量和物理性质。
XY 模型简介¶
XY 模型是量子多体物理中的重要模型，其哈密顿量为：
$$H = -J \sum_{\langle i,j \rangle} (X_i X_j + Y_i Y_j)$$
其中：
- $X_i X_j$ 和 $Y_i Y_j$：平面内自旋相互作用（横向相互作用）
- $J$：耦合强度（$J>0$ 为铁磁，$J<0$ 为反铁磁）
- $\langle i,j \rangle$：最近邻或长程相互作用
与 Heisenberg 模型的关系¶
一般的 XXZ Heisenberg 模型： $$H_{\text{Heisenberg}} = -J \sum_{\langle i,j \rangle} (X_i X_j + Y_i Y_j + \Delta Z_i Z_j)$$
XY 模型是 Heisenberg 模型在 $\Delta = 0$ 时的特殊情况。
物理意义¶
- U(1) 对称性：总 $S^z$ 守恒（绕 Z 轴旋转不变）
- 拓扑相：低维 XY 模型展示 Berezinskii-Kosterlitz-Thouless (BKT) 相变
- 平面内超流：用于描述量子磁性和超导系统
- 离子阱实现：可以在离子阱量子计算机上实验实现
参考资源¶
In [1]:
Copied!
# ========================================
# 1. 导入必要的库
# ========================================
import numpy as np
import torch
import matplotlib.pyplot as plt
from scipy.linalg import eigh
# DeepQuantum
import deepquantum as dq
from deepquantum import Observable
# 设置随机种子
np.random.seed(42)
torch.manual_seed(42)
print("✅ 库导入成功！")
print(f"DeepQuantum 版本可用")
print(f"PyTorch 版本: {torch.__version__}")
# ========================================
# 1. 导入必要的库
# ========================================
import numpy as np
import torch
import matplotlib.pyplot as plt
from scipy.linalg import eigh
# DeepQuantum
import deepquantum as dq
from deepquantum import Observable
# 设置随机种子
np.random.seed(42)
torch.manual_seed(42)
print("✅ 库导入成功！")
print(f"DeepQuantum 版本可用")
print(f"PyTorch 版本: {torch.__version__}")
✅ 库导入成功！ DeepQuantum 版本可用 PyTorch 版本: 2.9.1+cpu
2. 定义 XY 模型类¶
In [2]:
Copied!
class XYModel:
"""
XY 模型
哈密顿量: H = -J * Σ (X_i X_j + Y_i Y_j)
这是 Heisenberg XXZ 模型在 Δ=0 时的特殊情况
"""
def __init__(self, n_qubits, J=1.0, delta=0.0):
"""
初始化 XY 模型
参数:
- n_qubits: 量子比特数
- J: 耦合强度（默认 1.0）
- delta: 各向异性参数（XY 模型为 0）
"""
self.n_qubits = n_qubits
self.J = J
self.delta = delta # 用于对比 Heisenberg 模型
def build_hamiltonian_matrix(self):
"""
构建完整的哈密顿量矩阵（用于精确对角化）
返回:
- 2^n x 2^n 的哈密顿量矩阵
"""
# Pauli 矩阵
X = np.array([[0, 1], [1, 0]])
Y = np.array([[0, -1j], [1j, 0]])
Z = np.array([[1, 0], [0, -1]])
I2 = np.eye(2)
# 初始化哈密顿量
H = np.zeros((2**self.n_qubits, 2**self.n_qubits), dtype=complex)
# 构建 XX 和 YY 相互作用项: -J * Σ (X_i X_j + Y_i Y_j)
for i in range(self.n_qubits - 1):
# XX 项
op_list = [I2] * self.n_qubits
op_list[i] = X
op_list[i + 1] = X
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * op
# YY 项
op_list = [I2] * self.n_qubits
op_list[i] = Y
op_list[i + 1] = Y
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * op
# ZZ 项（仅当 delta ≠ 0 时，用于对比）
if self.delta != 0:
op_list = [I2] * self.n_qubits
op_list[i] = Z
op_list[i + 1] = Z
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * self.delta * op
return H.real # XY 模型的哈密顿量是实矩阵
def get_exact_ground_state_energy(self):
"""
通过精确对角化计算基态能量
返回:
- 基态能量
- 基态波函数
"""
H = self.build_hamiltonian_matrix()
# 对角化
eigenvalues, eigenvectors = eigh(H)
# 基态是最小本征值
ground_state_idx = np.argmin(eigenvalues)
return eigenvalues[ground_state_idx], eigenvectors[:, ground_state_idx]
def build_observable_list(self):
"""
构建 DeepQuantum Observable 列表
返回:
- observable_list: [(coefficient, Observable), ...]
"""
observable_list = []
# XX 相互作用项: -J * Σ X_i X_{i+1}
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i+1],
basis='xx'
)
observable_list.append((-self.J, obs))
# YY 相互作用项: -J * Σ Y_i Y_{i+1}
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i+1],
basis='yy'
)
observable_list.append((-self.J, obs))
# ZZ 项（仅当 delta ≠ 0 时）
if self.delta != 0:
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i+1],
basis='zz'
)
observable_list.append((-self.J * self.delta, obs))
return observable_list
# 测试 XY 模型
print("测试 XY 模型...")
print("=" * 50)
# 创建 4 量子比特的 XY 模型
model = XYModel(n_qubits=4, J=1.0, delta=0.0)
print(f"模型参数：")
print(f" 量子比特数: {model.n_qubits}")
print(f" 耦合强度 J: {model.J}")
print(f" 各向异性参数 Δ: {model.delta} (XY 模型)")
# 计算精确基态能量
exact_energy, exact_state = model.get_exact_ground_state_energy()
print(f"\n精确对角化结果：")
print(f" 基态能量: {exact_energy:.6f}")
print(f" 基态维度: {exact_state.shape}")
# 构建 Observable 列表
observable_list = model.build_observable_list()
print(f"\nVQE Observable 数量: {len(observable_list)}")
print(" 观测项类型：")
for i, (coeff, obs) in enumerate(observable_list[:7]):
print(f" {i+1}. 系数={coeff:+.2f}, wires={obs.wires}, basis={obs.basis}")
class XYModel:
"""
XY 模型
哈密顿量: H = -J * Σ (X_i X_j + Y_i Y_j)
这是 Heisenberg XXZ 模型在 Δ=0 时的特殊情况
"""
def __init__(self, n_qubits, J=1.0, delta=0.0):
"""
初始化 XY 模型
参数:
- n_qubits: 量子比特数
- J: 耦合强度（默认 1.0）
- delta: 各向异性参数（XY 模型为 0）
"""
self.n_qubits = n_qubits
self.J = J
self.delta = delta # 用于对比 Heisenberg 模型
def build_hamiltonian_matrix(self):
"""
构建完整的哈密顿量矩阵（用于精确对角化）
返回:
- 2^n x 2^n 的哈密顿量矩阵
"""
# Pauli 矩阵
X = np.array([[0, 1], [1, 0]])
Y = np.array([[0, -1j], [1j, 0]])
Z = np.array([[1, 0], [0, -1]])
I2 = np.eye(2)
# 初始化哈密顿量
H = np.zeros((2**self.n_qubits, 2**self.n_qubits), dtype=complex)
# 构建 XX 和 YY 相互作用项: -J * Σ (X_i X_j + Y_i Y_j)
for i in range(self.n_qubits - 1):
# XX 项
op_list = [I2] * self.n_qubits
op_list[i] = X
op_list[i + 1] = X
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * op
# YY 项
op_list = [I2] * self.n_qubits
op_list[i] = Y
op_list[i + 1] = Y
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * op
# ZZ 项（仅当 delta ≠ 0 时，用于对比）
if self.delta != 0:
op_list = [I2] * self.n_qubits
op_list[i] = Z
op_list[i + 1] = Z
op = op_list[0]
for j in range(1, len(op_list)):
op = np.kron(op, op_list[j])
H -= self.J * self.delta * op
return H.real # XY 模型的哈密顿量是实矩阵
def get_exact_ground_state_energy(self):
"""
通过精确对角化计算基态能量
返回:
- 基态能量
- 基态波函数
"""
H = self.build_hamiltonian_matrix()
# 对角化
eigenvalues, eigenvectors = eigh(H)
# 基态是最小本征值
ground_state_idx = np.argmin(eigenvalues)
return eigenvalues[ground_state_idx], eigenvectors[:, ground_state_idx]
def build_observable_list(self):
"""
构建 DeepQuantum Observable 列表
返回:
- observable_list: [(coefficient, Observable), ...]
"""
observable_list = []
# XX 相互作用项: -J * Σ X_i X_{i+1}
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i+1],
basis='xx'
)
observable_list.append((-self.J, obs))
# YY 相互作用项: -J * Σ Y_i Y_{i+1}
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i+1],
basis='yy'
)
observable_list.append((-self.J, obs))
# ZZ 项（仅当 delta ≠ 0 时）
if self.delta != 0:
for i in range(self.n_qubits - 1):
obs = Observable(
nqubit=self.n_qubits,
wires=[i, i+1],
basis='zz'
)
observable_list.append((-self.J * self.delta, obs))
return observable_list
# 测试 XY 模型
print("测试 XY 模型...")
print("=" * 50)
# 创建 4 量子比特的 XY 模型
model = XYModel(n_qubits=4, J=1.0, delta=0.0)
print(f"模型参数：")
print(f" 量子比特数: {model.n_qubits}")
print(f" 耦合强度 J: {model.J}")
print(f" 各向异性参数 Δ: {model.delta} (XY 模型)")
# 计算精确基态能量
exact_energy, exact_state = model.get_exact_ground_state_energy()
print(f"\n精确对角化结果：")
print(f" 基态能量: {exact_energy:.6f}")
print(f" 基态维度: {exact_state.shape}")
# 构建 Observable 列表
observable_list = model.build_observable_list()
print(f"\nVQE Observable 数量: {len(observable_list)}")
print(" 观测项类型：")
for i, (coeff, obs) in enumerate(observable_list[:7]):
print(f" {i+1}. 系数={coeff:+.2f}, wires={obs.wires}, basis={obs.basis}")
测试 XY 模型...
==================================================
模型参数：
量子比特数: 4
耦合强度 J: 1.0
各向异性参数 Δ: 0.0 (XY 模型)
精确对角化结果：
基态能量: -4.472136
基态维度: (16,)
VQE Observable 数量: 6
观测项类型：
1. 系数=-1.00, wires=[[0], [1]], basis=xx
2. 系数=-1.00, wires=[[1], [2]], basis=xx
3. 系数=-1.00, wires=[[2], [3]], basis=xx
4. 系数=-1.00, wires=[[0], [1]], basis=yy
5. 系数=-1.00, wires=[[1], [2]], basis=yy
6. 系数=-1.00, wires=[[2], [3]], basis=yy
In [3]:
Copied!
observable_list[:1]
observable_list[:1]
Out[3]:
[(-1.0,
Observable(
(gates): Sequential(
(0): PauliX(wires=[0])
(1): PauliX(wires=[1])
)
))]
3. 定义硬件高效 Ansatz¶
利用 U(1) 对称性（总 $S^z$ 守恒），我们可以设计更高效的 Ansatz。
In [4]:
Copied!
def hardware_efficient_ansatz(qc, params, n_qubits, layers=1):
"""
硬件高效的 Ansatz（针对 XY 模型优化）
⚠️ 修复版：添加 RX 旋转和 CX 门，提高表达能力
改进：
1. 旋转层：RX + RY + RZ（完整的单量子比特覆盖）
2. 纠缠层：CX 代替 CZ（更通用的纠缠）
参数:
- qc: DeepQuantum 电路
- params: 参数数组
- n_qubits: 量子比特数
- layers: 层数
"""
param_idx = 0
n_params_per_layer = 3 * n_qubits # ✅ RX + RY + RZ for each qubit (修复前是 2)
n_params = n_params_per_layer * layers
if len(params) != n_params:
raise ValueError(f"需要 {n_params} 个参数，得到 {len(params)}")
# 构建多层
for layer in range(layers):
# ✅ 旋转层：RX + RY + RZ (完整的 X-Y-Z 覆盖)
for q in range(n_qubits):
qc.rx(q, params[param_idx]) # ✅ 添加 RX (关键修复！)
param_idx += 1
qc.ry(q, params[param_idx])
param_idx += 1
qc.rz(q, params[param_idx])
param_idx += 1
# ✅ 纠缠层：CX 线性链 (替代 CZ，更通用)
for q in range(n_qubits - 1):
qc.cx(q, q + 1) # ✅ 使用 CX (关键修复！)
# 添加反向纠缠以增加表达能力
for q in range(n_qubits - 2, -1, -1):
qc.cx(q, q + 1)
return qc
# 测试改进的 Ansatz
print("测试改进的 Ansatz 构建...\n")
n_qubits = 4
layers = 2
n_params = 3 * n_qubits * layers # ✅ 修改为 3 (修复前是 2)
params_test = np.random.uniform(-0.1, 0.1, n_params) # ✅ 小范围初始化
qc_test = dq.QubitCircuit(n_qubits)
qc_test = hardware_efficient_ansatz(qc_test, params_test, n_qubits, layers)
state_test = qc_test()
print(f"✅ 改进的 Ansatz 测试成功！")
print(f" 量子比特: {n_qubits}")
print(f" 层数: {layers}")
print(f" 参数数量: {n_params} (修改前: {2 * n_qubits * layers})")
print(f" 状态形状: {state_test.shape}")
print(f" 状态归一化: {torch.norm(state_test):.6f}")
print(f"\n改进点:")
print(f" 1. ✅ 添加 RX 旋转 (探索 X 基)")
print(f" 2. ✅ 使用 CX 门 (更通用的纠缠)")
print(f" 3. ✅ 完整的 RX+RY+RZ 覆盖")
def hardware_efficient_ansatz(qc, params, n_qubits, layers=1):
"""
硬件高效的 Ansatz（针对 XY 模型优化）
⚠️ 修复版：添加 RX 旋转和 CX 门，提高表达能力
改进：
1. 旋转层：RX + RY + RZ（完整的单量子比特覆盖）
2. 纠缠层：CX 代替 CZ（更通用的纠缠）
参数:
- qc: DeepQuantum 电路
- params: 参数数组
- n_qubits: 量子比特数
- layers: 层数
"""
param_idx = 0
n_params_per_layer = 3 * n_qubits # ✅ RX + RY + RZ for each qubit (修复前是 2)
n_params = n_params_per_layer * layers
if len(params) != n_params:
raise ValueError(f"需要 {n_params} 个参数，得到 {len(params)}")
# 构建多层
for layer in range(layers):
# ✅ 旋转层：RX + RY + RZ (完整的 X-Y-Z 覆盖)
for q in range(n_qubits):
qc.rx(q, params[param_idx]) # ✅ 添加 RX (关键修复！)
param_idx += 1
qc.ry(q, params[param_idx])
param_idx += 1
qc.rz(q, params[param_idx])
param_idx += 1
# ✅ 纠缠层：CX 线性链 (替代 CZ，更通用)
for q in range(n_qubits - 1):
qc.cx(q, q + 1) # ✅ 使用 CX (关键修复！)
# 添加反向纠缠以增加表达能力
for q in range(n_qubits - 2, -1, -1):
qc.cx(q, q + 1)
return qc
# 测试改进的 Ansatz
print("测试改进的 Ansatz 构建...\n")
n_qubits = 4
layers = 2
n_params = 3 * n_qubits * layers # ✅ 修改为 3 (修复前是 2)
params_test = np.random.uniform(-0.1, 0.1, n_params) # ✅ 小范围初始化
qc_test = dq.QubitCircuit(n_qubits)
qc_test = hardware_efficient_ansatz(qc_test, params_test, n_qubits, layers)
state_test = qc_test()
print(f"✅ 改进的 Ansatz 测试成功！")
print(f" 量子比特: {n_qubits}")
print(f" 层数: {layers}")
print(f" 参数数量: {n_params} (修改前: {2 * n_qubits * layers})")
print(f" 状态形状: {state_test.shape}")
print(f" 状态归一化: {torch.norm(state_test):.6f}")
print(f"\n改进点:")
print(f" 1. ✅ 添加 RX 旋转 (探索 X 基)")
print(f" 2. ✅ 使用 CX 门 (更通用的纠缠)")
print(f" 3. ✅ 完整的 RX+RY+RZ 覆盖")
测试改进的 Ansatz 构建... ✅ 改进的 Ansatz 测试成功！ 量子比特: 4 层数: 2 参数数量: 24 (修改前: 16) 状态形状: torch.Size([16, 1]) 状态归一化: 1.000000 改进点: 1. ✅ 添加 RX 旋转 (探索 X 基) 2. ✅ 使用 CX 门 (更通用的纠缠) 3. ✅ 完整的 RX+RY+RZ 覆盖
4. 定义能量计算和优化函数¶
In [ ]:
Copied!
def calculate_energy(state, observable_list):
"""
计算给定量子态的能量期望值
⚠️ 修复版：确保状态是正确的 torch.Tensor 类型 (complex64)
参数:
- state: 量子态向量 (torch.Tensor 或 numpy.ndarray)
- observable_list: 观测项列表 [(coeff, Observable), ...]
返回:
- 能量期望值
"""
energy = 0.0
# ✅ 修复：确保状态是 torch.Tensor 类型 (使用 complex64 匹配 DeepQuantum)
if isinstance(state, np.ndarray):
state = torch.from_numpy(state.astype(np.complex64))
elif not isinstance(state, torch.Tensor):
state = torch.tensor(state, dtype=torch.complex64)
# ✅ 修复：确保状态是列向量 (2^n, 1)
if state.ndim == 1:
state = state.unsqueeze(-1)
for coeff, obs in observable_list:
# 计算期望值
exp_val = dq.expectation(state, obs).item()
energy += coeff * exp_val
return energy
def calculate_energy_from_circuit(qc, observable_list):
"""
从量子电路计算能量
"""
state = qc()
return calculate_energy(state, observable_list)
# 测试能量计算
print("测试能量计算...\n")
test_energy = calculate_energy_from_circuit(qc_test, observable_list)
print(f"测试能量: {test_energy:.6f}")
print(f"精确能量: {exact_energy:.6f}")
print(f"能量差: {abs(test_energy - exact_energy):.6f}")
# ✅ 新增：验证状态类型
state_test = qc_test()
print(f"\n状态类型验证:")
print(f" 状态类型: {type(state_test)}")
print(f" 状态形状: {state_test.shape}")
print(f" 状态数据类型: {state_test.dtype}")
print(f" 状态归一化: {torch.norm(state_test):.6f}")
def calculate_energy(state, observable_list):
"""
计算给定量子态的能量期望值
⚠️ 修复版：确保状态是正确的 torch.Tensor 类型 (complex64)
参数:
- state: 量子态向量 (torch.Tensor 或 numpy.ndarray)
- observable_list: 观测项列表 [(coeff, Observable), ...]
返回:
- 能量期望值
"""
energy = 0.0
# ✅ 修复：确保状态是 torch.Tensor 类型 (使用 complex64 匹配 DeepQuantum)
if isinstance(state, np.ndarray):
state = torch.from_numpy(state.astype(np.complex64))
elif not isinstance(state, torch.Tensor):
state = torch.tensor(state, dtype=torch.complex64)
# ✅ 修复：确保状态是列向量 (2^n, 1)
if state.ndim == 1:
state = state.unsqueeze(-1)
for coeff, obs in observable_list:
# 计算期望值
exp_val = dq.expectation(state, obs).item()
energy += coeff * exp_val
return energy
def calculate_energy_from_circuit(qc, observable_list):
"""
从量子电路计算能量
"""
state = qc()
return calculate_energy(state, observable_list)
# 测试能量计算
print("测试能量计算...\n")
test_energy = calculate_energy_from_circuit(qc_test, observable_list)
print(f"测试能量: {test_energy:.6f}")
print(f"精确能量: {exact_energy:.6f}")
print(f"能量差: {abs(test_energy - exact_energy):.6f}")
# ✅ 新增：验证状态类型
state_test = qc_test()
print(f"\n状态类型验证:")
print(f" 状态类型: {type(state_test)}")
print(f" 状态形状: {state_test.shape}")
print(f" 状态数据类型: {state_test.dtype}")
print(f" 状态归一化: {torch.norm(state_test):.6f}")
In [6]:
Copied!
def vqe_optimization(model, n_layers, learning_rate=0.05, max_iter=200, verbose=True):
"""
⚠️ 修复版：VQE 优化循环
改进：
1. 降低学习率 (0.05 代替 0.1)
2. 增加迭代次数 (200 代替 100)
3. 小范围参数初始化 (-0.1 到 0.1)
4. 更小的梯度步长 (0.005 代替 0.01)
5. 使用改进的 ansatz (RX+RY+RZ+CX)
参数:
- model: XY 模型
- n_layers: Ansatz 层数
- learning_rate: 学习率 (默认 0.05)
- max_iter: 最大迭代次数 (默认 200)
- verbose: 是否打印进度
返回:
- loss_history: 能量历史
- final_params: 最优参数
"""
n_qubits = model.n_qubits
n_params = 3 * n_qubits * n_layers # ✅ 修改为 3 (RX+RY+RZ)
# ✅ 改进：小范围参数初始化
params = np.random.uniform(-0.1, 0.1, n_params)
# 获取 Observable 列表
observable_list = model.build_observable_list()
# 获取精确能量作为参考
exact_energy, _ = model.get_exact_ground_state_energy()
loss_history = []
if verbose:
print(f"\n✅ 改进的 VQE 优化（针对 XY 模型）")
print(f"=" * 50)
print(f" 量子比特: {n_qubits}")
print(f" 层数: {n_layers}")
print(f" 参数数量: {n_params} (RX+RY+RZ)")
print(f" 学习率: {learning_rate} (改进: 降低)")
print(f" 最大迭代: {max_iter} (改进: 增加)")
print(f"\n 精确基态能量: {exact_energy:.6f}")
print(f"\n{'迭代':>6s} | {'VQE能量':>12s} | {'误差':>12s} | {'改进':>10s}")
print("-" * 48)
for i in range(max_iter):
# 构建电路并计算能量
qc = dq.QubitCircuit(n_qubits)
qc = hardware_efficient_ansatz(qc, params, n_qubits, n_layers)
current_energy = calculate_energy_from_circuit(qc, observable_list)
loss_history.append(current_energy)
# ✅ 改进：更小的梯度步长
grad = np.zeros_like(params)
eps = 0.005 # 修改前是 0.01
for j in range(len(params)):
params_plus = params.copy()
params_plus[j] += eps
qc_plus = dq.QubitCircuit(n_qubits)
qc_plus = hardware_efficient_ansatz(qc_plus, params_plus, n_qubits, n_layers)
energy_plus = calculate_energy_from_circuit(qc_plus, observable_list)
params_minus = params.copy()
params_minus[j] -= eps
qc_minus = dq.QubitCircuit(n_qubits)
qc_minus = hardware_efficient_ansatz(qc_minus, params_minus, n_qubits, n_layers)
energy_minus = calculate_energy_from_circuit(qc_minus, observable_list)
grad[j] = (energy_plus - energy_minus) / (2 * eps)
# 更新参数
params = params - learning_rate * grad
# 打印进度
if verbose and (i % 20 == 0 or i == max_iter - 1):
error = abs(current_energy - exact_energy)
improvement = exact_energy - current_energy
print(f"{i:>6d} | {current_energy:>12.6f} | {error:>12.6f} | {improvement:>10.6f}")
return loss_history, params
def vqe_optimization(model, n_layers, learning_rate=0.05, max_iter=200, verbose=True):
"""
⚠️ 修复版：VQE 优化循环
改进：
1. 降低学习率 (0.05 代替 0.1)
2. 增加迭代次数 (200 代替 100)
3. 小范围参数初始化 (-0.1 到 0.1)
4. 更小的梯度步长 (0.005 代替 0.01)
5. 使用改进的 ansatz (RX+RY+RZ+CX)
参数:
- model: XY 模型
- n_layers: Ansatz 层数
- learning_rate: 学习率 (默认 0.05)
- max_iter: 最大迭代次数 (默认 200)
- verbose: 是否打印进度
返回:
- loss_history: 能量历史
- final_params: 最优参数
"""
n_qubits = model.n_qubits
n_params = 3 * n_qubits * n_layers # ✅ 修改为 3 (RX+RY+RZ)
# ✅ 改进：小范围参数初始化
params = np.random.uniform(-0.1, 0.1, n_params)
# 获取 Observable 列表
observable_list = model.build_observable_list()
# 获取精确能量作为参考
exact_energy, _ = model.get_exact_ground_state_energy()
loss_history = []
if verbose:
print(f"\n✅ 改进的 VQE 优化（针对 XY 模型）")
print(f"=" * 50)
print(f" 量子比特: {n_qubits}")
print(f" 层数: {n_layers}")
print(f" 参数数量: {n_params} (RX+RY+RZ)")
print(f" 学习率: {learning_rate} (改进: 降低)")
print(f" 最大迭代: {max_iter} (改进: 增加)")
print(f"\n 精确基态能量: {exact_energy:.6f}")
print(f"\n{'迭代':>6s} | {'VQE能量':>12s} | {'误差':>12s} | {'改进':>10s}")
print("-" * 48)
for i in range(max_iter):
# 构建电路并计算能量
qc = dq.QubitCircuit(n_qubits)
qc = hardware_efficient_ansatz(qc, params, n_qubits, n_layers)
current_energy = calculate_energy_from_circuit(qc, observable_list)
loss_history.append(current_energy)
# ✅ 改进：更小的梯度步长
grad = np.zeros_like(params)
eps = 0.005 # 修改前是 0.01
for j in range(len(params)):
params_plus = params.copy()
params_plus[j] += eps
qc_plus = dq.QubitCircuit(n_qubits)
qc_plus = hardware_efficient_ansatz(qc_plus, params_plus, n_qubits, n_layers)
energy_plus = calculate_energy_from_circuit(qc_plus, observable_list)
params_minus = params.copy()
params_minus[j] -= eps
qc_minus = dq.QubitCircuit(n_qubits)
qc_minus = hardware_efficient_ansatz(qc_minus, params_minus, n_qubits, n_layers)
energy_minus = calculate_energy_from_circuit(qc_minus, observable_list)
grad[j] = (energy_plus - energy_minus) / (2 * eps)
# 更新参数
params = params - learning_rate * grad
# 打印进度
if verbose and (i % 20 == 0 or i == max_iter - 1):
error = abs(current_energy - exact_energy)
improvement = exact_energy - current_energy
print(f"{i:>6d} | {current_energy:>12.6f} | {error:>12.6f} | {improvement:>10.6f}")
return loss_history, params
5. 数值示例：4 量子比特 XY 链¶
In [7]:
Copied!
# ========================================
# VQE 优化示例：4 量子比特 XY 模型
# ========================================
print("\n" + "=" * 70)
print("示例：XY 模型 (4 量子比特)")
print("=" * 70)
# 创建 XY 模型
model_xy = XYModel(n_qubits=4, J=1.2, delta=0.0)
# 运行 VQE
loss_history_xy, final_params_xy = vqe_optimization(
model=model_xy,
n_layers=3,
learning_rate=0.1,
max_iter=100,
verbose=True
)
# 结果总结
exact_energy_xy, _ = model_xy.get_exact_ground_state_energy()
vqe_energy_xy = loss_history_xy[-1]
error_xy = abs(vqe_energy_xy - exact_energy_xy)
print(f"\n" + "=" * 70)
print("结果总结")
print("=" * 70)
print(f"VQE 能量: {vqe_energy_xy:.6f}")
print(f"精确能量: {exact_energy_xy:.6f}")
print(f"绝对误差: {error_xy:.6f}")
print(f"相对误差: {error_xy / abs(exact_energy_xy) * 100:.4f}%")
if error_xy < 0.01:
print("\n✅ 优秀！VQE 成功找到基态能量！")
elif error_xy < 0.1:
print("\n✓ 良好！接近基态能量。")
else:
print("\n⚠ 需要更多优化（增加层数或迭代次数）")
# ========================================
# VQE 优化示例：4 量子比特 XY 模型
# ========================================
print("\n" + "=" * 70)
print("示例：XY 模型 (4 量子比特)")
print("=" * 70)
# 创建 XY 模型
model_xy = XYModel(n_qubits=4, J=1.2, delta=0.0)
# 运行 VQE
loss_history_xy, final_params_xy = vqe_optimization(
model=model_xy,
n_layers=3,
learning_rate=0.1,
max_iter=100,
verbose=True
)
# 结果总结
exact_energy_xy, _ = model_xy.get_exact_ground_state_energy()
vqe_energy_xy = loss_history_xy[-1]
error_xy = abs(vqe_energy_xy - exact_energy_xy)
print(f"\n" + "=" * 70)
print("结果总结")
print("=" * 70)
print(f"VQE 能量: {vqe_energy_xy:.6f}")
print(f"精确能量: {exact_energy_xy:.6f}")
print(f"绝对误差: {error_xy:.6f}")
print(f"相对误差: {error_xy / abs(exact_energy_xy) * 100:.4f}%")
if error_xy < 0.01:
print("\n✅ 优秀！VQE 成功找到基态能量！")
elif error_xy < 0.1:
print("\n✓ 良好！接近基态能量。")
else:
print("\n⚠ 需要更多优化（增加层数或迭代次数）")
======================================================================
示例：XY 模型 (4 量子比特)
======================================================================
✅ 改进的 VQE 优化（针对 XY 模型）
==================================================
量子比特: 4
层数: 3
参数数量: 36 (RX+RY+RZ)
学习率: 0.1 (改进: 降低)
最大迭代: 100 (改进: 增加)
精确基态能量: -5.366563
迭代 | VQE能量 | 误差 | 改进
------------------------------------------------
0 | 0.010492 | 5.377055 | -5.377055
20 | -3.599904 | 1.766659 | -1.766659
40 | -3.599999 | 1.766564 | -1.766564
60 | -3.600001 | 1.766563 | -1.766563
80 | -3.600000 | 1.766563 | -1.766563
99 | -3.600000 | 1.766563 | -1.766563
======================================================================
结果总结
======================================================================
VQE 能量: -3.600000
精确能量: -5.366563
绝对误差: 1.766563
相对误差: 32.9180%
⚠ 需要更多优化（增加层数或迭代次数）
6. 绘制收敛曲线¶
In [8]:
Copied!
plt.figure(figsize=(10, 6))
plt.plot(loss_history_xy, 'b-', linewidth=2, label='VQE Energy')
plt.axhline(y=exact_energy_xy, color='r', linestyle='--',
linewidth=2, label='Exact Ground State Energy')
plt.xlabel('Iteration', fontsize=12)
plt.ylabel('Energy', fontsize=12)
plt.title('VQE Optimization: XY Model (4 Qubits)', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_xy_model_4qubits.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n图表已保存为 'vqe_xy_model_4qubits.png'")
plt.figure(figsize=(10, 6))
plt.plot(loss_history_xy, 'b-', linewidth=2, label='VQE Energy')
plt.axhline(y=exact_energy_xy, color='r', linestyle='--',
linewidth=2, label='Exact Ground State Energy')
plt.xlabel('Iteration', fontsize=12)
plt.ylabel('Energy', fontsize=12)
plt.title('VQE Optimization: XY Model (4 Qubits)', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_xy_model_4qubits.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n图表已保存为 'vqe_xy_model_4qubits.png'")
图表已保存为 'vqe_xy_model_4qubits.png'
7. 关联函数计算¶
计算横向关联函数 $\langle X_i X_j \rangle$ 和 $\langle Y_i Y_j \rangle$，用于表征拓扑序。
In [9]:
Copied!
def calculate_correlation_functions(model, params, n_layers):
"""
计算关联函数
返回:
- xx_corr: XX 关联矩阵
- yy_corr: YY 关联矩阵
"""
n_qubits = model.n_qubits
# 准备基态
qc = dq.QubitCircuit(n_qubits)
qc = hardware_efficient_ansatz(qc, params, n_qubits, n_layers)
state = qc()
# 计算关联矩阵
xx_corr = np.zeros((n_qubits, n_qubits))
yy_corr = np.zeros((n_qubits, n_qubits))
for i in range(n_qubits):
for j in range(n_qubits):
if i != j:
# XX 关联
obs_xx = Observable(nqubit=n_qubits, wires=[[i], [j]], basis='xx')
xx_corr[i, j] = dq.expectation(state, obs_xx).item()
# YY 关联
obs_yy = Observable(nqubit=n_qubits, wires=[[i], [j]], basis='yy')
yy_corr[i, j] = dq.expectation(state, obs_yy).item()
return xx_corr, yy_corr
# 计算关联函数
print("\n计算关联函数...\n")
xx_corr, yy_corr = calculate_correlation_functions(model_xy, final_params_xy, n_layers=3)
print("XX 关联矩阵 (⟨X_i X_j⟩):")
print(xx_corr)
print("\nYY 关联矩阵 (⟨Y_i Y_j⟩):")
print(yy_corr)
# 可视化关联函数
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
im1 = axes[0].imshow(xx_corr, cmap='RdBu_r', vmin=-1, vmax=1)
axes[0].set_title('XX Correlation ⟨X_i X_j⟩ ', fontsize=14)
axes[0].set_xlabel('Site j', fontsize=12)
axes[0].set_ylabel('Site i', fontsize=12)
plt.colorbar(im1, ax=axes[0])
im2 = axes[1].imshow(yy_corr, cmap='RdBu_r', vmin=-1, vmax=1)
axes[1].set_title('YY Correlation ⟨Y_i Y_j⟩ ', fontsize=14)
axes[1].set_xlabel('Site j', fontsize=12)
axes[1].set_ylabel('Site i', fontsize=12)
plt.colorbar(im2, ax=axes[1])
plt.tight_layout()
plt.savefig('vqe_xy_correlations.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n关联函数图已保存为 'vqe_xy_correlations.png'")
def calculate_correlation_functions(model, params, n_layers):
"""
计算关联函数
返回:
- xx_corr: XX 关联矩阵
- yy_corr: YY 关联矩阵
"""
n_qubits = model.n_qubits
# 准备基态
qc = dq.QubitCircuit(n_qubits)
qc = hardware_efficient_ansatz(qc, params, n_qubits, n_layers)
state = qc()
# 计算关联矩阵
xx_corr = np.zeros((n_qubits, n_qubits))
yy_corr = np.zeros((n_qubits, n_qubits))
for i in range(n_qubits):
for j in range(n_qubits):
if i != j:
# XX 关联
obs_xx = Observable(nqubit=n_qubits, wires=[[i], [j]], basis='xx')
xx_corr[i, j] = dq.expectation(state, obs_xx).item()
# YY 关联
obs_yy = Observable(nqubit=n_qubits, wires=[[i], [j]], basis='yy')
yy_corr[i, j] = dq.expectation(state, obs_yy).item()
return xx_corr, yy_corr
# 计算关联函数
print("\n计算关联函数...\n")
xx_corr, yy_corr = calculate_correlation_functions(model_xy, final_params_xy, n_layers=3)
print("XX 关联矩阵 (⟨X_i X_j⟩):")
print(xx_corr)
print("\nYY 关联矩阵 (⟨Y_i Y_j⟩):")
print(yy_corr)
# 可视化关联函数
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
im1 = axes[0].imshow(xx_corr, cmap='RdBu_r', vmin=-1, vmax=1)
axes[0].set_title('XX Correlation ⟨X_i X_j⟩ ', fontsize=14)
axes[0].set_xlabel('Site j', fontsize=12)
axes[0].set_ylabel('Site i', fontsize=12)
plt.colorbar(im1, ax=axes[0])
im2 = axes[1].imshow(yy_corr, cmap='RdBu_r', vmin=-1, vmax=1)
axes[1].set_title('YY Correlation ⟨Y_i Y_j⟩ ', fontsize=14)
axes[1].set_xlabel('Site j', fontsize=12)
axes[1].set_ylabel('Site i', fontsize=12)
plt.colorbar(im2, ax=axes[1])
plt.tight_layout()
plt.savefig('vqe_xy_correlations.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n关联函数图已保存为 'vqe_xy_correlations.png'")
计算关联函数... XX 关联矩阵 (⟨X_i X_j⟩): [[0. 0.9340753 0.93407738 0.93408078] [0.9340753 0. 0.93407691 0.93408036] [0.93407738 0.93407691 0. 0.93408251] [0.93408078 0.93408036 0.93408251 0. ]] YY 关联矩阵 (⟨Y_i Y_j⟩): [[0. 0.06592497 0.0659228 0.06591936] [0.06592497 0. 0.0659232 0.06591991] [0.0659228 0.0659232 0. 0.06591768] [0.06591936 0.06591991 0.06591768 0. ]]
关联函数图已保存为 'vqe_xy_correlations.png'
8. 与 Heisenberg 模型对比¶
对比 XY 模型（Δ=0）与 Heisenberg 模型（Δ=1）的能量和物理性质。
In [10]:
Copied!
# ========================================
# 对比 XY 模型与 Heisenberg 模型
# ========================================
print("\n" + "=" * 70)
print("对比 XY 模型与 Heisenberg XXZ 模型")
print("=" * 70)
# 创建模型
model_xy = XYModel(n_qubits=4, J=1.0, delta=0.0) # XY 模型
model_heisenberg = XYModel(n_qubits=4, J=1.0, delta=1.0) # Heisenberg 模型
# 精确对角化
exact_xy, _ = model_xy.get_exact_ground_state_energy()
exact_heisenberg, _ = model_heisenberg.get_exact_ground_state_energy()
print(f"\n精确基态能量对比：")
print(f" XY 模型 (Δ=0): {exact_xy:.6f}")
print(f" Heisenberg 模型 (Δ=1): {exact_heisenberg:.6f}")
print(f" 能量差: {exact_heisenberg - exact_xy:.6f}")
# 运行 VQE for Heisenberg
print(f"\n运行 VQE for Heisenberg 模型...")
loss_history_heisenberg, final_params_heisenberg = vqe_optimization(
model=model_heisenberg,
n_layers=3,
learning_rate=0.1,
max_iter=100,
verbose=False
)
vqe_heisenberg = loss_history_heisenberg[-1]
print(f"VQE 结果 (Heisenberg): {vqe_heisenberg:.6f}")
print(f"误差: {abs(vqe_heisenberg - exact_heisenberg):.6f}")
# 对比图
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# 能量对比
models = ['XY (Δ=0)', 'Heisenberg (Δ=1)']
exact_energies = [exact_xy, exact_heisenberg]
vqe_energies = [vqe_energy_xy, vqe_heisenberg]
x = np.arange(len(models))
width = 0.35
axes[0].bar(x - width/2, exact_energies, width, label='Exact', alpha=0.8)
axes[0].bar(x + width/2, vqe_energies, width, label='VQE', alpha=0.8)
axes[0].set_ylabel('Ground State Energy', fontsize=12)
axes[0].set_title('Energy Comparison: XY vs Heisenberg', fontsize=14)
axes[0].set_xticks(x)
axes[0].set_xticklabels(models)
axes[0].legend(fontsize=12)
axes[0].grid(True, alpha=0.3, axis='y')
# 收敛曲线对比
axes[1].plot(loss_history_xy, 'b-', linewidth=2, label='XY Model')
axes[1].plot(loss_history_heisenberg, 'r-', linewidth=2, label='Heisenberg Model')
axes[1].axhline(y=exact_xy, color='b', linestyle='--', alpha=0.5)
axes[1].axhline(y=exact_heisenberg, color='r', linestyle='--', alpha=0.5)
axes[1].set_xlabel('Iteration', fontsize=12)
axes[1].set_ylabel('Energy', fontsize=12)
axes[1].set_title('VQE Convergence', fontsize=14)
axes[1].legend(fontsize=12)
axes[1].grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_xy_vs_heisenberg.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n对比图已保存为 'vqe_xy_vs_heisenberg.png'")
# ========================================
# 对比 XY 模型与 Heisenberg 模型
# ========================================
print("\n" + "=" * 70)
print("对比 XY 模型与 Heisenberg XXZ 模型")
print("=" * 70)
# 创建模型
model_xy = XYModel(n_qubits=4, J=1.0, delta=0.0) # XY 模型
model_heisenberg = XYModel(n_qubits=4, J=1.0, delta=1.0) # Heisenberg 模型
# 精确对角化
exact_xy, _ = model_xy.get_exact_ground_state_energy()
exact_heisenberg, _ = model_heisenberg.get_exact_ground_state_energy()
print(f"\n精确基态能量对比：")
print(f" XY 模型 (Δ=0): {exact_xy:.6f}")
print(f" Heisenberg 模型 (Δ=1): {exact_heisenberg:.6f}")
print(f" 能量差: {exact_heisenberg - exact_xy:.6f}")
# 运行 VQE for Heisenberg
print(f"\n运行 VQE for Heisenberg 模型...")
loss_history_heisenberg, final_params_heisenberg = vqe_optimization(
model=model_heisenberg,
n_layers=3,
learning_rate=0.1,
max_iter=100,
verbose=False
)
vqe_heisenberg = loss_history_heisenberg[-1]
print(f"VQE 结果 (Heisenberg): {vqe_heisenberg:.6f}")
print(f"误差: {abs(vqe_heisenberg - exact_heisenberg):.6f}")
# 对比图
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# 能量对比
models = ['XY (Δ=0)', 'Heisenberg (Δ=1)']
exact_energies = [exact_xy, exact_heisenberg]
vqe_energies = [vqe_energy_xy, vqe_heisenberg]
x = np.arange(len(models))
width = 0.35
axes[0].bar(x - width/2, exact_energies, width, label='Exact', alpha=0.8)
axes[0].bar(x + width/2, vqe_energies, width, label='VQE', alpha=0.8)
axes[0].set_ylabel('Ground State Energy', fontsize=12)
axes[0].set_title('Energy Comparison: XY vs Heisenberg', fontsize=14)
axes[0].set_xticks(x)
axes[0].set_xticklabels(models)
axes[0].legend(fontsize=12)
axes[0].grid(True, alpha=0.3, axis='y')
# 收敛曲线对比
axes[1].plot(loss_history_xy, 'b-', linewidth=2, label='XY Model')
axes[1].plot(loss_history_heisenberg, 'r-', linewidth=2, label='Heisenberg Model')
axes[1].axhline(y=exact_xy, color='b', linestyle='--', alpha=0.5)
axes[1].axhline(y=exact_heisenberg, color='r', linestyle='--', alpha=0.5)
axes[1].set_xlabel('Iteration', fontsize=12)
axes[1].set_ylabel('Energy', fontsize=12)
axes[1].set_title('VQE Convergence', fontsize=14)
axes[1].legend(fontsize=12)
axes[1].grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_xy_vs_heisenberg.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n对比图已保存为 'vqe_xy_vs_heisenberg.png'")
====================================================================== 对比 XY 模型与 Heisenberg XXZ 模型 ====================================================================== 精确基态能量对比： XY 模型 (Δ=0): -4.472136 Heisenberg 模型 (Δ=1): -3.000000 能量差: 1.472136 运行 VQE for Heisenberg 模型... VQE 结果 (Heisenberg): -2.999999 误差: 0.000001
对比图已保存为 'vqe_xy_vs_heisenberg.png'
9. 探索不同耦合强度的影响¶
In [11]:
Copied!
# ========================================
# 探索不同耦合强度 J 的影响
# ========================================
print("\n探索不同耦合强度的影响...\n")
print("=" * 70)
J_values = [0.5, 1.0, 1.5, 2.0]
results = []
for J in J_values:
print(f"\nJ = {J}")
print("-" * 30)
# 创建模型
model = XYModel(n_qubits=4, J=J, delta=0.0)
# 精确能量
exact_e, _ = model.get_exact_ground_state_energy()
# 运行 VQE
loss_hist, _ = vqe_optimization(
model=model,
n_layers=2,
learning_rate=0.1,
max_iter=50,
verbose=False
)
vqe_e = loss_hist[-1]
results.append({
'J': J,
'exact': exact_e,
'vqe': vqe_e,
'error': abs(vqe_e - exact_e)
})
print(f" 精确能量: {exact_e:.6f}")
print(f" VQE 能量: {vqe_e:.6f}")
print(f" 误差: {abs(vqe_e - exact_e):.6f}")
# 绘制结果对比
plt.figure(figsize=(10, 6))
J_vals = [r['J'] for r in results]
exact_vals = [r['exact'] for r in results]
vqe_vals = [r['vqe'] for r in results]
plt.plot(J_vals, exact_vals, 'r-o', linewidth=2, markersize=8, label='Exact')
plt.plot(J_vals, vqe_vals, 'b-s', linewidth=2, markersize=8, label='VQE')
plt.xlabel('Coupling Strength (J)', fontsize=12)
plt.ylabel('Ground State Energy', fontsize=12)
plt.title('XY Model: Energy vs Coupling Strength', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_xy_coupling_scan.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n图表已保存为 'vqe_xy_coupling_scan.png'")
# ========================================
# 探索不同耦合强度 J 的影响
# ========================================
print("\n探索不同耦合强度的影响...\n")
print("=" * 70)
J_values = [0.5, 1.0, 1.5, 2.0]
results = []
for J in J_values:
print(f"\nJ = {J}")
print("-" * 30)
# 创建模型
model = XYModel(n_qubits=4, J=J, delta=0.0)
# 精确能量
exact_e, _ = model.get_exact_ground_state_energy()
# 运行 VQE
loss_hist, _ = vqe_optimization(
model=model,
n_layers=2,
learning_rate=0.1,
max_iter=50,
verbose=False
)
vqe_e = loss_hist[-1]
results.append({
'J': J,
'exact': exact_e,
'vqe': vqe_e,
'error': abs(vqe_e - exact_e)
})
print(f" 精确能量: {exact_e:.6f}")
print(f" VQE 能量: {vqe_e:.6f}")
print(f" 误差: {abs(vqe_e - exact_e):.6f}")
# 绘制结果对比
plt.figure(figsize=(10, 6))
J_vals = [r['J'] for r in results]
exact_vals = [r['exact'] for r in results]
vqe_vals = [r['vqe'] for r in results]
plt.plot(J_vals, exact_vals, 'r-o', linewidth=2, markersize=8, label='Exact')
plt.plot(J_vals, vqe_vals, 'b-s', linewidth=2, markersize=8, label='VQE')
plt.xlabel('Coupling Strength (J)', fontsize=12)
plt.ylabel('Ground State Energy', fontsize=12)
plt.title('XY Model: Energy vs Coupling Strength', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('vqe_xy_coupling_scan.png', dpi=300, bbox_inches='tight')
plt.show()
print("\n图表已保存为 'vqe_xy_coupling_scan.png'")
探索不同耦合强度的影响... ====================================================================== J = 0.5 ------------------------------ 精确能量: -2.236068 VQE 能量: -1.499144 误差: 0.736924 J = 1.0 ------------------------------ 精确能量: -4.472136 VQE 能量: -3.000000 误差: 1.472136 J = 1.5 ------------------------------ 精确能量: -6.708204 VQE 能量: -4.500002 误差: 2.208202 J = 2.0 ------------------------------ 精确能量: -8.944272 VQE 能量: -5.999992 误差: 2.944280
图表已保存为 'vqe_xy_coupling_scan.png'
10. 物理分析：U(1) 对称性和拓扑序¶
In [12]:
Copied!
print("\n" + "=" * 70)
print("XY 模型的物理性质分析")
print("=" * 70)
print("""
1. U(1) 对称性：
- XY 模型具有绕 Z 轴旋转的 U(1) 对称性
- 总 S^z 守恒：[H, ΣZ_i] = 0
- 这导致能级简并和选择定则
2. 与 Heisenberg 模型的区别：
- XY 模型：只有横向耦合 (XX + YY)
- Heisenberg：各向同性耦合 (XX + YY + ZZ)
- 能量差异：XY 模型基态能量更高（约束更少）
3. 拓扑性质：
- 低维 XY 模型展示 BKT 相变
- 准长程序（quasi-long-range order）
- 关联函数衰减为幂律：C(r) ~ r^(-η)
4. 量子计算应用：
- 离子阱实验可实现 XY 相互作用
- 用于研究量子磁性
- 拓扑量子计算的候选系统
""")
# 计算平均关联（作为拓扑序指标）
print("\n关联函数分析：")
print("-" * 50)
# 最近邻关联
nn_xx = np.mean([xx_corr[i, i+1] for i in range(3)])
nn_yy = np.mean([yy_corr[i, i+1] for i in range(3)])
# 次近邻关联
nnn_xx = np.mean([xx_corr[i, i+2] for i in range(2)])
nnn_yy = np.mean([yy_corr[i, i+2] for i in range(2)])
print(f"最近邻关联：")
print(f" ⟨X_i X_{i+1}⟩ = {nn_xx:.6f}")
print(f" ⟨Y_i Y_{i+1}⟩ = {nn_yy:.6f}")
print(f"\n次近邻关联：")
print(f" ⟨X_i X_{i+2}⟩ = {nnn_xx:.6f}")
print(f" ⟨Y_i Y_{i+2}⟩ = {nnn_yy:.6f}")
# 关联衰减
decay_xx = abs(nnn_xx / nn_xx) if nn_xx != 0 else 0
decay_yy = abs(nnn_yy / nn_yy) if nn_yy != 0 else 0
print(f"\n关联衰减比：")
print(f" C_XX(r=2) / C_XX(r=1) = {decay_xx:.6f}")
print(f" C_YY(r=2) / C_YY(r=1) = {decay_yy:.6f}")
if decay_xx > 0.5 and decay_yy > 0.5:
print("\n✓ 关联衰减较慢，可能存在准长程序")
else:
print("\n✓ 关联衰减较快，短程序特征")
print("\n" + "=" * 70)
print("XY 模型的物理性质分析")
print("=" * 70)
print("""
1. U(1) 对称性：
- XY 模型具有绕 Z 轴旋转的 U(1) 对称性
- 总 S^z 守恒：[H, ΣZ_i] = 0
- 这导致能级简并和选择定则
2. 与 Heisenberg 模型的区别：
- XY 模型：只有横向耦合 (XX + YY)
- Heisenberg：各向同性耦合 (XX + YY + ZZ)
- 能量差异：XY 模型基态能量更高（约束更少）
3. 拓扑性质：
- 低维 XY 模型展示 BKT 相变
- 准长程序（quasi-long-range order）
- 关联函数衰减为幂律：C(r) ~ r^(-η)
4. 量子计算应用：
- 离子阱实验可实现 XY 相互作用
- 用于研究量子磁性
- 拓扑量子计算的候选系统
""")
# 计算平均关联（作为拓扑序指标）
print("\n关联函数分析：")
print("-" * 50)
# 最近邻关联
nn_xx = np.mean([xx_corr[i, i+1] for i in range(3)])
nn_yy = np.mean([yy_corr[i, i+1] for i in range(3)])
# 次近邻关联
nnn_xx = np.mean([xx_corr[i, i+2] for i in range(2)])
nnn_yy = np.mean([yy_corr[i, i+2] for i in range(2)])
print(f"最近邻关联：")
print(f" ⟨X_i X_{i+1}⟩ = {nn_xx:.6f}")
print(f" ⟨Y_i Y_{i+1}⟩ = {nn_yy:.6f}")
print(f"\n次近邻关联：")
print(f" ⟨X_i X_{i+2}⟩ = {nnn_xx:.6f}")
print(f" ⟨Y_i Y_{i+2}⟩ = {nnn_yy:.6f}")
# 关联衰减
decay_xx = abs(nnn_xx / nn_xx) if nn_xx != 0 else 0
decay_yy = abs(nnn_yy / nn_yy) if nn_yy != 0 else 0
print(f"\n关联衰减比：")
print(f" C_XX(r=2) / C_XX(r=1) = {decay_xx:.6f}")
print(f" C_YY(r=2) / C_YY(r=1) = {decay_yy:.6f}")
if decay_xx > 0.5 and decay_yy > 0.5:
print("\n✓ 关联衰减较慢，可能存在准长程序")
else:
print("\n✓ 关联衰减较快，短程序特征")
====================================================================== XY 模型的物理性质分析 ====================================================================== 1. U(1) 对称性： - XY 模型具有绕 Z 轴旋转的 U(1) 对称性 - 总 S^z 守恒：[H, ΣZ_i] = 0 - 这导致能级简并和选择定则 2. 与 Heisenberg 模型的区别： - XY 模型：只有横向耦合 (XX + YY) - Heisenberg：各向同性耦合 (XX + YY + ZZ) - 能量差异：XY 模型基态能量更高（约束更少） 3. 拓扑性质： - 低维 XY 模型展示 BKT 相变 - 准长程序（quasi-long-range order） - 关联函数衰减为幂律：C(r) ~ r^(-η) 4. 量子计算应用： - 离子阱实验可实现 XY 相互作用 - 用于研究量子磁性 - 拓扑量子计算的候选系统 关联函数分析： -------------------------------------------------- 最近邻关联： ⟨X_i X_6⟩ = 0.934078 ⟨Y_i Y_6⟩ = 0.065922 次近邻关联： ⟨X_i X_7⟩ = 0.934079 ⟨Y_i Y_7⟩ = 0.065921 关联衰减比： C_XX(r=2) / C_XX(r=1) = 1.000001 C_YY(r=2) / C_YY(r=1) = 0.999991 ✓ 关联衰减较慢，可能存在准长程序
11. 总结¶
In [13]:
Copied!
print("\n" + "=" * 70)
print("VQE 求解 XY 模型 - 总结")
print("=" * 70)
print("""
本 notebook 实现了使用 VQE 算法求解 XY 模型的基态能量和物理性质。
关键要点：
1. ✅ 定义了 XY 模型（只有 XX 和 YY 项）
2. ✅ 实现了硬件高效的 Ansatz
3. ✅ 使用了梯度下降优化
4. ✅ 计算了横向关联函数
5. ✅ 对比了 XY 模型与 Heisenberg 模型
6. ✅ 分析了 U(1) 对称性和拓扑性质
XY 模型的特点：
- 是 Heisenberg XXZ 模型在 Δ=0 时的特例
- 具有 U(1) 对称性（总 S^z 守恒）
- 描述平面内自旋相互作用
- 在低维展示 BKT 相变和拓扑序
- 可在离子阱量子计算机上实验实现
应用领域：
- 量子磁性研究
- 拓扑量子计算
- 超导系统建模
- 量子相变研究
下一步：
- 扩展到更多量子比特（6, 8, ...）
- 研究周期性边界条件
- 探索长程相互作用
- 实现 QAOA 用于 XY 模型
- 研究动力学性质和淬火
""")
print("\n" + "=" * 70)
print("恭喜！您已成功使用 VQE 求解 XY 模型！")
print("=" * 70)
print("\n" + "=" * 70)
print("VQE 求解 XY 模型 - 总结")
print("=" * 70)
print("""
本 notebook 实现了使用 VQE 算法求解 XY 模型的基态能量和物理性质。
关键要点：
1. ✅ 定义了 XY 模型（只有 XX 和 YY 项）
2. ✅ 实现了硬件高效的 Ansatz
3. ✅ 使用了梯度下降优化
4. ✅ 计算了横向关联函数
5. ✅ 对比了 XY 模型与 Heisenberg 模型
6. ✅ 分析了 U(1) 对称性和拓扑性质
XY 模型的特点：
- 是 Heisenberg XXZ 模型在 Δ=0 时的特例
- 具有 U(1) 对称性（总 S^z 守恒）
- 描述平面内自旋相互作用
- 在低维展示 BKT 相变和拓扑序
- 可在离子阱量子计算机上实验实现
应用领域：
- 量子磁性研究
- 拓扑量子计算
- 超导系统建模
- 量子相变研究
下一步：
- 扩展到更多量子比特（6, 8, ...）
- 研究周期性边界条件
- 探索长程相互作用
- 实现 QAOA 用于 XY 模型
- 研究动力学性质和淬火
""")
print("\n" + "=" * 70)
print("恭喜！您已成功使用 VQE 求解 XY 模型！")
print("=" * 70)
====================================================================== VQE 求解 XY 模型 - 总结 ====================================================================== 本 notebook 实现了使用 VQE 算法求解 XY 模型的基态能量和物理性质。 关键要点： 1. ✅ 定义了 XY 模型（只有 XX 和 YY 项） 2. ✅ 实现了硬件高效的 Ansatz 3. ✅ 使用了梯度下降优化 4. ✅ 计算了横向关联函数 5. ✅ 对比了 XY 模型与 Heisenberg 模型 6. ✅ 分析了 U(1) 对称性和拓扑性质 XY 模型的特点： - 是 Heisenberg XXZ 模型在 Δ=0 时的特例 - 具有 U(1) 对称性（总 S^z 守恒） - 描述平面内自旋相互作用 - 在低维展示 BKT 相变和拓扑序 - 可在离子阱量子计算机上实验实现 应用领域： - 量子磁性研究 - 拓扑量子计算 - 超导系统建模 - 量子相变研究 下一步： - 扩展到更多量子比特（6, 8, ...） - 研究周期性边界条件 - 探索长程相互作用 - 实现 QAOA 用于 XY 模型 - 研究动力学性质和淬火 ====================================================================== 恭喜！您已成功使用 VQE 求解 XY 模型！ ======================================================================