{ "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.1.3。" ] }, { "cell_type": "code", "execution_count": 1, "id": "bb7c0db4", "metadata": {}, "outputs": [], "source": [ "import time\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", "\n", "import paddle\n", "from paddle_quantum.circuit import UAnsatz\n", "from paddle_quantum.utils import pauli_str_to_matrix, schmidt_decompose" ] }, { "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 = vecs[:, 0].numpy()\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 3.\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_mtr = paddle.to_tensor(pauli_str_to_matrix(zip(coefs, pauli_str), n=N))\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_theta(param, N, D):\n", " \n", " cir = UAnsatz(N) # 初始化一个宽度为 N 量子比特的电路\n", " cir.complex_entangled_layer(param, D) # 添加量子门\n", " return cir.U # 获取参数化电路的矩阵\n", "\n", "# 把参数化电路作用在计算基底上\n", "# 并返回一个形状为 [2**N, num_states] 的张量\n", "def output_states(theta, num_states, N, D):\n", " # 创建 num_states 个计算基底\n", " basis = paddle.eye(2**N, num_states)\n", " \n", " # 获得参数化电路\n", " U = U_theta(theta, N, D)\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", " # 定义常数 S\n", " self.S = S\n", " self.N, self.D = N, D\n", " # 初始化参数列表 theta, phi,并用 [0, 2*pi] 的均匀分布来填充初始值\n", " self.theta = self.create_parameter(shape=[D, N//2, 3], dtype=\"float64\",\n", " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", " self.phi = self.create_parameter(shape=[D, N - N//2, 3], dtype=\"float64\",\n", " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", " \n", " # 分布式 VQE 的核心逻辑\n", " def forward(self):\n", " # 分别获得子系统 A、B 上的 U|k> 和 V|k> \n", " vec_A = output_states(self.theta, self.S, self.N//2, self.D)\n", " vec_B = output_states(self.phi, self.S, self.N - self.N//2, self.D)\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", " \n", " # 我们使用基于梯度下降的优化器 Adam 来优化 theta 和 phi\n", " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=model.parameters())\n", " summary_loss = [] # 记录损失历史\n", "\n", " # 迭代优化\n", " for itr in range(ITR):\n", "\n", " # 前向传播,计算损失函数\n", " loss = model()\n", "\n", " # 后向传播,优化损失函数\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", "\n", " # 更新优化结果\n", " summary_loss.append(loss.numpy())\n", "\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": null, "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 13.01s\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEICAYAAABcVE8dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAuEElEQVR4nO3deXxU5dnw8d+VSUiAJEBIQFZZRARZNSwiICrWHbBq1VYFrfL4WH1t61Kr79OitupTfau1i0utiIqKoiK4I1XBikpAkF0WQXaSSCAhhGzX+8d9gkOYkGWSOcnM9f185jNz5pw593XmPnPNPfe55xxRVYwxxkS/OL8DMMYYExmW8I0xJkZYwjfGmBhhCd8YY2KEJXxjjIkRlvCNMSZGWMJvACLSXETmiMheEXk1guUWiEiPelrXXSLytPe4m4ioiMTXx7rrEMsUEXnBj7KNIyJjRGTrUeY/ISL/E8mYakNEfiYiHwRNq4gc10Bl1dvnsL5FdcIXkU0iMtaHoi8B2gNtVfXScFfmfdjKvR2pQES2isgrIjIkeDlVTVbVjTVYV5Uf3KB13a+q14Ubu1dmvdSDiCSJSJ6InBFi3iMiMjNoepKILBeRQhHZKSL/EJFWQfOniEhJ0HtaICJ54cZY30TkPm87SkVkSoj5PxWRzSKyX0RmiUiaD2Giqjeo6n1eTNXuYyLyrIj8odJzDdawUNXpqvqjmsYSZlnVfg79EtUJ30fHAt+oamltX3iUnX27qiYDKcBwYA2wQETOrHuYtY7BV6paBMwArg5+XkQCwBXANG/6VuB/gduBVrj3qxvwgYgkBL10hvfhrLi1bvCNqL31wB3A25VniMiJwJPAVbgGRiHwj4hGZ5oWVY3aG7AJGBvi+UTgUWC7d3sUSPTmpQNvAXnA98ACIM6b9xtgG5APrAXODLHue4BioAQoAH6O+2L9v8BmYDfwHNDKW74boN5y3wHzQ6xzDLA1xPN/A7KCphU4znt8HrDKi3UbcBvQEjgAlHuxFQAdgSnATOAFYB9wnffcC5VinOy9XzuA24LKfRb4Q6h4gee98g545d3hPT8c+Mx7n5cBY4Je3x34xIt9rredFbGM8J5vEbT8ed77Gg+keuX8pNJ7lQxkAxO96UPbV8N9aRyw0ov3Y6BPpf3sNuBrYC/uSympivX0BP4N5AI5wHSgdQ3KfwGYUum5+4EXK627GEipYh3Nvbra4+0btwfvV8H7T+V6rahT4C4v7k3AzyovSxX7WIhYDttnKu1n8d70+cBXuH1yS/D2By17jTdvD3ADMMSrhzzgb0HLTwI+rbytuH26xHvfCoA53vw+Xj3nefU+rlLsf8d9CecDXwA9q/gc1mQbJuI++znA3Q2aExty5X7fqDrh3wt8DrQDMnCJ5z5v3gPAE0CCdxsFCNDbq7COQZXVs4pypxCUTIBrcS21HrjE8zrwfKVKf877sDQPsb4xhE74Z3gfrJYhdrQdwCjvcRvgpKrW5cVbAkzAfTk1J3TCf8mLsT8ueY4N9eGtXEblegA64RLeeV55Z3nTGd78hcCfcV/Mo3EfquD38xvgyqDpl4BHvcfnAKV4SaPSdk4Dpoeqo2r2o+OB/V6cCbgW93qgWdD2fYn78kwDVgM3VLGu47z1JOL2vfkVsVcTQ6iE/ybwm0rPFQAnV7GOB3ENmDSgC7CC2iX80qB6Oc17T3pXsewR+2ulWA7bZyrtZ/FB6+nv7SMDgF3AhErLPgEkAT8CioBZuM91J1wj4DRv+UmESPhV7L8JXv3eBTTDfc7yK21rLjAU18iYDrxcxbprsg3/xH3mBgIHCWpM1PctVrt0fgbcq6q7VTUb1yq/yptXAnQAjlXVElVdoK52ynA7el8RSVDVTaq6oRbl/VlVN6pqAfBb4PJKXSdTVHW/qh6oxXZsx30ZtQ4xr8SLNVVV96jqkmrWtVBVZ6lq+VFiuMeLcTkwFdeNUhdXAu+o6jteeXOBLOA8EemKa6X9j6oeVNX5wJxKr38Or1tHRFKB8XjdObhfaDkaujttBy7JVviJd0yg4vZRFfFeBrytqnNVtQR4GPcBHRG0zGOqul1Vv/fiHRRqRaq63lvPQW/f+zMuedZFMu4XRbC9uG6/UH4C/FFVv1fVLcBjdSizol4+wbVwf1KHdVS4Lfj9x7XMD1HVj1V1ubePfI37Yq/8Xt2nqkWq+gHuC+gl73O9DfflNrgOcQ3HvbcPqmqxqv4b96s/eH9/Q1W/9Paz6VRd3zXZhntU9YCqLsP92h1Yh5hrJFYTfkdc90qFzd5zAA/hvt0/EJGNInInuA8q8Etcy3C3iLwsIh2pmVDlxeP6XStsqeU2gGvFKO5nZ2UX41rQm0XkExE5pZp11aT84GWC37PaOha4tNKHfSTui7YjsEdV91cqK9jzwOne+38JsEFVv/Lm5QDpVRyH6ODNr/CKqrYOup1eRbyH1Z+qluPei05By+wMelyISxhHEJH23r6zTUT24Vru6VWUW50CXBdWsFQg3xuVUnEw+t2g7ahch7URql7qug8APBz8/uNawIeIyDAR+UhEskVkL67LpvJ7tSvo8YEQ0yHroRodgS1ePVfYTN3quybbUKN11YdYTfjbcUmnQlfvOVQ1X1VvVdUeuH7bX1ccGFXVF1V1pPdaxR0YrGt5pRy+c2odtuMiYEmlDyFerItUdTzu5+0s4JVqyqlJ+V2CHh96z3AtqxZB846pZt1bcF1awcm2pao+iGuFtxGRlpXK+mFlqptxrbcrcb/MpgXNXoj7Wfzj4NeISDJwLq5ftrYOqz8REdx7sa0O67of9370V9VU3DZIHdYDrm/5UGvQGwqYiBswMF1/OBh9rrfIDo6sw2CFHL0eQ9XLdo5Ul305lBeB2UAXVW2F676p63t1NJXj3Q50EZHg/NiVutV3pLahRmIh4Sd4w/kqbvG4n1X/V0QyRCQd+B2upYWIXCAix3kf6r24rpxyEektImeISCKur7DiwFRNvAT8SkS6e4nnftwIkbqM4hER6SQiv8cdXL0rxDLNvBZeK68LYl9QrLuAtsFDFGvhf0SkhTc65BrcwUmApbjumDQROQb3SyjYLtzxiwovABeKyNkiEvDqZYyIdPaSeRZwj7cdI4ELQ8QyDbgJOBX3kxoAVd2L66L7q4icIyIJItIN94WXE7xsLbwCnC8iZ3qjfG7Ffal8Vod1peBa5ntFpBPuwGmVvPiTcJ/VeO+9Cnizp+Pex1FeIr4XeF1V84+yHb8VkTYi0hm4udL8pcBPvTo5h9BdTRX1Mgq4AAj1P5Nw9rFgKcD3qlokIkOBn4a5vqpU3j+/wH353eG9/2Nw++DLdVh3pLahRmIh4b+DS84Vtym40QRZuD7D5cAS7zmAXsCHuA/lQuAfqvoRruX0IC5p7MS1nH9bwxiewXVDzAe+xX1hVP6wVaejiFSMeliEOxA0xuu7DOUqYJPXbXAD7jgCqroG9wW00etOqc1P8k9w3V3zcD/HK8p+Htf3uAn4gB++CCo8gPuCzROR27z+4/G4L6tsXIv/dn7YH38KDMONkvo9rs++stdwBx/nqeqO4Bmq+idv3Q/jDrZ9i2u5jq30a+gyOXwcfoGItKtckKquxbXE/4qr/wuBC1W1uMp3qmr3ACfhGhNv4w7gH80/cfvtFcDd3uOrvLhW4up2Ou4AZQpwYzVlb8a9Hx/g6i3YLbhty8PtL7Mqzd+JGw2z3SvzBm9/OkyY+1iwG4F7RSQf1yh7pZrl6+pfuONdeSIyy6vXC3G/CHNwQ12vDrWtNRCpbagRcccjjYleInINrvV7qqp+53c8jYXXcn1BVTv7HIqJkEb5Bxtj6pOqThWRUtyoGkv4JmZZwjcxQVUrd18YE3OsS8cYY2JELBy0NcYYQyPu0klPT9du3br5HYYxxjQpixcvzlHVjFDzGm3C79atG1lZWX6HYYwxTYqIVPkPauvSMcaYGGEJ3xhjYoQlfGOMiRGNtg/fGNM4lZSUsHXrVoqKivwOJaYlJSXRuXNnEhISql/YYwnfGFMrW7duJSUlhW7duuHOMWgiTVXJzc1l69atdO/evcavsy4dY0ytFBUV0bZtW0v2PhIR2rZtW+tfWZbwjTG1Zsnef3Wpg+hL+Hv2wH33gY3hN8aYw0Rfwg8E4He/g7lz/Y7EGNNAkpMb7CqAUS36En5qKnTtCitW+B2JMcY0KtGX8AH69YPly/2OwhjTwFSV22+/nX79+tG/f39mzHAXW9uxYwejR49m0KBB9OvXjwULFlBWVsakSZMOLfvII4/4HH3kReewzH79XJdOSQnUYoyqMaaWfvlLWLq0ftc5aBA8+miNFn399ddZunQpy5YtIycnhyFDhjB69GhefPFFzj77bO6++27KysooLCxk6dKlbNu2jRXer/+8vLz6jbsJiM4Wfv/+LtmvW+d3JMaYBvTpp59yxRVXEAgEaN++PaeddhqLFi1iyJAhTJ06lSlTprB8+XJSUlLo0aMHGzdu5Oabb+a9994jNTXV7/AjLnpb+OD68fv29TcWY6JZDVvikTZ69Gjmz5/P22+/zaRJk/j1r3/N1VdfzbJly3j//fd54okneOWVV3jmmWf8DjWiorOFf8IJEBdnB26NiXKjRo1ixowZlJWVkZ2dzfz58xk6dCibN2+mffv2XH/99Vx33XUsWbKEnJwcysvLufjii/nDH/7AkiVL/A4/4qKzhZ+UBL16WcI3JspddNFFLFy4kIEDByIi/OlPf+KYY45h2rRpPPTQQyQkJJCcnMxzzz3Htm3buOaaaygvLwfggQce8Dn6yGu017TNzMzUsC6AcsklsGyZ9eMbU89Wr15Nnz59/A7DELouRGSxqmaGWj46u3TAHbjdsAEKC/2OxBhjGoXoTfj9+oEqrF7tdyTGGNMoRHfCB+vHN8YYT/Qm/J49ITHREr4xxniiN+HHx7sx+HaKBWOMAaI54YPr1rEWvjHGALGQ8Ldtc+fIN8aYejJlyhQefvjhI56fNWsWq1atqvX6Nm3axIsvvnho+tlnn+Wmm24KK8ZQoj/hA6xc6W8cxpiIKy0tjXiZR0v4R4uncsJvKLGR8K0f35ioct9999G7d29GjhzJFVdccai1PWbMGH75y1+SmZnJX/7yF+bNm8fgwYPp378/1157LQcPHgSgW7du5OTkAJCVlcWYMWMA13K/9tprGTNmDD169OCxxx47VOYf//hHjj/+eEaOHMnatWuPiOmzzz5j9uzZ3H777QwaNIgNGzYcEc+kSZOYOXPmoddUXMjlzjvvZMGCBQwaNOjQaZu3b9/OOeecQ69evbjjjjvq5X2L7oTfpQskJ9tYfGMa0GVPLuTVrC0AlJSVc9mTC3njq60AHCgu47InFzJn2XYA9hWVcNmTC3lvxQ4Avt9fzGVPLuTDVbsA2J1f/UW5Fy1axGuvvcayZct49913qfyP/OLiYrKysvjFL37BpEmTmDFjBsuXL6e0tJTHH3+82vWvWbOG999/ny+//JJ77rmHkpISFi9ezMsvv8zSpUt55513WLRo0RGvGzFiBOPGjeOhhx5i6dKl9OzZ87B4br311irLfPDBBxk1ahRLly7lV7/6FQBLly49FPuMGTPYsmVLtbFXJ7oTvog7kZolfGOixn/+8x/Gjx9PUlISKSkpXHjhhYfNv+yyywBYu3Yt3bt35/jjjwdg4sSJzJ8/v9r1n3/++SQmJpKenk67du3YtWsXCxYs4KKLLqJFixakpqYybty4GsdbEU9tnXnmmbRq1YqkpCT69u3L5s2b67SeYNF58rRgffrARx/5HYUxUWvGf51y6HFCIO6w6ebNAodNpyYlHDad1rLZYdPtUpLCjqdly5bVLhMfH3/oJGpFRYf/qkhMTDz0OBAIhH0sIDie4HLLy8spLi6u8nX1HQdEewsfXAt/61bIz/c7EmNMPTj11FOZM2cORUVFFBQU8NZbb4Vcrnfv3mzatIn169cD8Pzzz3PaaacBrg9/8eLFALz22mvVljl69GhmzZrFgQMHyM/PZ86cOSGXS0lJIf8ouSa43NmzZ1NSUlKj19WX6E/4FWeSC3GQxRjT9AwZMoRx48YxYMAAzj33XPr370+rVq2OWC4pKYmpU6dy6aWX0r9/f+Li4rjhhhsA+P3vf88tt9xCZmYmgUCg2jJPOukkLrvsMgYOHMi5557LkCFDQi53+eWX89BDDzF48GA2bNhwxPzrr7+eTz75hIEDB7Jw4cJDrf8BAwYQCAQYOHBgg15rN3pPj1xh9Wr3j9vnnoOrrgp/fcbEuMZweuSCggKSk5MpLCxk9OjRPPXUU5x00km+xuSH2p4eOfr78I87zp1mYc0avyMxxtSTyZMns2rVKoqKipg4cWJMJvu6iP6En5Dgkr6N1DEmakTiT0rRKPr78MEduLUWvjH1prF2BceSutRBWAlfRNJEZK6IrPPu24RYZpCILBSRlSLytYjUbVBqOPr0cZc69I6IG2PqLikpidzcXEv6PlJVcnNzSUqq3TDWcLt07gTmqeqDInKnN/2bSssUAler6joR6QgsFpH3VTUvzLJr7oQToLTUXfLwhBMiVqwx0ahz585s3bqV7Oxsv0OJaUlJSXTu3LlWrwk34Y8HxniPpwEfUynhq+o3QY+3i8huIAPIC7Psmqs4ir1mjSV8Y8KUkJBA9+7d/Q7D1EG4ffjtVXWH93gn0P5oC4vIUKAZcOQAVTd/sohkiUhWvbYeevd293bg1hgTw6pt4YvIh8AxIWbdHTyhqioiVXbqiUgH4HlgoqqWh1pGVZ8CngI3Dr+62GosNRU6dbIDt8aYmFZtwlfVsVXNE5FdItJBVXd4CX13FculAm8Dd6vq53WONhx2EjVjTIwLt0tnNjDRezwReLPyAiLSDHgDeE5VZ1aeHzF9+rgWvo0sMMbEqHAT/oPAWSKyDhjrTSMimSLytLfMT4DRwCQRWerdBoVZbu316eNOoLZ9e8SLNsaYxiCsUTqqmgucGeL5LOA67/ELwAvhlFMvKkbnrFnj+vONMSbGxMY/beGHoZnWj2+MiVGxk/CPOQZatbKEb4yJWbGT8EXcaZKruKK8McZEu9hJ+GAJ3xgT02Iv4e/eDTk5fkdijDERF3sJH6wf3xgTk2Iz4Vu3jjEmBsVWwu/SBZKTLeEbY2JSbCV8ETcef+VKvyMxxpiIi62EDzZSxxgTs2Iz4e/YAXv2+B2JMcZEVOwl/BNPdPc2UscYE2NiL+HbSB1jTIyKvYR/7LHQvLklfGNMzIm9hB8X50bqWMI3xsSY2Ev4YCN1jDExKXYT/pYtsG+f35EYY0zExG7CB3f1K2OMiRGxnfCtW8cYE0NiM+H36AGJifD1135HYowxERObCT8QgCFD4LPP/I7EGGMiJjYTPsDIkbB4MRQW+h2JMcZERGwn/NJS+PJLvyMxxpiIiN2EP2KEO13yggV+R2KMMRERuwm/TRvo1w8+/dTvSIwxJiJiN+GD69b57DPXtWOMMVEuthP+qFFQUGDDM40xMSG2E/7Ike7eunWMMTEgthN+ly7QtaslfGNMTIjthA+ulb9gAaj6HYkxxjQoS/ijRsHOnbBxo9+RGGNMg7KEb/34xpgYYQm/b19IS4N58/yOxBhjGlRYCV9E0kRkrois8+7bHGXZVBHZKiJ/C6fMehcXBxdcAHPmQHGx39EYY0yDCbeFfycwT1V7AfO86arcB8wPs7yGcemlkJdnrXxjTFQLN+GPB6Z5j6cBE0ItJCInA+2BD8Isr2GcdRakpsKrr/odiTHGNJhwE357Vd3hPd6JS+qHEZE44P8Bt1W3MhGZLCJZIpKVnZ0dZmi1kJgI48bBrFlQUhK5co0xJoKqTfgi8qGIrAhxGx+8nKoqEGow+43AO6q6tbqyVPUpVc1U1cyMjIwab0S9uPRS2LMH/v3vyJZrjDEREl/dAqo6tqp5IrJLRDqo6g4R6QDsDrHYKcAoEbkRSAaaiUiBqh6tvz/yfvQjSEmBmTPh7LP9jsYYY+pduF06s4GJ3uOJwJuVF1DVn6lqV1XthuvWea7RJXuApCS48EJ44w3r1jHGRKVwE/6DwFkisg4Y600jIpki8nS4wUXcpZdCbi58/LHfkRhjTL0TbaTnkMnMzNSsrKzIFnrgALRrBxdfDM8+G9myjTGmHojIYlXNDDXP/mkbrHlzmDQJpk+HTZv8jsYYY+qVJfzKfvMb9+/bBx7wOxJjjKlXlvAr69wZrrsOpk6F777zOxpjjKk3lvBDudMbRGStfGNMFLGEH0qXLvDzn8O//mWtfGNM1LCEX5Xf/tbdP/ywv3EYY0w9sYRfla5dYcIEeOUVKC/3OxpjjAmbJfyjmTABdu2CL77wOxJjjAmbJfyjOe88iI93Z9E0xpgmzhL+0bRuDaef7s6v00j/kWyMMTVlCb86EybAunWwZo3fkRhjTFgs4Vdn3Dh3/+YRJwI1xpgmxRJ+dTp3hsxM68c3xjR5lvBrYsIEN1Jn+3a/IzHGmDqzhF8TEya4+9mzfQ3DGGPCYQm/Jvr2hZ494a23/I7EGGPqzBJ+TYjAaafB55/b8ExjTJNlCb+mhg1zlz/csMHvSIwxpk4s4dfUsGHu3k6zYIxpoizh19SJJ0KLFpbwjTFNliX8moqPd+Pxv/zS70iMMaZOLOHXxtCh8NVXcPCg35EYY0ytWcKvjWHDoLgYli3zOxJjjKk1S/i1YQdujTFNmCX82ujcGTp0sIRvjGmSLOHXhohr5VvCN8Y0QZbwa2voUFi/Hr7/3u9IjDGmVizh11ZFP74NzzTGNDGW8GsrM9N17Vi3jjGmibGEX1upqe7smZbwjTFNjCX8usjMhCVL/I7CGGNqxRJ+XQwaBLt2wc6dfkdijDE1Zgm/LgYPdvdffeVvHMYYUwthJXwRSRORuSKyzrtvU8VyXUXkAxFZLSKrRKRbOOX6buBAd28J3xjThITbwr8TmKeqvYB53nQozwEPqWofYCiwO8xy/dW6NXTvDkuX+h2JMcbUWLgJfzwwzXs8DZhQeQER6QvEq+pcAFUtUNXCMMv13+DB1sI3xjQp4Sb89qq6w3u8E2gfYpnjgTwReV1EvhKRh0QkEGplIjJZRLJEJCs7OzvM0BrYoEHuH7f5+X5HYowxNVJtwheRD0VkRYjb+ODlVFWBUFf4jgdGAbcBQ4AewKRQZanqU6qaqaqZGRkZtd2WyKo4cGunSjbGNBHx1S2gqmOrmiciu0Skg6ruEJEOhO6b3wosVdWN3mtmAcOBf9Ut5EYieKTOyJH+xmKMMTUQbpfObGCi93gi8GaIZRYBrUWkosl+BrAqzHL917EjpKfbgVtjTJMRbsJ/EDhLRNYBY71pRCRTRJ4GUNUyXHfOPBFZDgjwzzDL9Z+IHbg1xjQp1XbpHI2q5gJnhng+C7guaHouMCCcshqlQYPg0UfdZQ+bNfM7GmOMOSr7p204Bg+GkhJYvdrvSIwxplqW8MNhp1gwxjQhlvDD0asXtGhhCd8Y0yRYwg9HIAADBljCN8Y0CZbww1VxbvzSUr8jMcaYo7KEH67hw2H/fli50u9IjDHmqCzhh6viouZ2yUNjTCNnCT9cPXtC27bw+ed+R2KMMUdlCT9cIq5bxxK+MaaRs4RfH4YNc3++ysvzOxJjjKmSJfz6MHy4u1+0yN84jDHmKCzh14ehQ13Xjh24NcY0Ypbw60OrVtCnj/XjG2MaNUv49WXYMNfC11AX/TLGGP9Zwq8vw4dDTg5s3Oh3JMYYE5Il/PpSceDWunWMMY2UJfz6cuKJ0LKlHbg1xjRalvDrSyAAQ4bAwoV+R2KMMSFZwq9Po0a5M2fu3et3JMYYcwRL+PVp7FgoL4ePP/Y7EmOMOYIl/Po0fLi7AtaHH/odiTHGHMESfn1q1gxGj4Z58/yOxBhjjmAJv76NHetOpLZtm9+RGGPMYSzh17exY929tfKNMY2MJfz61r8/pKdbP74xptGxhF/f4uLgzDNdwrfz6hhjGhFL+A1h7FjYsQPWrPE7EmOMOcQSfkOo6Me3bh1jTCNiCb8hdOsGPXpYwjfGNCqW8BvK2LHw0UdQWup3JMYYA1jCbzhnnQX5+fDll35HYowxgCX8hnP66e46t9atY4xpJCzhN5S2beHkk2HuXL8jMcYYIMyELyJpIjJXRNZ5922qWO5PIrJSRFaLyGMiIuGU22SMHeuugJWf73ckxhgTdgv/TmCeqvYC5nnThxGREcCpwACgHzAEOC3McpuGs85yB20/+cTvSIwxJuyEPx6Y5j2eBkwIsYwCSUAzIBFIAHaFWW7TMGIENG9u3TrGmEYh3ITfXlV3eI93Au0rL6CqC4GPgB3e7X1VXR1qZSIyWUSyRCQrOzs7zNAagaQkdxUsO3BrjGkEqk34IvKhiKwIcRsfvJyqKq41X/n1xwF9gM5AJ+AMERkVqixVfUpVM1U1MyMjo04b1OicdRasWmWnSzbG+C6+ugVUdWxV80Rkl4h0UNUdItIB2B1isYuAz1W1wHvNu8ApwII6xty0BJ8u+eqr/Y3FGBPTwu3SmQ1M9B5PBN4Mscx3wGkiEi8iCbgDtiG7dKLSgAGQkWH9+MYY34Wb8B8EzhKRdcBYbxoRyRSRp71lZgIbgOXAMmCZqs4Js9ymIy7OtfLnznUXODfGGJ9U26VzNKqaC5wZ4vks4DrvcRnwX+GU0+RdcAG89JIbkz9ihN/RGGNilP3TNhIuuMBd4HzmTL8jMcbEMEv4kZCa6kbrvP66XQXLGOMbS/iRcvHFsHkzLF7sdyTGmBhlCT9Sxo+H+Hh47TW/IzHGxChL+JGSluZOmfzaa9atY4zxhSX8SLr4Yli3Dlas8DsSY0wMsoQfSRMmuIuiWLeOMcYHlvAjqX17dzI1G55pjPGBJfxIu/xyWLnSrnVrjIk4S/iRduWVkJICf/ub35EYY2KMJfxIS0lxZ82cMQOi4Zz/xpgmwxK+H268EYqL4emnq1/WGGPqiSV8P/TtC2ecAU884a55a4wxEWAJ3y+/+AV89x289ZbfkRhjYoQlfL+MGwedO8Pf/+53JMaYGGEJ3y/x8fDf/+0ucP7FF35HY4yJAZbw/XTzzdCuHdx+u51fxxjT4Czh+yklBaZMgQULrC/fGNPgLOH77brr4Pjj4Te/sRE7xpgGFdY1bU09SEiABx+EH/8Ypk6F66+v2etKS+Gjj2DfPjemXxVOPNHd4q1ajTFHsszQGEyY4C5u/rvfuVMop6VVvawqvPOO6/dfvfrI+c2bQ2amG+d/9tkwdCgEAg0WujGm6bAuncZABB57DHJz3bl2ystDL7dlC/zoR+6i6KWl7vQMy5a5xL9yJUyfDpMnQ1ER3Huv+xLJyIA77oCdOyO7TcaYRke0kY4OyczM1KysLL/DiKzHH3enXbjnHtfaD7Z8OZx7ruvC+cMf4IYboFmzqteVm+uGfL7+ujsdc7Nmrrvo97+Htm0bdjuMMb4RkcWqmhlyniX8RkTVnVht+nR4913XJQOur37CBEhOds8PGFC79a5b544TPPccdO/uuoSOO67ewzfG+M8SflNSWAjDh8Pata4lLgK7d7uRPO++C1271n3d//mPu5g6wOzZrsvHGBNVjpbw7aBtY9OiBcyZA3/+Mxw44Fr9rVvDXXdBmzbhrfvUU+Hzz13X0BlnuF8SF19cL2EbYxo/a+HHopwc19JfuNAdLL7pJr8jMsbUk6O18G2UTixKT3cHdMeNc6d3uPtuO7WDMTHAEn6sat7cjd6ZPBnuvx/OOw82bPA7KmNMA7KEH8vi491FWB57DD79FPr1c+P38/P9jswY0wCsD98427bBr38Nr7wCcXEwaBCMHAn9+0O3bu7WsaM7qGyMabRslI6pXqdO7p+7t9wC77/vWvxPP+2GiQZLSnLHAIJv7du7L4NOnaBLF+jRw03H2Q9IYxoTS/jmcCNG/DA+v7TUtfw3bYJvv4Vdu9wIn5wc90/e7Gz3/M6dsH//4etJTHR/7howwN169HC/Dpo3d18EBQXuVlgIBw+6E8ABtGrlhqGmp0PPntChg/svgjEmbGElfBG5FJgC9AGGqmrIPhgROQf4CxAAnlbVB8Mp10RIfDwce6y7nXba0ZfNz3dfDt99Bxs3utuaNfDZZ/DSS3WPoUULl/hPOMHd+vRx971716x7qbwcysp+GIWUkGBfICZmhdvCXwH8GHiyqgVEJAD8HTgL2AosEpHZqroqzLJNY5KS8kNSriwvz30ZHDjgWvTl5e40EcnJLmknJv5wXqC9e93yu3a5UUPr18M338BXX8Frr/1wYjkR132UkeH+kdyqlVv//v3ul0Nurrvt3XtkPElJ7pdGUpIru+K+4nFqqvuTW1qaW3dGhru1aePmpaa65QIB96Wo6r5Uysrcr6KKx8G3ii8cEXcLBH54fXy8+yKqeC4uLvR9xa1iHcbUUlgJX1VXA8jRd76hwHpV3egt+zIwHmjQhH/Zkwu55OTOXJrZhZKycq58+gsuH9qFiwZ35kBxGZOmfsmVw4/lwoEd2VdUwvXTsrjm1G6c068D3+8v5r9fWMz1o3owtm97ducXcfOLX/HfY3oypnc7tucd4FczlnLzGb0Y2Sud73ILuX3mMn511vEM79GWDdkF3PX6cu44pzcnH5vG2p35/O7NFdx1Xh8GdmnNyu17uXfOKn53YV9O7NiKZVvyuP+d1dw7vh+9j0lh8ebv+dN7a7n/x/3pmZHM5xtzeWTuNzx0yUC6tm3Bp+ty+Ou/1/HIZYPo2Lo5H6/dzeMfb+CvPx1Mu5QkPly1i38u2MjjV55MWstmvLdiB1P/s4l/TswkNSmBOcu288Lnm3n2mqE0bxbgja+28vKXW3jhumEkBOJ4NWsLMxdvZcZ/nQLAS19+x1tfb2f6dcMBeH7hJj5cvZtp1w4F4JlPv+WzDTk8PXEIAE/N38CSzXk8cdXJAPxjaQ6rth/kbz91x5Eem7eOjesLePRy9+Xw5w/Wsn1vEQ9fOhDatOF/31tDXmEHHrjRnUvoj2+voqiknPvO7QXr1vHq8x+QvnUjpwf2QU4OW9ZvpfmB9aSnp0LLlnxTkkBJ176ceH53SEvj3TU5pCQlMLJXOhw8yLyvNpMeKGdgu+ZQVMSSb3bQJqB0T4mHAwf47utvaFO8n5T9+xrtiCWNi0MCAVSEEoVAIEAgTihHOFimNEuIIyBCmcLB0jIS4wMEhB+mE+IJxAllqhSVlJOUECCAUqbKwZJyEhPc+koRCkuVls0TCAQCFJcrBcXltGrZjIAIRWVKwcEy2rRMIBAXx4HScvKLSmnbshkBgQMlZewvKiWtZTPiKqYPlpGW3Iw4EQqLyygoLiMjJREB9peUs/9gKe1SEkGE/OIyCovLaJ+aBMC+olIKS8o4xpveW1TKgaDpvAMlHCwpp31q4qHp4tJytz5gT2EJJWXB08WUlisZKe71ufuLKVMOzc/ZX4yqkpHsTRe4rsf0ZNdAyS44iEjcoend+QcJxAltW7rpXfkHiQ+e3ldEQnwcaS3c9M59RSTGx9GmRTMYPpwbzriJk45tzeTRPRtit4lIH34nYEvQ9FZgWKgFRWQyMBmgazjnjDHRKTER+vVj1UjXwDj9whMBeGrWCpIS4rj7/L4ATH39a1q3aMaJ57gvlHmvLqNjqyRG/qg3AHNe/ooeGckMPLMXAM+8uIS+HVO5cYw7odz9zy/+4UNXXMyt//iQUa1hQo9k2LuXJ2cvoX+75ow4tjWUlvLMZ5vo1yWNocdlQHw8f/1kI0N6ZjC8VztKRXjk3xsY2bsdp3Rvy8GScv764VrGHJdGZpdWFBYWMfWT9Yzu0Zr+7ZPZf6CYGZ9v4tTubejdriX5Bw4yO2sLp3RrTY+05uzbX8QHy3cwtGsrurZKZF9hMR+v2cWQrq3p2CqJffsP8um6bIZ0S6N9ahJ79xfz2YYchnVvS0ZKInsKDvLFhlyGd29D2+REvs8/yKJvcxneM520ls3IyT9I1qY9nHpcW1onxZOdd4Blm7/n1O5tSEkM8P2eQlZty2NYjzRaJgTYk1fImp35DO+eRvP4OPbkHeCbXQWc0rMtgYQAuXsKWb+7gBG9MmgWiCP7+0I2ZBcw6rh04uKE7NwCvs0uZPTx6QiQnbufzbmFtOuVDqrk5Oxn255C2h+XDkBudgE79hZxTM+2bn52ATkFBzmmuzsDbM7uAr7fX0z77u6aErt35bPvQAntunnTO/MpOFhKu2PdaUp27djHgeIyMrq2dvO376W4rJx2nd30ru37KFclo1MrAHZud78Y0zt601vzCMQJ6R1SD00nxMfR9hg3vWNLHs0TArQ9JgWA7d/toWViPGnt3fS2zXto1TyBNu2S3XGuBlbtsEwR+RA4JsSsu1X1TW+Zj4HbQvXhi8glwDmqep03fRUwTFWP+n9+G5ZpjDG1F9awTFUdG2b524AuQdOdveeMMcZEUCQGSi8CeolIdxFpBlwOzI5AucYYY4KElfBF5CIR2QqcArwtIu97z3cUkXcAVLUUuAl4H1gNvKKqK8ML2xhjTG2FO0rnDeCNEM9vB84Lmn4HeCecsowxxoTH/vtujDExwhK+McbECEv4xhgTIyzhG2NMjGi058MXkWxgcxirSAdy6imcpiLWtjnWthdsm2NFONt8rKpmhJrRaBN+uEQkq6p/m0WrWNvmWNtesG2OFQ21zdalY4wxMcISvjHGxIhoTvhP+R2AD2Jtm2Nte8G2OVY0yDZHbR++McaYw0VzC98YY0wQS/jGGBMjoi7hi8g5IrJWRNaLyJ1+x9MQRKSLiHwkIqtEZKWI3OI9nyYic0VknXffxu9Y65uIBETkKxF5y5vuLiJfePU9wzsFd9QQkdYiMlNE1ojIahE5JdrrWUR+5e3XK0TkJRFJirZ6FpFnRGS3iKwIei5kvYrzmLftX4vISXUtN6oSftAF088F+gJXiEhff6NqEKXAraraFxgO/MLbzjuBearaC5jnTUebW3Cn2a7wv8AjqnocsAf4uS9RNZy/AO+p6gnAQNy2R209i0gn4P8AmaraDwjgrqERbfX8LHBOpeeqqtdzgV7ebTLweF0LjaqET9AF01W1GKi4YHpUUdUdqrrEe5yPSwKdcNs6zVtsGjDBlwAbiIh0Bs4HnvamBTgDmOktElXbLCKtgNHAvwBUtVhV84jyesadtr25iMQDLYAdRFk9q+p84PtKT1dVr+OB59T5HGgtIh3qUm60JfxQF0zv5FMsESEi3YDBwBdAe1Xd4c3aCbT3K64G8ihwB1DuTbcF8ryL7ED01Xd3IBuY6nVjPS0iLYnielbVbcDDwHe4RL8XWEx013OFquq13vJatCX8mCIiycBrwC9VdV/wPHXjbaNmzK2IXADsVtXFfscSQfHAScDjqjoY2E+l7psorOc2uBZtd6Aj0JIjuz6iXkPVa7Ql/Ji5YLqIJOCS/XRVfd17elfFTz3vfrdf8TWAU4FxIrIJ11V3Bq5/u7X30x+ir763AltV9QtveibuCyCa63ks8K2qZqtqCfA6ru6juZ4rVFWv9ZbXoi3hx8QF072+638Bq1X1z0GzZgMTvccTgTcjHVtDUdXfqmpnVe2Gq9d/q+rPgI+AS7zFom2bdwJbRKS399SZwCqiuJ5xXTnDRaSFt59XbHPU1nOQqup1NnC1N1pnOLA3qOundlQ1qm64a+l+A2wA7vY7ngbaxpG4n3tfA0u923m4Pu15wDrgQyDN71gbaPvHAG95j3sAXwLrgVeBRL/jq+dtHQRkeXU9C2gT7fUM3AOsAVYAzwOJ0VbPwEu4YxQluF9yP6+qXgHBjT7cACzHjWCqU7l2agVjjIkR0dalY4wxpgqW8I0xJkZYwjfGmBhhCd8YY2KEJXxjjIkRlvCNMSZGWMI3xpgY8f8BNLWhHZfidXcAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "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):\n", " super().__init__()\n", " paddle.seed(SEED)\n", " self.N, self.D = N, D\n", " self.theta = self.create_parameter(shape=[D, N, 3], dtype=\"float64\",\n", " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", " \n", " def forward(self):\n", " vec = output_states(self.theta, 1, self.N, self.D)\n", " loss = vec.conj().t() @ H_mtr @ vec\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 721.76s\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "svqe = StandardVQE(N, D)\n", "train(svqe) # 训练标准 VQE" ] }, { "cell_type": "markdown", "id": "5688a618", "metadata": {}, "source": [ "有趣的是,通过比较两个模型的运行时间,我们发现,分布式 VQE 的运行速度比标准 VQE 快了五十多倍!事实上,这很容易理解:在分布式模型中,我们只需模拟两个 $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.7.10" } }, "nbformat": 4, "nbformat_minor": 5 }