量子计算中常见哈密顿量实现教程¶

本 notebook 展示如何使用 Qibo 框架实现量子计算中常见的各种哈密顿量。

目录¶

1. 自旋模型哈密顿量
2. 优化问题哈密顿量
3. 多体物理哈密顿量
4. 核物理哈密顿量
5. 实用示例

---

环境设置¶

首先导入必要的库：

In [ ]:

# 导入 Qibo 核心模块
import numpy as np
import matplotlib.pyplot as plt
from qibo import hamiltonians, models, Circuit, gates
from qibo.symbols import X, Y, Z, I
from qibo.models import QAOA

# 设置图形显示
plt.rcParams['font.sans-serif'] = ['SimHei']  # 中文字体
plt.rcParams['axes.unicode_minus'] = False

print("Qibo 环境设置完成！")
print(f"当前后端: {hamiltonians._available_backends}")

# 导入 Qibo 核心模块 import numpy as np import matplotlib.pyplot as plt from qibo import hamiltonians, models, Circuit, gates from qibo.symbols import X, Y, Z, I from qibo.models import QAOA # 设置图形显示 plt.rcParams['font.sans-serif'] = ['SimHei'] # 中文字体 plt.rcParams['axes.unicode_minus'] = False print("Qibo 环境设置完成！") print(f"当前后端: {hamiltonians._available_backends}")

---

1. 自旋模型哈密顿量¶

1.1 横向场伊辛模型 (Transverse Field Ising Model - TFIM)¶

数学形式: $$ H = -J \sum_{i=1}^{n-1} Z_i \otimes Z_{i+1} - h \sum_{i=1}^{n} X_i $$

参数说明:

• $J$: 耦合强度（通常取 J=1）
• $h$: 横向场强度
• $n$: 量子比特数

物理意义:

• 描述自旋间的相互作用和量子涨落
• 在 $h \approx 1$ 附近发生量子相变

In [ ]:

# 创建 TFIM 哈密顿量
def create_tfim(nqubits, h=1.0, dense=True):
    """
    创建横向场伊辛模型哈密顿量
    
    参数:
        nqubits: 量子比特数
        h: 横向场强度 (默认 1.0)
        dense: 是否使用稠密矩阵 (默认 True)
    
    返回:
        哈密顿量对象
    """
    return hamiltonians.TFIM(nqubits=nqubits, h=h, dense=dense)

# 示例：创建 6 量子比特的 TFIM
nqubits = 6
h_field = 0.5

tfim_ham = create_tfim(nqubits, h=h_field, dense=False)
print(f"TFIM 哈密顿量 ({nqubits} 量子比特, h={h_field})")
print(f"符号形式: {tfim_ham.form}")
print(f"项数: {len(tfim_ham.terms)}")

# 创建 TFIM 哈密顿量 def create_tfim(nqubits, h=1.0, dense=True): """ 创建横向场伊辛模型哈密顿量 参数: nqubits: 量子比特数 h: 横向场强度 (默认 1.0) dense: 是否使用稠密矩阵 (默认 True) 返回: 哈密顿量对象 """ return hamiltonians.TFIM(nqubits=nqubits, h=h, dense=dense) # 示例：创建 6 量子比特的 TFIM nqubits = 6 h_field = 0.5 tfim_ham = create_tfim(nqubits, h=h_field, dense=False) print(f"TFIM 哈密顿量 ({nqubits} 量子比特, h={h_field})") print(f"符号形式: {tfim_ham.form}") print(f"项数: {len(tfim_ham.terms)}")

In [ ]:

# 计算能谱并可视化
def plot_tfim_spectrum(nqubits=6, h_values=np.linspace(0, 2, 21)):
    """
    绘制 TFIM 能级随横向场的变化
    """
    energies = []
    
    for h in h_values:
        ham = hamiltonians.TFIM(nqubits, h=h)
        eigvals = ham.eigenvalues()
        energies.append(eigvals[:5])  # 只取前5个能级
    
    energies = np.array(energies)
    
    plt.figure(figsize=(10, 6))
    for i in range(5):
        plt.plot(h_values, energies[:, i], 'o-', label=f'E_{i}', markersize=4)
    
    plt.axvline(x=1.0, color='red', linestyle='--', alpha=0.5, label='临界点 h_c=1')
    plt.xlabel('横向场强度 h', fontsize=12)
    plt.ylabel('能量', fontsize=12)
    plt.title(f'TFIM 能级随横向场的变化 ({nqubits} 量子比特)', fontsize=14)
    plt.legend()
    plt.grid(alpha=0.3)
    plt.show()

# 绘制能谱
plot_tfim_spectrum(nqubits=6)

# 计算能谱并可视化 def plot_tfim_spectrum(nqubits=6, h_values=np.linspace(0, 2, 21)): """ 绘制 TFIM 能级随横向场的变化 """ energies = [] for h in h_values: ham = hamiltonians.TFIM(nqubits, h=h) eigvals = ham.eigenvalues() energies.append(eigvals[:5]) # 只取前5个能级 energies = np.array(energies) plt.figure(figsize=(10, 6)) for i in range(5): plt.plot(h_values, energies[:, i], 'o-', label=f'E_{i}', markersize=4) plt.axvline(x=1.0, color='red', linestyle='--', alpha=0.5, label='临界点 h_c=1') plt.xlabel('横向场强度 h', fontsize=12) plt.ylabel('能量', fontsize=12) plt.title(f'TFIM 能级随横向场的变化 ({nqubits} 量子比特)', fontsize=14) plt.legend() plt.grid(alpha=0.3) plt.show() # 绘制能谱 plot_tfim_spectrum(nqubits=6)

1.2 海森堡模型 (Heisenberg Models)¶

XXZ 模型¶

数学形式: $$ H = \sum_{i=1}^{n} (X_i \otimes X_{i+1} + Y_i \otimes Y_{i+1} + \Delta Z_i \otimes Z_{i+1}) $$

参数:

• $\Delta$: Z 方向各向异性参数
  • $\Delta = 1$: XXX 模型（各向同性）
  • $\Delta = 0$: XY 模型
  • $\Delta \neq 1$: XXZ 各向异性

In [ ]:

# 创建 XXZ 哈密顿量
def create_xxz(nqubits, delta=0.5, dense=True):
    """
    创建 XXZ 海森堡模型哈密顿量
    
    参数:
        nqubits: 量子比特数
        delta: Z 方向各向异性参数
        dense: 是否使用稠密矩阵
    """
    return hamiltonians.XXZ(nqubits=nqubits, delta=delta, dense=dense)

# 示例：创建 XXZ 模型
nqubits = 5
delta = 0.8

xxz_ham = create_xxz(nqubits, delta=delta, dense=False)
print(f"XXZ 哈密顿量 ({nqubits} 量子比特, Δ={delta})")
print(f"符号形式: {xxz_ham.form}")

# 创建 XXZ 哈密顿量 def create_xxz(nqubits, delta=0.5, dense=True): """ 创建 XXZ 海森堡模型哈密顿量 参数: nqubits: 量子比特数 delta: Z 方向各向异性参数 dense: 是否使用稠密矩阵 """ return hamiltonians.XXZ(nqubits=nqubits, delta=delta, dense=dense) # 示例：创建 XXZ 模型 nqubits = 5 delta = 0.8 xxz_ham = create_xxz(nqubits, delta=delta, dense=False) print(f"XXZ 哈密顿量 ({nqubits} 量子比特, Δ={delta})") print(f"符号形式: {xxz_ham.form}")

In [ ]:

# 比较不同各向异性参数的能谱
def compare_xxz_anisotropy(nqubits=5, delta_values=[0, 0.5, 1.0, 1.5, 2.0]):
    """
    比较不同 Delta 参数下的基态能量
    """
    ground_energies = []
    
    for delta in delta_values:
        ham = hamiltonians.XXZ(nqubits, delta=delta)
        gs_energy = ham.ground_state()
        energy = ham.expectation(gs_energy)
        ground_energies.append(energy)
        print(f"Δ = {delta:.1f}: 基态能量 = {energy:.4f}")
    
    plt.figure(figsize=(10, 6))
    plt.plot(delta_values, ground_energies, 'o-', linewidth=2, markersize=8)
    plt.axvline(x=1.0, color='red', linestyle='--', alpha=0.5, label='XXX (各向同性)')
    plt.xlabel('各向异性参数 Δ', fontsize=12)
    plt.ylabel('基态能量', fontsize=12)
    plt.title(f'XXZ 模型基态能量 vs Δ ({nqubits} 量子比特)', fontsize=14)
    plt.legend()
    plt.grid(alpha=0.3)
    plt.show()

# 比较不同 Delta
compare_xxz_anisotropy()

# 比较不同各向异性参数的能谱 def compare_xxz_anisotropy(nqubits=5, delta_values=[0, 0.5, 1.0, 1.5, 2.0]): """ 比较不同 Delta 参数下的基态能量 """ ground_energies = [] for delta in delta_values: ham = hamiltonians.XXZ(nqubits, delta=delta) gs_energy = ham.ground_state() energy = ham.expectation(gs_energy) ground_energies.append(energy) print(f"Δ = {delta:.1f}: 基态能量 = {energy:.4f}") plt.figure(figsize=(10, 6)) plt.plot(delta_values, ground_energies, 'o-', linewidth=2, markersize=8) plt.axvline(x=1.0, color='red', linestyle='--', alpha=0.5, label='XXX (各向同性)') plt.xlabel('各向异性参数 Δ', fontsize=12) plt.ylabel('基态能量', fontsize=12) plt.title(f'XXZ 模型基态能量 vs Δ ({nqubits} 量子比特)', fontsize=14) plt.legend() plt.grid(alpha=0.3) plt.show() # 比较不同 Delta compare_xxz_anisotropy()

通用 Heisenberg 模型¶

In [ ]:

# 创建通用 Heisenberg 模型
def create_heisenberg(nqubits, coupling_constants=None, external_field=None):
    """
    创建通用海森堡模型
    
    参数:
        nqubits: 量子比特数
        coupling_constants: 耦合常数 [Jx, Jy, Jz]
        external_field: 外部磁场 [hx, hy, hz]
    """
    # 默认值
    if coupling_constants is None:
        coupling_constants = [1.0, 1.0, 1.0]  # 各向同性
    if external_field is None:
        external_field = [0.0, 0.0, 0.0]
    
    return hamiltonians.Heisenberg(
        nqubits=nqubits,
        coupling_constants=coupling_constants,
        external_field_strengths=external_field
    )

# 示例：创建带外场的 Heisenberg 模型
heisenberg_ham = create_heisenberg(
    nqubits=4,
    coupling_constants=[1.0, 1.0, 0.5],  # XXZ
    external_field=[0.3, 0, 0]  # X 方向外场
)

print("通用 Heisenberg 模型")
print(f"量子比特数: {heisenberg_ham.nqubits}")
print(f"矩阵形状: {heisenberg_ham.matrix.shape}")

# 创建通用 Heisenberg 模型 def create_heisenberg(nqubits, coupling_constants=None, external_field=None): """ 创建通用海森堡模型 参数: nqubits: 量子比特数 coupling_constants: 耦合常数 [Jx, Jy, Jz] external_field: 外部磁场 [hx, hy, hz] """ # 默认值 if coupling_constants is None: coupling_constants = [1.0, 1.0, 1.0] # 各向同性 if external_field is None: external_field = [0.0, 0.0, 0.0] return hamiltonians.Heisenberg( nqubits=nqubits, coupling_constants=coupling_constants, external_field_strengths=external_field ) # 示例：创建带外场的 Heisenberg 模型 heisenberg_ham = create_heisenberg( nqubits=4, coupling_constants=[1.0, 1.0, 0.5], # XXZ external_field=[0.3, 0, 0] # X 方向外场 ) print("通用 Heisenberg 模型") print(f"量子比特数: {heisenberg_ham.nqubits}") print(f"矩阵形状: {heisenberg_ham.matrix.shape}")

1.3 Pauli 哈密顿量 (X, Y, Z)¶

数学形式:

• X-哈密顿量: $H = -\sum_{i=1}^n X_i$
• Y-哈密顿量: $H = -\sum_{i=1}^n Y_i$
• Z-哈密顿量: $H = -\sum_{i=1}^n Z_i$

用途:

• QAOA 的 mixer 哈密顿量
• 绝热演化的初态哈密顿量

In [ ]:

# 创建 Pauli 哈密顿量
def create_pauli_hamiltonians(nqubits, dense=True):
    """
    创建 X, Y, Z 哈密顿量
    """
    X_ham = hamiltonians.X(nqubits=nqubits, dense=dense)
    Y_ham = hamiltonians.Y(nqubits=nqubits, dense=dense)
    Z_ham = hamiltonians.Z(nqubits=nqubits, dense=dense)
    
    return X_ham, Y_ham, Z_ham

# 示例
nqubits = 4
X_ham, Y_ham, Z_ham = create_pauli_hamiltonians(nqubits, dense=False)

print(f"Pauli 哈密顿量 ({nqubits} 量子比特):")
print(f"X-哈密顿量: {X_ham.form}")
print(f"Y-哈密顿量: {Y_ham.form}")
print(f"Z-哈密顿量: {Z_ham.form}")

# 创建 Pauli 哈密顿量 def create_pauli_hamiltonians(nqubits, dense=True): """ 创建 X, Y, Z 哈密顿量 """ X_ham = hamiltonians.X(nqubits=nqubits, dense=dense) Y_ham = hamiltonians.Y(nqubits=nqubits, dense=dense) Z_ham = hamiltonians.Z(nqubits=nqubits, dense=dense) return X_ham, Y_ham, Z_ham # 示例 nqubits = 4 X_ham, Y_ham, Z_ham = create_pauli_hamiltonians(nqubits, dense=False) print(f"Pauli 哈密顿量 ({nqubits} 量子比特):") print(f"X-哈密顿量: {X_ham.form}") print(f"Y-哈密顿量: {Y_ham.form}") print(f"Z-哈密顿量: {Z_ham.form}")

1.4 Sherrington-Kirkpatrick (SK) 模型¶

数学形式: $$ H = -\sum_{i<j} J_{ij} Z_i \otimes Z_j $$

特点:

• 全连接：每个自旋与其他所有自旋相互作用
• 随机耦合：$J_{ij}$ 从高斯分布抽取
• 自旋玻璃模型

In [ ]:

import numpy as np
from qibo import hamiltonians
from qibo.symbols import Z

def create_sk_model(nqubits, J_variance=1.0, dense=False):
    """
    创建 Sherrington-Kirkpatrick 模型
    
    参数:
        nqubits: 量子比特数
        J_variance: 耦合强度方差
        dense: 是否使用稠密矩阵
    """
    # 生成随机耦合矩阵
    np.random.seed(42)  # 固定随机种子
    J_matrix = np.random.normal(0, J_variance/np.sqrt(nqubits), (nqubits, nqubits))
    J_matrix = (J_matrix + J_matrix.T) / 2  # 对称化
    np.fill_diagonal(J_matrix, 0)  # 对角线为0
    
    # 构建符号表达式
    form = 0
    for i in range(nqubits):
        for j in range(i+1, nqubits):
            form += J_matrix[i, j] * Z(i) * Z(j)
    
    return hamiltonians.SymbolicHamiltonian(form=form)

# 示例：创建 SK 模型
nqubits = 6
sk_ham = create_sk_model(nqubits)

print(f"SK 模型 ({nqubits} 量子比特):")
print(f"项数: {len(sk_ham.terms)}")
print(f"总相互作用数: {nqubits * (nqubits - 1) // 2}")

import numpy as np from qibo import hamiltonians from qibo.symbols import Z def create_sk_model(nqubits, J_variance=1.0, dense=False): """ 创建 Sherrington-Kirkpatrick 模型 参数: nqubits: 量子比特数 J_variance: 耦合强度方差 dense: 是否使用稠密矩阵 """ # 生成随机耦合矩阵 np.random.seed(42) # 固定随机种子 J_matrix = np.random.normal(0, J_variance/np.sqrt(nqubits), (nqubits, nqubits)) J_matrix = (J_matrix + J_matrix.T) / 2 # 对称化 np.fill_diagonal(J_matrix, 0) # 对角线为0 # 构建符号表达式 form = 0 for i in range(nqubits): for j in range(i+1, nqubits): form += J_matrix[i, j] * Z(i) * Z(j) return hamiltonians.SymbolicHamiltonian(form=form) # 示例：创建 SK 模型 nqubits = 6 sk_ham = create_sk_model(nqubits) print(f"SK 模型 ({nqubits} 量子比特):") print(f"项数: {len(sk_ham.terms)}") print(f"总相互作用数: {nqubits * (nqubits - 1) // 2}")

---

2. 优化问题哈密顿量¶

2.1 最大割问题 (MaxCut)¶

数学形式: $$ H = -\frac{1}{2} \sum_{i<j} W_{ij} (1 - Z_i \otimes Z_j) $$

参数说明:

• $W_{ij}$: 图中边 (i,j) 的权重
• 目标：最大化图的割集权重和

In [ ]:

# 创建 MaxCut 哈密顿量
def create_maxcut(nqubits, adj_matrix=None, dense=True):
    """
    创建最大割问题哈密顿量
    
    参数:
        nqubits: 图的节点数
        adj_matrix: 邻接矩阵 (默认全连接)
        dense: 是否使用稠密矩阵
    """
    return hamiltonians.MaxCut(nqubits=nqubits, adj_matrix=adj_matrix, dense=dense)

# 示例 1：默认全连接图
nqubits = 5
maxcut_default = create_maxcut(nqubits, dense=False)
print(f"MaxCut 哈密顿量 (全连接图, {nqubits} 节点):")
print(f"项数: {len(maxcut_default.terms)}")

# 示例 2：自定义图
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]
])

maxcut_custom = create_maxcut(nqubits, adj_matrix=adj_matrix, dense=False)
print(f"\nMaxCut 哈密顿量 (自定义图):")
print(f"项数: {len(maxcut_custom.terms)}")
print(f"符号形式: {maxcut_custom.form}")

