{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 含噪声量子线路\n", "\n", "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindquantum/zh_cn/middle_level/mindspore_noise.ipynb) \n", "[![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindquantum/zh_cn/middle_level/mindspore_noise.py) \n", "[![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source.svg)](https://gitee.com/mindspore/docs/blob/master/docs/mindquantum/docs/source_zh_cn/middle_level/noise.ipynb)\n", "\n", "## 概述\n", "\n", "在真实量子设备中，由于现阶段技术的不成熟，量子系统会由于量子操作、环境影响等各种因素而产生噪声。现阶段噪声对量子设备的影响不可忽略，因此在量子线路中加入对噪声的模拟，可以帮助我们寻找对噪声具有鲁棒性的量子算法，或设计减少噪声影响的纠错方案。\n", "\n", "噪声分为两种类型：相干噪声和非相干噪声。相干噪声一般来源于门操作中参数的噪声化，因此是幺正演化并且易于模拟；非相干噪声则来源于系统与环境的相互作用，因此通常是非幺正演化，会使量子系统从纯态变为混态，这个过程也被称为量子信道（Quantum channel）。混态的量子系统通常用密度矩阵的形式表示，但也可以通过“采样-统计”的蒙特卡洛法得到统计模拟结果。在MindSpore Quantum中，我们用蒙特卡洛法来模拟量子信道，其中噪声门会以一定概率影响量子比特，通过对线路的多次采样，可以得到含噪声量子线路的模拟运行结果。\n", "\n", "量子信道的数学表示如下：\n", "\n", "$$\n", "\\varepsilon(\\rho) =\\sum_{k=0}^{m-1} E_{k} \\rho E_{k}^{\\dagger}\n", "$$\n", "\n", "其中$\\{E_k\\}$是Kraus算符，需要满足完备性条件$\\sum_k E_k^\\dagger E_k= I$；$\\rho$是量子态的密度矩阵，$\\varepsilon(\\rho)$是演化后的量子态。\n", "\n", "## [泡利信道](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.PauliChannel.html)（Pauli Channel）\n", "\n", "有一类噪声对量子线路的影响体现为，当进行了某种量子操作后，线路有概率额外受到一个泡利门的影响，被称为泡利信道。例如，经过某个操作后比特以一定概率被额外作用一个[X](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.XGate.html)门，即该比特以一定概率发生了翻转，这就是比特翻转信道(Bit Flip Channel)，数学表示为：\n", "\n", "$$\n", "\\varepsilon_{BF}( \\rho ) =(1-p)I \\rho I +pX \\rho X\n", "$$\n", "\n", "其中$I$是单位矩阵，$X$是泡利`X`门。该信道对应的Kraus算符为：\n", "\n", "$$\n", "E_0=\\sqrt{1-p}\\begin{bmatrix}\n", "1 & 0\\\\\n", "0 & 1\n", "\\end{bmatrix}, E_{1} =\\sqrt{p}\\begin{bmatrix}\n", "0 & 1\\\\\n", "1 & 0\n", "\\end{bmatrix}\n", "$$\n", "\n", "其中$p$可以视为发生比特翻转的概率。由这个例子可以看到，一个纯态量子态经过比特翻转信道后会变为混态，该混态由原本的态和比特翻转后的态构成。\n", "\n", "同理，若比特以一定概率额外作用一个[Z](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.ZGate.html)门称为相位翻转信道，[Y](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.YGate.html)门是比特相位翻转信道。若是[X](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.XGate.html)、[Y](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.YGate.html)、[Z](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.ZGate.html)三个门平分概率，则称为去极化信道，该信道常常被用来描述真实量子硬件中门操作产生的噪声。此外，也可以使用通用的泡利信道自定义三个泡利门的概率。\n", "\n", "下面是这些信道的数学表示。\n", "\n", "泡利信道（Pauli Channel）：\n", "\n", "$$\n", "\\varepsilon _{Pauli}( \\rho ) =(1-p_x-p_y-p_z)\\rho + p_x X \\rho X+ p_y Y \\rho Y+p_z Z \\rho Z\n", "$$\n", "\n", "相位翻转信道（Phase Flip Channel）：\n", "\n", "$$\n", "\\varepsilon _{PF}( \\rho ) =(1-p)\\rho +pZ \\rho Z\n", "$$\n", "\n", "比特相位翻转信道（Bit-Phase Flip Channel）：\n", "\n", "$$\n", "\\varepsilon _{BPF}( \\rho ) =(1-p)\\rho +pY \\rho Y\n", "$$\n", "\n", "去极化信道（Depolarizing Channel）：\n", "\n", "$$\n", "\\varepsilon _{DF}( \\rho ) =(1-p)\\rho + \\frac{p}{3}(X \\rho X+ Y \\rho Y+Z \\rho Z)\n", "$$\n", "\n", "下面我们以去极化信道为例，看看如何将噪声信道加入线路中。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "q0: X DC p=1/10 " ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.core.gates import DepolarizingChannel, X\n", "from mindquantum.core.circuit import Circuit\n", "\n", "circ = Circuit()\n", "circ += X.on(0)\n", "circ += DepolarizingChannel(0.1).on(0)\n", "circ.measure(0)\n", "circ.svg()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "此时我们成功搭建了一个单比特的量子线路，该比特在作用[X](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.XGate.html)门后，会受到去极化噪声的影响，具体表现为有10%概率额外作用一个泡利门，其中[X](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.XGate.html)、[Y](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.YGate.html)、[Z](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.ZGate.html)门平分概率。\n", "\n", "现在我们对该线路进行1000次模拟并输出采样结果：" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "Shots:\n", " 1000 Keys: q0 0.0 0.191 0.381 0.572 0.762 0.953 0 47 1 953 probability " ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.simulator import Simulator\n", "\n", "sim = Simulator('mqvector', 1)\n", "result = sim.sampling(circ, shots=1000)\n", "result.svg()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "倘若没有噪声影响，量子态应该处于$|1\\rangle$态，测量结果全为1，但在以上结果中，约有7%的模拟结果测得为0，这就是去极化信道产生的影响。采样结果与预期中3.3%概率额外作用[X](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.XGate.html)门、[Y](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.YGate.html)门和[Z](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.ZGate.html)门的预测结果相符。\n", "\n", "至此我们就完成了一次对含去极化噪声量子线路的模拟。\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## [振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)和[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道（Damping Channel）\n", "\n", "[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道（Amplitude Damping Channel）和[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道（Phase Damping Channel）也是比较常见的信道，其中[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道描述了量子系统能量的耗散，[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道则描述了系统量子信息的损失。具体来说，[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道会使量子比特从激发态回到基态，[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道则会使量子比特从叠加态退回到坍缩态。\n", "\n", "[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道的表达形式为：\n", "\n", "$$\n", "\\varepsilon_{AD}( \\rho ) =E_{0} \\rho E_{0}^{\\dagger } +E_{1} \\rho E_{1}^{\\dagger }\n", "$$\n", "\n", "其中$E_{0}, E_{1}$是Kraus算符，\n", "\n", "$$\n", "E_{0} =\\begin{bmatrix}\n", "1 & 0\\\\\n", "0 & \\sqrt{1-\\gamma }\n", "\\end{bmatrix}, E_{1} =\\begin{bmatrix}\n", "0 & \\sqrt{\\gamma }\\\\\n", "0 & 0\n", "\\end{bmatrix}\n", "$$\n", "\n", "$\\gamma$为耗散系数。\n", "\n", "[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道的表达形式为：\n", "\n", "$$\n", "\\varepsilon_{PD}( \\rho ) =E_{0} \\rho E_{0}^{\\dagger } +E_{1} \\rho E_{1}^{\\dagger }\n", "$$\n", "\n", "其中\n", "\n", "$$\n", "E_{0} =\\begin{bmatrix}\n", "1 & 0\\\\\n", "0 & \\sqrt{1-\\gamma }\n", "\\end{bmatrix}, E_{1} =\\begin{bmatrix}\n", "0 & 0\\\\\n", "0 & \\sqrt{\\gamma }\n", "\\end{bmatrix}\n", "$$\n", "\n", "$\\gamma$为损失系数。\n", "\n", "由以上两式可以发现，阻尼信道的Kraus算符不具有幺正性，因此阻尼信道不能表示为以一定概率作用量子门的形式。\n", "接下来我们来看看两个阻尼信道的效果，首先是[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道。" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "q0: H ADC γ=4/5 " ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.core.gates import AmplitudeDampingChannel, H\n", "\n", "circ2 = Circuit()\n", "circ2 += H.on(0)\n", "circ2 += AmplitudeDampingChannel(0.8).on(0)\n", "circ2.svg()" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.912870929175277¦0⟩\n", "0.408248290463863¦1⟩\n", "\n", "1¦0⟩\n", "\n", "0.912870929175277¦0⟩\n", "0.408248290463863¦1⟩\n", "\n", "1¦0⟩\n", "\n", "0.912870929175277¦0⟩\n", "0.408248290463863¦1⟩\n", "\n" ] } ], "source": [ "# 将线路演化5次并打印量子态\n", "for i in range(5):\n", " sim.reset() # 初始化模拟器\n", " sim.apply_circuit(circ2) # 演化线路\n", " print(sim.get_qs(ket=True)) # 获取量子态\n", " print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "从以上采样结果可以看出，[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道作用在叠加态 $|\\psi\\rangle=|0\\rangle+|1\\rangle$态后会使其变为混态，混态的其中一部分是$|0\\rangle$态，另一部分仍是叠加态，但$|1\\rangle$态的振幅发生了衰减。该混态的比例由初始量子态和耗散系数$\\gamma$共同决定，初始量子态中的$|1\\rangle$态振幅越大，混态中$|0\\rangle$态的比例就越大。\n", "\n", "具体来说，对于初始量子态 $|\\psi\\rangle=a|0\\rangle+b|1\\rangle$，[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道作用后变成$|0\\rangle$态的概率为 $p=\\gamma b^2$，或以$(1-p)$的概率变为叠加态 $|\\psi'\\rangle=\\frac{1}{\\sqrt{1-\\gamma b^{2}}}(a|0\\rangle+b\\sqrt{1-\\gamma}|1\\rangle)$。\n", "\n", "由此可见，量子比特经过[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道后能量发生耗散，叠加态中激发态$|1\\rangle$态的部分减少，或者直接变为基态$|0\\rangle$态。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "接下来是[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道。" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "q0: H PDC γ=0.7 " ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.core.gates import PhaseDampingChannel\n", "\n", "circ3 = Circuit()\n", "circ3 += H.on(0)\n", "circ3 += PhaseDampingChannel(0.7).on(0)\n", "circ3.svg()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8770580193070293¦0⟩\n", "0.4803844614152615¦1⟩\n", "\n", "0.8770580193070293¦0⟩\n", "0.4803844614152615¦1⟩\n", "\n", "1¦1⟩\n", "\n", "1¦1⟩\n", "\n", "0.8770580193070293¦0⟩\n", "0.4803844614152615¦1⟩\n", "\n" ] } ], "source": [ "# 将线路演化5次并打印量子态\n", "for i in range(5):\n", " sim.reset() # 初始化模拟器\n", " sim.apply_circuit(circ3) # 演化线路\n", " print(sim.get_qs(ket=True)) # 获取量子态\n", " print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "与[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道类似，相位[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)作用在叠加态 $|\\psi\\rangle=|0\\rangle+|1\\rangle$态后同样会使其变为混态，混态的其中一部分是$|1\\rangle$态，另一部分仍是叠加态，但$|1\\rangle$态的振幅发生了衰减。该混态的比例由初始量子态和耗散系数$\\gamma$共同决定，初始量子态中的$|1\\rangle$态振幅越大，混态中$|1\\rangle$态的比例就越大。\n", "\n", "具体来说，对于初始量子态 $|\\psi\\rangle=a|0\\rangle+b|1\\rangle$，[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道作用后变成$|1\\rangle$态的概率为 $p=\\gamma b^2$，或以$(1-p)$的概率变为叠加态 $|\\psi'\\rangle=\\frac{1}{\\sqrt{1-\\gamma b^{2}}}(a|0\\rangle+b\\sqrt{1-\\gamma}|1\\rangle)$。\n", "\n", "由此可见，量子比特经过[相位阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道后并没有损失能量，但量子信息（这里体现为量子态叠加）发生了损失。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 实例演示——含噪声QAOA\n", "\n", "量子近似优化算法（Quantum Approximate Optimization Algorithm）是利用量子计算机来近似解决组合优化问题的量子算法，详尽的介绍可以参考教案[quantum_approximate_optimization_algorithm.ipynb](https://mindspore.cn/mindquantum/docs/zh-CN/master/case_library/quantum_approximate_optimization_algorithm.html)，在此我们以该算法为案例，看看引入噪声会对量子算法产生怎样的影响。在这里我们与QAOA教案保持一致，解决同一个图的Max-Cut问题。\n", "\n", "由于目前模拟器采用蒙特卡洛法模拟噪声，每次演化线路的结果具有随机性，与真实量子计算机类似，但也因此需要多次采样并分析统计结果，即每次计算哈密顿量期望值之前都需要先重新演化线路。与此同时，我们也无法直接得到含噪声量子线路的梯度，因此需要采用非梯度的优化方法。Nelder-Mead法可以得到多元标量函数的最小值，这里我们采用它来优化含参线路，得到目标哈密顿量期望值的最小值。" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABh5klEQVR4nO3deVjNaR8G8Pu0CFmL7DGDMqQkO2OYwSyWwWyWyViGGUXZx65Eicg+CBEpg7GPXXZt0mLPMpNtipL27Zzf+8e8NQwlzqnnLPfnulzX0Fnu3pe6e57f7/nKJEmSQERERET0jvREByAiIiIizcZCSURERERKYaEkIiIiIqWwUBIRERGRUlgoiYiIiEgpLJREREREpBQWSiIiIiJSCgslERERESmFhZKIiIiIlMJCSURERERKYaEkIiIiIqWwUBIRERGRUlgoiYiIiEgpLJREREREpBQWSiIiIiJSCgslERERESmFhZKIiIiIlMJCSURERERKYaEkIiIiIqWwUBIRERGRUlgoiYiIiEgpLJREREREpBQWSiIiIiJSCgslERERESmFhZKIiIiIlMJCSURERERKYaEkIiIiIqWwUBIRERGRUlgoiYiIiEgpLJREREREpBQWSiIiIiJSCgslERERESmFhZKIiIiIlMJCSURERERKYaEkIiIiIqWwUBIRERGRUlgoiYiIiEgpBqIDEBERqVJ6dh7+TExHTp4CZQz00MDUGMZG/HZHVJL4L4yIiDRebHwq/EPiEHQzAXFJGZBe+JgMgLlJeXS1NMPgtuZoXKOiqJhEWksmSZL05ocRERGpn/tJGZi+OwZnbz+Fvp4MckXh39LyP/5ho2pw79cc9UzKl2JSIu3GQklERBopMCwOc/ZdRZ5CKrJI/pe+ngwGejK49mmGAa3NSzAhke5goSQiIo2zMigWXkdvKf06k3pYYEzXxipIRKTbeJc3ERFplMCwOJWUSQDwOnoL28PiVPJaRLqMK5RERKQx7idloJv3aWTnKV75WE7Cn0gJ2Ynsv29DnvYMUm4W9IyMUcasASpY94Bxsy6vfU0jAz0cH/8Rr6kkUgJXKImISGNM3x2DvEKul8xJuIf0q6eQl/gAUnY6oJBDkZmCrL+i8XS/F55f/O21z8tTSJi+O6YkYxNpPR4bREREGiE2PhVnbz8t9OP65Sqggs2nMKpnBf0KVaHISkNq2B5kP7wBAEgN34/K7b995XlyhYSzt5/idkIqGpnxSCGid8FCSUREGsE/JK7Io4HKNWyNcg1bv/RnhlVr47GvEwBAkZNZ6Gvr68mwNTgOLn2aqS4wkQ7hljcREWmEoJsJxT4eSJIUyEtNRGrkoYI/K2vevNDHyxUSgm4lKJ2RSFdxhZKIiNReWnYe4pIyivXYx34TkfPo5gt/IkO5hq1g+oVzkc+LS8xAenYexzQSvQOuUBIRkdr7KzEd73wkiUwG6OkDbzjURALwZ2L6u74LkU7jj2FERKT2cl5zTFBhTD8bA0VWGvJSniLt8h/IfngdmbHBSEhNRK2h3ip7HyL6FwslERGpvTIGxd9QK2P2XsF/l7dsjwfLBkHKy0HO37HITXoIQ5M6KnkfIvoX/+UQEZHaa2BqDNkbHqPIzS7kI/8+U5GVVujzZf9/HyJ6e1yhJCIitWdsZABzk/L4q4gbc/7ePB5laluibN2m0K9UHYqM50iNOAgp75+iKTMwgqFpvUKfb25anjfkEL0j/sshIiKN0NXSDFtC/ir06CBFThbSo48hPfrYaz9e9ePh0DN6/XhFfT0ZulqYqSwrka7hljcREWmEwW3NizyHslLbfij7ni30K1YD9A0BfQPoV66B8k0/Qo3BC1CxZc9CnytXSPi+nXlJxCbSCVyhJCIijSBLjYdR0l1kVTaHTP/Vb1+V7Hqjkl3vt35dfT0ZOrxvyrGLRErgCiUREak1SZKwZs0a2NjYIPeiH8oYqnYtxEBPBvd+hU/RIaI3Y6EkIiK19ejRI3zxxRcYPXo07O3tEX0hCG59VVv+5vZphnomr7+2koiKh1veRESklgIDA+Hg4ICyZcvijz/+wOeffw4AGNC6Ap6mZcPr6K13fm1JkiCTyTC5hyW+a81rJ4mUxRVKIiJSK0lJSRgwYAAGDhyIHj164MqVKwVlMt+Yro2xoH9zGBnoQV/vTSdUvkxfTwY9SY7sMxvRvwnPnSRSBRZKIiJSG4cPH4aVlRWOHj2KgIAABAYGwsTE5LWPHdDaHMfHf4QO75sCwBuLZf7HO7xvit0j7SC7dxH29vZQKDhukUhZMkmSCj+DgYiIqBSkpaVh8uTJWLNmDT799FNs2LABdeoUPiLxv2LjU+EfEoegWwmIS8zAi9/YZPjn0PKuFmb4vp15wd3cJ0+eRLdu3eDh4YFffvlFtZ8QkY5hoSQiIqHOnz+PH374AY8fP8bixYvx008/QSZ7u23sF6Vn5+HPxHTk5ClQxkAPDUyNC52AM2PGDCxcuBDnzp1D27Zt3/k9iXQdCyUREQmRnZ0NFxcXLFy4EG3btoWfnx8aNWpUqhlyc3PRuXNnxMfH4/Lly6hcuXKpvj+RtuA1lEREVOqio6PRpk0bLF68GPPnz8fZs2dLvUwCgKGhIbZt24bExET8/PPP4BoL0bthoSQiolIjl8vh6emJVq1aQZIkhIWFYerUqdDX1xeW6b333sO6desQGBiIzZs3C8tBpMm45U1ERKXizp07+OGHH3DhwgVMmTIFrq6uMDIyEh2rwIgRI7B9+3ZcunQJlpaWouMQaRQWSiIiKlGSJGHdunWYOHEiatSogc2bN6NTp06iY70iPT0ddnZ2KF++PC5evKhWZZdI3XHLm4iISkz+6MSff/4Z33//PaKiotSyTAKAsbExAgICcPXqVUybNk10HCKNwkJJREQlYvv27bCyskJkZCQOHjyINWvWoEKFCqJjFcnW1hYLFy6Et7c3/vjjD9FxiDQGt7yJiEilkpKS4OjoiMDAQHzzzTf49ddfYWpqKjpWsUmShN69eyM0NBRRUVGoVauW6EhEao+FkoiIVObw4cMYPnw4MjMzsXr1agwYMECpQ8pFefLkCaytrWFlZYUjR45AT48bekRF4b8QIiJSWnp6OkaPHo3PP/8czZs3x5UrVzBw4ECNLJMAUL16dWzduhUnTpyAl5eX6DhEao8rlEREpJQLFy5gyJAhePz4Mby8vPDzzz9rbJH8r2nTpsHLywvnz59HmzZtRMchUlsslERE9E5ycnLg4uICT09PtGnTBn5+fmjcuLHoWCqVm5uLTp064enTp7h8+TIqVaokOhKRWuKWNxERvbX80YleXl6YN28ezp49q3VlEvhnNGNAQACePHmC0aNHczQjUSFYKImIqNjkcjkWLlyI1q1bQy6XIzQ0FNOmTYOBgYHoaCXm/fffx9q1a7Ft2zZs2bJFdBwitcQtbyIiKpYXRydOnjwZc+fO1alpMsOGDcOOHTsQEREBCwsL0XGI1AoLJRERFUmSJPj4+GDChAkwMzPD5s2b8eGHH4qOVerS0tLQsmVLVKxYERcvXkSZMmVERyJSG9zyJiKiQj1+/Bg9e/bETz/9hMGDByMqKkonyyQAVKhQAYGBgYiJicH06dNFxyFSKyyURET0Wr/99husrKxw+fJlHDx4EGvXrkXFihVFxxKqZcuW8PT0xOLFi3H48GHRcYjUBre8iYjoJUlJSRgzZgwCAgI0cnRiSZMkCb169UJ4eDiioqJQs2ZN0ZGIhGOhJCKiAkePHsWwYcOQkZGBVatWafS0m5KUkJAAGxsbNG/eHIcPH+ZoRtJ5/BdARERIT0+Hg4MDPv30UzRr1gwxMTEYNGgQy2QhzMzMsGXLFhw/fhyLFy8WHYdIOK5QEhHpuIsXL2LIkCF4+PAhvLy8MHr0aBbJYpo6dSoWL16MCxcuoHXr1qLjEAnDQklEpKNycnLg6uqKBQsWaO3oxJKWP5oxMTERERERHM1IOotb3kREOigmJgZt2rTBwoUL4ebmprWjE0uaoaEhtm3bhoSEBDg6OoqOQyQMCyURkQ6Ry+VYtGgRWrVqVTA6cfr06Vo9OrGkNWzYEGvWrMHWrVs5mpF0Fre8iYh0xN27d/HDDz/g/PnzmDRpEubOnYuyZcuKjqU1hg4dil27diEiIoKrvaRzWCiJiLScJElYv349xo8fr9OjE0taamoq7OzsUKlSJVy4cIGjGUmncMubiEiLPX78GL169cKoUaMwaNAgnR6dWNIqVqyIgIAAREdHY8aMGaLjEJUqFkoiIi21Y8cOWFlZ4dKlSzhw4ADWrVun86MTS5qdnR0WLFgALy8vHDlyRHQcolLDLW8iIi3z7NkzjBkzBtu2bcPXX3+NX3/9FdWqVRMdS2coFAr07NkTERERiI6ORo0aNURHIipxLJRERFrk6NGjGD58ONLT0zk6UaD4+HjY2NigRYsW+OOPPziakbQe/4YTEWmB9PR0ODo64tNPP8UHH3zA0YmC1ahRA35+fjhy5Ai8vb1FxyEqcVyhJCLScC+OTly0aBFGjx7NFTE1MWXKFCxduhQXLlxAq1atRMchKjEslEREGurF0YmtW7eGn58fLCwsRMeiF+Tk5KBjx45ITk5GREQEb4oircUfYYmINNCVK1fQtm1bLFy4EHPnzsW5c+dYJtVQmTJlEBAQgL///htjxowRHYeoxLBQEhFpELlcDi8vL9jZ2SE3NxehoaGYMWMGRyeqsUaNGuHXX3+Fn58ftm7dKjoOUYngljcRkYa4e/cuhg4dinPnzmHixIlwc3Pj6EQNMmTIEOzevRuRkZFo2LCh6DhEKsVCSUSk5iRJwoYNGzB+/HhUq1YNmzdvRufOnUXHoreUmpqKli1bomrVqjh37hxHM5JW4ZY3EZEa+/vvv9G7d2+MHDkSAwYMQHR0NMukhqpYsSICAwMRGRmJWbNmiY5DpFIslEREamrnzp2wsrJCeHg49u/fDx8fH94lrOHs7Ozg4eGBhQsX4ujRo6LjEKkMt7yJiNTMs2fPMHbsWPj7++Orr77CmjVrODpRiygUCnzxxReIjIxEVFQURzOSVmChJCJSI8eOHcOwYcOQlpaGlStXYvDgwZx2o4Xi4+NhbW2Nli1b4uDBgzyInjQe/wYTEamB9PR0jBkzBj169CgYnfj999+zTGqp/NGMhw8fxtKlS0XHIVIaVyiJiAQLDg7GkCFD8ODBAyxcuBAODg5csdIRkydPxrJly3Dx4kXY2dmJjkP0zlgoiYgEycnJgZubG9zd3dGqVSv4+fnB0tJSdCwqRTk5OejQoQOeP3/O0Yyk0fgjMBGRAFeuXEG7du2wYMECuLq64vz58yyTOujF0Yxjx44VHYfonbFQEhGVohdHJ2ZnZyMkJAQzZ87k6EQd1rhxY6xevRqbN2+Gv7+/6DhE74Rb3kREpeTevXsYOnQozp49iwkTJmDevHkcnUgF7O3tsXfvXly+fJmjGUnjsFASEZUwSZKwceNGjBs3Dqampti8eTM++ugj0bFIzaSkpKBly5YwMTHhaEbSONzyJiIqQX///Tf69OmDH3/8Ed999x2io6NZJum1KlWqhICAAFy+fBmzZ88WHYforbBQEhGVkF27dsHKygqhoaHYt28f1q9fj0qVKomORWqsdevWcHd3h6enJ44dOyY6DlGxccubiEjFkpOTMXbsWGzduhX9+/fHmjVrUL16ddGxSEMoFAp89tlniImJQVRUFMzMzERHInojFkoiIhU6fvw4hg0bhtTUVI5OpHf2999/w9raGq1atcKBAwd40D2pPf4NJSJSgYyMDIwdOxbdu3eHpaUlRyeSUmrWrInNmzfj0KFDWL58ueg4RG/EFUoiIiWFhIRgyJAhuH//PkcnkkpNnDgRK1asQHBwMFq2bCk6DlGhWCiJiN4RRydSScvOzkaHDh2QlpaGS5cuoUKFCqIjEb0Wf4QmInoHV69eRfv27bFgwQK4uLhwdCKVCCMjIwQEBODhw4dwcnISHYeoUCyURERvQS6XY/HixbCzs0NWVhaCg4Mxa9Ysjk6kEmNhYYHVq1fD19cXAQEBouMQvRa3vImIiunPP//EDz/8gLNnz2L8+PGYP38+RydSqZAkCfb29ti3bx8iIyPx/vvvi45E9BIWSiKiN5AkCb6+vnB2doapqSk2bdqELl26iI5FOiYlJQW2traoVq0azp07B0NDQ9GRiApwy5uIqAjx8fH48ssvMWLECHz77beIjo5mmSQh8kczRkREcDQjqR0WSiKiQuSPTgwJCcHevXuxYcMGjk4kodq0aYP58+fD09MTx48fFx2HqAC3vImI/iM5ORlOTk7YsmUL+vXrh7Vr13J0IqkNhUKBTz/9FFeuXEF0dDT/bpJaYKEkInpB/ujElJQUrFy5ktNuSC09fvwYNjY2aN26NQ4cOMC/oyQct7yJiPDP6EQnJyd0794dFhYWiImJgb29Pb9Rk1qqVasWNm3ahD/++IOjGUktcIWSiHReaGgo7O3tERcXB09PT4wZM4ajE0kjTJgwAatWrUJwcDBsbW1FxyEdxkJJRDorNze3YHRiy5Yt4efnhyZNmoiORVRs2dnZaN++PdLT0zmakYTij+BEpJOuXbuGdu3awcPDA7Nnz8aFCxdYJknjGBkZITAwEA8fPoSzs7PoOKTDWCiJSKcoFAp4e3ujZcuWyMzMxMWLFzF79myOTiSNZWFhgZUrV2Ljxo0IDAwUHYd0FLe8iUhn/Pnnnxg6dChOnz5dMDqxXLlyomMRKU2SJAwePBgHDx5EZGQk3nvvPdGRSMewUBKR1ssfnThu3DhUrVoVmzZtQteuXUXHIlKp58+fw9bWFjVq1MCZM2c4mpFKFbe8iUirxcfHo2/fvhgxYgS+/vprxMTEsEySVqpcuTICAgIQHh4OFxcX0XFIx7BQEpHW2r17N6ysrHDx4kXs2bMHGzdu5OhE0mpt27aFm5sbPDw8cPLkSdFxSIdwy5uItM7z58/h5OQEPz8/9O3bF2vXroWZmZnoWESlQqFQoEePHrh27Rqio6NRrVo10ZFIB3CFkoi0yokTJ9C8eXPs2bMHmzdvxu+//84ySTpFT08Pfn5+yM3NxbBhw8B1IyoNLJREpBUyMjLg7OyMbt26oXHjxoiJicGQIUM4OpF0Uu3atbFp0yYcOHAAK1euFB2HdAC3vIlI44WFhcHe3h5//fUXRycSvWD8+PFYvXo1QkNDYWNjIzoOaTEWSiLSWLm5uZg3bx7mz58PW1tb+Pn54YMPPhAdi0htZGdno127dsjMzMSlS5dgbGwsOhJpKf4IT0Qa6dq1a2jfvj3mz5+PWbNm4cKFCyyTRP+RP5rx/v37HM1IJYqFkog0youjE9PT0xEcHIw5c+bwEGeiQlhaWmLlypXYsGEDtm/fLjoOaSlueRORxvjrr78wdOhQnDp1CuPGjYO7uztHJxIVgyRJGDRoEP744w+OZqQSwUJJRGpPkiRs3rwZTk5OHJ1I9I6eP3+OFi1aoGbNmhzNSCrHLW8iUmsJCQno168fhg0bhq+++grR0dEsk0TvIH80Y1hYGFxdXUXHIS3DFUoiUlu7d+/GTz/9BABYt24d+vbtKzYQkRbw8PDAjBkzcOLECf5wRirDQklEauf58+dwdnbG5s2b8eWXX2LdunWcdkOkInK5HD169MCNGzcQFRXF0YykEiyURKRWTp48iaFDhyI5ORkrVqzgtBuiEvDo0SNYW1ujQ4cO2Lt3L/+NkdJ4DSURqYXMzEyMGzcOn3zyCRo1aoSYmBj88MMP/EZHVALyRzPu378fq1atEh2HtABXKIlIuLCwMAwZMgR//vknFixYgLFjx3J0IlEpcHZ2xtq1axESEsLRjKQUFkoiEiY3Nxfz58/HvHnz0KJFC2zZsoXTbohKUVZWFtq1a4fs7GyEh4dzNCO9My4BEJEQ169fR/v27TFv3jzMnDkTFy9eZJkkKmVly5ZFYGAg4uLiMH78eNFxSIOxUBJRqVIoFFi6dGnB6MSLFy/CxcWFhywTCdKkSRMsX74cPj4+2LFjh+g4pKG45U1EpYajE4nUkyRJGDBgAI4cOYKoqCjUr19fdCTSMCyURFTiXhydWKVKFWzatAkff/yx6FhE9ILk5GS0aNECderUwenTp2FgYCA6EmkQbnkTUYlKSEhA//79MWzYMPTv3x8xMTEsk0RqqEqVKti2bRtCQkIwd+5c0XFIw3CFkohKzJ49ezBq1CgAwNq1a9GvXz/BiYjoTebPn49Zs2bh5MmT6NKli+g4pCFYKIlI5Tg6kUhzyeVydOvWDbGxsYiKioKpqanoSKQBuOVNRCoVFBQEa2tr/P777/D19cXu3btZJok0iL6+PrZu3YqsrCyMGDECXHei4mChJCKVyMzMxPjx4/Hxxx/j/fffR0xMDIYOHcrRiUQaqE6dOvD19cXevXuxevVq0XFIA3DLm4iUFh4eDnt7e9y7dw8LFiyAk5MTRycSaQEnJyesW7cOoaGhsLa2Fh2H1BgLJRG9s9zcXLi7u8PNzQ0tWrSAn58fmjZtKjoWEalIVlYW2rZti9zcXISHh6N8+fKiI5Ga4hICEb2TGzduoEOHDnBzcysYncgySaRd8kcz/vnnnxzNSEVioSSit6JQKLBs2TLY2toiNTWVoxOJtNwHH3yA5cuXY926ddi5c6foOKSmuOVNRMUWFxeHYcOG4eTJk3BycoKHhwe3wIh0gCRJ+O6773Ds2DFERkZyNCO9goWSiN5IkiT4+fnByckJlStXhq+vLz755BPRsYioFOWPZqxbty5OnTrF0Yz0Em55E1GR8kcnDh06FH379kVMTAzLJJEOyh/NGBwcDDc3N9FxSM1whZKICrV3716MGjUKCoUCa9euRf/+/UVHIiLB5s2bhzlz5uDkyZP46KOPRMchNcFCSUSvSElJwbhx4+Dr64vevXvDx8cHNWrUEB2LiNSAXC7HJ598gjt37iAyMpKjGQkAt7yJ6D9OnToFa2tr7Ny5Exs3bsTevXtZJomoQP5oxoyMDPz4448czUgAWCiJ6P8yMzMxYcIEdO3aFQ0aNEB0dDSGDRvG0YlE9Iq6deti48aN2LNnD9asWSM6DqkBbnkTES5dugR7e3vcvXsXHh4ecHZ25uhEInqjMWPGYP369QgLC0Pz5s1FxyGBWCiJdFhubi48PDzg5uYGa2trbNmyhdNuiKjYMjMz0bZtWygUCoSGhvJcWh3GJQgiHXXjxg107NgRc+fOxfTp0xEcHMwySURvpVy5cggMDMTdu3cxceJE0XFIIBZKIh2jUCiwfPly2Nra4vnz57hw4QJcXV05OpGI3knTpk2xdOlSrFmzBr///rvoOCQIt7yJdAhHJxJRSZAkCd988w1OnDiBqKgomJubi45EpYyFkkgHSJKErVu3YsyYMahUqRJ8fX3RrVs30bGISIs8e/YMLVq0QP369XHy5EmOZtQx3PIm0nJPnjzBV199hSFDhuDLL79ETEwMyyQRqVzVqlWxbds2nD9/HvPnzxcdh0oZVyiJtNi+ffswcuRIjk4kolLj5uYGFxcXBAUFoXPnzqLjUClhoSTSQikpKRg/fjw2btyI3r17Y926dahZs6boWESkA+RyOT7++GPcvXsXUVFRMDExER2JSgG3vIm0zOnTp2FtbY3ffvsNGzZswN69e1kmiajU6Ovrw9/fn6MZdQwLJZGWyMrKwsSJE9G1a1fUr18f0dHRGD58OEcnElGpq1u3LjZs2IDdu3dj7dq1ouNQKeCWN5EWuHTpEoYMGYI7d+7A3d0d48aN4+hEIhLO0dERGzduRFhYGKysrETHoRLEQkmkwfLy8uDh4YG5c+eiefPm2LJlC5o1ayY6FhERgH9GM7Zp0waSJCEsLAzlypUTHYlKCJcwiDTUzZs30bFjR7i6umLatGkIDg5mmSQitZI/mvHOnTsczajlWCiJNIxCocCKFStga2uL5ORknD9/HnPnzkWZMmVERyMiekWzZs2wdOlS/Prrr9i9e7foOFRCuOVNpEHu37+PYcOG4cSJExg7diwWLFjA0YlEpPYkScLXX3+NoKAgREVFoV69eqIjkYqxUBJpgPzRiWPHjkXFihU5OpGINE5SUhJatGiBBg0aICgoCPr6+qIjkQpxy5tIzT158gRff/01hgwZgt69e3N0IhFpJBMTE/j7+3M0o5biCiWRGssfnSiXy7FmzRp8/fXXoiMRESnF1dUVc+fOxenTp9GpUyfRcUhFWCiJ1NCLoxN79eoFHx8fTrshIq2Ql5eHjz/+GH/++SeioqJQtWpV0ZFIBbjlTaRmTp8+DRsbG/z2229Yv3499u3bxzJJRFrDwMAAW7duRVpaGkaOHMnRjFqChZJITWRlZWHSpEno2rUr6tWrh+joaIwYMYKjE4lI65ibm2P9+vXYtWsXfHx8RMchFeCWN5EaiIiIgL29PW7fvl0wOpF3QBKRths9ejQ2bdqE8PBwDmbQcCyURALl5eVhwYIFcHV1RfPmzeHn58d5t0SkMzIzM9G6dWvo6ekhJCSEoxk1GLe8iQTJH504Z84cTJ06FcHBwSyTRKRT8kczxsbGYvLkyaLjkBJYKIlKmUKhwMqVK2Fra4tnz57h/PnzcHNz4+hEItJJVlZW8Pb2xqpVq7B3717RcegdccubqBTdv38fw4cPx/Hjx+Ho6AhPT08YGxuLjkVEJJQkSfjqq69w+vRpREVFoW7duqIj0VtioSQqBZIkwd/fH2PGjEGFChXg6+uL7t27i45FRKQ2kpKSYGNjg4YNG+LEiRO8MVHDcMubqIQ9ffoU33zzDezt7QtGJ7JMEhG9LH8049mzZ+Hu7i46Dr0lrlASlaADBw7gxx9/RF5eHkcnEhEVg4uLC9zc3HDmzBl07NhRdBwqJhZKohKQmpqKCRMmYP369ejZsyd8fHxQq1Yt0bGIiNReXl4eunbtiri4OERGRnI0o4bgljeRip05cwbW1tYIDAyEj48P9u/fzzJJRFRMBgYG8Pf3R0pKCkczahAWStJ56dl5uProOS7HPcPVR8+Rnp33Tq+TPzqxS5cuqFevHqKiovDjjz9ydCIR0Vt6cTTj+vXrRcehYuCWN+mk2PhU+IfEIehmAuKSMvDiPwIZAHOT8uhqaYbBbc3RuEbFN77e5cuXYW9vj9jYWMyfPx/jx4/nHYpEREr6+eef4efnh/DwcDRt2lR0HCoCCyXplPtJGZi+OwZnbz+Fvp4MckXhf/3zP/5ho2pw79cc9UzKv/KYvLw8eHp6wsXFBVZWVtiyZQun3RARqUhGRgZat24NfX19hIaGomzZsqIjUSFYKElnBIbFYc6+q8hTSEUWyf/S15PBQE8G1z7NMKC1ecGf37p1C0OGDEFYWBimTZuG2bNnc9oNEZGKxcTEoHXr1hg5ciRWrFghOg4VgtdQkk5YGRSLqb/HIDtP8VZlEgDkCgnZeQpM/T0GK4NioVAosGrVKrRo0QJJSUk4f/485s2bxzJJRFQCmjdvjiVLlmDlypXYt2+f6DhUCK5QktYLDIvD1N9jVPZ6Nf48jtDApRydSERUSiRJQr9+/XD27FlER0ejTp06oiPRf7BQkla7n5SBbt6nkZ2neOVjOX/fQfqNs8i+fwV5zxMgz0iBnlF5GNW2RKV2X6FsvVevhZQkCZDnwqNTeQz68tPS+BSIiAhAYmIibGxs0LhxYxw/fpw3PqoZbnmTVpu+OwZ5hWxxp0YeQkrwTmQ/vAF5WhKgyIMiMwWZd8IQv206Mm5eeOU5MpkMBoZlcOhplRJOTkRELzI1NYW/vz9Onz6NBQsWiI5D/8FCSVorNj4VZ28/LfpObuOqqNThO5h964pqfSbDwKTuPx+QFEg68fqzz+QScPb2U9xOSC2J2EREVIiPPvoIM2fOxJw5c3Dhwqs/9JM43PImreWy7yq2hPxVaKHMun8VZWo2hJ7hv8dQ5MTfxWNfp4Lf1x27FfrGVV55rr6eDPZt68OlTzOV5yYiosLl5eXho48+wsOHDxEZGYkqVaqIjkTgCiVpsaCbCUWuTpat1+ylMgkABia1X/q9zNDotc+VKyQE3UpQPiQREb0VAwMDbNu2DcnJyRg1ahRHM6oJFkrSSmnZeYhLynjr57143aRR3WbQK1Ou0MfGJWa885hGIiJ6d/Xr14ePjw927NiBjRs3io5DYKEkLfVXYjre9mfW7L9vI+nY2n9+o2+Iqt1GFvl4CcCfienvlI+IiJTzzTffYOTIkXBycsL169dFx9F5LJSklXJec0xQUbLuX0V8wHRI2emAnj6q95kMo5qNVP4+RESkOkuXLkX9+vUxcOBAZGVliY6j01goSSuVMSj+X+3MexFI+G02pOwMQN8Q1ftOQ3nLDip/HyIiUq3y5csjMDAQN27cwJQpU0TH0Wn8bkhaqYGpMWTFeFzGzQtI2DkXUm42ZIZlYfbNHJS3aFes95D9/32IiEgca2trLF68GCtWrMD+/ftFx9FZLJSklYyNDGBuUr7Ix6TfOIcnexYA8jwAMlTuNBAyfUNk3b9a8EvKyy30+eam5WFsZKDi5ERE9LYcHBzQp08fDBs2DA8fPhQdRyfxuyFpra6WZkWeQ5l5OwyQ8q+BlJAc5PvKY+r8vAEGVWq88uf6ejJ0tTBTZVwiInpHMpkMGzduhI2NDezt7XHs2DGOZixlXKEkrTW4rXmR51AqQ66Q8H078xJ5bSIienumpqbYunUrTp06BU9PT9FxdA4n5ZBWs98Qggt3E1VaLPX1ZOjwvim2jGirstckIiLVmDVrFjw8PHD27Fm0b99edBydwUJJWu1+Uga6eZ9GtgqP9zEy0MPx8R+h3huu0SQiotKXl5eHzp0749GjRxzNWIq45U1arZ5JebiqeN723D7NWCaJiNTUi6MZf/75Z45mLCUslKT1BrQ2x6QeFkq9Rv4XpMk9LPFda147SUSkzho0aAAfHx9s374dvr6v3nBJqsctb9IZgWFxmLk7Grl5csj0i3/Agb6eDPLcHBhG70bkrtUwNubZk0REmmDkyJHYtm0bLl26hCZNmoiOo9VYKElnZGVl4YPWH6L8RyOQXrHeP0WxiJt18j/+YaNqGGFdHj27tMOgQYPg4+NTiqmJiOhdpaeno1WrVjAyMkJwcDDKli0rOpLW4jmUpDOWLVuGBzciEbOjC/Sr1oF/SByCbiUgLjEDL9ZKGf45tLyrhRm+b2eORmYVAQArVqzAiBEj0L17d3z77bdCPgciIio+Y2NjBAYGok2bNpg6dSqWLl0qOpLW4gol6YT4+Hg0btwYw4YNw7Jly176WHp2Hv5MTEdOngJlDPTQwNT4tRNwJEnCwIEDcfjwYURGRqJBgwallJ6IiJSxYsUKODk5Yf/+/ejVq5foOFqJhZJ0wqhRo7Bz507cvn0bJiYm7/w6ycnJsLW1Ra1atXDmzBkYGHCRn4hI3UmShD59+iA4OBhRUVGoXbu26Ehah3d5k9aLjIzE+vXr4eLiolSZBIAqVapg27ZtCA0Nhaurq4oSEhFRSZLJZPD19YWhoSHs7e0hl8tFR9I6XKEkrSZJEj755BM8evQIMTExMDQ0VMnruru7Y+bMmTh58iS6dOmiktckIqKSdfLkSXTr1g3u7u6YOnWq6DhahYWStNrevXvRt29fHDx4EF988YXKXlcul6N79+64efMmoqKiUK1aNZW9NhERlZwZM2bA09MT586dQ7t27UTH0RoslKS1srOz0axZMzRs2BCHDx+GTCZT6es/fPgQNjY26NixI/bs2aPy1yciItXLzc1F586dER8fj8uXL6Ny5cqiI2kFXkNJWmvlypW4d+8elixZUiJlr06dOvD19cW+ffuwevVqlb8+ERGpnqGhIQICApCYmMjRjCrEFUrSSk+ePEHjxo0xePBgrFq1qkTfy8nJCevWrUNoaCisra1L9L2IiEg1tm/fjgEDBmDjxo0YNmyY6Dgaj4WStJKDgwO2bduG27dvl/j1jVlZWWjbti1yc3MRHh6O8uXLl+j7ERGRavz4448ICAhAREQELC0tRcfRaCyUpHWuXLkCGxsbLFq0CBMmTCiV97x+/Trs7Oxgb2+PtWvXlsp7EhGRctLT02FnZ4dy5cohODgYRkZGoiNpLBZK0iqSJOHTTz/FvXv3cPXqVZQpU6bU3nv9+vUYOXIkduzYga+//rrU3peIiN5dZGQk2rZtCwcHB3h7e4uOo7FYKEmrHDx4EL169cKePXvw5Zdflup7S5KE7777DseOHUNkZCTq169fqu9PRETvZvny5XB2dsaBAwfQs2dP0XE0EgslaY3c3Fw0b94cderUwfHjx4Uc45OcnIwWLVqgbt26OHXqFEczEhFpAEmS0Lt3b4SEhCA6Ohq1atUSHUnj8Ngg0hq//vorYmNj4e3tLexMyPzRjMHBwXBzcxOSgYiI3s5/RzMqFArRkTQOCyVphaSkJLi4uGDEiBHCj+7p0KEDXF1dMW/ePJw+fVpoFiIiKp7q1atjy5YtOHnyJBYtWiQ6jsbhljdpBWdnZ/j6+iI2NhY1atQQHQdyuRzdunVDbGwsoqKiYGpqKjoSEREVw/Tp07Fo0SKcO3cObdu2FR1HY7BQksa7fv06mjdvjvnz5+OXX34RHafAw4cPYW1tjQ8//BC7d+/maEYiIg2Qm5uLDz/8EAkJCRzN+Ba45U0ab9KkSTA3N4ezs7PoKC/JH824d+9e/Prrr6LjEBFRMbw4mnH06NEczVhMLJSk0Y4cOYI//vgDixYtQtmyZUXHeUWfPn0wZswYTJgwATExMaLjEBFRMbz33ntYs2YNAgIC4Ofn99rHpGfn4eqj57gc9wxXHz1HenZeKadUL9zyJo2Vl5cHGxsbVKtWDadOnVLbLeWsrCy0adMGcrkcYWFhHM1IRKQhhg8fjt9++w0RERGwsLBAbHwq/EPiEHQzAXFJGXixQMkAmJuUR1dLMwxua47GNSqKii0ECyVprNWrV2PMmDEICwuDnZ2d6DhFunbtGlq1aoUhQ4ZgzZo1ouMQEVExpKWlwc7ODmWr1YHV0Pk4fzcJ+noyyBWFV6f8j3/YqBrc+zVHPRPdWERgoSSNlJycjEaNGqFPnz7YuHGj6DjF4uPjg1GjRmHnzp346quvRMchIqJiWLjrHFZdTICegSEkWfGvFNTXk8FATwbXPs0woLV5CSZUDyyUpJEmTpyItWvXIjY2VmMmGkiShG+//RbHjx9HVFQUzM21/wsMEZEmWxkUC6+jtwBI+GdT+91M6mGBMV0bqyyXOuJNOaRxYmNjsWLFCkybNk1jyiTwzySGdevWoVKlShg8eDDy8nT7Am4iInUWGBb3/zIJKFMmAcDr6C1sD4tTPpQa4wolaZy+ffvi8uXLuHHjBsqVKyc6zls7f/48OnfujFmzZsHFxUV0HCIi+o/7SRno5n0a2XlvHsGYsMMFmXfCC35fe+SvMDSt98rjjAz0cHz8R1p7TSVXKEmjnDx5Env37oWnp6dGlkkA6NixI1xcXODm5oYzZ86IjkNERP8xfXcM8oq48SZf2tWgl8pkUfIUEqbv1t7j47hCSRpDLpejZcuWMDY2xvnz59X2mKDikMvl+Pjjj3H37l1ERUXBxMREdCQiIgIQG5+K7kvf/MO+POM5HvmMhiIzFdDXB+T/XMZU2AplvuPjO6ORmfYdKcQVStIYGzduRHR0NJYuXarRZRIA9PX14e/vj4yMDPz444+cxEBEpCb8Q+Kgr/fm7zHPTvhAkZmCCi0+hb5x8RYF9PVk2BqsnddSslCSRkhJScHMmTPx/fffo02bNqLjqETdunWxYcMG7N69G2vXrhUdh4iIAATdTCjynEkAyLx7CelXT0G/ggmqdhlW7NeWKyQE3UpQNqJaYqEkjeDu7o7U1FR4eHiIjqJSffv2hYODA8aPH48rV66IjkNEpNPSsvMQl5RR5GMUOZlIPLwKAGDSwwF6ZY3f6j3iEjO0ckwjCyWpvbt378Lb2xtTpkxB3bp1RcdROS8vLzRq1AgDBgxAZmam6DhERDrrr8R0vOkCpOTTfpCnJKB8k04ob9Hurd9DAvBnYvo75VNnLJSk9qZMmYLq1atj8uTJoqOUiHLlyiEwMBB37tzBxIkTRcchItJZOW84Jig38T5SIw5Cr2wFmHT/qcTeRxMZiA5AVJQzZ85g165d2LJlC4yN325bQZM0a9YMS5cuxc8//4zu3bujX79+oiMREemcMgZFr7PJ054BkgKKrDQ8WGH/2sc88hkNQ7P3UHv4ind+H02kfZ8RaQ25XI5x48ahdevWGDRokOg4JW7UqFH46quvMGLECNy/f190HCIindPA1FjJmThvJvv/+2gbrlCS2vLz88Ply5dx/vx56Olp/88+MpkMPj4+sLGxweDBgxEUFAR9fX3RsYiIdIaxkQHMTcrjr0JuzDGoWhtVPxn5yp8/Px8ARVYaAKBS+29gWM280PcwNy0PYyPtq1/a/12aNFJaWhqmT5+OAQMGoEOHDqLjlJqqVati27ZtOH/+PObNmyc6DhGRzulqaVboOZQGlaqhUusvX/klK/PvOMUKVh+jQrOur32+vp4MXS3MSiS3aCyUpJYWLFiA5ORkLFiwQHSUUtepUyfMmTMHc+fOxdmzZ0XHISLSKQNa133jOZTvSq6Q8H27wlcvNRlHL5La+euvv9CkSRNMnDhRZ1fp8kcz3rt3D5GRkRzNSERUCi5evAhHR0c8tOiP8g1sIMlUt+6mrydDh/dNsWVEW5W9pjrhCiWpnalTp6JKlSqYOnWq6CjC6OvrY+vWrUhLS8PIkSM5mpGIqAQ9efIEI0aMQIcOHaCvr48NP32CMoaqvc7RQE8G937NVfqa6oSFktTKhQsXEBgYCHd3d1SoUEF0HKHq1auHDRs24Pfff8e6detExyEi0jpyuRyrV6+GhYUFdu/ejTVr1iA4OBi9uraHa59mKn2vuX2aoZ5J+Tc/UENxy5vUhkKhQPv27ZGbm4vw8HCduLO7OBwcHODr64vw8HA0a6baL3BERLoqODgYjo6OiIiIwI8//ggPDw9Uq1btpcesDIqF19FbSr/X5B6WcOzaSOnXUWf8jk1qY9u2bQgNDcXSpUtZJl+wePFiNGzYkKMZiYhUIH97u3379pDJZAgODoaPj88rZRIAxnRtjAX9m8PIQK/QO78Lo68ng5GBHjz7N9f6MglwhZLURHp6OiwtLdGuXTvs3LlTdBy1c+XKFbRu3RrDhw/HqlWrRMchItI4crkc69atw/Tp0yGTyeDu7o6RI0cW67zf+0kZmL47BmdvP4W+nqzIu8DzP/5ho2pw79dcq7e5X8RCSWrB1dUV7u7uuH79Ot5//33RcdTSmjVrMHr0aOzevRt9+/YVHYeISGOEhITAwcGhyO3t4oiNT4V/SByCbiUgLjEDLxYoGf45tLyrhRm+b2eORmYVVZZfE7BQknAPHjyAhYUFxo4dC09PT9Fx1JYkSfjqq69w6tQpREVFoV69eqIjERGptSdPnmDatGnYsGEDWrZsiVWrVqFdu3Yqee307Dz8mZiOnDwFyhjooYGpsVZOwCkuFkoSzt7eHkePHkVsbCwqVaokOo5aS0pKgo2NDd5//32cPHmSoxmJiF4jf3t7xowZkCQJ7u7uGDVqFL9mliDe+UBChYaGYuvWrZg3bx7LZDGYmJjA398f586dg7u7u+g4RERqJyQkBG3atIGDgwP69++PW7duYfTo0SyTJYwrlCSMJEno2LEj0tPTERERwX/sb8HFxQVubm44c+YMOnbsKDoOEZFwT58+xbRp07B+/XrY2tpi9erVKtvepjdjoSRhAgMDMXDgQJw4cQIff/yx6DgaJS8vD127dkVcXBwiIyNRtWpV0ZGIiISQy+Xw8fHB9OnTub0tEAslCZGZmYkmTZrA1tYWe/bsER1HI8XFxcHGxgaffPIJduzYAZns7c5IIyLSdKGhoXBwcMClS5cwfPhwLFiwANWrVxcdSyfxGkoSYsmSJXj8+DEWLVokOorGMjc3x/r167Fr1y6sX79edBwiolLz9OlTjBo1Cu3atYNCocCFCxewYcMGlkmBuEJJpe7x48do3LgxfvrpJyxevFh0HI33888/w8/PD+Hh4WjatKnoOEREJUYul2P9+vWYPn06FAoF5s+fj59++onb22qAhZJK3fDhw7Fv3z7cvn0bVapUER1H42VkZKB169bQ19dHaGgoypYtKzoSEZHKhYaGwtHREeHh4Rg2bBgWLFgAMzMz0bHo/7jlTaUqIiICmzZtwty5c1kmVaR8+fIIDAxEbGwsJk+eLDoOEZFKvbi9nZeXhwsXLmDjxo0sk2qGK5RUaiRJQpcuXfD06VNERUXBwEB3JwqUhF9//RUODg7Yu3cv+vTpIzoOEZFS5HI5NmzYgGnTpkGhUGDevHn4+eefub2tplgoqdTs2rULX3/9NY4cOYIePXqIjqN1JElC//79cebMGURFRaFu3bqiIxERvZOwsDA4ODhwe1uDsFBSqcjKykLTpk3xwQcf4ODBg6LjaK380YwNGzbEiRMn+JM8EWmUxMRETJ8+HT4+PrCxscGqVavQoUMH0bGoGHgNJZWK5cuXIy4ujnd1lzATExNs3boVZ8+ehYeHh+g4RETFolAosG7dOlhYWGD79u1YsWIFwsPDWSY1CFcoqcTFx8ejcePGGDp0KJYvXy46jk6YM2cO5s+fj9OnT3M0IxGptbCwMDg6OiIsLAxDhw6Fp6cnt7c1EAsllbhRo0Zh586diI2Nhampqeg4OiEvLw9dunTB/fv3ERUVxTvqiUjtvLi9bW1tjVWrVvEHYA3GLW8qUVFRUdiwYQNcXFxYJkuRgYEB/P39kZKSglGjRoE/NxKRulAoFPDx8SnY3l6+fDnCw8NZJjUcVyipxEiShE8++QSPHj1CTEwMDA0NRUfSOTt37sQ333wDHx8f/Pjjj6LjEJGOCw8Ph6OjI0JDQzF06FAsWLAANWrUEB2LVIArlFRi9u3bh6CgICxevJhlUpCvv/4ao0aNgpOTE65fvy46DhHpqMTERPz8889o06YNsrOzce7cOfj6+rJMahGuUFKJyMnJQbNmzfD+++/j8OHDkMlkoiPprIyMDLRq1QqGhoYICQnhaEYiKjUKhQIbN27E1KlTkZubi3nz5mH06NEcbKGFuEJJJWLlypW4e/cuFi9ezDIpWP5oxps3b2LKlCmi4xCRjrh06RLat2+PkSNHolevXrh16xbGjh3LMqmlWChJ5Z4+fYq5c+fip59+gpWVleg4BMDa2hqLFy/GihUrsH//ftFxiEiLJSUlYfTo0WjdujWysrJw9uxZbNq0idvbWo5b3qRyjo6O8Pf3R2xsLKpXry46Dv2fJEno27cvzp8/j6ioKNSpU0d0JCLSIv/d3nZzc4ODgwNXJHUEVyhJpa5evYo1a9Zg1qxZLJNqRiaTYePGjShbtizs7e0hl8tFRyIiLXHp0iV06NABI0eORM+ePXHz5k04OTmxTOoQFkpSGUmSMGHCBLz//vsYO3as6Dj0Gqampti6dStOnToFT09P0XGISMO9uL2dmZmJs2fPYvPmzahZs6boaFTKWChJZQ4dOoSjR4/Cy8sLZcqUER2HCtGlSxfMmDEDs2fPxsWLF0XHISINpFAosGHDBlhYWGDbtm1YunQpLl26hE6dOomORoLwGkpSidzcXDRv3hy1a9fGiRMneGe3msvLy0Pnzp3x6NEjREZGcjQjERVbREQEHBwcEBISAnt7eyxcuJArksQVSlKNNWvW4NatW/D29maZ1AAGBgbYtm0bkpOT8fPPP3M0IxG9UVJSEhwcHNCqVStkZGTgzJkz8PPzY5kkACyUpAJJSUmYM2cORowYARsbG9FxqJgaNGgAHx8fbN++Hb6+vqLjEJGayr9729LSEv7+/vD29kZERAQ+/PBD0dFIjXDLm5Tm7OwMX19fxMbG8pwxDTRy5Ehs27YNly5dQpMmTUTHISI1wu1tKi6uUJJSbty4gdWrV2PGjBkskxpq2bJlqF+/PgYMGICsrCzRcYhIDTx79gyOjo4F29unT5/m9jYViSuUpJRevXrh6tWruH79OmdEa7CoqCi0bdsWP/30E5YtWyY6DhEJolAosGnTJvzyyy/Izs6Gm5sbHB0deZ4kvRFXKOmdHT16FAcPHsSiRYtYJjWcjY0NvLy8sHz5co5mJNJRERER6NixI0aMGIHPPvsMN2/ehLOzM8skFQtXKOmd5OXloUWLFjAxMcHp06d5Z7cWkCQJX375JS5cuIDo6GjUrl1bdCQiKgXPnj3DrFmz8Ouvv6Jp06ZYtWoVOnfuLDoWaRiuUNI78fHxwbVr13hMkBbJH81oZGSE77//nqMZibScQqGAr68vLC0t4efnh8WLFyMiIoJlkt4JCyW9teTkZMyePRs//PAD7OzsRMchFapWrVrBaMaFCxeKjkNEJeTy5cvo1KkThg8fjh49euDmzZsYN24cDA0NRUcjDcVCSW9t3rx5yMzMxPz580VHoRLQtWtXTJ8+HbNmzUJwcLDoOESkQs+ePcOYMWPQqlUrpKSk4NSpU9i6dStq1aolOhppOF5DSW8lNjYWzZo1w+zZszFz5kzRcaiE5Obm4qOPPsLjx48RGRmJypUri45EREpQKBTw8/PDlClTkJWVBVdXV4wZM4YrkqQyLJT0Vvr164dLly7h5s2bKFeunOg4VIL+/PNP2NjY4PPPP0dAQACvlSXSUJcvX4ajoyMuXryIwYMHY9GiRVyRJJXjljcV28mTJ7Fnzx4sXLiQZVIHNGjQAOvWrcP27duxadMm0XGI6C0lJydj7Nix3N6mUsEVSioWuVyOli1bwtjYGOfPn+dqlQ758ccfERAQgIiICFhaWoqOQ0Rv8OL2dmZmJlxdXTF27Fhub1OJYqGkYlm/fj1GjhyJ4OBgtG3bVnQcKkXp6emws7NDuXLlEBwcDCMjI9GRiKgQkZGRcHR0xIULFzBo0CAsWrSIZ8pSqeCWN71RSkoKZsyYgcGDB7NM6iBjY2MEBgbi2rVrmDp1qug4RPQaycnJcHJygp2dHZKTkxEUFAR/f3+WSSo1LJT0Ru7u7khNTYWHh4foKCRIixYtsGjRIixduhQHDx4UHYeI/k+hUGDz5s2wtLSEr68vFi1ahMjISHTp0kV0NNIx3PKmIt27dw9NmjTBtGnT4OLiIjoOCSRJEnr37o2QkBBER0fzwn4iwaKiouDo6Ijz589j4MCB8PLy4ookCcMVSirSlClTUK1aNUyePFl0FBJMJpPB19cXhoaGsLe3h0KhEB2JSCflb2+3bNkSz549w8mTJ7Ft2zaWSRKKhZIKdebMGezcuRMLFiyAsbGx6DikBqpXr44tW7bg5MmTWLRokeg4RDpFkiT4+fkVbG8vXLgQkZGR6Nq1q+hoRNzyptdTKBRo3bo19PX1ERwcDD09/uxB/5o+fToWLVqEc+fO8UYtolIQFRWFMWPG4Ny5cxgwYAC8vLxQp04d0bGICrAl0Gv5+fkhIiIC3t7eLJP0CldXV9jZ2WHgwIF4/vy56DhEWuv58+dwdnZGy5YtkZiYiJMnTyIgIIBlktQOVyjpFWlpabCwsEDnzp0RGBgoOg6pqXv37qFFixbo2bMn/P39edg9kQpJkoQtW7ZgypQpSE9Px5w5c+Ds7MzDyUltcemJXuHp6YmkpCR4enqKjkJq7L333sO6desQEBAAPz8/0XGItEZ0dDQ6d+6MH374AV27dsWNGzcwadIklklSayyU9JK4uDh4eXlh4sSJqF+/vug4pOa+++47DB8+HI6Ojrh165boOEQa7fnz5xg3blzB9vaJEye4vU0ag1ve9JJBgwYhKCgIt27dQsWKFUXHIQ2QP5qxfPnyuHjxIkczEr0lSZKwdetWTJ48GWlpaQXb22XKlBEdjajYuEJJBS5cuICAgAC4u7uzTFKxGRsbIyAgAFevXsW0adNExyHSKPnb20OGDEGXLl1w48YNTJ48mWWSNA5XKAnAP8cEtW/fHrm5uQgPD+ed3fTWli1bhnHjxuHgwYP44osvRMchUmvPnz/HnDlzsHLlSjRu3BgrV67EJ598IjoW0TtjoSQAgL+/P77//nucOnUKH330keg4pIHyRzOGhoYiKiqKoxmJXkOSJPj7+2PSpEnc3iatwkJJSE9Ph6WlJdq2bYtdu3aJjkMa7MmTJ7C2toaVlRWOHDnClW6iF8TExMDR0RFnz57Fd999By8vL9StW1d0LCKV4Fd7gpeXF548eYKFCxeKjkIarnr16ti6dStOnDgBLy8v0XGI1MLz588xfvx42Nra4smTJzh+/DgCAwNZJkmrcIVSxz148ACWlpYYM2YMz50klZk2bRq8vLxw/vx5tGnTRnQcIiEkScK2bdswadIkpKamYvbs2Rg3bhy3t0krsVDquCFDhuDw4cO4ffs2KlWqJDoOaYnc3Fx06tQJT58+xeXLl/l3i3ROTEwMxowZgzNnzuDbb7/F4sWLuSJJWo1b3josNDQUW7Zswbx58/gNn1TK0NAQAQEBePLkCUaPHg3+3Eq6IiUlBRMmTICtrS3i4+Nx7NgxbN++nWWStB5XKHWUJEno1KkT0tLSEBERAX19fdGRSAsFBARg0KBB2Lx5M4YMGSI6DlGJeXF7OyUlBbNnz8b48eO5vU06gyuUOuq3337DhQsXsGTJEpZJKjEDBw7E0KFD4eDgwNGMpLWuXLmCLl264Pvvv8eHH36IGzdu4JdffmGZJJ3CFUodlJmZiQ8++AA2NjbYu3ev6Dik5dLS0tCyZUtUrFgRFy9e5DdZ0hopKSlwcXHB8uXL0ahRI6xYsQLdu3cXHYtICK5Q6iBvb288evSIx7pQqahQoQICAwMRExOD6dOni45DpLT87W1LS0usXbsW8+fPR3R0NMsk6TQWSh3z+PFjuLu7Y8yYMWjcuLHoOKQjWrZsCU9PTyxevBiHDx8WHYfonV29ehVdu3bF4MGD0alTJ25vE/0ft7x1zIgRI7B3717ExsaiatWqouOQDlEoFOjVqxcuXbqEqKgo1KxZU3QkomJLSUmBq6srli1bhoYNG2LlypVckSR6AVcodUhERAR8fX0xd+5clkkqdXp6eti0aRNkMhl++OEHKBQK0ZGI3ih/e7tJkyZYs2YN5s2bx+1totfgCqWOkCQJXbp0wdOnTxEVFQUDAwPRkUhHHTt2DD169MCiRYswadIk0XGICnX16lU4Ojri9OnT+Prrr7F48WKYm5uLjkWklrhCqSN2796NM2fOYMmSJSyTJFT37t0xZcoUTJs2DWFhYaLjEL0iNTUVkyZNQosWLfD48WMcOXIEO3bsYJkkKgJXKHVAdnY2PvjgAzRp0gR//PGH6DhEyMnJQadOnZCUlITLly+jYsWKoiMRQZIkBAYGYuLEiXj+/DlmzpyJCRMmwMjISHQ0IrXHFUodsGzZMsTFxWHx4sWioxABAMqUKYOAgAAkJCTA0dFRdBwiXL16FR9//DEGDRqEDh064Pr165g2bRrLJFExsVBqufj4eMybNw8ODg744IMPRMchKtCwYUOsWbMGW7ZswZYtW0THIR2VmpqKyZMno0WLFnj48CEOHz6MnTt3cnub6C1xy1vL/fTTT9ixYwdiY2NhamoqOg7RK4YOHYpdu3YhIiKCZ6NSqZEkCdu3b8fEiRPx7NkzzJo1i9vbREpgodRi0dHRsLW1xZIlS+Ds7Cw6DtFrpaamws7ODpUqVcKFCxd4QDSVuGvXrmHMmDEICgpC//794e3tzRVJIiVxy1tLSZKECRMmoHHjxnBwcBAdh6hQFStWREBAAKKjozFjxgzRcUiL5W9v29jY4MGDBzh8+DB27drFMkmkAiyUWmr//v04ceIEvLy8YGhoKDoOUZHs7OywYMECeHl54ciRI6LjkJbJv3u7SZMmWLVqFVxdXRETE4NPP/1UdDQircEtby2Uk5MDKysrNGjQAEeOHIFMJhMdieiNFAoFevbsiYiICERHR6NGjRqiI5EWeHF7u1+/fvD29kb9+vVFxyLSOlyh1EKrVq3CnTt3sGTJEpZJ0hgczUiqlJqaiilTpsDGxgb379/HoUOH8Pvvv7NMEpUQFkot8/TpU7i6umLUqFGwsrISHYfordSoUQN+fn44cuQIvL29RcchDZR/9/YHH3yAlStXwsXFBVeuXMFnn30mOhqRVmOh1DIuLi6QJAlz584VHYXonfTo0QOTJ0/GtGnTEB4eLjoOaZDr16+jW7duGDBgANq0aYPr169jxowZPAqIqBTwGkotcvXqVdjY2MDT0xMTJ04UHYfoneXk5KBjx45ITk5GREQERzNSkdLS0jB37lx4e3ujQYMGWL58OT7//HPRsYh0CgulFvnss89w+/ZtXL16lT+Rk8a7ffs2bG1t0b9/f2zevFl0HFJDkiRhx44dmDBhApKSkjBjxgxMnDgRZcuWFR2NSOdwy1tLHDp0CEeOHIGXlxfLJGmFRo0a4ddff4Wfnx+2bt0qOg6pmevXr6N79+747rvv0Lp1a1y7dg0zZsxgmSQShCuUWiA3NxfW1taoWbMmTp48yTu7SasMGTIEu3fvRmRkJBo2bCg6DgmWlpYGNzc3LFmyBPXr18eKFSu4vU2kBlgotcCKFSvg7OyMiIgItGjRQnQcIpVKTU1Fy5YtUbVqVZw7d46jGXWUJEnYuXMnxo8fj8TERMyYMQOTJk3iiiSRmuCWt4ZLSkqCi4sLRowYwTJJWil/NOPly5cxa9Ys0XFIgBs3bqBHjx749ttv0apVK1y/fh0zZ85kmSRSIyyUGm7u3LnIycmBm5ub6ChEJaZVq1bw8PDAwoULcfToUdFxqJSkpaVh6tSpsLa2xr1793Dw4EHs2bMHDRo0EB2NiP6DW94a7ObNm7CysoKbmxumTp0qOg5RiVIoFPj8888RFRWF6OhomJmZiY5EJSR/e3vChAl4+vQppk+fjsmTJ3NFkkiNsVBqsN69e+PKlSu4fv06v9CSTvj7779hY2ODli1b4uDBg9DT4yaLtrlx4wbGjh2L48eP48svv4S3tzfee+890bGI6A341VhDHTt2DAcOHMDChQtZJkln1KxZE35+fjh8+DCWLVsmOg6p0Ivb23fv3sWBAwewZ88elkkiDcEVSg2Ul5cHW1tbVKlSBWfOnOExQaRzJk+ejGXLliE4OBgtW7YUHYeUIEkSdu3ahfHjx+Pp06eYNm0apkyZwh+UiTQMC6UGWrNmDRwcHBAWFgY7OzvRcYhKXU5ODjp06ICUlBRcunSJoxk11M2bNzF27FgcO3YMffr0wdKlS7kiSaShuOWtYZKTkzFr1iwMGTKEZZJ0VpkyZRAQEIDHjx9j7NixouPQW0pPT8e0adPQvHlz3LlzB/v378fevXtZJok0GAulhpk/fz4yMjLg7u4uOgqRUI0bN8bq1auxefNm+Pv7i45DxZC/vf3BBx9g6dKlmDlzJq5evYpevXqJjkZESuKWtwa5ffs2mjZtitmzZ2PmzJmi4xCpBXt7e+zduxeXL1/maEY19uL2du/evbF06VK8//77omMRkYqwUGqQfv364dKlS7h58ybKlSsnOg6RWkhJSUHLli1hYmLC0YxqKD09HfPnz4eXlxfq1q2L5cuXc0WSSAtxy1tDBAUFYc+ePfD09GSZJHpBpUqVCkYzzp49W3Qc+r8Xt7eXLFmCGTNmcHubSItxhVIDyOVy2NnZoVy5crhw4QKPCSJ6jUWLFmHKlCk4evQounfvLjqOTrt16xbGjh2Lo0ePolevXli2bBm3t4m0HFcoNYCvry+ioqLg7e3NMklUiIkTJ6J79+4YMmQIEhISRMfRSenp6ZgxYwasrKwQGxuLffv2Yf/+/SyTRDqAK5RqLiUlBRYWFujWrRu2bt0qOg6RWvv7779hbW2NVq1a4cCBAxzNWEokScLu3bsxbtw4JCQkYOrUqfjll194eQ6RDuFXWzXn4eGBlJQUeHh4iI5CpPZq1qyJzZs349ChQ1i+fLnoODrh1q1b+Pzzz/HVV1/B2toaV69ehYuLC8skkY5hoVRj9+7dw5IlSzB58mTUq1dPdBwijfD5559jwoQJmDJlCiIiIkTH0Vr529vNmzfHzZs3sW/fPhw4cIBHNxHpKG55q7Fvv/0W58+fx61bt2BsbCw6DpHGyM7ORocOHZCWloZLly6hQoUKoiNpDUmSsGfPHowbNw7x8fHc3iYiAFyhVFtnz57Fjh074OHhwTJJ9JaMjIwQEBCAhw8fwsnJSXQcrREbG4vPP/8c/fv3h5WVFbe3iagAVyjVkEKhQJs2bSCTyRASEsIbC4je0ebNmzF06FBs27YNAwcOFB1HY+WPe120aBFq166NZcuWoXfv3jx1gogKsFCqofxvgufOnUPHjh1FxyHSWJIk4fvvv8eBAwdw+fJlHl/zlv67vf3LL79g6tSpXJEkolewUKqZtLQ0WFhY4MMPP8T27dtFxyHSeCkpKWjRogXMzMxw9uxZGBoaio6kEWJjY+Hk5ITDhw/jiy++wPLly3nDDREVinupambhwoVISkqCp6en6ChEWiF/NOOlS5cwZ84c0XHUXkZGBmbNmgUrKytcv34de/fu5d3bRPRGLJRqJC4uDosWLcLEiRPRoEED0XGItEbbtm0xb948LFiwACdOnBAdRy3lb283bdoUixYtwi+//IJr166hT58+vFaSiN6IW95qZNCgQQgKCsKtW7dQsWJF0XGItIpCocCnn36Kq1evIioqCtWrVxcdSW3cvn0bTk5OOHToED7//HMsX74cjRo1Eh2LiDQIVyjVxMWLFxEQEID58+ezTBKVAD09Pfj5+SEvLw/Dhg0Df5b+d3u7WbNmuHbtGvbs2YODBw+yTBLRW+MKpRpQKBTo0KEDcnJyEBYWBn19fdGRiLTWH3/8gZ49e2Lp0qVwdnYWHUcISZKwb98+ODs74/Hjx5gyZQqmTZuG8uXLi45GRBqKK5RqICAgACEhIfD29maZJCphX3zxBcaPH48pU6bg8uXLouOUutu3b6NXr17o27cvmjZtiitXrsDNzY1lkoiUwhVKwTIyMmBpaYk2bdpg165douMQ6YTs7Gy0b98e6enpOjOaMSMjAwsWLICnpydq1aqFpUuX4ssvv+QNN0SkElyhFMzLywsJCQlYuHCh6ChEOsPIyAiBgYF4+PCh1m97S5KEvXv3omnTpvD09MSUKVNw7do19O3bl2WSiFSGhVKghw8fwtPTE87OzjzjjaiUWVhYYOXKldi4cSMCAwNFxykRd+7cKdjebtKkCbe3iajEcMtboB9++AGHDh1CbGwsKleuLDoOkc6RJAmDBw/GwYMHERkZiffee090JJXIzMws2N6uUaMGli5dyhVJIipRLJSChIWFoU2bNlizZg1++ukn0XGIdNbz589ha2uLGjVq4MyZMxo9mlGSJOzfvx/Ozs549OgRJk+ejOnTp3NFkohKHAulAJIk4cMPP0RKSgoiIiJgYGAgOhKRTgsJCUGnTp0wZcoUzJ8/X3Scd3Lnzh04Ozvj4MGD+PTTT7FixQo0btxYdCwi0hG8hlKAHTt24Pz58/D29maZJFIDbdu2hZubGzw8PHDy5EnRcd5KZmYm5syZg2bNmiEmJga///47Dh06xDJJRKWKK5SlLCsrC02aNIG1tTX27dsnOg4R/Z9CoUCPHj1w7do1REdHo1q1aqIjvVH+9vbDhw+5vU1EQnGFspR5e3vj4cOH8PLyEh2FiF6QP5oxNzdX7Ucz5t+93adPHzRu3BgxMTGYN28eyyQRCcNCWYoeP34Md3d3jB07FhYWFqLjENF/1K5dG5s2bcKBAwewcuVK0XFekZmZCRcXFzRr1gzR0dHYtWsXDh8+zK8nRCQct7xL0YgRI7B3717ExsaiatWqouMQUSHGjRuHX3/9FaGhobCxsREdBwBw4MABODk54cGDBwXb28bGxqJjEREBYKEsNZcvX4adnR1WrFgBR0dH0XGIqAjZ2dlo164dsrKyEB4eLrS43b17F87Ozjhw4AB69OiBFStWcEWSiNQOC2UpkCQJXbt2xZMnTxAVFcU7u4k0wI0bN2BnZ4dBgwbBx8en1N8/MzMTCxcuhIeHB8zMzODt7Y3+/fvzcHIiUktsNqVg9+7dOH36NA4dOsQySaQhmjRpghUrVmDEiBHo3r07vv3229c+Lj07D38mpiMnT4EyBnpoYGoMYyPl/p2/uL09adIkzJgxg9vbRKTWuEJZwrKzs9G0aVNYWlrijz/+EB2HiN6CJEkYOHAgDh8+jMjISDRo0AAAEBufCv+QOATdTEBcUgZe/CIqA2BuUh5dLc0wuK05GteoWOz3u3v3LsaNG4f9+/eje/fuWLFiBSwtLVX6ORERlQQWyhK2aNEiTJs2DTExMfjggw9ExyGit5ScnAxbW1vUqlUL/nsPY/a+6zh7+yn09WSQKwr/8pn/8Q8bVYN7v+aoZ1L4kT4vbm9Xr14dS5cu5fY2EWkUFsoSlJCQgEaNGuGHH37AihUrRMchond08eJFfOowF9U/cwD09Isskv+lryeDgZ4Mrn2aYUBr81c+fvDgQTg5OeH+/fuYOHEiZs6cye1tItI4PIeyBM2ePRv6+vpwcXERHYWIlHApqxpMPhuDPKnoVcnXkSskZOcpMPX3GKwMii3483v37uHLL79Er1690LBhQ8TExMDDw4Nlkog0Eu8QKSExMTHw8fHB4sWLYWpqKjoOEb2jwLA4eB29BQBKb0F7Hb2FKkb6uHt8Kzw8PFCtWjXs2LEDX331Fbe3iUijccu7BEiShO7du+P+/fuIiYlBmTJlREciondwPykD3bxPIztP8dqPS3m5SAndjfSrQchN/ht6hmVhVK8ZKnccAKOajV7/onk5iPcdi3Ej7TFjxgxUqFChBD8DIqLSwUJZAvbv348+ffpg//796NWrl+g4RPSO7DeE4MLdxNduc0sKORK2z0bWX1GvPlHfEGbfzEG5Bi1e/ZikQMvaxvjd6WPVByYiEoTXUKpYTk4OJk6ciG7duqFnz56i4xDRO4qNT8XZ208LvWYyNeJgQZk0rF4f1ftNR+UO3/3zQXkuEg8uhZSX++oTZXqIeJyJ2wmpJRWdiKjUsVCq2OrVq3Hnzh0sWbKE10QRaTD/kDjo6xX+bzjt8qGC/zb9bCzKW3ZAlc72KPteSwCAPPUpMm6Hvva5+noybA2OU21gIiKBWChV6OnTp3B1dcWoUaPQvHlz0XGISAlBNxMKXZ2UZ6YiN/H+P7/RM0CZWo0LPmZU59/zZrMfXH398xUSgm4lqC4sEZFgLJQq5OLiAoVCgblz54qOQkRKSMvOQ1xSRqEfz3seX/Df+uUqQqan/+/vjSv/+7jkeBQmLjED6dl5SiYlIlIPLJQqcu3aNaxZswazZs1C9erVRcchIiX8lZiOou5WlHKz/v2N/sunr8n0DF7/uP++BoA/E9PfMSERkXphoVSRiRMnokGDBhg7dqzoKESkpMKOCconMyxb8N+S/OUbbyRF3msf9zo5b3gfIiJNwYPNVeDQoUM4fPgwfv/9dxgZGYmOQ0RvkJKSgri4ONy/f/+1v/7OMoDJ4EWFPt+gco2C/1ZkpkJSyAu2veVpz/59XJUarzz3RWUM+DM9EWkHFkol5ebmYuLEiejSpQv69u0rOg6RzsvMzCy0KOb/SklJKXi8np4eatWqhXr16qFevXpo0aIFatQxx+onEoDX3+WtX64iDE3r/XNjjkKOnMe3Cm7GyX50o+BxRnWbFZpTBqCBKccsEpF2YKFU0tq1a3Hjxg1s27aNxwQRlbCcnBw8fPiwyLKYmJj40nPMzMwKyuLHH39c8N/5v2rVqgVDQ8NX3uvgoiD8VcSNORVsP8ez4+sAAImHVqDKh98jO/4Osu5dBgDoV6yG8o3aFPp8c9PyMDbil2Ai0g6clKOEZ8+eoVGjRujXrx/Wr18vOg6RRpPL5fj7779fKYgvbk3Hx8fjxS9ZVapUeaUg5v8yNzdHnTp1ULZs0dcxFsZl31VsCfmr0KOD3nlSDv45h9K+bX249Cl8BZOISJOwUCph/PjxWL9+PWJjY1GzZk3RcYjUliRJePLkSZEri48ePUJe3r83tBgbGxdaFvN/leQc7Nj4VHRfeqboz+v/s7zTrp5EXnL8P7O86zZF5U4DC5/l/X/Hx3dGI7OKqoxMRCQMC+U7unnzJqysrDB37lxMmzZNdBwiYSRJQnJycpFl8cGDB8jOzi54TpkyZVC3bt2ClcTXlcUqVaoIv4ykqFne70pfT4YO75tiy4i2KntNIiLRWCjfUZ8+fRAdHY0bN26885YakSZIT09/400uaWlpBY/X19dH7dq1i1xZrF69OvT01P8O5/tJGejmffqNxwi9DSMDPRwf/xHqmZRX2WsSEYnGK8LfwbFjx7B//3789ttvLJOk0bKzs/HgwYMiy+KzZ89eek7NmjULimGPHj1eKYs1a9aEgYF2fGmpZ1Iern2aYervMSp7zbl9mrFMEpHW4QrlW8rLy4OtrS2qVKmCM2fOCN+SIypMXl4eHj9+XOgNLvfv30dCwsvzpE1MTIpcWaxTp45OnrW6MigWXkdvKf06k3tYwrFr0ddWEhFpIu1YRihFGzZswJUrVxAWFsYyScIoFAokJCS88SYXheLfrdqKFSsWFENbW1v06dPnpbJYt25dGBvzXMTXGdO1MapVMMKcfVeRp5De6ppKfT0ZDPRkmNunGb5rbV6CKYmIxOEK5Vt4/vw5GjVqhJ49e2LTpk2i45CWkiQJSUlJRZbFhw8fIicnp+A5RkZGRR6fU69ePVSuXFngZ6Ud7idlYPruGJy9/RT6erIii2X+xz9sVA3u/Zpzm5uItBoL5VuYPHkyVq9ejdjYWNSuXVt0HNJQqampb7zJJSPj3wO1DQwMUKdOnSK3oqtVq8YV81IUG58K/5A4BN1KQFxiBl78IirDP4eWd7Uww/ftzHk0EBHpBBbKYrp9+zaaNm2KWbNmYdasWaLjkJrKzMx8400uz58/L3i8TCZ76SaX1x2jU6NGDejr6wv8rKgo6dl5+DMxHTl5CpQx0EMDU2NOwCEincNCWUz9+/dHeHg4bty4gfLluXWli3Jzc/Ho0aNCb3C5f/8+nj59+tJzqlWrVuTKYu3atVGmTBlBnxEREZFqsFAWQ1BQED7++GP4+/tj0KBBouNQCVAoFK8d+/fir8ePH7809q9y5cpFlsW6deuiXLlyAj8rIiKi0sFC+QZyuRytWrVC2bJlceHCBV6npoEkScLTp0/feJPLi2P/ypUr98axf5UqVRL4WREREakPXujzBps2bUJkZCQuXrzIMqmmnj9/XmhRjIuLw4MHD5CVlVXweENDw4Kxf/Xr10enTp1eKYsmJib8/5uIiKiYdH6FsqgL6lNTU9G4cWN88skn8Pf3F5xUN2VkZLzxjujU1NSCx+vp6aFWrVqFHp1Tr149mJmZacTYPyIiIk2hkyuUBUd+3ExAXNJrjvwwKY+ulmZ4cvF3pKSkYMGCBaKiarWcnBw8fPiw0Btc7t+/j6SkpJeeY2ZmVlAMP/nkk9fe5KItY/+IiIg0hU6tUL7VocQyQC4BtWTJ+G1SPx5K/JbkcvkrY//++ys+Pv6lm1yqVKlS6NE5+WP/ODudiIhI/ehMoQwMi3u3sWkywEBfD659mmEAx6YB+Ocml+KM/ZPL5QXPMTY2fuNNLhUqVBD4WREREdG70olCuTIoFl5Hbyn9OpN6WGBM18YqSKS+JElCcnJyoTe43L9/Hw8ePHhp7F+ZMmXeWBarVKnCm1yIiIi0lNYXysCwOEz9PUZlr+fZvzm+0+CVyrS0tDfe5JKenl7weH19fdSuXbvIsli9enXe5EJERKTDtLpQ3k/KQDfv08jOU7zyMXlmKlJCdiH74Q3kPI6FlJcNADC2+gTVeo0v9DWNDPRwfPxHanlNZVZW1hvH/iUnJ7/0nP+O/fvvr5o1a/ImFyIiIiqSVjeF6btjkFfI9ZLylCdICd751q+Zp5AwfXcMtoxoq2y8t3vfvLyXxv697ldCQsJLzzExMSkohp06dXrlRpc6depw7B8REREpTWsLZWx8Ks7eflr4A/QNYFTPCkZ1mkCe8Rzp0ceK9bpyhYSzt5/idkIqGplVVElWhUKB+Pj4N479Uyj+XWmtWLFiQTG0tbVFnz59Xhn7Z2xsrJJ8REREREXR2kLpHxJX5NFAZaqZo+bgf86XTL38R7ELJQDo68mwNTgOLn2avfGxkiQhKSnptTe3vDj2Lzc3t+A5ZcuWRd26dWFubg5LS0t069btla3oypUrFzsvERERUUnS2kIZdDPhrY4HehtyhYSgWwlwQTOkpKS88SaXzMzMgucaGBigTp06BcWwffv2r5TFatWq8Y5oIiIi0hhaWSjTsvMQl5RRou/x19N0VDY1Q0rSk4I/k8lkL439s7a2fqUs1qhRA/r6+iWajYiIiKg0aWWh/CsxHSV+67pMhlETZsD2veov3eRiaGhY0u9MREREpFa0slDmvOaYoJIwyH4IbM2rlsp7EREREakrrTyNuoxB6XxapfU+REREROpMKxtRA1NjlPQtLbL/vw8RERGRrtPKLW9jIwOYm5THX0XcmKPIzULmnXAAQE783YI/z0tJQPqNcwAAo1oWMKhs9trnm5uWh7GRVv7PR0RERPRWtLYRdbU0w5aQvwo9OkiR/hxP9yx45c+z42KQHffP7G/TL8ahgnW3Vx6jrydDV4vXF00iIiIiXaOVW94AMLiteYmeQ/l9O/MSeW0iIiIiTSOTJKnET9gRxX5DCC7cTVRpsdTXk6HD+6alPsubiIiISF1p7QolALj3aw4DPdXenmOgJ4N7v+YqfU0iIiIiTabVhbKeSXm4FmPe9tuY26cZ6pmUV+lrEhEREWkyrS6UADCgtTkm9bBQyWtN7mGJ71rz2kkiIiKiF2n1NZQvCgyLw5x9V5GnkN7qmkp9PRkM9GSY26cZyyQRERHRa+hMoQSA+0kZmL47BmdvP4W+nqzIYpn/8Q8bVYN7v+bc5iYiIiIqhE4Vynyx8anwD4lD0K0ExCVm4MX/AWT459DyrhZm+L6dORqZVRQVk4iIiEgj6GShfFF6dh7+TExHTp4CZQz00MDUmBNwiIiIiN6CzhdKIiIiIlKO1t/lTUREREQli4WSiIiIiJTCQklERERESmGhJCIiIiKlsFASERERkVJYKImIiIhIKSyURERERKQUFkoiIiIiUgoLJREREREphYWSiIiIiJTCQklERERESmGhJCIiIiKlsFASERERkVJYKImIiIhIKSyURERERKQUFkoiIiIiUgoLJREREREphYWSiIiIiJTCQklERERESmGhJCIiIiKlsFASERERkVJYKImIiIhIKSyURERERKQUFkoiIiIiUgoLJREREREphYWSiIiIiJTCQklERERESmGhJCIiIiKlsFASERERkVJYKImIiIhIKSyURERERKQUFkoiIiIiUgoLJREREREphYWSiIiIiJTCQklERERESmGhJCIiIiKlsFASERERkVL+BzAD3KAkwG/EAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from mindquantum.core.circuit import Circuit, UN\n", "from mindquantum.core.gates import H, RX, Rzz, AmplitudeDampingChannel\n", "from mindquantum.core.operators import Hamiltonian, QubitOperator\n", "from mindquantum.simulator import Simulator\n", "from scipy.optimize import minimize\n", "import networkx as nx\n", "import mindspore as ms\n", "ms.set_context(mode=ms.PYNATIVE_MODE, device_target=\"CPU\")\n", "\n", "# 生成待求解的图\n", "g = nx.Graph()\n", "nx.add_path(g, [0, 1])\n", "nx.add_path(g, [1, 2])\n", "nx.add_path(g, [2, 3])\n", "nx.add_path(g, [3, 4])\n", "nx.add_path(g, [0, 4])\n", "nx.add_path(g, [0, 2])\n", "nx.draw(g, with_labels=True, font_weight='bold')" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "q0: q1: q2: q3: q4: H H H H H Rzz g0 Rzz g0 Rzz g0 Rzz g0 Rzz g0 Rzz g0 RX b0 RX b0 RX b0 RX b0 RX b0 Rzz g1 Rzz g1 Rzz g1 Rzz g1 Rzz g1 Rzz g1 RX b1 RX b1 RX b1 RX b1 RX b1 Rzz g2 Rzz g2 Rzz g2 Rzz g2 Rzz g2 Rzz g2 RX b2 RX b2 RX b2 RX b2 RX b2 Rzz g3 Rzz g3 Rzz g3 Rzz g3 Rzz g3 Rzz g3 RX b3 RX b3 RX b3 RX b3 RX b3 " ], "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\n", "gamma = 0.005 # 设定振幅阻尼信道的耗散系数\n", "circ = Circuit(UN(H, g.nodes)) # 生成均匀叠加态\n", "\n", "# 生成ansatz线路，详细的原理请参考QAOA教案\n", "for i in range(4):\n", " for j in g.edges:\n", " circ += Rzz(f'g{i}').on(j) # 对图中的每条边作用ZZ门\n", " circ.barrier(False)\n", " for j in g.nodes:\n", " circ += RX(f'b{i}').on(j) # 对每个节点作用RX门\n", " circ.barrier(False)\n", "circ.svg()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里我们假设存在一个简单的噪声模型：每一个[H](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.HGate.html)门和[RX](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.RX.html)门后都有一个[振幅阻尼](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.AmplitudeDampingChannel.html)信道。噪声模型的构建方式如下（请参考[教程](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/middle_level/noise_simulator.html)了解如何构建噪声模型）：" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "q0: q1: q2: q3: q4: H ADC γ=1/200 H ADC γ=1/200 H ADC γ=1/200 H ADC γ=1/200 H ADC γ=1/200 Rzz g0 Rzz g0 Rzz g0 Rzz g0 Rzz g0 Rzz g0 RX b0 ADC γ=1/200 RX b0 ADC γ=1/200 RX b0 ADC γ=1/200 RX b0 ADC γ=1/200 RX b0 ADC γ=1/200 Rzz g1 Rzz g1 Rzz g1 Rzz g1 Rzz g1 Rzz g1 RX b1 ADC γ=1/200 RX b1 ADC γ=1/200 RX b1 ADC γ=1/200 RX b1 ADC γ=1/200 RX b1 ADC γ=1/200 Rzz g2 Rzz g2 Rzz g2 q0: q1: q2: q3: q4: Rzz g2 Rzz g2 Rzz g2 RX b2 ADC γ=1/200 RX b2 ADC γ=1/200 RX b2 ADC γ=1/200 RX b2 ADC γ=1/200 RX b2 ADC γ=1/200 Rzz g3 Rzz g3 Rzz g3 Rzz g3 Rzz g3 Rzz g3 RX b3 ADC γ=1/200 RX b3 ADC γ=1/200 RX b3 ADC γ=1/200 RX b3 ADC γ=1/200 RX b3 ADC γ=1/200 " ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.core.circuit import GateSelector, SequentialAdder, MixerAdder, NoiseChannelAdder\n", "\n", "noise_model = SequentialAdder([\n", " MixerAdder([\n", " GateSelector('h'),\n", " NoiseChannelAdder(AmplitudeDampingChannel(gamma)),\n", " ]),\n", " MixerAdder([\n", " GateSelector('rx'),\n", " NoiseChannelAdder(AmplitudeDampingChannel(gamma))\n", " ]),\n", "])\n", "\n", "noise_circ = noise_model(circ)\n", "noise_circ.svg(width=1500)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "max cut: 4.463308996965548\n" ] } ], "source": [ "\n", "# 生成哈密顿量\n", "ham = QubitOperator()\n", "for i in g.edges:\n", " ham += QubitOperator(f'Z{i[0]} Z{i[1]}')\n", "ham = Hamiltonian(ham)\n", "\n", "sim = Simulator('mqvector', noise_circ.n_qubits) # 初始化模拟器\n", "\n", "# 定义待优化的函数，由于噪声存在，每次需要重新演化线路\n", "def func(x):\n", " sim.reset() # 重置模拟器\n", " sim.apply_circuit(noise_circ, x) # 演化线路，参数x是优化器生成的线路参数数值\n", " f = sim.get_expectation(ham).real # 计算并返回哈密顿量的期望值\n", " return f\n", "\n", "# 设置线路参数的初始数值\n", "n_paras = len(noise_circ.params_name)\n", "init_amp = [0.0 for i in range(n_paras)]\n", "\n", "res = minimize(func, init_amp, method='nelder-mead') # 使用优化器优化参数，得到哈密顿量期望值的最小值，优化方法是nelder-mead\n", "cut = (len(g.edges) - res.fun) / 2 # 计算max-cut数\n", "print('max cut:', cut) # 打印结果" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "从结果可以看出，受到噪声影响，QAOA算法的结果变差，但当耗散系数不高时还是能收敛得到一个接近的结果。" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", " \n", " \n", "\n", "\n", "
SoftwareVersion
mindquantum0.9.11
scipy1.10.1
numpy1.24.4
SystemInfo
Python3.8.17
OSLinux x86_64
Memory16.62 GB
CPU Max Thread16
DateTue Jan 2 16:17:25 2024
\n" ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.utils.show_info import InfoTable\n", "\n", "InfoTable('mindquantum', 'scipy', 'numpy')" ] } ], "metadata": { "kernelspec": { "display_name": "MindSpore", "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.17" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }