tutorials/quantum_simulation/DistributedVQE_CN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c1a5f1e6",
   "metadata": {},
   "source": [
    "# 基于施密特分解的分布式变分量子本征求解器\n",
    "\n",
    "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf44390c",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 概览\n",
    "\n",
    "在物理和化学等学科中，一个非常重要的问题就是提取分子、原子等物理系统的基态信息。系统的基态是由系统对应的哈密顿量决定的。目前普遍认为量子计算机在求解哈密顿量基态问题上具有优势。[变分量子本征求解器](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)（variational quantum eigensolver, VQE），作为有望在近期展现量子优势的算法之一，为研究者们提供了可以在含噪的中等规模量子（NISQ）设备上研究量子化学的可能。然而，目前 NISQ 设备仍存在许多局限性，阻碍了大规模量子算法的运行。例如，受限于现有量子设备所能提供的量子比特数，研究者们无法利用 VQE 在 NISQ 设备上模拟真实的大分子。为了突破这一限制，许多分布式方案 [1-3] 相继被提出。\n",
    "在本教程中，我们以 [4] 提出的基于施密特分解的 VQE 为例，向读者展示如何利用 Paddle Quantum 实现分布式量子算法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3fcc1b4",
   "metadata": {},
   "source": [
    "## 施密特分解\n",
    "\n",
    "对于任意处于复合系统 $AB$ 上的纯态 $|\\psi\\rangle$，我们有如下平凡分解:\n",
    "\n",
    "$$\n",
    "|\\psi\\rangle=\\sum_{ij}a_{ij}|i\\rangle\\otimes|j\\rangle,\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "其中 $|i\\rangle$ 和 $|j\\rangle$ 分别是子系统 $A$、$B$ 上的计算基底，$a_{ij}$ 是某复矩阵 $a$ 的元素。接下来，我们对矩阵 $a$ 运用[奇异值分解](https://zh.wikipedia.org/wiki/奇异值分解)（singular value decomposition, SVD），即，$a = udv$，其中 $u,v$ 是酉矩阵，$d$ 是对角矩阵。那么，$a_{ij}=\\sum_ku_{ik}d_{kk}v_{kj}$。\n",
    "\n",
    "通过定义 \n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "|k_A\\rangle\\equiv & \\sum_iu_{ik}|i\\rangle=u|k\\rangle,\\\\\n",
    "|k_B\\rangle\\equiv & \\sum_jv_{kj}|j\\rangle=v^T|k\\rangle,\\\\\n",
    "\\lambda_k\\equiv & d_{kk},\\end{aligned}\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "我们可以把（1）式重写为\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "    |\\psi\\rangle  &= \\sum_{ijk}u_{ik}d_{kk}v_{kj}|i\\rangle\\otimes|j\\rangle \\\\\n",
    "                &= \\sum_{k}\\lambda_{k}\\Big(\\sum_iu_{ik}|i\\rangle\\Big)\\otimes\\Big(\\sum_jv_{kj}|j\\rangle\\Big) \\\\\n",
    "                &=\\sum_{k}\\lambda_k(u|k\\rangle\\otimes v^T|k\\rangle)\\\\\n",
    "                &=\\sum_{k}\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle.\n",
    "\\end{aligned}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "形如 $|\\psi\\rangle=\\sum_k\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle$ 的分解方式就称为 **施密特分解**  [5]。同时，$\\{\\lambda_k\\}_k$ 被称作施密特系数，非零 $\\lambda_k$ 的数量被称为 $|\\psi\\rangle$ 的施密特秩。事实上，奇异值分解的性质还保证了 $\\lambda_k\\in\\mathbb{R}^+$ 及 $\\sum_k\\lambda_k^2=1$。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "620e053c",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 基于施密特分解的分布式 VQE\n",
    "\n",
    "作为标准 VQE [6] 的一个变种，分布式 VQE 同样试图寻找一个 $N$ 量子比特哈密顿量 $\\hat{H}=\\sum_tc_t\\hat{H}_t^{(A)}\\otimes\\hat{H}_t^{(B)}$ 的基态及其能量，其中 $\\hat{H}_t^{(A)},\\hat{H}_t^{(B)}$ 是分别作用于子系统 $A$、$B$ 上的哈密顿量分量（我们假设 $A$、$B$ 都包含 $N/2$ 量子比特）。\n",
    "\n",
    "我们从如下试探波函数开始：\n",
    "\n",
    "$$\n",
    "|\\psi\\rangle\\equiv\\sum_{k=1}^S\\lambda_k\\Big(U(\\boldsymbol{\\theta})|k\\rangle\\Big)\\otimes\\Big(V(\\boldsymbol{\\phi})|k\\rangle\\Big)\n",
    "\\tag{4},\n",
    "$$\n",
    "\n",
    "其中 $\\boldsymbol{\\lambda}\\equiv(\\lambda_1, \\lambda_2,...,\\lambda_S)^T$，$1\\leq S\\leq 2^{N/2}$ 是一个用户定义的常数。根据施密特分解，目标基态同样可写成（4）式的形式。因此，通过寻找合适的参数向量 $\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}$ 和 $\\boldsymbol{\\phi}$，我们可以在任意误差内近似目标基态。\n",
    "\n",
    "接下来，对于所有 $i,j=1,...,S$，我们在一台 $N/2$ 量子比特的量子计算机上计算如下项：\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "E_{ijt}^A(\\boldsymbol{\\theta}) &\\equiv \\langle i|U^\\dagger(\\boldsymbol{\\theta}) \\hat{H}_t^{(A)} U(\\boldsymbol{\\theta})|j\\rangle,\\\\\n",
    "E_{ijt}^B(\\boldsymbol{\\phi}) &\\equiv \\langle i|V^\\dagger(\\boldsymbol{\\phi}) \\hat{H}_t^{(B)} V(\\boldsymbol{\\phi}))|j\\rangle.\n",
    "\\end{aligned}\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "然后，在一台经典计算机上，我们根据如下定义构造一个 $S\\times S$ 维的矩阵 $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$：\n",
    "\n",
    "$$\n",
    "[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\equiv\\sum_tc_tE_{ijt}^A(\\boldsymbol{\\theta})E_{ijt}^B(\\boldsymbol{\\phi}).\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "这样，目标基态能量就可以写为 \n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "E_{tar}   &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}} \\langle{\\psi}|\\hat{H}|\\psi\\rangle \\\\\n",
    "    &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}}\\Big(\\sum_{i,j=1}^S\\lambda_i\\lambda_j[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\Big)\\\\\n",
    "    &= \\min_{\\boldsymbol{\\theta}, \\boldsymbol{\\phi}} E(\\boldsymbol{\\theta},\\boldsymbol{\\phi}),\n",
    "\\end{aligned}\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "其中 $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\equiv\\min_{\\boldsymbol{\\lambda}} \\boldsymbol{\\lambda}^T M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\boldsymbol{\\lambda}$。根据线性代数的内容，不难发现，$E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ 正是矩阵 $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ 的最小特征值，可以通过经典算法求得。\n",
    "\n",
    "最终，我们重复如上过程，并使用基于梯度下降的优化方法最小化 $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$，使其趋近于 $E_{tar}$。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f79d3333",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 量桨实现\n",
    "\n",
    "首先，我们导入必要的包。由于我们要使用飞桨和量桨的最新功能，请确保您的 *PaddlePaddle* >= 2.2.0 且 *Paddle Quantum* >= 2.2.0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bb7c0db4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/v_zhanglei48/opt/anaconda3/envs/pq/lib/python3.8/site-packages/paddle/tensor/creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "/Users/v_zhanglei48/opt/anaconda3/envs/pq/lib/python3.8/site-packages/paddle/tensor/creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "import paddle\n",
    "import paddle_quantum\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.hamiltonian import Hamiltonian\n",
    "from paddle_quantum.loss import ExpecVal\n",
    "from paddle_quantum.state import State\n",
    "from paddle_quantum.qinfo import pauli_str_to_matrix, schmidt_decompose\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c84dd264",
   "metadata": {},
   "source": [
    "定义一些全局常数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "27e4ce36",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10     # 量子比特数\n",
    "SEED = 16   # 固定随机种子\n",
    "ITR = 100   # 设置迭代次数\n",
    "LR = 0.1    # 设置学习率\n",
    "D = 3       # 设置量子神经网络的层数"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3db38f56",
   "metadata": {},
   "source": [
    "下面这一函数经典地计算出哈密顿量 $H$ 的基态信息（基态对能量和施密特秩），以作为后面量子模型的基准参照。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "32b310ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ground_state_info(H):\n",
    "\n",
    "    # 计算 H 的特征值与特征向量\n",
    "    vals, vecs = paddle.linalg.eigh(H)\n",
    "    # 获取基态\n",
    "    ground_state = paddle_quantum.State(vecs[:, 0])\n",
    "    # 获取基态能量\n",
    "    ground_state_energy = vals.tolist()[0]\n",
    "    print(f'The ground state energy is {ground_state_energy:.5f} Ha.')\n",
    "    # 对基态运用施密特分解\n",
    "    l, _, _ = schmidt_decompose(ground_state)\n",
    "    print(f'Schmidt rank of the ground state is {l.size}.')\n",
    "\n",
    "    return ground_state_energy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c2c88d3",
   "metadata": {},
   "source": [
    "现在，我们生成一个哈密顿量并计算其基态信息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6149b4d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The ground state energy is -0.99783 Ha.\n",
      "Schmidt rank of the ground state is 32.\n"
     ]
    }
   ],
   "source": [
    "# 固定随机种子\n",
    "np.random.seed(SEED)\n",
    "\n",
    "# 硬编码一个哈密顿量\n",
    "coefs = [-0.8886258, 0.453882]\n",
    "pauli_str = ['x0,z1,z2,z4,x5,y6,y7,x8,x9', 'y0,x1,x2,x3,y4,x5,z6,z7,y8,x9']\n",
    "pauli_str_A = ['x0,z1,z2,z4', 'y0,x1,x2,x3,y4']     # 子系统 A 的泡利字符串\n",
    "pauli_str_B = ['x0,y1,y2,x3,x4', 'x0,z1,z2,y3,x4']  # 子系统 B 的泡利字符串\n",
    "\n",
    "# 把相关对象转换为张量形式\n",
    "H = Hamiltonian(list(zip(coefs, pauli_str)))\n",
    "H_mtr = paddle.to_tensor(H.construct_h_matrix())\n",
    "coefs = paddle.to_tensor(coefs)\n",
    "H_A = [pauli_str_to_matrix([[1., pstr]], n=N//2) for pstr in pauli_str_A]\n",
    "H_A = paddle.to_tensor(np.stack(H_A))\n",
    "H_B = [pauli_str_to_matrix([[1., pstr]], n=N-N//2) for pstr in pauli_str_B]\n",
    "H_B = paddle.to_tensor(np.stack(H_B))\n",
    "\n",
    "# 计算该哈密顿量的基态信息\n",
    "ground_state_energy = get_ground_state_info(H_mtr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9abf331c",
   "metadata": {},
   "source": [
    "准备好一个哈密顿量后，我们可以构建一个分布式 VQE 来求解它。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "32cacc67",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构造参数化量子电路\n",
    "def U_cir(N, D):\n",
    "    cir = Circuit(N)  # 初始化一个宽度为 N 量子比特的电路\n",
    "    cir.complex_entangled_layer(depth=D)  # 添加量子门\n",
    "    return cir  \n",
    "\n",
    "# 把参数化电路作用在计算基底上\n",
    "# 并返回一个形状为 [2**N, num_states] 的张量\n",
    "def output_states(num_states, N, cir):\n",
    "    # 创建 num_states 个计算基底\n",
    "    basis = paddle.eye(2**N, num_states)\n",
    "\n",
    "    # 获取参数化电路的矩阵\n",
    "    U = cir.unitary_matrix()\n",
    "    \n",
    "    # 把参数化电路作用在这些基底上\n",
    "    vec = U @ basis                         \n",
    "    \n",
    "    return vec"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ca5787c",
   "metadata": {},
   "source": [
    "以下代码是本教程的核心。请读者仔细阅读，并与前文的公式叙述做比较。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6ebf5159",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构造分布式模型\n",
    "class DistributedVQE(paddle.nn.Layer):\n",
    "    def __init__(self, N, D, S):\n",
    "        super().__init__()\n",
    "        paddle.seed(SEED)\n",
    "\n",
    "        self.S = S  # 定义常数 S\n",
    "        self.N = N\n",
    "        self.cir = [U_cir(N//2, D), U_cir(N - N//2, D)]\n",
    "        \n",
    "    # 分布式 VQE 的核心逻辑\n",
    "    def forward(self):\n",
    "        # 分别获得子系统 A、B 上的 U|k> 和 V|k> \n",
    "        vec_A = output_states(self.S, self.N//2, self.cir[0])\n",
    "        vec_B = output_states(self.S, self.N - self.N//2, self.cir[1])\n",
    "        \n",
    "        # 计算由前文定义的 E_{ijt}^A 和 E_{ijt}^B 组成的张量 E_A, E_B\n",
    "        E_A = vec_A.conj().t() @ H_A @ vec_A\n",
    "        E_B = vec_B.conj().t() @ H_B @ vec_B\n",
    "        M = (coefs.reshape([-1, 1, 1]) * E_A * E_B).sum(0)\n",
    "\n",
    "        # 计算矩阵 M 的最小特征值\n",
    "        eigval = paddle.linalg.eigvalsh(M)\n",
    "        loss = eigval[0]\n",
    "        \n",
    "        return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d04669ff",
   "metadata": {},
   "source": [
    "定义训练函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "066f5e72",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model):\n",
    "    start_time = time.time()    # 用以计算该函数的运行时长\n",
    "    params = sum([cir.parameters() for cir in model.cir], [])\n",
    "    # 我们使用基于梯度下降的优化器 Adam 来优化 theta 和 phi\n",
    "    opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n",
    "    summary_loss = []           # 记录损失历史\n",
    "\n",
    "    # 迭代优化\n",
    "    for itr in range(ITR):\n",
    "        # 前向传播，计算损失函数\n",
    "        loss = model()\n",
    "        # 后向传播，优化损失函数\n",
    "        loss.backward()\n",
    "        opt.minimize(loss)\n",
    "        opt.clear_grad()\n",
    "        # 更新优化结果\n",
    "        summary_loss.append(loss.numpy())\n",
    "        # 打印中间结果\n",
    "        if (itr+1) % 20 == 0:\n",
    "            print(f\"iter: {itr+1}, loss: {loss.tolist()[0]: .4f} Ha\")\n",
    "\n",
    "    print(f'Ground truth is  {ground_state_energy:.4f} Ha')\n",
    "    print(f'Training took {time.time() - start_time:.2f}s')\n",
    "    \n",
    "    plt.plot(list(range(ITR)), summary_loss, color='r', label='loss')\n",
    "    plt.hlines(y=ground_state_energy, xmin=0, xmax=ITR, linestyle=':',  label='ground truth')\n",
    "    plt.legend()\n",
    "    plt.title(f'Loss for {type(model).__name__} on a {N}-qubit Hamiltonian')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8770b19",
   "metadata": {},
   "source": [
    "现在，我们实例化并训练分布式模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "78b46dcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 20, loss: -0.9244 Ha\n",
      "iter: 40, loss: -0.9906 Ha\n",
      "iter: 60, loss: -0.9968 Ha\n",
      "iter: 80, loss: -0.9977 Ha\n",
      "iter: 100, loss: -0.9978 Ha\n",
      "Ground truth is  -0.9978 Ha\n",
      "Training took 11.03s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 注意，由于我们构造的哈密顿量在两子系统间相互作用较小，我们只需设置 S = 4.\n",
    "#（更多解释请见总结部分）\n",
    "vqe = DistributedVQE(N, D, S=4)\n",
    "train(vqe)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eb85055",
   "metadata": {},
   "source": [
    "在上图中，我们用虚线画出了真实的基态能量。可以看到，loss 曲线收敛至虚线，表明我们的分布式 VQE 成功找到了该哈密顿量的基态能量。然而，要妥当地评估我们的模型，我们还需将它与标准 VQE 做比较。因此，下面我们构建标准 VQE 模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2fff9166",
   "metadata": {},
   "outputs": [],
   "source": [
    "class StandardVQE(paddle.nn.Layer):\n",
    "    def __init__(self, N, D, S):\n",
    "        super().__init__()\n",
    "        paddle.seed(SEED)\n",
    "        self.cir = U_cir(N, D)\n",
    "        self.loss_fcn = ExpecVal(H)\n",
    "      \n",
    "    def forward(self):\n",
    "        output_state = self.cir()\n",
    "        loss = self.loss_fcn(output_state)\n",
    "        return loss.cast('float64').flatten()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bc5dcfd",
   "metadata": {},
   "source": [
    "实例化并训练标准 VQE。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a35f3eb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 20, loss: -0.8365 Ha\n",
      "iter: 40, loss: -0.9852 Ha\n",
      "iter: 60, loss: -0.9958 Ha\n",
      "iter: 80, loss: -0.9975 Ha\n",
      "iter: 100, loss: -0.9978 Ha\n",
      "Ground truth is  -0.9978 Ha\n",
      "Training took 6.84s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "svqe = StandardVQE(N, D, S=1)\n",
    "train(svqe)  # 训练标准 VQE"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5688a618",
   "metadata": {},
   "source": [
    "有趣的是，在分布式模型中，我们只需模拟两个 $N/2$ 量子比特的酉变换，这无论在时间还是空间上，都比标准 VQE 中模拟一个 $N$ 量子比特的酉变换高效得多。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94cda668",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 总结\n",
    "\n",
    "在此教程中，我们构造了一个分布式 VQE 并展示了其部分优势：\n",
    "- NISQ 设备的计算范围得以拓展。通过分布式策略，我们可以运行超过硬件量子比特数的量子算法。\n",
    "- 计算效率得到提升。对于量子过程的经典模拟而言，分布式算法降低了酉矩阵的维度，因此降低了模拟这些矩阵所需的时间、空间消耗。\n",
    "\n",
    "同时，需要注意的是，用户定义的常数 $S$ 在训练准确度和效率上扮演了重要角色：\n",
    "- 对于子系统间相互作用弱的哈密顿量而言，其基态在子系统间纠缠较弱 [7]。因此，其施密特秩较低，可以被一个较小的 $S$ 精确且高效地模拟。事实上，我们所给的演示及大多数物理、化学中有意义的哈密顿量都具有此性质。\n",
    "- 相反的，对于子系统间相互作用强的哈密顿量而言，其基态在子系统间纠缠较强，因此需要一个较大的 $S$ 来模拟。但是，无论如何，$S$ 的上界是 $2^{N/2}$，因此矩阵 $M$ 的维度上界是 $2^{N/2}\\times2^{N/2}$，这仍然比初始哈密顿量的维度（$2^{N}\\times 2^{N}$）小。因此，该算法的效率总是优于纯经典模拟。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "922679aa",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "_______\n",
    "\n",
    "# 参考文献\n",
    "\n",
    "[1] Fujii, Keisuke, et al. \"Deep Variational Quantum Eigensolver: a divide-and-conquer method for solving a larger problem with smaller size quantum computers.\" [arXiv preprint arXiv:2007.10917 (2020)](https://arxiv.org/abs/2007.10917).\n",
    "\n",
    "[2] Zhang, Yu, et al. \"Variational Quantum Eigensolver with Reduced Circuit Complexity.\" [arXiv preprint arXiv:2106.07619 (2021)](https://arxiv.org/abs/2106.07619).\n",
    "\n",
    "[3] Peng, Tianyi et al. \"Simulating Large Quantum Circuits On A Small Quantum Computer\". [Physical Review Letters 125.15, (2020): 150504](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.150504).\n",
    "\n",
    "[4] Eddins, Andrew, et al. \"Doubling the size of quantum simulators by entanglement forging.\" [arXiv preprint arXiv:2104.10220 (2021)](https://arxiv.org/abs/2104.10220).\n",
    "\n",
    "[5] Nielsen, Michael A., and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2010.\n",
    "\n",
    "[6] Moll, Nikolaj, et al. \"Quantum optimization using variational algorithms on near-term quantum devices.\" [Quantum Science and Technology 3.3 (2018): 030503](https://iopscience.iop.org/article/10.1088/2058-9565/aab822).\n",
    "\n",
    "[7] Khatri, Sumeet, and Mark M. Wilde. \"Principles of quantum communication theory: A modern approach.\" [arXiv preprint arXiv:2011.04672 (2020)](https://arxiv.org/abs/2011.04672)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}