# 创建 MaxCut 哈密顿量 def create_maxcut(nqubits, adj_matrix=None, dense=True): """ 创建最大割问题哈密顿量 参数: nqubits: 图的节点数 adj_matrix: 邻接矩阵 (默认全连接) dense: 是否使用稠密矩阵 """ return hamiltonians.MaxCut(nqubits=nqubits, adj_matrix=adj_matrix, dense=dense) # 示例 1：默认全连接图 nqubits = 5 maxcut_default = create_maxcut(nqubits, dense=False) print(f"MaxCut 哈密顿量 (全连接图, {nqubits} 节点):") print(f"项数: {len(maxcut_default.terms)}") # 示例 2：自定义图 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] ]) maxcut_custom = create_maxcut(nqubits, adj_matrix=adj_matrix, dense=False) print(f"\nMaxCut 哈密顿量 (自定义图):") print(f"项数: {len(maxcut_custom.terms)}") print(f"符号形式: {maxcut_custom.form}")

In [ ]:

# 使用 QAOA 求解 MaxCut
def solve_maxcut_with_qaoa(nqubits, adj_matrix=None, n_layers=2):
    """
    使用 QAOA 求解 MaxCut 问题
    
    参数:
        nqubits: 节点数
        adj_matrix: 邻接矩阵
        n_layers: QAOA 层数
    """
    # 创建哈密顿量
    ham = create_maxcut(nqubits, adj_matrix=adj_matrix, dense=False)
    
    # 创建 QAOA 模型
    qaoa = models.QAOA(ham, n_layers=n_layers)
    
    # 随机初始化参数
    initial_params = np.random.uniform(0, 2*np.pi, 2*n_layers)
    
    print(f"使用 QAOA 求解 {nqubits} 节点 MaxCut 问题 ({n_layers} 层)...")
    
    # 优化（注意：实际运行可能需要较长时间）
    # best_params, best_energy = qaoa.minimize(initial_params)
    
    # 这里仅演示创建，不执行优化
    print("QAOA 模型已创建（优化过程已注释）")
    print(f"参数数量: {2*n_layers}")
    
    return qaoa

# 演示
nqubits = 4
adj_matrix = np.array([
    [0, 1, 1, 0],
    [1, 0, 1, 1],
    [1, 1, 0, 1],
    [0, 1, 1, 0]
])

qaoa_model = solve_maxcut_with_qaoa(nqubits, adj_matrix, n_layers=2)

# 使用 QAOA 求解 MaxCut def solve_maxcut_with_qaoa(nqubits, adj_matrix=None, n_layers=2): """ 使用 QAOA 求解 MaxCut 问题 参数: nqubits: 节点数 adj_matrix: 邻接矩阵 n_layers: QAOA 层数 """ # 创建哈密顿量 ham = create_maxcut(nqubits, adj_matrix=adj_matrix, dense=False) # 创建 QAOA 模型 qaoa = models.QAOA(ham, n_layers=n_layers) # 随机初始化参数 initial_params = np.random.uniform(0, 2*np.pi, 2*n_layers) print(f"使用 QAOA 求解 {nqubits} 节点 MaxCut 问题 ({n_layers} 层)...") # 优化（注意：实际运行可能需要较长时间） # best_params, best_energy = qaoa.minimize(initial_params) # 这里仅演示创建，不执行优化 print("QAOA 模型已创建（优化过程已注释）") print(f"参数数量: {2*n_layers}") return qaoa # 演示 nqubits = 4 adj_matrix = np.array([ [0, 1, 1, 0], [1, 0, 1, 1], [1, 1, 0, 1], [0, 1, 1, 0] ]) qaoa_model = solve_maxcut_with_qaoa(nqubits, adj_matrix, n_layers=2)

2.2 QUBO (二次无约束二值优化)¶

通用形式: $$ H = \sum_{i,j} Q_{ij} x_i x_j + \sum_i c_i x_i $$

Ising 形式: $$ H = \sum_{i<j} J_{ij} Z_i Z_j + \sum_i h_i Z_i + \text{constant} $$

包含的问题:

• 最大割
• 图着色
• 背包问题
• 旅行商问题 (TSP)

In [ ]:

def create_qubo_hamiltonian(Q_matrix, c_vector=None):
    """
    从 QUBO 矩阵创建哈密顿量
    
    参数:
        Q_matrix: 二次项系数矩阵 (n x n)
        c_vector: 线性项系数向量 (可选)
    
    返回:
        SymbolicHamiltonian
    """
    n = len(Q_matrix)
    
    # 从 QUBO 变量 x 转换为 Ising 变量 Z
    # x_i = (1 - Z_i) / 2
    
    form = 0
    
    # 二次项
    for i in range(n):
        for j in range(n):
            if Q_matrix[i, j] != 0:
                form += Q_matrix[i, j] * (1 - Z(i)) * (1 - Z(j)) / 4
    
    # 线性项
    if c_vector is not None:
        for i in range(n):
            if c_vector[i] != 0:
                form += c_vector[i] * (1 - Z(i)) / 2
    
    return hamiltonians.SymbolicHamiltonian(form=form)

# 示例：简单的 QUBO 问题
Q = np.array([
    [1, -1, 0],
    [-1, 2, -1],
    [0, -1, 1]
])
c = np.array([0, 0, 0])

qubo_ham = create_qubo_hamiltonian(Q, c)
print(f"QUBO 哈密顿量:")
print(f"变量数: {len(Q)}")
print(f"项数: {len(qubo_ham.terms)}")

def create_qubo_hamiltonian(Q_matrix, c_vector=None): """ 从 QUBO 矩阵创建哈密顿量 参数: Q_matrix: 二次项系数矩阵 (n x n) c_vector: 线性项系数向量 (可选) 返回: SymbolicHamiltonian """ n = len(Q_matrix) # 从 QUBO 变量 x 转换为 Ising 变量 Z # x_i = (1 - Z_i) / 2 form = 0 # 二次项 for i in range(n): for j in range(n): if Q_matrix[i, j] != 0: form += Q_matrix[i, j] * (1 - Z(i)) * (1 - Z(j)) / 4 # 线性项 if c_vector is not None: for i in range(n): if c_vector[i] != 0: form += c_vector[i] * (1 - Z(i)) / 2 return hamiltonians.SymbolicHamiltonian(form=form) # 示例：简单的 QUBO 问题 Q = np.array([ [1, -1, 0], [-1, 2, -1], [0, -1, 1] ]) c = np.array([0, 0, 0]) qubo_ham = create_qubo_hamiltonian(Q, c) print(f"QUBO 哈密顿量:") print(f"变量数: {len(Q)}") print(f"项数: {len(qubo_ham.terms)}")

---

3. 多体物理哈密顿量¶

3.1 费米-哈伯德模型 (Fermi-Hubbard Model)¶

数学形式: $$ H = -t \sum_{\langle i,j \rangle, \sigma} (c^\dagger_{i\sigma} c_{j\sigma} + h.c.) + U \sum_i n_{i\uparrow} n_{i\downarrow} $$

参数说明:

• $t$: 跳跃振幅（动能项）
• $U$: 同格点库仑排斥势
• $c^\dagger, c$: 费米子产生/湮灭算符

物理意义:

• 强关联电子系统
• 金属-绝缘体转变
• 高温超导

In [ ]:

def create_hubbard_1d(n_sites, t=1.0, U=2.0):
    """
    创建一维费米-哈伯德模型
    
    注意: 需要将费米子算符映射到量子比特（Jordan-Wigner 或 Bravyi-Kitaev）
    这里使用简化版本演示概念
    
    参数:
        n_sites: 格点数
        t: 跳跃振幅
        U: 相互作用强度
    """
    # 简化版本：仅展示自旋部分
    # 实际实现需要费米子到量子比特的映射
    
    # 这里使用 Heisenberg 模型作为 Hubbard 的强关联极限
    # H = J sum (Z_i Z_{i+1} + 1/2(X_i X_{i+1} + Y_i Y_{i+1}))
    
    J = 4 * t**2 / U if U != 0 else 1.0
    
    form = 0
    for i in range(n_sites - 1):
        form += J * (Z(i) * Z(i+1) + 0.5 * (X(i) * X(i+1) + Y(i) * Y(i+1)))
    
    return hamiltonians.SymbolicHamiltonian(form=form)

# 示例
n_sites = 4
t = 1.0
U = 4.0

hubbard_ham = create_hubbard_1d(n_sites, t, U)
print(f"费米-哈伯德模型 ({n_sites} 格点):")
print(f"跳跃振幅 t = {t}")
print(f"相互作用 U = {U}")
print(f"有效耦合 J = 4t²/U = {4*t**2/U:.2f}")
print(f"项数: {len(hubbard_ham.terms)}")

def create_hubbard_1d(n_sites, t=1.0, U=2.0): """ 创建一维费米-哈伯德模型 注意: 需要将费米子算符映射到量子比特（Jordan-Wigner 或 Bravyi-Kitaev） 这里使用简化版本演示概念 参数: n_sites: 格点数 t: 跳跃振幅 U: 相互作用强度 """ # 简化版本：仅展示自旋部分 # 实际实现需要费米子到量子比特的映射 # 这里使用 Heisenberg 模型作为 Hubbard 的强关联极限 # H = J sum (Z_i Z_{i+1} + 1/2(X_i X_{i+1} + Y_i Y_{i+1})) J = 4 * t**2 / U if U != 0 else 1.0 form = 0 for i in range(n_sites - 1): form += J * (Z(i) * Z(i+1) + 0.5 * (X(i) * X(i+1) + Y(i) * Y(i+1))) return hamiltonians.SymbolicHamiltonian(form=form) # 示例 n_sites = 4 t = 1.0 U = 4.0 hubbard_ham = create_hubbard_1d(n_sites, t, U) print(f"费米-哈伯德模型 ({n_sites} 格点):") print(f"跳跃振幅 t = {t}") print(f"相互作用 U = {U}") print(f"有效耦合 J = 4t²/U = {4*t**2/U:.2f}") print(f"项数: {len(hubbard_ham.terms)}")

3.2 Lipkin-Meshkov-Glick (LMG) 模型¶

数学形式: $$ H = \frac{\varepsilon}{2} J_z + \frac{V}{2N} (J_x^2 + \gamma J_y^2) $$

参数说明:

• $\varepsilon$: 单粒子能级分裂
• $V$: 相互作用强度
• $\gamma$: 各向异性参数
• $J_\alpha = \frac{1}{2}\sum_i \sigma_\alpha^{(i)}$: 总自旋算符

物理意义:

• 核物理简化模型
• 全对全相互作用
• 可精确求解

In [ ]:

def create_lmg_model(nqubits, epsilon=1.0, V=1.0, gamma=1.0, dense=True):
    """
    创建 Lipkin-Meshkov-Glick 模型
    
    参数:
        nqubits: 粒子数
        epsilon: 单粒子能级分裂
        V: 相互作用强度
        gamma: 各向异性参数
        dense: 是否使用稠密矩阵
    """
    # 单粒子项
    form = (epsilon / 2) * sum(Z(i) for i in range(nqubits))
    
    # 相互作用项（全对全）
    # J_x^2 = (sum X_i)^2 / 4
    Jx = sum(X(i) for i in range(nqubits))
    Jy = sum(Y(i) for i in range(nqubits))
    
    form += (V / (2 * nqubits)) * (Jx * Jx + gamma * Jy * Jy)
    
    if dense and nqubits <= 10:
        # 转换为矩阵形式
        dense_ham = hamiltonians.SymbolicHamiltonian(form=form)
        return dense_ham.dense
    else:
        return hamiltonians.SymbolicHamiltonian(form=form)

# 示例
nqubits = 6
epsilon = 1.0
V = 0.5
gamma = 0.8

lmg_ham = create_lmg_model(nqubits, epsilon, V, gamma, dense=False)
print(f"LMG 模型 ({nqubits} 粒子):")
print(f"ε = {epsilon}, V = {V}, γ = {gamma}")
print(f"项数: {len(lmg_ham.terms)}")

def create_lmg_model(nqubits, epsilon=1.0, V=1.0, gamma=1.0, dense=True): """ 创建 Lipkin-Meshkov-Glick 模型 参数: nqubits: 粒子数 epsilon: 单粒子能级分裂 V: 相互作用强度 gamma: 各向异性参数 dense: 是否使用稠密矩阵 """ # 单粒子项 form = (epsilon / 2) * sum(Z(i) for i in range(nqubits)) # 相互作用项（全对全） # J_x^2 = (sum X_i)^2 / 4 Jx = sum(X(i) for i in range(nqubits)) Jy = sum(Y(i) for i in range(nqubits)) form += (V / (2 * nqubits)) * (Jx * Jx + gamma * Jy * Jy) if dense and nqubits <= 10: # 转换为矩阵形式 dense_ham = hamiltonians.SymbolicHamiltonian(form=form) return dense_ham.dense else: return hamiltonians.SymbolicHamiltonian(form=form) # 示例 nqubits = 6 epsilon = 1.0 V = 0.5 gamma = 0.8 lmg_ham = create_lmg_model(nqubits, epsilon, V, gamma, dense=False) print(f"LMG 模型 ({nqubits} 粒子):") print(f"ε = {epsilon}, V = {V}, γ = {gamma}") print(f"项数: {len(lmg_ham.terms)}")

In [ ]:

# 研究 LMG 模型的能谱
def plot_lmg_spectrum(nqubits=4, V_values=np.linspace(0, 2, 11)):
    """
    绘制 LMG 模型能谱随相互作用强度的变化
    """
    energies = []
    
    for V in V_values:
        ham = create_lmg_model(nqubits, epsilon=1.0, V=V, gamma=1.0, dense=True)
        eigvals = ham.eigenvalues()
        energies.append(eigvals[:5])
    
    energies = np.array(energies)
    
    plt.figure(figsize=(10, 6))
    for i in range(5):
        plt.plot(V_values, energies[:, i], 'o-', label=f'E_{i}', markersize=4)
    
    plt.xlabel('相互作用强度 V', fontsize=12)
    plt.ylabel('能量', fontsize=12)
    plt.title(f'LMG 模型能谱 ({nqubits} 粒子)', fontsize=14)
    plt.legend()
    plt.grid(alpha=0.3)
    plt.show()

# 绘制能谱
plot_lmg_spectrum()

# 研究 LMG 模型的能谱 def plot_lmg_spectrum(nqubits=4, V_values=np.linspace(0, 2, 11)): """ 绘制 LMG 模型能谱随相互作用强度的变化 """ energies = [] for V in V_values: ham = create_lmg_model(nqubits, epsilon=1.0, V=V, gamma=1.0, dense=True) eigvals = ham.eigenvalues() energies.append(eigvals[:5]) energies = np.array(energies) plt.figure(figsize=(10, 6)) for i in range(5): plt.plot(V_values, energies[:, i], 'o-', label=f'E_{i}', markersize=4) plt.xlabel('相互作用强度 V', fontsize=12) plt.ylabel('能量', fontsize=12) plt.title(f'LMG 模型能谱 ({nqubits} 粒子)', fontsize=14) plt.legend() plt.grid(alpha=0.3) plt.show() # 绘制能谱 plot_lmg_spectrum()

---

4. 核物理哈密顿量¶

4.1 配对哈密顿量 (Pairing Hamiltonian)¶

数学形式: $$ H = \sum_i \varepsilon_i n_i - G \sum_{i,j} P^\dagger_i P_j $$

其中: $$P^\dagger_i = c^\dagger_{i\uparrow} c^\dagger_{i\downarrow}$$

物理意义:

• 核子间的配对相互作用
• 超导性
• 能隙

In [ ]:

def create_pairing_hamiltonian(n_levels, G=0.5, epsilon_spacing=1.0):
    """
    创建简化的配对哈密顿量模型
    
    参数:
        n_levels: 能级数
        G: 配对相互作用强度
        epsilon_spacing: 能级间距
    """
    # 简化版本：使用自旋模型表示配对
    # 每个能级用 2 个量子比特表示（自旋向上和向下）
    
    nqubits = 2 * n_levels
    form = 0
    
    # 单粒子项
    for i in range(n_levels):
        eps_i = i * epsilon_spacing
        form += eps_i * (Z(2*i) + Z(2*i+1)) / 2
    
    # 配对相互作用项（简化）
    for i in range(n_levels):
        for j in range(n_levels):
            # 使用 X 和 Y 表示配对产生/湮灭
            form += -G * (X(2*i) * X(2*j) + Y(2*i) * Y(2*j)) / 4
    
    return hamiltonians.SymbolicHamiltonian(form=form)

# 示例
n_levels = 3
G = 0.3

pairing_ham = create_pairing_hamiltonian(n_levels, G=G)
print(f"配对哈密顿量 ({n_levels} 能级):")
print(f"相互作用强度 G = {G}")
print(f"量子比特数: {pairing_ham.nqubits}")

def create_pairing_hamiltonian(n_levels, G=0.5, epsilon_spacing=1.0): """ 创建简化的配对哈密顿量模型 参数: n_levels: 能级数 G: 配对相互作用强度 epsilon_spacing: 能级间距 """ # 简化版本：使用自旋模型表示配对 # 每个能级用 2 个量子比特表示（自旋向上和向下） nqubits = 2 * n_levels form = 0 # 单粒子项 for i in range(n_levels): eps_i = i * epsilon_spacing form += eps_i * (Z(2*i) + Z(2*i+1)) / 2 # 配对相互作用项（简化） for i in range(n_levels): for j in range(n_levels): # 使用 X 和 Y 表示配对产生/湮灭 form += -G * (X(2*i) * X(2*j) + Y(2*i) * Y(2*j)) / 4 return hamiltonians.SymbolicHamiltonian(form=form) # 示例 n_levels = 3 G = 0.3 pairing_ham = create_pairing_hamiltonian(n_levels, G=G) print(f"配对哈密顿量 ({n_levels} 能级):") print(f"相互作用强度 G = {G}") print(f"量子比特数: {pairing_ham.nqubits}")

---

5. 实用示例¶

5.1 计算基态和能谱¶

In [ ]:

def analyze_hamiltonian(ham, name="哈密顿量"):
    """
    分析哈密顿量的基本性质
    
    参数:
        ham: 哈密顿量对象
        name: 哈密顿量名称
    """
    print(f"\n{'='*60}")
    print(f"{name} 分析")
    print(f"{'='*60}")
    
    # 基本信息
    print(f"量子比特数: {ham.nqubits}")
    
    # 计算特征值
    eigvals = ham.eigenvalues()
    print(f"\n前 5 个能级:")
    for i, E in enumerate(eigvals[:5]):
        print(f"  E_{i} = {E:.6f}")
    
    # 基态
    gs = ham.ground_state()
    gs_energy = ham.expectation(gs)
    print(f"\n基态能量: {gs_energy:.6f}")
    
    # 能隙
    if len(eigvals) > 1:
        gap = eigvals[1] - eigvals[0]
        print(f"能隙: {gap:.6f}")
    
    return eigvals, gs

# 分析几个哈密顿量
tfim_ham_dense = hamiltonians.TFIM(4, h=1.0)
analyze_hamiltonian(tfim_ham_dense, "TFIM (4q, h=1.0)")

xxz_ham_dense = hamiltonians.XXZ(4, delta=0.5)
analyze_hamiltonian(xxz_ham_dense, "XXZ (4q, Δ=0.5)")

def analyze_hamiltonian(ham, name="哈密顿量"): """ 分析哈密顿量的基本性质 参数: ham: 哈密顿量对象 name: 哈密顿量名称 """ print(f"\n{'='*60}") print(f"{name} 分析") print(f"{'='*60}") # 基本信息 print(f"量子比特数: {ham.nqubits}") # 计算特征值 eigvals = ham.eigenvalues() print(f"\n前 5 个能级:") for i, E in enumerate(eigvals[:5]): print(f" E_{i} = {E:.6f}") # 基态 gs = ham.ground_state() gs_energy = ham.expectation(gs) print(f"\n基态能量: {gs_energy:.6f}") # 能隙 if len(eigvals) > 1: gap = eigvals[1] - eigvals[0] print(f"能隙: {gap:.6f}") return eigvals, gs # 分析几个哈密顿量 tfim_ham_dense = hamiltonians.TFIM(4, h=1.0) analyze_hamiltonian(tfim_ham_dense, "TFIM (4q, h=1.0)") xxz_ham_dense = hamiltonians.XXZ(4, delta=0.5) analyze_hamiltonian(xxz_ham_dense, "XXZ (4q, Δ=0.5)")

5.2 时间演化模拟¶

In [ ]:

def time_evolution_trotter(ham, initial_state, T=1.0, dt=0.01):
    """
    使用 Trotter 分解模拟时间演化
    
    参数:
        ham: 哈密顿量
        initial_state: 初始状态
        T: 总时间
        dt: 时间步长
    
    返回:
        演化后的状态
    """
    # 仅 SymbolicHamiltonian 支持 circuit 方法
    if not isinstance(ham, hamiltonians.SymbolicHamiltonian):
        print("警告: 仅 SymbolicHamiltonian 支持 Trotter 分解")
        return None
    
    n_steps = int(T / dt)
    state = initial_state.copy()
    
    for step in range(n_steps):
        # 创建 Trotter 步的电路
        trotter_circuit = ham.circuit(dt)
        
        # 应用到状态
        state = trotter_circuit(initial_state=state).state()
        
        if (step + 1) % 10 == 0:
            energy = ham.expectation(state)
            print(f"步骤 {step+1}/{n_steps}, 能量: {energy:.6f}")
    
    return state

# 示例：TFIM 的时间演化
print("TFIM 时间演化模拟:")
tfim_ham_symbolic = hamiltonians.TFIM(4, h=0.5, dense=False)

# 创建初态（所有自旋向上）
circuit = Circuit(4)
initial_state = circuit().state()

# 演化（注意：实际运行可能需要较长时间）
# final_state = time_evolution_trotter(tfim_ham_symbolic, initial_state, T=0.5, dt=0.05)
print("时间演化函数已定义（实际运行已注释）")

def time_evolution_trotter(ham, initial_state, T=1.0, dt=0.01): """ 使用 Trotter 分解模拟时间演化 参数: ham: 哈密顿量 initial_state: 初始状态 T: 总时间 dt: 时间步长 返回: 演化后的状态 """ # 仅 SymbolicHamiltonian 支持 circuit 方法 if not isinstance(ham, hamiltonians.SymbolicHamiltonian): print("警告: 仅 SymbolicHamiltonian 支持 Trotter 分解") return None n_steps = int(T / dt) state = initial_state.copy() for step in range(n_steps): # 创建 Trotter 步的电路 trotter_circuit = ham.circuit(dt) # 应用到状态 state = trotter_circuit(initial_state=state).state() if (step + 1) % 10 == 0: energy = ham.expectation(state) print(f"步骤 {step+1}/{n_steps}, 能量: {energy:.6f}") return state # 示例：TFIM 的时间演化 print("TFIM 时间演化模拟:") tfim_ham_symbolic = hamiltonians.TFIM(4, h=0.5, dense=False) # 创建初态（所有自旋向上） circuit = Circuit(4) initial_state = circuit().state() # 演化（注意：实际运行可能需要较长时间） # final_state = time_evolution_trotter(tfim_ham_symbolic, initial_state, T=0.5, dt=0.05) print("时间演化函数已定义（实际运行已注释）")

5.3 期望值计算¶

In [ ]:

# 创建哈密顿量和状态
tfim_ham = hamiltonians.TFIM(3, h=1.0)

# 创建叠加态
circuit = Circuit(3)
circuit.add(gates.H(0))
circuit.add(gates.H(1))
circuit.add(gates.H(2))
result = circuit()

state = result.state()

# 计算期望值
exp_value = tfim_ham.expectation(state)
print(f"叠加态在 TFIM 中的期望值: {exp_value:.6f}")

# 从测量样本计算（仅对角哈密顿量）
z_ham = hamiltonians.Z(3)
frequencies = result.frequencies()
exp_from_samples = z_ham.expectation_from_samples(frequencies)
print(f"\nZ 哈密顿量从样本计算的期望值: {exp_from_samples:.6f}")

# 创建哈密顿量和状态 tfim_ham = hamiltonians.TFIM(3, h=1.0) # 创建叠加态 circuit = Circuit(3) circuit.add(gates.H(0)) circuit.add(gates.H(1)) circuit.add(gates.H(2)) result = circuit() state = result.state() # 计算期望值 exp_value = tfim_ham.expectation(state) print(f"叠加态在 TFIM 中的期望值: {exp_value:.6f}") # 从测量样本计算（仅对角哈密顿量） z_ham = hamiltonians.Z(3) frequencies = result.frequencies() exp_from_samples = z_ham.expectation_from_samples(frequencies) print(f"\nZ 哈密顿量从样本计算的期望值: {exp_from_samples:.6f}")

5.4 绝热演化¶

In [ ]:

# 创建绝热演化
def create_adiabatic_evolution(nqubits, h0_ham, h1_ham, final_time=10.0):
    """
    创建绝热演化模型
    
    参数:
        nqubits: 量子比特数
        h0_ham: 初始哈密顿量
        h1_ham: 目标哈密顿量
        final_time: 总演化时间
    """
    # 定义调度函数
    def schedule(t):
        """线性调度"""
        return t
    
    # 创建绝热演化模型
    evolution = models.AdiabaticEvolution(
        h0_ham, h1_ham,
        schedule,
        dt=0.01
    )
    
    print(f"绝热演化模型已创建:")
    print(f"  初始哈密顿量: {type(h0_ham).__name__}")
    print(f"  目标哈密顿量: {type(h1_ham).__name__}")
    print(f"  总演化时间: {final_time}")
    
    return evolution

# 示例：从 X 哈密顿量演化到 TFIM
nqubits = 4
h0 = hamiltonians.X(nqubits, dense=False)  # 初始
h1 = hamiltonians.TFIM(nqubits, h=1.0, dense=False)  # 目标

evolution = create_adiabatic_evolution(nqubits, h0, h1, final_time=5.0)

# 执行演化（注意：实际运行需要时间）
# final_state = evolution(final_time=5.0)
print("\n绝热演化模型已创建（实际运行已注释）")

# 创建绝热演化 def create_adiabatic_evolution(nqubits, h0_ham, h1_ham, final_time=10.0): """ 创建绝热演化模型 参数: nqubits: 量子比特数 h0_ham: 初始哈密顿量 h1_ham: 目标哈密顿量 final_time: 总演化时间 """ # 定义调度函数 def schedule(t): """线性调度""" return t # 创建绝热演化模型 evolution = models.AdiabaticEvolution( h0_ham, h1_ham, schedule, dt=0.01 ) print(f"绝热演化模型已创建:") print(f" 初始哈密顿量: {type(h0_ham).__name__}") print(f" 目标哈密顿量: {type(h1_ham).__name__}") print(f" 总演化时间: {final_time}") return evolution # 示例：从 X 哈密顿量演化到 TFIM nqubits = 4 h0 = hamiltonians.X(nqubits, dense=False) # 初始 h1 = hamiltonians.TFIM(nqubits, h=1.0, dense=False) # 目标 evolution = create_adiabatic_evolution(nqubits, h0, h1, final_time=5.0) # 执行演化（注意：实际运行需要时间） # final_state = evolution(final_time=5.0) print("\n绝热演化模型已创建（实际运行已注释）")

5.5 多个哈密顿量的组合¶

In [ ]:

# 演示哈密顿量的运算
nqubits = 3

H1 = hamiltonians.X(nqubits, dense=False)
H2 = hamiltonians.Z(nqubits, dense=False)

# 哈密顿量组合
H_sum = H1 + H2  # 加法
H_diff = H1 - H2  # 减法
H_scaled = 2.0 * H1  # 标量乘法

print("哈密顿量运算:")
print(f"H1 (X): {H1.form}")
print(f"H2 (Z): {H2.form}")
print(f"\nH1 + H2: {H_sum.form}")
print(f"H1 - H2: {H_diff.form}")
print(f"2.0 * H1: {H_scaled.form}")

# 作用到状态
circuit = Circuit(nqubits)
state = circuit().state()

new_state = H1 @ state
print(f"\nH1 作用到状态后的范数: {np.linalg.norm(new_state):.6f}")

# 演示哈密顿量的运算 nqubits = 3 H1 = hamiltonians.X(nqubits, dense=False) H2 = hamiltonians.Z(nqubits, dense=False) # 哈密顿量组合 H_sum = H1 + H2 # 加法 H_diff = H1 - H2 # 减法 H_scaled = 2.0 * H1 # 标量乘法 print("哈密顿量运算:") print(f"H1 (X): {H1.form}") print(f"H2 (Z): {H2.form}") print(f"\nH1 + H2: {H_sum.form}") print(f"H1 - H2: {H_diff.form}") print(f"2.0 * H1: {H_scaled.form}") # 作用到状态 circuit = Circuit(nqubits) state = circuit().state() new_state = H1 @ state print(f"\nH1 作用到状态后的范数: {np.linalg.norm(new_state):.6f}")

---

6. 总结与最佳实践¶

6.1 哈密顿量选择指南¶

量子比特数	推荐类型	内存	速度
≤ 10	Hamiltonian (稠密)	高	快
> 10	SymbolicHamiltonian (符号)	低	较慢

6.2 常用哈密顿量总结¶

哈密顿量	函数	应用
TFIM	hamiltonians.TFIM()	QAOA, 量子退火
XXZ	hamiltonians.XXZ()	量子多体
Heisenberg	hamiltonians.Heisenberg()	强关联系统
MaxCut	hamiltonians.MaxCut()	组合优化
X/Y/Z	hamiltonians.X/Y/Z()	QAOA mixer

6.3 性能优化建议¶

1. 大规模系统：使用 dense=False
2. 频繁对角化：使用 Hamiltonian
3. 变分算法：使用 SymbolicHamiltonian
4. 缓存结果：利用自动缓存机制

6.4 实用技巧¶

• 使用 expectation_from_circuit() 支持非对角可观测量
• 使用 circuit(dt) 进行 Trotter 时间演化
• 使用 ground_state() 快速获取基态
• 使用 eigenvalues() 和 eigenvectors() 计算能谱

---

参考资源¶

Qibo 官方文档¶

• Qibo Documentation
• Qibo GitHub

相关论文¶

• TFIM: VQE for Ising Model (2024)
• QAOA: The QAOA and SK Model (2022)
• Hubbard: Resource-optimized simulation (2025)
• LMG: Solving the Lipkin model (2024)

---

恭喜！ 你已经学会了如何使用 Qibo 实现量子计算中常见的各种哈密顿量。

继续探索：

• 尝试不同的参数值
• 运行 QAOA 和 VQE 算法
• 研究量子相变
• 求解优化问题