{ "cells": [ { "cell_type": "markdown", "id": "ad8dc776-3c05-4f83-a47c-b50416b4ea08", "metadata": {}, "source": [ "## CEMRACS 2025 - Hands-on session\n", "# Quantum chemistry with short-term & long-term quantum algorithms\n", "\n", "The goal of this hands-on session is to give you a flavor of two algorithms for handling ground-state energy estimation problems such as the ones arising in quantum chemistry: given a Hamiltonian $H$, we want to find its ground state energy $E_0$, namely its lowest eigenvalue.\n", "\n", "Two main algorithms have been proposed to this avail: the quantum phase estimation (QPE) algorithm, and the variational quantum eigensolver (VQE) algorithm. The former is aimed at noiseless (or error-corrected) quantum processors, while the second is aimed as noisy quantum processors, aka NISQ processors." ] }, { "cell_type": "markdown", "id": "3b291f00-a470-4bd4-bdbf-47227b867962", "metadata": {}, "source": [ "## Prerequisite: spin-fermion transforms\n", "\n", "Chemistry describes the behavior of electrons, which are fermionic particles. Their algebraic properties differ from those of qubits: $N$ fermionic spin-orbitals are described by a $2^N$-dimensional Fock space with a basis $|n_1, n_2, \\dots, n_N\\rangle$ defined as the eigenbasis of the so-called number operators $\\hat{n}_i = c^\\dagger_i c_i$ ($i=1\\dots N$) with \n", "$$ \\hat{n}_i |n_1, n_2, \\dots, n_N\\rangle = n_i |n_1, n_2, \\dots, n_N\\rangle, $$\n", "with $n_i \\in \\lbrace 0 , 1 \\rbrace$.\n", "\n", "The creation (resp. annihilation) operators create (resp. annihilate) electrons:\n", "$$ c^\\dagger_i |n_1, n_2, \\dots, n_i, \\dots, n_N\\rangle = (-)^{\\sum_{k does not match any known type: falling back to type probe function.\n", "This warnings indicates broken support for the dtype!\n", " machar = _get_machar(dtype)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " HF energy : -1.1166843870853405\n", " MP2 energy : -1.1298551535553094\n", " FCI energy : -1.1372701746609035\n", "\n", "Number of orbitals (qubits) = 4\n", "0.7137539936876182 * I^4 +\n", "(-1.2524635735648983+0j) * (Cc|[0, 0]) +\n", "(-1.2524635735648983+0j) * (Cc|[1, 1]) +\n", "(-0.4759487152209643+0j) * (Cc|[2, 2]) +\n", "(-0.4759487152209643+0j) * (Cc|[3, 3]) +\n", "(-0.6744887663568379+0j) * (CCcc|[0, 1, 0, 1]) +\n", "(-0.18128880821149598+0j) * (CCcc|[0, 1, 2, 3]) +\n", "(-0.48217928821207207+0j) * (CCcc|[0, 2, 0, 2]) +\n", "(-0.663468096423568+0j) * (CCcc|[1, 2, 1, 2]) +\n", "(0.18128880821149598+0j) * (CCcc|[1, 2, 0, 3]) +\n", "(-0.663468096423568+0j) * (CCcc|[0, 3, 0, 3]) +\n", "(0.18128880821149598+0j) * (CCcc|[0, 3, 1, 2]) +\n", "(-0.48217928821207207+0j) * (CCcc|[1, 3, 1, 3]) +\n", "(-0.18128880821149598+0j) * (CCcc|[2, 3, 0, 1]) +\n", "(-0.6973937674230271+0j) * (CCcc|[2, 3, 2, 3])\n" ] } ], "source": [ "from qat.fermion.chemistry.pyscf_tools import perform_pyscf_computation\n", "geometry = [(\"H\", (0.0, 0.0, 0.0)), (\"H\", (0.0, 0.0, 0.7414))]\n", "basis, spin, charge = \"sto-3g\", 0, 0\n", "\n", "(\n", " rdm1,\n", " orbital_energies,\n", " nuclear_repulsion,\n", " n_electrons,\n", " one_body_integrals,\n", " two_body_integrals,\n", " info,\n", ") = perform_pyscf_computation(geometry=geometry, basis=basis, spin=spin, charge=charge, run_fci=True)\n", "\n", "print(\n", " f\" HF energy : {info['HF']}\\n\",\n", " f\"MP2 energy : {info['MP2']}\\n\",\n", " f\"FCI energy : {info['FCI']}\\n\",\n", ")\n", "nqbits = rdm1.shape[0] * 2\n", "print(\"Number of orbitals (qubits) = \", nqbits)\n", "\n", "from qat.fermion.chemistry import MolecularHamiltonian, MoleculeInfo\n", "mol_h = MolecularHamiltonian(one_body_integrals, two_body_integrals, nuclear_repulsion)\n", "hamiltonian = mol_h.get_electronic_hamiltonian()\n", "print(hamiltonian)" ] }, { "cell_type": "markdown", "id": "28f5d076-0e1d-457c-af98-0869b949e4db", "metadata": {}, "source": [ "### Fermion-qubit conversion\n", "\n", "We now perform the fermion-to-qubit conversion. The default mapping is Jordan-Wigner, but you can try others." ] }, { "cell_type": "code", "execution_count": 2, "id": "7c064c26-01ef-4ed1-a678-011371c64bd5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(-0.09886396933545832+0j) * I^4 +\n", "(0.16862219158920946+0j) * (ZZ|[0, 1]) +\n", "(0.12054482205301802+0j) * (ZZ|[0, 2]) +\n", "(0.165867024105892+0j) * (ZZ|[1, 2]) +\n", "(0.165867024105892+0j) * (ZZ|[0, 3]) +\n", "(0.17119774903432972+0j) * (Z|[0]) +\n", "(0.12054482205301802+0j) * (ZZ|[1, 3]) +\n", "(0.17119774903432972+0j) * (Z|[1]) +\n", "(0.045322202052873996+0j) * (XYYX|[0, 1, 2, 3]) +\n", "(-0.045322202052873996+0j) * (XXYY|[0, 1, 2, 3]) +\n", "(-0.045322202052873996+0j) * (YYXX|[0, 1, 2, 3]) +\n", "(0.045322202052873996+0j) * (YXXY|[0, 1, 2, 3]) +\n", "(0.17434844185575676+0j) * (ZZ|[2, 3]) +\n", "(-0.2227859304041846+0j) * (Z|[2]) +\n", "(-0.2227859304041846+0j) * (Z|[3])\n" ] } ], "source": [ "hamiltonian_qubit = hamiltonian.to_spin() # default is Jordan Wigner\n", "print(hamiltonian_qubit)" ] }, { "cell_type": "markdown", "id": "40b272ef-f6ce-4958-b789-37146b913763", "metadata": {}, "source": [ "## Exact result\n", "\n", "For comparison with the two quantum methods we are about to implement, let us solve the problem exactly: since it is a small molecule (= small number of orbitals), we can afford to diagonalize the corresponding Hamiltonian exactly. How does the lowest eigenenergy compare with the \"FCI\" energy printed above? " ] }, { "cell_type": "code", "execution_count": 3, "id": "919c9c25-a788-4fed-a334-7e320a6245a4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "E0 = -1.1372701746609029\n" ] } ], "source": [ "import numpy as np\n", "\n", "# extract the matrix representation of the Hamiltonian (can make it sparse, see docstring of get_matrix)\n", "ham_matrix = hamiltonian_qubit.get_matrix()\n", "\n", "# diagonalize\n", "eigvals = np.linalg.eigvalsh(ham_matrix)\n", "E0 = min(eigvals)\n", "print(\"E0 = \", E0)" ] }, { "cell_type": "markdown", "id": "a4616174-c2cf-41b2-967b-438861740eba", "metadata": {}, "source": [ "## NISQ: the variational quantum eigensolver\n", "\n", "Take a hardware-efficient ansatz, with an alternation of walls of $R_y$ rotations and walls of CNOT gates." ] }, { "cell_type": "code", "execution_count": 4, "id": "975d9c6b-1265-4999-afcc-06a95850ab8a", "metadata": {}, "outputs": [ { "data": { "text/html": [ "Q0Q1Q2Q3RY [theta_0]RY [theta_1]RY [theta_2]RY [theta_3]RY [theta_4]RY [theta_5]RY [theta_6]RY [theta_7]RY [theta_8]RY [theta_9]RY [theta_10]RY [theta_11]" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from qat.lang.AQASM import RY, CNOT, Program\n", "\n", "def generate_ansatz(n_layers):\n", " prog = Program()\n", " qreg = prog.qalloc(nqbits)\n", " \n", " for id_layer in range(n_layers):\n", " for qb in range(nqbits):\n", " prog.apply(RY(prog.new_var(float, f\"\\\\theta_{nqbits*id_layer+qb}\")), qb)\n", " for qb in range(nqbits-1):\n", " prog.apply(CNOT, qreg[qb], qreg[qb+1])\n", " \n", " circ = prog.to_circ()\n", " return circ\n", "\n", "n_layers = 3\n", "circ = generate_ansatz(n_layers)\n", "circ.display()" ] }, { "cell_type": "markdown", "id": "b55944f3-7f08-4b78-80b4-a2e8951b602c", "metadata": {}, "source": [ "We now implement the VQE per se." ] }, { "cell_type": "code", "execution_count": 5, "id": "dc8cee0f-bb9e-4676-b3fb-7034525a6912", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "variational energy = -1.1372701744322027\n" ] } ], "source": [ "from qat.qpus import get_default_qpu\n", "from qat.plugins import ScipyMinimizePlugin\n", "\n", "def perform_vqe(circ, nbshots, qpu, method=\"bfgs\"):\n", " \"\"\"\n", " This function performs the VQE algorithm for a given variational circuit and quantum processor.\n", "\n", " Args:\n", " circ (Circuit): variational circuit\n", " nbshots (int): number of shots \n", " qpu (QPUHandler): a quantum processor (emulator, or experimental one)\n", "\n", " Returns:\n", " Result: an object containing the results (including the variational energy)\n", " \"\"\"\n", " \n", " # define the plugin (optimization module)\n", " # the optimization method can be picked from the various methods implemented in scipy.optimize.minimize, see online doc\n", " plugin = ScipyMinimizePlugin(method=method,\n", " x0 = [np.random.rand() for _ in range(n_layers*nqbits)],\n", " options={'maxiter': 500})\n", " # define the stack\n", " stack = plugin | qpu\n", " \n", " # create a job with a parametric circuit and hamiltonian to be optimized\n", " # here nbshots will control the number of shots per term of the Hamiltonian\n", " # (thus the total number of shots is nbshots x number of terms)\n", " job = circ.to_job(observable=hamiltonian_qubit, nbshots=nbshots)\n", " \n", " # submit the job (=perform the computation)\n", " res = stack.submit(job)\n", "\n", " return res\n", "\n", "# instantiate the default QPU emulator: a perfect circuit emulator\n", "qpu = get_default_qpu()\n", "\n", "res = perform_vqe(circ, 0, qpu)\n", "print(\"variational energy = \", res.value)" ] }, { "cell_type": "markdown", "id": "574355fd-7448-433b-b171-037c9298e442", "metadata": {}, "source": [ "Let us plot the evolution of the energy along the optimization procedure." ] }, { "cell_type": "code", "execution_count": 6, "id": "64983523-1d39-4156-a29c-498e26a3e864", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "optimization_trace = eval(res.meta_data[\"optimization_trace\"])\n", "\n", "plt.plot(optimization_trace, '-', lw=4)\n", "plt.plot([E0]*len(optimization_trace), '--k', lw=3, label=\"exact ground state energy\")\n", "plt.xlabel(\"optimization step\")\n", "plt.ylabel(\"energy\")\n", "plt.legend();" ] }, { "cell_type": "markdown", "id": "80a7a9e6-af41-491d-b495-ecefa694813a", "metadata": {}, "source": [ "Let us look at the corresponding state by extracting the optimized parameters and running the corresponding circuit." ] }, { "cell_type": "code", "execution_count": 7, "id": "98dc5089-49f0-453d-ba99-a95b19178230", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "optimized parameters: {'\\\\theta_0': 2.6893894100172804, '\\\\theta_1': -0.06613311060628065, '\\\\theta_10': 1.2210053797787144, '\\\\theta_11': -0.06413240125502888, '\\\\theta_2': 1.570787550813338, '\\\\theta_3': 0.35539079079672214, '\\\\theta_4': -0.03210478333449806, '\\\\theta_5': -0.07348208811388075, '\\\\theta_6': 1.3968452861451626, '\\\\theta_7': 1.3855353907338779, '\\\\theta_8': 0.6772770996894059, '\\\\theta_9': -2.626885793134871e-07}\n", "|0011> (3): (-0.1128269814371377+0j)\n", "|1100> (12): (0.9936146496204724+0j)\n" ] } ], "source": [ "# extract the optimized parameters\n", "pmap = eval(res.meta_data[\"parameter_map\"])\n", "print(\"optimized parameters:\", pmap)\n", "sol_circ = circ(**pmap)\n", "qpu = get_default_qpu()\n", "res2 = qpu.submit(sol_circ.to_job())\n", "for sample in res2:\n", " if abs(sample.amplitude)>1e-1:\n", " print(f\"{sample.state} ({sample.state.int}): {sample.amplitude}\")" ] }, { "cell_type": "markdown", "id": "0857d7b4-8c33-4788-b9f5-857fde92324b", "metadata": {}, "source": [ "### Check: exact ground state\n", "\n", "For comparison, let us print the exact ground state wavevector that we get through exact diagonalization." ] }, { "cell_type": "code", "execution_count": 8, "id": "20f34268-7c16-4140-9ef1-814f1b035320", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Psi0: [ 0. +0.j 0. +0.j 0. +0.j 0.11282737+0.j\n", " 0. +0.j 0. +0.j 0. +0.j 0. +0.j\n", " 0. +0.j 0. +0.j 0. +0.j 0. +0.j\n", " -0.99361461+0.j 0. +0.j 0. +0.j 0. +0.j]\n" ] } ], "source": [ "eigvals, eigvecs = np.linalg.eigh(ham_matrix)\n", "psi0 = eigvecs[:, np.argmin(eigvals)]\n", "print(\"Psi0:\", psi0)" ] }, { "cell_type": "markdown", "id": "881b3c8a-83b3-433e-98d9-0679db5da270", "metadata": {}, "source": [ "### Influence of the number of shots on the energy estimation" ] }, { "cell_type": "code", "execution_count": 9, "id": "0fd71d3c-a6d8-4d63-827b-4b9a6317af45", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "100 -1.141135718484212\n", "500 -1.1361100643545485\n", "1000 -1.129116454764365\n", "10000 -1.1385003599862593\n", "50000 -1.1371525036670502\n" ] }, { "data": { "text/plain": [ "Text(0, 0.5, 'converged energy')" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sol_circ = circ(**pmap)\n", "qpu = get_default_qpu()\n", "nshot_list = [100, 500, 1000, 10000, 50000]\n", "\n", "value_list = []\n", "for nshots in nshot_list:\n", " res3 = qpu.submit(sol_circ.to_job(observable=hamiltonian_qubit, nbshots=nshots))\n", " print(nshots, res3.value)\n", " value_list.append(res3.value)\n", "\n", "plt.plot(nshot_list, value_list, '-o')\n", "plt.plot(nshot_list, [res.value]*len(value_list), '--k', label=\"inf number of shots\")\n", "plt.legend()\n", "plt.xlabel(\"number of shots\")\n", "plt.ylabel(\"converged energy\")" ] }, { "cell_type": "markdown", "id": "9f03f0b9-3e00-40b8-a78e-a617fe9b9a89", "metadata": {}, "source": [ "### Influence of shot noise on the optimization\n", "\n", "Let us now look at the influence of a finite number of shots to compute the estimate of the energy." ] }, { "cell_type": "code", "execution_count": 10, "id": "ba23a7a8-75c9-491e-a321-165618b54a58", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "500 -0.8419137674708442\n", "1000 -0.9912143600894742\n", "10000 -1.1347455263498207\n", "20000 -1.1337868650989045\n", "50000 -1.1369465942090218\n" ] } ], "source": [ "n_layers = 3\n", "circ = generate_ansatz(n_layers)\n", "qpu = get_default_qpu()\n", "nshot_list = [500, 1000, 10000, 20000, 50000]\n", "\n", "value_list = []\n", "for nshots in nshot_list:\n", " res = perform_vqe(circ, nbshots=nshots, qpu=qpu, method=\"COBYLA\") # we switch to COBYLA because bfgs is too sensitive to shot noise\n", " print(nshots, res.value)\n", " value_list.append(res.value)\n", "\n", "res = perform_vqe(circ, nbshots=0, qpu=qpu)\n", "inf_nshots = res.value" ] }, { "cell_type": "code", "execution_count": 11, "id": "466330d3-9948-41c3-acc5-7d72a3348e24", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkMAAAGwCAYAAACq12GxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIt0lEQVR4nO3deVhUZf8/8PcZVgGHRVmVBDcWRcQNMbOnREXLtHrcIgszt7TVLH1SSVtEf2Wpj+WWS2WalZaa8Y3AJRVBUVJUcMMdREMYEFnn/v3h4+TIsAzOApz367rmyjn3fc75zFGYd+fc9zmSEEKAiIiISKYU5i6AiIiIyJwYhoiIiEjWGIaIiIhI1hiGiIiISNYYhoiIiEjWGIaIiIhI1hiGiIiISNYszV1AfadWq3H16lU0bdoUkiSZuxwiIiKqBSEECgoK4OXlBYWi+nM/DEM1uHr1Kry9vc1dBhEREdXBpUuX0LJly2r7MAzVoGnTpgDuHEylUmnmaoiIiKg2VCoVvL29Nd/j1WEYqsHdS2NKpZJhiIiIqIGpzRAXDqAmIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlnjs8nMLCwszKDbGzlyJF5//fVq+yxatAgbN2406H4TExOrbc/JycGQIUMMus/XXnsNo0aNqrbPe++9h4SEBIPt09XVFVu3bq22z7FjxzB+/HiD7RMAPvzwQ/Tt27faPuPGjUNaWprB9tmxY0esXLmy2j7x8fGYOXOmwfYJACtWrEBQUFC1fZ566ilcv37dYPt8/PHH8dFHH1XbZ8OGDVi8eLHB9gkAv/zyC9zc3Krtw98RdcffEdrq6++Imv5tmALDkJkdOHDAoNurzS/OCxcuGHy/NSktLTX4PocNG1Zjn1OnThl0vy1atKixT2FhocE/a25ubo190tLSTP73mpuba/B9FhYW1tjn8OHDuHLlisH22bJlyxr7ZGVlGfyzlpaW1tiHvyPqjr8jtDWW3xHGwMtkREREJGsMQ0RERCRrDENEREQkaxwzZGY9e/Y06PZatWpVqz6G3m9NrK2tDb5PT0/PGvu0b9/eoPt1dXWtsY+Dg4PBP6uLi0uNfTp27GjQfdZmey4uLgb/rA4ODjX26dKlC7y9vQ22z/bt29fYx9PT0+Cf1drausY+/B1Rd/wdoa2x/I4wBkkIIcxdRH2mUqng6OiI/Px8KJVKc5dDREREtaDP9zcvkxEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkaw1mDCUm5uLyMhIKJVKODk5YezYsSgsLKxxvcTERDz++OOwt7eHUqlEnz59cPv2bRNUTERERA1BgwlDkZGROH78OOLi4rB9+3bs2bMH48ePr3adxMREREREoH///khOTsbBgwcxZcoUKBQN5mMTERGRkUlCCGHuImpy8uRJBAYG4uDBg+jWrRsAIDY2FoMGDcLly5fh5eWlc72ePXuiX79++OCDD2q9r5KSEpSUlGjeq1QqeHt7Iz8/H0ql8sE+CBEREZmESqWCo6Njrb6/G8QpksTERDg5OWmCEACEh4dDoVAgKSlJ5zo5OTlISkqCm5sbevXqBXd3dzz66KPYu3dvtfuaN28eHB0dNS9vb2+DfhYiIiKqXxpEGMrOzoabm5vWMktLS7i4uCA7O1vnOufOnQMAvP/++xg3bhxiY2PRpUsX9O3bF6dPn65yXzNmzEB+fr7mdenSJcN9ECIiIqp3zBqGpk+fDkmSqn2lp6fXadtqtRoAMGHCBIwZMwYhISH47LPP4Ofnh9WrV1e5no2NDZRKpdaLiIiIGi9Lc+586tSpiIqKqrZP69at4eHhgZycHK3l5eXlyM3NhYeHh871PD09AQCBgYFaywMCAnDx4sW6F01ERESNilnDkKurK1xdXWvsFxYWhry8PKSkpKBr164AgISEBKjVaoSGhupcx8fHB15eXsjIyNBafurUKQwcOPDBiyciIqJGoUGMGQoICEBERATGjRuH5ORk7Nu3D1OmTMHIkSM1M8muXLkCf39/JCcnAwAkScK0adOwePFi/Pjjjzhz5gxmzZqF9PR0jB071pwfh4iIiOoRs54Z0sf69esxZcoU9O3bFwqFAs8++ywWL16saS8rK0NGRgaKioo0y9544w0UFxfjzTffRG5uLoKDgxEXF4c2bdqY4yMQERFRPdQg7jNkTvrcp4CIiIjqh0Z3nyEiIiIiY2EYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlljGCIiIiJZYxgiIiIiWWMYIiIiIlnTOwydO3fOGHXUKDc3F5GRkVAqlXBycsLYsWNRWFhYZf/z589DkiSdrx9++MGElRMREVF9pncYatu2LR577DF8++23KC4uNkZNOkVGRuL48eOIi4vD9u3bsWfPHowfP77K/t7e3sjKytJ6zZkzBw4ODhg4cKDJ6iYiIqL6TRJCCH1WSE1NxZo1a7BhwwaUlpZixIgRGDt2LHr06GGsGnHy5EkEBgbi4MGD6NatGwAgNjYWgwYNwuXLl+Hl5VWr7YSEhKBLly746quvar1vlUoFR0dH5OfnQ6lU1ql+IiIiMi19vr/1PjPUuXNnLFq0CFevXsXq1auRlZWF3r17o2PHjli4cCGuX79e58KrkpiYCCcnJ00QAoDw8HAoFAokJSXVahspKSlITU3F2LFjq+1XUlIClUql9SIiIqLGq84DqC0tLfHMM8/ghx9+wPz583HmzBm8/fbb8Pb2xgsvvICsrCyDFZmdnQ03N7dK+3dxcUF2dnattvHVV18hICAAvXr1qrbfvHnz4OjoqHl5e3vXuW4iIiKq/+ochg4dOoRXXnkFnp6eWLhwId5++22cPXsWcXFxuHr1KoYMGVLjNqZPn17lIOe7r/T09LqWqHH79m189913NZ4VAoAZM2YgPz9f87p06dID75+IiIjqL0t9V1i4cCHWrFmDjIwMDBo0CF9//TUGDRoEheJOrvL19cXatWvh4+NT47amTp2KqKioavu0bt0aHh4eyMnJ0VpeXl6O3NxceHh41LifH3/8EUVFRXjhhRdq7GtjYwMbG5sa+xEREVHjoHcY+vLLL/HSSy8hKioKnp6eOvu4ubnVapCyq6srXF1da+wXFhaGvLw8pKSkoGvXrgCAhIQEqNVqhIaG1rj+V199haeeeqpW+yIiIiJ50Xs2mbkMHDgQ165dw7Jly1BWVoYxY8agW7du+O677wAAV65cQd++ffH1119rzWw7c+YM2rdvjx07diAiIkLv/XI2GRERUcOjz/e33meGjh49qnO5JEmwtbXFQw89ZJTLTOvXr8eUKVPQt29fKBQKPPvss1i8eLGmvaysDBkZGSgqKtJab/Xq1WjZsiX69+9v8JqIiIio4dP7zJBCoYAkSVW2W1lZYcSIEVi+fDlsbW0fuEBz45khIiKihseo9xnasmUL2rVrhxUrViA1NRWpqalYsWIF/Pz88N133+Grr75CQkICZs6cWecPQERERGQqel8m++ijj7Bo0SIMGDBAsywoKAgtW7bErFmzkJycDHt7e0ydOhWffPKJQYslIiIiMjS9zwwdO3YMrVq1qrS8VatWOHbsGIA7d6k25E0XiYiIiIxF7zDk7++PmJgYlJaWapaVlZUhJiYG/v7+AO7M7HJ3dzdclURERERGovdlsqVLl+Kpp55Cy5Yt0alTJwB3zhZVVFRg+/btAIBz587hlVdeMWylREREREZQp/sMFRQUYP369Th16hQAwM/PD8899xyaNm1q8ALNjbPJiIiIGh6j3WeorKwM/v7+2L59OyZOnPhARRIRERHVB3qNGbKyskJxcbGxaiEiIiIyOb0HUE+ePBnz589HeXm5MeohIiIiMim9B1AfPHgQ8fHx+P333xEUFAR7e3ut9s2bNxusOCIiIiJj0zsMOTk54dlnnzVGLUREREQmp3cYWrNmjTHqICIiIjILvccMAUB5eTn++OMPLF++HAUFBQCAq1evorCw0KDFERERERmb3meGLly4gIiICFy8eBElJSXo168fmjZtivnz56OkpATLli0zRp1ERERERqH3maHXX38d3bp1w82bN9GkSRPN8qeffhrx8fEGLY6IiIjI2PQ+M/Tnn39i//79sLa21lru4+ODK1euGKwwIiIiIlPQ+8yQWq1GRUVFpeWXL19ulI/jICIiosZN7zDUv39/fP7555r3kiShsLAQ0dHRGDRokCFrIyIiIjI6vR/UevnyZQwYMABCCJw+fRrdunXD6dOn0bx5c+zZswdubm7GqtUs+KBWIiKihkef7+86PbW+vLwcGzduxNGjR1FYWIguXbogMjJSa0B1Y8EwRERE1PAY7an1mpUsLfH888/XqTgiIiKi+qROYej06dPYuXMncnJyoFartdpmz55tkMKIiIiITEHvMLRy5UpMmjQJzZs3h4eHByRJ0rRJksQwRERERA2K3mHoww8/xEcffYR3333XGPUQERERmZTeU+tv3ryJYcOGGaMWIiIiIpPTOwwNGzYMv//+uzFqISIiIjI5vS+TtW3bFrNmzcKBAwcQFBQEKysrrfbXXnvNYMURERERGZve9xny9fWtemOShHPnzj1wUfUJ7zNERETU8Bj1PkOZmZl1LoyIiIiovtF7zNBdpaWlyMjIQHl5uSHrISIiIjIpvcNQUVERxo4dCzs7O3To0AEXL14EALz66quIiYkxeIFERERExqR3GJoxYwb++usv7Nq1C7a2tprl4eHh+P777w1aHBEREZGx6T1m6Oeff8b333+Pnj17at19ukOHDjh79qxBiyMiIiIyNr3PDF2/fh1ubm6Vlt+6dUsrHBERERE1BHqHoW7duuHXX3/VvL8bgFatWoWwsDDDVUZERERkAnpfJvv4448xcOBAnDhxAuXl5Vi0aBFOnDiB/fv3Y/fu3caokYiIiMho9D4z1Lt3b6SmpqK8vBxBQUH4/fff4ebmhsTERHTt2tUYNRIREREZjd53oJYb3oGaiIio4dHn+7vON10kIiIiagwYhoiIiEjWGIaIiIhI1hiGiIiISNYMFoaEEMjJyTHU5oiIiIhMotZhyM7ODtevX9e8f+KJJ5CVlaV5n5OTA09PT8NWR0RERGRktQ5DxcXFuHcW/p49e3D79m2tPpylT0RERA2NQccMGfPZZLm5uYiMjIRSqYSTkxPGjh2LwsLCatfJzs7G6NGj4eHhAXt7e3Tp0gU//fST0WokIiKihqfBDKCOjIzE8ePHERcXh+3bt2PPnj0YP358teu88MILyMjIwNatW3Hs2DE888wzGD58OI4cOWKiqomIiKi+q3UYkiRJ68zP/e+N6eTJk4iNjcWqVasQGhqK3r17Y8mSJdi4cSOuXr1a5Xr79+/Hq6++ih49eqB169aYOXMmnJyckJKSYpK6iYiIqP6rdRgSQqB9+/ZwcXGBi4sLCgsLERISonnv7+9vtCITExPh5OSEbt26aZaFh4dDoVAgKSmpyvV69eqF77//Hrm5uVCr1di4cSOKi4vxr3/9q8p1SkpKoFKptF5ERETUeNX6qfVr1qwxZh3Vys7Ohpubm9YyS0tLuLi4IDs7u8r1Nm3ahBEjRqBZs2awtLSEnZ0dtmzZgrZt21a5zrx58zBnzhyD1U5ERET1W63D0IsvvmjwnU+fPh3z58+vts/JkyfrvP1Zs2YhLy8Pf/zxB5o3b46ff/4Zw4cPx59//omgoCCd68yYMQNvvfWW5r1KpYK3t3edayAiIqL6rdZh6K7bt28jLi4Op06dgrW1Nfz8/BAeHg4LCwu9dz516lRERUVV26d169bw8PCodEPH8vJy5ObmwsPDQ+d6Z8+exX//+1+kpaWhQ4cOAIDg4GD8+eefWLp0KZYtW6ZzPRsbG9jY2Oj9WYiIiKhh0isMbd26FS+//DJu3LihtbxFixZYv349+vTpAwDIzMyEr69vjdtzdXWFq6trjf3CwsKQl5eHlJQUdO3aFQCQkJAAtVqN0NBQnesUFRUBABQK7WFRFhYWUKvVNe6TiIiI5KHWA6j379+Pf//73+jTpw/27duH3Nxc5ObmYu/evejRowcGDBiA9PR0vPvuu/jmm28MWmRAQAAiIiIwbtw4JCcnY9++fZgyZQpGjhwJLy8vAMCVK1fg7++P5ORkAIC/vz/atm2LCRMmIDk5GWfPnsWnn36KuLg4DB061KD1ERERUcNV6zNDH374IcaMGYPly5drLe/Vqxd69eqFCRMm4JFHHoEQAvHx8QYvdP369ZgyZQr69u0LhUKBZ599FosXL9a0l5WVISMjQ3NGyMrKCjt27MD06dMxePBgFBYWom3btli3bh0GDRpk8PqIiIioYZJELZ+h4eLigt27d1c58Pjo0aPo3LkzDh8+jM6dOxuyRrNSqVRwdHREfn4+lEqlucshIiKiWtDn+7vWl8lu375d7cYcHR1hY2PTqIIQERERNX61DkPt2rVDQkJCle3x8fFo166dQYoiIiIiMpVah6ExY8bg7bffxo4dOyq1/frrr3jnnXdqnCZPREREVN/UegD166+/jv379+PJJ5+En58fAgICIITAyZMncfr0aQwZMgRvvPGGEUslIiIiMrxanxlSKBT44YcfsGHDBvj5+SE9PR0ZGRnw8/PD+vXrsXnz5kr39CEiIiKq72o9myw3NxcuLi7Grqfe4WwyIiKihscos8m8vLwwcuRIxMXFPXCBRERERPVFrcPQypUrcf36dURERMDHxwfvv/8+zp8/b8TSiIiIiIyv1mFo9OjRiI+Px5kzZ/Diiy9i3bp1aNu2Lfr164fvv/8epaWlxqyTiIiIyCj0HvHs6+uLOXPmIDMzE7GxsXBzc8NLL70ET09PvPbaa8aokYiIiMhoaj2Aujo//fQTxo8fj7y8PFRUVBiirnqDA6iJiIgaHn2+v2t9n6H7XbhwAWvWrMG6detw6dIlPPbYYxg7dmxdNyc7FWqB5Mxc5BQUw62pLXr4usBCIZm7LCIiItnRKwyVlJTgp59+wurVq7Fr1y60aNECUVFRGDNmDHx8fIxUYuMTm5aFOdtOICu/WLPM09EW0YMDEdHR04yVERERyU+tw9Arr7yCjRs3oqioCEOGDMGOHTvQr18/SBLPZuhjSfxpfBp3qtLyrPxiTPr2ML58vgsDERERkQnVOgzt3bsX0dHReP7559GsWTNj1tRoVagFVu/LrLbPnG0n0C/Qg5fMiIiITKTWYejo0aPGrEMWkjNzcbOorMp2gTtniJIzcxHWhoGTiIjIFPgwMRPKKSiuuZMe/YiIiOjBMQyZkFtTW4P2IyIiogfHMGRCPXxd4K60qbJdwp1ZZT185fdAXCIiInNhGDIhC4WE2U8GVtsnenAgB08TERGZUK0GUOszeLpTp051LkYOnujkhTe//wulFWqt5XbWFlg4PJjT6omIiEysVmGoc+fOkCQJQoga7yvU2B7HYQyOdla4XlCitexffq4MQkRERGZQq8tkmZmZOHfuHDIzM/HTTz/B19cXX3zxBY4cOYIjR47giy++QJs2bfDTTz8Zu95GoalN5Qx6q4QhkoiIyBxqdWaoVatWmj8PGzYMixcvxqBBgzTLOnXqBG9vb8yaNQtDhw41eJGNjYNt5cNeWFJuhkqIiIhI7wHUx44dg6+vb6Xlvr6+OHHihEGKauwcdJwZKixmGCIiIjIHvcNQQEAA5s2bh9LSUs2y0tJSzJs3DwEBAQYtrrHSGYZ4ZoiIiMgs9HpqPQAsW7YMgwcPRsuWLTUzx44ePQpJkrBt2zaDF9gY6bpMVlBc9WM6iIiIyHj0DkM9evTAuXPnsH79eqSnpwMARowYgeeeew729vYGL7Ax0jWAurCkvFaz9YiIiMiw9A5DAGBvb4/x48cbuhbZ0HVmSC2A22UVsLOu018JERER1VGd7kD9zTffoHfv3vDy8sKFCxcAAJ999hl++eUXgxbXWDnYWOlczkHUREREpqd3GPryyy/x1ltvYeDAgbh586bmJovOzs74/PPPDV1fo6TrzBAAFHAQNRERkcnpHYaWLFmClStX4r333oOl5T9f6t26dcOxY8cMWlxjpWvMEAAU8MwQERGRyekdhjIzMxESElJpuY2NDW7dumWQoho7XVPrAV4mIyIiMge9w5Cvry9SU1MrLY+NjeV9hmqpqstkhSWcXk9ERGRqek9deuuttzB58mQUFxdDCIHk5GRs2LAB8+bNw6pVq4xRY6NT1ZkhXiYjIiIyPb3D0Msvv4wmTZpg5syZKCoqwnPPPQcvLy8sWrQII0eONEaNjU7TKs8MMQwRERGZWp1uahMZGYnIyEgUFRWhsLAQbm5uhq6rUeOYISIiovrjge7wZ2dnBzs7O0PVIhtVjxliGCIiIjI1vcNQSEiIzkdGSJIEW1tbtG3bFlFRUXjssccMUmBjZGNpAWsLBUor1FrLeZ8hIiIi09N7NllERATOnTsHe3t7PPbYY3jsscfg4OCAs2fPonv37sjKykJ4eDjvRl0DXeOGeJmMiIjI9PQ+M3Tjxg1MnToVs2bN0lr+4Ycf4sKFC/j9998RHR2NDz74AEOGDDFYoY2Ng60l/r5VqrWMl8mIiIhMT+8zQ5s2bcKoUaMqLR85ciQ2bdoEABg1ahQyMjIevLpGTNcgap4ZIiIiMj29w5CtrS32799fafn+/ftha2sLAFCr1Zo/k266whDHDBEREZme3pfJXn31VUycOBEpKSno3r07AODgwYNYtWoV/vOf/wAA/u///g+dO3c2aKGNjc4xQ7wDNRERkcnpHYZmzpwJX19f/Pe//8U333wDAPDz88PKlSvx3HPPAQAmTpyISZMmGbbSRoaXyYiIiOoHvS6TlZeXY+7cuXj00UeRmJiI3Nxc5ObmIjExUROEAKBJkyYGv0yWm5uLyMhIKJVKODk5YezYsSgsLKx2nbNnz+Lpp5+Gq6srlEolhg8fjmvXrhm0rrrSda+hwpJyCCHMUA0REZF86RWGLC0tsWDBApSXm/4MRmRkJI4fP464uDhs374de/bswfjx46vsf+vWLfTv3x+SJCEhIQH79u1DaWkpBg8eDLVaXeV6puJgY1VpWVmFQEm5+WsjIiKSE70vk/Xt2xe7d++Gj4+PEcrR7eTJk4iNjcXBgwfRrVs3AMCSJUswaNAgfPLJJ/Dy8qq0zr59+3D+/HkcOXIESqUSALBu3To4OzsjISEB4eHhOvdVUlKCkpISzXuVSmWET1T988lsrSyMsk8iIiKqTO8wNHDgQEyfPh3Hjh1D165dYW9vr9X+1FNPGay4uxITE+Hk5KQJQgAQHh4OhUKBpKQkPP3005XWKSkpgSRJsLGx0SyztbWFQqHA3r17qwxD8+bNw5w5cwz+Ge5X3fPJmjvY6GwjIiIiw9M7DL3yyisAgIULF1ZqkyQJFRUVD17VfbKzsys9DNbS0hIuLi7Izs7WuU7Pnj1hb2+Pd999Fx9//DGEEJg+fToqKiqQlZVV5b5mzJiBt956S/NepVLB29vbMB/kHlWGIU6vJyIiMim97zOkVqurfOkbhKZPnw5Jkqp9paen61siAMDV1RU//PADtm3bBgcHBzg6OiIvLw9dunSBQlH1x7axsYFSqdR6GUNVD2tVFXN6PRERkSk90FPri4uLH2jW2NSpUxEVFVVtn9atW8PDwwM5OTlay8vLy5GbmwsPD48q1+3fvz/Onj2LGzduwNLSEk5OTvDw8EDr1q3rXLOhNK3mMhkRERGZjt5hqKKiAh9//DGWLVuGa9eu4dSpU2jdujVmzZoFHx8fjB07ttbbcnV1haura439wsLCkJeXh5SUFHTt2hUAkJCQALVajdDQ0BrXb968uWadnJwco4xr0ldVZ4Z4mYyIiMi09L5M9tFHH2Ht2rVYsGABrK2tNcs7duyIVatWGbS4uwICAhAREYFx48YhOTkZ+/btw5QpUzBy5EjNTLIrV67A398fycnJmvXWrFmDAwcO4OzZs/j2228xbNgwvPnmm/Dz8zNKnfrgmCEiIqL6Qe8w9PXXX2PFihWIjIyEhcU/U8CDg4PrPL6nNtavXw9/f3/07dsXgwYNQu/evbFixQpNe1lZGTIyMlBUVKRZlpGRgaFDhyIgIABz587Fe++9h08++cRoNeqjqjNDBbxMRkREZFJ6Xya7cuUK2rZtW2m5Wq1GWZnxBv+6uLjgu+++q7Ldx8en0t2bY2JiEBMTY7SaHkRTHTddBHhmiIiIyNT0PjMUGBiIP//8s9LyH3/8ESEhIQYpSg5srRSwUEiVlnMANRERkWnpfWZo9uzZePHFF3HlyhWo1Wps3rwZGRkZ+Prrr7F9+3Zj1NgoSZIEBxtL5N/WPpvGM0NERESmpfeZoSFDhmDbtm34448/YG9vj9mzZ+PkyZPYtm0b+vXrZ4waGy1dg6g5ZoiIiMi06nSfoUceeQRxcXGGrkV2dD2frLCEN10kIiIyJb3PDL388svYtWuXEUqRH91hiGeGiIiITEnvMHT9+nVERETA29sb06ZNQ2pqqhHKkgddl8k4gJqIiMi09A5Dv/zyC7KysjBr1iwcPHgQXbt2RYcOHfDxxx/j/PnzRiix8XKwrTy9nmeGiIiITEvvMAQAzs7OGD9+PHbt2oULFy4gKioK33zzjc77D1HVOICaiIjI/OoUhu4qKyvDoUOHkJSUhPPnz8Pd3d1QdcmCrjFDJeVqlJarzVANERGRPNUpDO3cuRPjxo2Du7s7oqKioFQqsX37dly+fNnQ9TVqVT2f7BYvlREREZmM3lPrW7RogdzcXERERGDFihUYPHgwbGxsjFFbo1fdw1qd7a11thEREZFh6R2G3n//fQwbNgxOTk5GKEde+LBWIiIi89M7DI0bN84YdchS02rODBEREZFp6B2Gbt26hZiYGMTHxyMnJwdqtfZg33PnzhmsuMau6jNDvAs1ERGRqegdhl5++WXs3r0bo0ePhqenJySp8pPXqXaqGzNEREREpqF3GPrtt9/w66+/4uGHHzZGPbKia2o9wDFDREREpqT31HpnZ2e4uLgYoxbZcbCpfAdqgGeGiIiITEnvMPTBBx9g9uzZKCoqMkY9slLVmCE+n4yIiMh09L5M9umnn+Ls2bNwd3eHj48PrKy0z24cPnzYYMU1dnZWFpAkQAjt5TwzREREZDp6h6GhQ4caoQx5UigkOFhbouC+8MMxQ0RERKajdxiKjo42Rh2y5WBbOQwVlnBqPRERkanoHYbuSklJwcmTJwEAHTp0QEhIiMGKkhNd0+t5mYyIiMh09A5DOTk5GDlyJHbt2qV5JEdeXh4ee+wxbNy4Ea6uroausVHTNb2eA6iJiIhMR+/ZZK+++ioKCgpw/Phx5ObmIjc3F2lpaVCpVHjttdeMUWOj5mBbeXr9/ZfNiIiIyHj0PjMUGxuLP/74AwEBAZplgYGBWLp0Kfr372/Q4uRA1/PJeGaIiIjIdPQ+M6RWqytNpwcAKyurSs8po5pxzBAREZF56R2GHn/8cbz++uu4evWqZtmVK1fw5ptvom/fvgYtTg503XixqLQCFWqhozcREREZmt5h6L///S9UKhV8fHzQpk0btGnTBr6+vlCpVFiyZIkxamzU+LBWIiIi89J7zJC3tzcOHz6MP/74A+np6QCAgIAAhIeHG7w4OajqYa2FJeVwbKL72WVERERkOHW6z5AkSejXrx/69etn6Hpkp8ozQxxETUREZBK1vkyWkJCAwMBAqFSqSm35+fno0KED/vzzT4MWJwdVPqyVd6EmIiIyiVqHoc8//xzjxo2DUqms1Obo6IgJEyZg4cKFBi1ODqo6M8TnkxEREZlGrcPQX3/9hYiIiCrb+/fvj5SUFIMUJSdVjRliGCIiIjKNWoeha9eu6by/0F2Wlpa4fv26QYqSEwcb3ceUs8mIiIhMo9ZhqEWLFkhLS6uy/ejRo/D09DRIUXJS5ZghnhkiIiIyiVqHoUGDBmHWrFkoLi6u1Hb79m1ER0fjySefNGhxclDlmCGeGSIiIjKJWk+tnzlzJjZv3oz27dtjypQp8PPzAwCkp6dj6dKlqKiowHvvvWe0QhsrTq0nIiIyr1qHIXd3d+zfvx+TJk3CjBkzIMSdx0VIkoQBAwZg6dKlcHd3N1qhjZWFQoKdtQWKSiu0lnNqPRERkWnoddPFVq1aYceOHbh58ybOnDkDIQTatWsHZ2dnY9UnCw42lpXCUEExwxAREZEp1OkO1M7Ozujevbuha5EtSaq8LD79OmLTshDRkYPSiYiIjEnvB7WSYcWmZeGaqqTS8tJyNSZ9exixaVlmqIqIiEg+GIbMqEItMGfbiWr7zNl2AhVqYaKKiIiI5IdhyIySM3ORlV/5VgV3CQBZ+cVIzsw1XVFEREQywzBkRjkFVQehe13NKzJyJURERPLVYMLQRx99hF69esHOzg5OTk61WkcIgdmzZ8PT0xNNmjRBeHg4Tp8+bdxC9eDW1LZW/b4+cAHFZRU1dyQiIiK9NZgwVFpaimHDhmHSpEm1XmfBggVYvHgxli1bhqSkJNjb22PAgAE676JtDj18XeDpaAsdk8m0/HUpHy+vO4TbpQxEREREhtZgwtCcOXPw5ptvIigoqFb9hRD4/PPPMXPmTAwZMgSdOnXC119/jatXr+Lnn382brG1ZKGQED04EABqDER7z9xA1Jpk3OJjOoiIiAyqwYQhfWVmZiI7Oxvh4eGaZY6OjggNDUViYmKV65WUlEClUmm9jCmioye+fL4LPBxrvmSWlJmLF1YnQ8UbMhIRERlMnW662BBkZ2cDQKVHhLi7u2vadJk3bx7mzJlj1NruF9HRE/0CPZCcmYucgmLcKinH/Nh05N+ufBYo5cJNjF6VhK9fCoWjnZVJ6yQiImqMzHpmaPr06ZAkqdpXenq6SWuaMWMG8vPzNa9Lly6ZZL8WCglhbZphSOcWeC60FTaOD0Mze2udff+6nI/nVh1A7q1Sk9RGRETUmJn1zNDUqVMRFRVVbZ/WrVvXadseHh4AgGvXrsHT859HWly7dg2dO3eucj0bGxvY2NjUaZ+GFOCpxMbxPfHcqiRcL6h8h+rjV1V4buUBfPtyKJo7mL9eIiKihsqsYcjV1RWurq5G2bavry88PDwQHx+vCT8qlQpJSUl6zUgzp3buTfH9+J54bmUSslWVZ8ClZxdg5IoD+O7lULgpazdNn4iIiLQ1mAHUFy9eRGpqKi5evIiKigqkpqYiNTUVhYWFmj7+/v7YsmULAECSJLzxxhv48MMPsXXrVhw7dgwvvPACvLy8MHToUDN9Cv21dnXApglhaOHURGf7mZxCjFhxAFn5t01cGRERUePQYMLQ7NmzERISgujoaBQWFiIkJAQhISE4dOiQpk9GRgby8/M179955x28+uqrGD9+PLp3747CwkLExsbC1rZhnUV5qJkdvp/QEw+52Olsz7xxC8OXJ+JSLu9UTUREpC9JCMGngFZDpVLB0dER+fn5UCqVZq0lO78Yz608gHM3bulsb+HUBN+NC0WrZvYmroyIiKh+0ef7u8GcGSLAw9EWGyf0RDs3B53tV/JuY/jyRJy9XqiznYiIiCpjGGpg3JraYuP4nvD3aKqz/ZqqBCOWH0BGdoGJKyMiImqYGIYaoGYONtgwric6ttB92u9GYQlGrTyAE1eNe/dsIiKixoBhqIFytrfG+pd7orO3k8723FulGLXyAI5ezjNpXURERA0Nw1AD5tjECt+M7YHuPs462/NvlyFyZRIOX7xp4sqIiIgaDoahBq6prRXWjumBsNbNdLYXlJRj9KokJGfmmrgyIiKihoFhqBGwt7HE6qjueKRdc53tt0or8OLqZOw/c8PElREREdV/DEONRBNrC6x8oRse93fT2X67rAJj1h7E7lPXTVwZERFR/cYw1IjYWllg2fNd0T/QXWd7Sbka49YdQvzJayaujIiIqP5iGGpkrC0VWBrZBU908tTZXlqhxsRvUxCblm3iyoiIiOonhqFGyMpCgUUjOuOZkBY628sqBCZ/dxjb/rpq4sqIiIjqH4ahRsrSQoH/NywYw7u11NleoRZ4feMRbD582cSVERER1S8MQ42YhUJCzDOd8HzPh3S2qwUw9Ye/sOngJRNXRkREVH8wDDVyCoWED4Z0xJiHfXS2CwG889NRfHPggmkLIyIiqicYhmRAkiTMfjIQEx5tXWWfWT+nYfXeTBNWRUREVD8wDMmEJEmYHuGP1x5vW2WfudtPYNnusyasioiIyPwYhmREkiS81d8PU/u1r7JPzG/pWBx/2oRVERERmRfDkAy92rcdZgz0r7J9YdwpfPp7BoQQJqyKiIjIPBiGZGrCo20w+8nAKtuXJJxBzG/pDERERNToMQzJ2Eu9ffHh0I5Vti/fcw5ztp1gICIiokaNYUjmnu/ZCgue7QRJ0t2+dv95vPdzGtRqBiIiImqcGIYIw7t7Y+HwYCiqCETfJV3Euz8dRQUDERERNUIMQwQAeDqkJRaNDIFFFYnoh5TLmLopFeUVahNXRkREZFwMQ6QxONgLS5/rAisL3YHo59SreH1jKsoYiIiIqBFhGCItER09sHx0V1hb6v6n8euxLExefxgl5RUmroyIiMg4GIaoksf93bHqhW6wqSIQ/X7iGiZ+k4LiMgYiIiJq+BiGSKc+7V2xZkx3NLGy0Nm+M+M6xn19CLdLGYiIiKhhYxiiKvVq0xxfj+0BBxtLne1/nr6BMWuTcauk3MSVERERGQ7DEFWru48LvhnbA01tdQeiA+dy8eLqZBQUl5m4MiIiIsNgGKIahTzkjO9e7gknOyud7Ycu3MTor5KRf5uBiIiIGh6GIaqVoJaO+O7lnnCxt9bZnnopD5GrDuDmrVITV0ZERPRgGIao1gK9lNg4vieaO9jobE+7osKolQdwo7DExJURERHVHcMQ6aW9e1N8P6En3JW6A1F6dgFGrTiAHFWxiSsjIiKqG4Yh0lsbVwdsmhCGFk5NdLafzinEyBUHkJ3PQERERPUfwxDVSatm9vh+Qk94u+gOROdu3MLw5Ym4fLPIxJURERHph2GI6qylsx02TQiDb3N7ne0Xc4swYvkBXPybgYiIiOovhiF6IJ6OTfD9+J5o6+ags/1K3m0MX56Ic9cLTVwZERFR7TAM0QNzU9pi4/ie8PdoqrM9W1WM4csP4PS1AhNXRkREVDOGITKI5g422DCuJzq2UOpsv1FYgpErDuBklsrElREREVWPYYgMxtneGutf7olgbyed7X/fKsWolQeQdiXftIURERFVg2GIDMqxiRW+HdsD3Vo562zPKyrDqJUHcOTiTRNXRkREpBvDEBlcU1srrHupB3q2dtHZXlBcjtFfJePg+VwTV0ZERFQZwxAZhb2NJdZE9cAj7ZrrbC8sKceLq5ORePZvE1dGRESkjWGIjKaJtQVWvtANj/m56mwvKq3AmLXJ+PP0dRNXRkRE9A+GITIqWysLLBvdFf0C3XW2F5epMXbdIexMzzFxZURERHc0mDD00UcfoVevXrCzs4OTk1Ot1tm8eTP69++PZs2aQZIkpKamGrVG0s3G0gJfRHbBE0GeOttLy9UY/80h/N/xbBNXRkRE1IDCUGlpKYYNG4ZJkybVep1bt26hd+/emD9/vhEro9qwslBg0cjOGNrZS2d7WYXA5PWH8evRLBNXRkREcmdp7gJqa86cOQCAtWvX1nqd0aNHAwDOnz9f63VKSkpQUlKiea9S8SaBhmJpocCnwzvD0kKBH1MuV2ovVwu8uuEwyio6Y2hICzNUSEREctRgzgyZyrx58+Do6Kh5eXt7m7ukRsVCIWHBs53wXOhDOtvVAnhzUyo2Hbpk4sqIiEiuGIbuM2PGDOTn52tely7xS9nQFAoJHw3tiKhePjrbhQDe+fEo1iddMG1hREQkS2YNQ9OnT4ckSdW+0tPTTVqTjY0NlEql1osMT5IkRA8OxPg+ravs896WNKzdl2nCqoiISI7MOmZo6tSpiIqKqrZP69ZVf1lSwyZJEmYM9Ie1hQL/3XlGZ5/3t51AaYUa4/u0MXF1REQkF2YNQ66urnB11X1DPpIHSZLw9gA/WFsqsDDulM4+H+9IR2m5GlMeb2fi6oiISA4azJihixcvIjU1FRcvXkRFRQVSU1ORmpqKwsJCTR9/f39s2bJF8z43Nxepqak4ceIEACAjIwOpqanIzub9bOqb1/q2w/SB/lW2f/L7KSyMOwUhhAmrIiIiOWgwYWj27NkICQlBdHQ0CgsLERISgpCQEBw6dEjTJyMjA/n5+Zr3W7duRUhICJ544gkAwMiRIxESEoJly5aZvH6q2cRH22DWk4FVti+OP435sRkMREREZFCS4DdLtVQqFRwdHZGfn8/B1CbyzYELmPVzWpXtYx72wewnAyFJkgmrIiKihkSf7+8Gc2aI5GN0z1aY/2wQqso6a/adx6xf0qBWM8cTEdGDYxiiemlE94fw6bBgKKoIRN8euIgZm4+hgoGIiIgeEMMQ1VvPdGmJRSNDYFFFIvr+0CVM++EvlFeoTVwZERE1JgxDVK8NDvbC0udCYGWhOxBtPnIFb3yfijIGIiIiqiOGIar3Ijp6YtnzXWFtofuf6/ajWZjy3WGUljMQERGR/hiGqEHoG+COlS92g42l7n+y/3f8GiZ9m4LisgoTV0ZERA0dwxA1GI+2d8WaqO5oYmWhsz0+PQfjvj7EQGQiFWqBxLN/45fUK0g8+zcHsxNRg8X7DNWA9xmqf5IzczFmTTJuleoOPYGeSox52Actne3Qw9elygHYVHexaVmYs+0EsvKLNcs8HW0RPTgQER09zVgZEdEd+nx/MwzVgGGofkq5cBNRq5NRUFJebT+3pjZ4q197POrnCiEAtRAQAndeEFALQIg7/4Xm/T/91P/78bj3vcCdde68/2d9gX+2fbef+s6Oql//njo0dalReX3cW///3qvvLr9v/XvqgFa/+9a/rw5x7+ep4vNfzC3Cn6dvVHnMH2nXHD7N7KGQ7jx7TpIAhSRBAqBQ3HkvQYLi7vK7/XDn/Z317ixTaNa/0watPpLufdyzzfv3obhn3/euV2mfWtvRrv9OttbetqYvJCgU//SvtA/8771C+/NC0+eefSugVYfWPu77XEQNUYVaIDkzFzkFxXBramvw/3llGDIghqH66+jlPIz+Khn5t8vMXQqRWVUKh9AOjdL9wQ339v8niAHQCnO6giWgva07Ye6egIbKQbJyIK0ipCpqqP/ucgWgK5BCa727bdqB+p/P/s/yugZqxZ10Wmmf/9Rx3z7uqV8TjKsKu4oaArW+Yb6GQK2QdP893/9vy1BMcXaZYciAGIbqt+NX8/H8qiTcLGIgIiIyNt2hUfvM5v1nP+8PpMVlFdX+zl72fBeDBCJ9vr8tH3hvRGbUwcsR/xkUgGk/HjV3KUREjZ4QQIXmHIpxzqXM2XYC/QI9TDrek7PJqMGzrmK6PRERNTxZ+cVIzsw16T55ZogaPLemtuYuoVG7d8wABFBWiyn0lgpAQNIMvCYi0kdOQXHNnQyIYYgavB6+LvB0tEV2fnGVJ22VtpaY8nhbWCgU/7uOfc8X/H2DIu8OKNQ5k6fScgC4f5BhFetD12BW7fXvvw6vGVRaQ23A/dfo71n/voGfumYpQWetugdMxqZlYdK3hwFonyS/2/NLHdf7/5mhdue/umapqQU0M+cqz567Z7mOGXtas+D+Nxvv3n1ozfqrNBNPxz7u1nzPrL7qZgDeu4/7a7vzuf753PfP0tOewfjPPrTq0DHrT9cMwUrrqf+ptfLMRO1lWvu4r/77Zzpq16bj2N5z7LSP0d317pthWVX9929b57GtvG1q+Ez9P7kMQ9TgWSgkRA8OxKRvD+N/Jy807n5BL/h3J97/xkAiOnriy+e7VJoJ4lHNTBBJkmDxv+BHZEz/BDcdgQvaobTaMHdvCNQVlPUN6TXsQ9ftN+7fB6AdNKsL0DWF9EoBVGdtlcO4dpD/ZznuC8pVhVy1Wo2E9OsoqebxSZ6Od6bZmxJnk9WAs8kaDt4I0LSMfY8QImqc6nJ2uS44td6AGIYaFn5BExHVf7zPUAPDMERERGR49ekO1BwzRERERCZnoZAQ1qaZucsAwPsMERERkcwxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrDEMERERkawxDBEREZGsMQwRERGRrPEO1DW4+7QSlUpl5kqIiIiotu5+b9fmqWMMQzUoKCgAAHh7e5u5EiIiItJXQUEBHB0dq+3DB7XWQK1W4+rVq2jatCkkqe4PkFOpVPD29salS5f4wFcj47E2HR5r0+GxNh0ea9Mx5rEWQqCgoABeXl5QKKofFcQzQzVQKBRo2bKlwbanVCr5w2UiPNamw2NtOjzWpsNjbTrGOtY1nRG6iwOoiYiISNYYhoiIiEjWGIZMxMbGBtHR0bCxsTF3KY0ej7Xp8FibDo+16fBYm059OdYcQE1ERESyxjNDREREJGsMQ0RERCRrDENEREQkawxDREREJGsMQyaydOlS+Pj4wNbWFqGhoUhOTjZ3SfXKnj17MHjwYHh5eUGSJPz8889a7UIIzJ49G56enmjSpAnCw8Nx+vRprT65ubmIjIyEUqmEk5MTxo4di8LCQq0+R48exSOPPAJbW1t4e3tjwYIFlWr54Ycf4O/vD1tbWwQFBWHHjh0G/7zmMm/ePHTv3h1NmzaFm5sbhg4dioyMDK0+xcXFmDx5Mpo1awYHBwc8++yzuHbtmlafixcv4oknnoCdnR3c3Nwwbdo0lJeXa/XZtWsXunTpAhsbG7Rt2xZr166tVE9j/rn48ssv0alTJ83N5MLCwvDbb79p2nmcjScmJgaSJOGNN97QLOPxNpz3338fkiRpvfz9/TXtDfJYCzK6jRs3Cmtra7F69Wpx/PhxMW7cOOHk5CSuXbtm7tLqjR07doj33ntPbN68WQAQW7Zs0WqPiYkRjo6O4ueffxZ//fWXeOqpp4Svr6+4ffu2pk9ERIQIDg4WBw4cEH/++ado27atGDVqlKY9Pz9fuLu7i8jISJGWliY2bNggmjRpIpYvX67ps2/fPmFhYSEWLFggTpw4IWbOnCmsrKzEsWPHjH4MTGHAgAFizZo1Ii0tTaSmpopBgwaJhx56SBQWFmr6TJw4UXh7e4v4+Hhx6NAh0bNnT9GrVy9Ne3l5uejYsaMIDw8XR44cETt27BDNmzcXM2bM0PQ5d+6csLOzE2+99ZY4ceKEWLJkibCwsBCxsbGaPo3952Lr1q3i119/FadOnRIZGRniP//5j7CyshJpaWlCCB5nY0lOThY+Pj6iU6dO4vXXX9cs5/E2nOjoaNGhQweRlZWleV2/fl3T3hCPNcOQCfTo0UNMnjxZ876iokJ4eXmJefPmmbGq+uv+MKRWq4WHh4f4f//v/2mW5eXlCRsbG7FhwwYhhBAnTpwQAMTBgwc1fX777TchSZK4cuWKEEKIL774Qjg7O4uSkhJNn3fffVf4+flp3g8fPlw88cQTWvWEhoaKCRMmGPQz1hc5OTkCgNi9e7cQ4s5xtbKyEj/88IOmz8mTJwUAkZiYKIS4E1wVCoXIzs7W9Pnyyy+FUqnUHNt33nlHdOjQQWtfI0aMEAMGDNC8l+PPhbOzs1i1ahWPs5EUFBSIdu3aibi4OPHoo49qwhCPt2FFR0eL4OBgnW0N9VjzMpmRlZaWIiUlBeHh4ZplCoUC4eHhSExMNGNlDUdmZiays7O1jqGjoyNCQ0M1xzAxMRFOTk7o1q2bpk94eDgUCgWSkpI0ffr06QNra2tNnwEDBiAjIwM3b97U9Ll3P3f7NNa/q/z8fACAi4sLACAlJQVlZWVax8Df3x8PPfSQ1rEOCgqCu7u7ps+AAQOgUqlw/PhxTZ/qjqPcfi4qKiqwceNG3Lp1C2FhYTzORjJ58mQ88cQTlY4Jj7fhnT59Gl5eXmjdujUiIyNx8eJFAA33WDMMGdmNGzdQUVGh9ZcOAO7u7sjOzjZTVQ3L3eNU3THMzs6Gm5ubVrulpSVcXFy0+ujaxr37qKpPY/y7UqvVeOONN/Dwww+jY8eOAO58fmtrazg5OWn1vf9Y1/U4qlQq3L59WzY/F8eOHYODgwNsbGwwceJEbNmyBYGBgTzORrBx40YcPnwY8+bNq9TG421YoaGhWLt2LWJjY/Hll18iMzMTjzzyCAoKChrsseZT64lkavLkyUhLS8PevXvNXUqj5efnh9TUVOTn5+PHH3/Eiy++iN27d5u7rEbn0qVLeP311xEXFwdbW1tzl9PoDRw4UPPnTp06ITQ0FK1atcKmTZvQpEkTM1ZWdzwzZGTNmzeHhYVFpZH0165dg4eHh5mqaljuHqfqjqGHhwdycnK02svLy5Gbm6vVR9c27t1HVX0a29/VlClTsH37duzcuRMtW7bULPfw8EBpaSny8vK0+t9/rOt6HJVKJZo0aSKbnwtra2u0bdsWXbt2xbx58xAcHIxFixbxOBtYSkoKcnJy0KVLF1haWsLS0hK7d+/G4sWLYWlpCXd3dx5vI3JyckL79u1x5syZBvtvm2HIyKytrdG1a1fEx8drlqnVasTHxyMsLMyMlTUcvr6+8PDw0DqGKpUKSUlJmmMYFhaGvLw8pKSkaPokJCRArVYjNDRU02fPnj0oKyvT9ImLi4Ofnx+cnZ01fe7dz90+jeXvSgiBKVOmYMuWLUhISICvr69We9euXWFlZaV1DDIyMnDx4kWtY33s2DGt8BkXFwelUonAwEBNn+qOo1x/LtRqNUpKSnicDaxv3744duwYUlNTNa9u3bohMjJS82ceb+MpLCzE2bNn4enp2XD/bes95Jr0tnHjRmFjYyPWrl0rTpw4IcaPHy+cnJy0RtLLXUFBgThy5Ig4cuSIACAWLlwojhw5Ii5cuCCEuDO13snJSfzyyy/i6NGjYsiQITqn1oeEhIikpCSxd+9e0a5dO62p9Xl5ecLd3V2MHj1apKWliY0bNwo7O7tKU+stLS3FJ598Ik6ePCmio6Mb1dT6SZMmCUdHR7Fr1y6tabFFRUWaPhMnThQPPfSQSEhIEIcOHRJhYWEiLCxM0353Wmz//v1FamqqiI2NFa6urjqnxU6bNk2cPHlSLF26VOe02Mb8czF9+nSxe/dukZmZKY4ePSqmT58uJEkSv//+uxCCx9nY7p1NJgSPtyFNnTpV7Nq1S2RmZop9+/aJ8PBw0bx5c5GTkyOEaJjHmmHIRJYsWSIeeughYW1tLXr06CEOHDhg7pLqlZ07dwoAlV4vvviiEOLO9PpZs2YJd3d3YWNjI/r27SsyMjK0tvH333+LUaNGCQcHB6FUKsWYMWNEQUGBVp+//vpL9O7dW9jY2IgWLVqImJiYSrVs2rRJtG/fXlhbW4sOHTqIX3/91Wif29R0HWMAYs2aNZo+t2/fFq+88opwdnYWdnZ24umnnxZZWVla2zl//rwYOHCgaNKkiWjevLmYOnWqKCsr0+qzc+dO0blzZ2FtbS1at26ttY+7GvPPxUsvvSRatWolrK2thaurq+jbt68mCAnB42xs94chHm/DGTFihPD09BTW1taiRYsWYsSIEeLMmTOa9oZ4rCUhhND/fBIRERFR48AxQ0RERCRrDENEREQkawxDREREJGsMQ0RERCRrDENEREQkawxDREREJGsMQ0RERCRrDENEREQkawxDRFSvnT9/HpIkITU11dylaKSnp6Nnz56wtbVF586d9V4/KioKQ4cONXhdRFQ3DENEVK2oqChIkoSYmBit5T///DMkSTJTVeYVHR0Ne3t7ZGRkVHqYpKmsXbsWTk5OZtk3UWPDMERENbK1tcX8+fNx8+ZNc5diMKWlpXVe9+zZs+jduzdatWqFZs2aGbAqIjIHhiEiqlF4eDg8PDwwb968Kvu8//77lS4Zff755/Dx8dG8v3t56OOPP4a7uzucnJwwd+5clJeXY9q0aXBxcUHLli2xZs2aSttPT09Hr169YGtri44dO2L37t1a7WlpaRg4cCAcHBzg7u6O0aNH48aNG5r2f/3rX5gyZQreeOMNNG/eHAMGDND5OdRqNebOnYuWLVvCxsYGnTt3RmxsrKZdkiSkpKRg7ty5kCQJ77//vs7t/PjjjwgKCkKTJk3QrFkzhIeH49atW1p9PvnkE3h6eqJZs2aYPHkyysrKNG03b97ECy+8AGdnZ9jZ2WHgwIE4ffo0AGDXrl0YM2YM8vPzIUmSVh1ffPEF2rVrB1tbW7i7u+Pf//63zvqI6B8MQ0RUIwsLC3z88cdYsmQJLl++/EDbSkhIwNWrV7Fnzx4sXLgQ0dHRePLJJ+Hs7IykpCRMnDgREyZMqLSfadOmYerUqThy5AjCwsIwePBg/P333wCAvLw8PP744wgJCcGhQ4cQGxuLa9euYfjw4VrbWLduHaytrbFv3z4sW7ZMZ32LFi3Cp59+ik8++QRHjx7FgAED8NRTT2mCSFZWFjp06ICpU6ciKysLb7/9dqVtZGVlYdSoUXjppZdw8uRJ7Nq1C8888wzufS72zp07cfbsWezcuRPr1q3D2rVrsXbtWk17VFQUDh06hK1btyIxMRFCCAwaNAhlZWXo1asXPv/8cyiVSmRlZWnqOHToEF577TXMnTsXGRkZiI2NRZ8+fer090QkK3V61j0RycaLL74ohgwZIoQQomfPnuKll14SQgixZcsWce+vkOjoaBEcHKy17meffSZatWqlta1WrVqJiooKzTI/Pz/xyCOPaN6Xl5cLe3t7sWHDBiGEEJmZmQKAiImJ0fQpKysTLVu2FPPnzxdCCPHBBx+I/v37a+370qVLAoDIyMgQQgjx6KOPipCQkBo/r5eXl/joo4+0lnXv3l288sormvfBwcEiOjq6ym2kpKQIAOL8+fM62+8eh/Lycs2yYcOGiREjRgghhDh16pQAIPbt26dpv3HjhmjSpInYtGmTEEKINWvWCEdHR63t/vTTT0KpVAqVSlXj5ySif/DMEBHV2vz587Fu3TqcPHmyztvo0KEDFIp/fvW4u7sjKChI897CwgLNmjVDTk6O1nphYWGaP1taWqJbt26aOv766y/s3LkTDg4Ompe/vz+AO+N77uratWu1talUKly9ehUPP/yw1vKHH35Yr88cHByMvn37IigoCMOGDcPKlSsrjbfq0KEDLCwsNO89PT01n/nkyZOwtLREaGiopr1Zs2bw8/Orto5+/fqhVatWaN26NUaPHo3169ejqKio1nUTyRXDEBHVWp8+fTBgwADMmDGjUptCodC6DARAawzMXVZWVlrvJUnSuUytVte6rsLCQgwePBipqalar9OnT2tdJrK3t6/1Nh+EhYUF4uLi8NtvvyEwMBBLliyBn58fMjMzNX0e9DPr0rRpUxw+fBgbNmyAp6cnZs+ejeDgYOTl5T3QdokaO4YhItJLTEwMtm3bhsTERK3lrq6uyM7O1gpEhrw30IEDBzR/Li8vR0pKCgICAgAAXbp0wfHjx+Hj44O2bdtqvfQJQEqlEl5eXti3b5/W8n379iEwMFCveiVJwsMPP4w5c+bgyJEjsLa2xpYtW2q1bkBAAMrLy5GUlKRZ9vfffyMjI0NTh7W1NSoqKiqta2lpifDwcCxYsABHjx7F+fPnkZCQoFftRHJjae4CiKhhCQoKQmRkJBYvXqy1/F//+heuX7+OBQsW4N///jdiY2Px22+/QalUGmS/S5cuRbt27RAQEIDPPvsMN2/exEsvvQQAmDx5MlauXIlRo0bhnXfegYuLC86cOYONGzdi1apVWpejajJt2jRER0ejTZs26Ny5M9asWYPU1FSsX7++1ttISkpCfHw8+vfvDzc3NyQlJeH69eua8FaTdu3aYciQIRg3bhyWL1+Opk2bYvr06WjRogWGDBkCAPDx8UFhYSHi4+MRHBwMOzs7JCQk4Ny5c+jTpw+cnZ2xY8cOqNVq+Pn51bp2IjnimSEi0tvcuXMrXdIJCAjAF198gaVLlyI4OBjJyck6Z1rVVUxMDGJiYhAcHIy9e/di69ataN68OQBozuZUVFSgf//+CAoKwhtvvAEnJyet8Um18dprr+Gtt97C1KlTERQUhNjYWGzduhXt2rWr9TaUSiX27NmDQYMGoX379pg5cyY+/fRTDBw4sNbbWLNmDbp27Yonn3wSYWFhEEJgx44dmstrvXr1wsSJEzFixAi4urpiwYIFcHJywubNm/H4448jICAAy5Ytw4YNG9ChQwe9jgGR3Eji/ov8RERERDLCM0NEREQkawxDREREJGsMQ0RERCRrDENEREQkawxDREREJGsMQ0RERCRrDENEREQkawxDREREJGsMQ0RERCRrDENEREQkawxDREREJGv/H+ZD1VkBmy3VAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(nshot_list, value_list, '-o', lw=4)\n", "plt.plot(nshot_list, [inf_nshots]*len(value_list), '--k', lw=4, label = \"exact value\")\n", "plt.ylabel(\"Converged VQE energy\")\n", "plt.xlabel(\"Number of shots\");\n" ] }, { "cell_type": "markdown", "id": "bcb08439-e062-4d84-a86c-28df43f75a8b", "metadata": {}, "source": [ "### Barren plateaux?\n", "\n", "Here we investigate the possible existence of barren plateaux by increasing the number of layers. Starting from a random initial guess, this should produce a more and more random state and thus favor barren plateaux. (Yet, here the number of qubits is quite low...)" ] }, { "cell_type": "code", "execution_count": 12, "id": "850cbee7-7dfb-4a6f-a3e7-fb7153b1c6ba", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2 -0.5040123416216896\n", "3 -1.1287811744125338\n", "5 -0.986202080737369\n", "10 -0.8000021594316069\n", "20 -1.1331764246532037\n" ] } ], "source": [ "qpu = get_default_qpu()\n", "n_layer_list = [2, 3, 5, 10, 20]\n", "value_list_nl = []\n", "for n_layers in n_layer_list:\n", " circ = generate_ansatz(n_layers)\n", " res = perform_vqe(circ, 1000, qpu, \"COBYLA\")\n", " print(n_layers, res.value)\n", " value_list_nl.append(res.value)\n", " " ] }, { "cell_type": "code", "execution_count": 13, "id": "8a57a736-7b60-4e07-b08a-0bb4d281e11b", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(n_layer_list, value_list_nl, '-o', lw=4)\n", "plt.ylabel(\"Converged VQE energy\")\n", "plt.xlabel(\"Number of layers\");\n" ] }, { "cell_type": "markdown", "id": "470ad76d-259a-40a9-a168-389bbca7d54a", "metadata": {}, "source": [ "### With decoherence\n", "\n", "We now turn to the influence of decoherence. Here, we create a \"noisy\" emulator that adds depolarizing noise after each gate of the circuit.\n", "\n", "How does the final energy compare with the final energy obtained in the absence of noise?" ] }, { "cell_type": "code", "execution_count": 14, "id": "eb0beee7-e7d4-4ac5-b01d-5c98c4a01a97", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMqElEQVR4nO3deVxU5f4H8M8MMMM6gyiroqgoLuWGSrhmcAOtrpa/zLSSMk1LbVETrdSWe+1a3myxPTXLMm+lWallKllKiCRuKQqiKIKoyACyDczz+wM5OjGDMMzKfN6v17wczvLMd86wfHzO85wjE0IIEBERETkhua0LICIiIrIVBiEiIiJyWgxCRERE5LQYhIiIiMhpMQgRERGR02IQIiIiIqfFIEREREROy9XWBdg7nU6Hc+fOwcfHBzKZzNblEBERUSMIIVBSUoKQkBDI5cb7fRiEbuDcuXMIDQ21dRlERERkgjNnzqBdu3ZG1zMI3YCPjw+A2gOpUqlsXA0RERE1RnFxMUJDQ6W/48YwCN1A3ekwlUrFIERERORgbjSshYOliYiIyGkxCBEREZHTYhAiIiIip+UwY4QKCwsxc+ZMfP/995DL5Rg7dizefPNNeHt7G91+0aJF+Pnnn5GTkwN/f3+MGTMGL7/8MtRqtZWrJyJHpdPpUFVVZesyiOhv3Nzc4OLi0ux2HCYITZw4EXl5edi2bRu0Wi0efvhhTJ06FV988YXB7c+dO4dz587h9ddfR48ePXD69GlMmzYN586dw9dff23l6onIEVVVVSE7Oxs6nc7WpRCRAb6+vggKCmrWdf5kQghhxpos4ujRo+jRowdSU1PRv39/AMDWrVsxatQonD17FiEhIY1q53//+x8eeOABXLlyBa6uhjNgZWUlKisrpa/rpt9pNBrOGiNyIkII5OTkQKvV3vCCbERkXUIIlJWVoaCgAL6+vggODq63TXFxMdRq9Q3/fjtEj1BycjJ8fX2lEAQAsbGxkMvlSElJwd13392oduoOhrEQBABLlizBiy++2OyaicixVVdXo6ysDCEhIfD09LR1OUT0Nx4eHgCAgoICBAQEmHyazCH+i5Ofn4+AgAC9Za6urvDz80N+fn6j2rh48SJefvllTJ06tcHt5s+fD41GIz3OnDljct1E5LhqamoAAAqFwsaVEJExdf9J0Wq1Jrdh0yCUmJgImUzW4OPYsWPNfp3i4mLccccd6NGjBxYvXtzgtkqlUrp4Ii+iSES8xyCR/TLHz6dNT43Nnj0bCQkJDW7TqVMnBAUFoaCgQG95dXU1CgsLERQU1OD+JSUliI+Ph4+PDzZs2AA3N7fmlk1EREQthE2DkL+/P/z9/W+4XXR0NIqKipCWlobIyEgAwI4dO6DT6RAVFWV0v+LiYsTFxUGpVGLTpk1wd3c3W+1ERETk+BxisHT37t0RHx+PKVOm4P3334dWq8WMGTMwfvx4acZYbm4uYmJisGbNGgwcOBDFxcW4/fbbUVZWhs8//xzFxcUoLi4GUBvAzHHtAVMkZRRg8aYjestc5DL0DvXFkzFd0KG1l03qIiKiG7v11lvRp08fLF++3NalkJk4xGBpAFi7di26deuGmJgYjBo1CkOGDMGHH34orddqtcjIyEBZWRkA4M8//0RKSgoOHTqE8PBwBAcHSw9bDoAuq6rBqUtleo+sC1fw7Z+5GP/hHyipMH3AFxGRPZDJZNi4caOty7A7q1evhq+vb5P3S0pKgkwmQ1FRkdlrIgfpEQIAPz8/oxdPBICwsDBcf0mkW2+9FQ5wiSQ9eZoK7Mm6hLieDY97IiLbuXDhgsn7ent7S1N+/+7ixYsGf2c1ZviAsxBCoKampsFLoJB90mq1djtG12F6hJxFXlG5rUsgogYEBASY/Fi5cqXRdrt3725wn6bS6XRYsmQJOnbsCA8PD/Tu3Vu6mr4QArGxsYiLi5NCV2FhIdq1a4eFCxcCqL1swOTJk6X9IyIi8Oabb9Z7nZUrV6Jnz55QKpUIDg7GjBkzANT+pxQA7r77bshkMulrQ/bs2YM+ffrA3d0d/fv3x8aNGyGTyZCeng7gWk/Ili1bEBkZCaVSid9//x2VlZWYNWsWAgIC4O7ujiFDhiA1NVVq11DPS13bdRYvXow+ffrgs88+Q1hYGNRqNcaPH4+SkhJpmytXruChhx6Ct7c3goODsWzZshse/wMHDmDEiBHw8fGBSqVCZGQk9u3bh6SkJDz88MPQaDTSrOi6WcyfffYZ+vfvDx8fHwQFBWHChAnSBKFTp05hxIgRAIBWrVpBJpNJk4wa+qyNqaysxJw5c9C2bVt4eXkhKioKSUlJ9Y7dTz/9hO7du8Pb2xvx8fHIy8vTa+fjjz9G9+7d4e7ujm7duuHdd9+V1p06dQoymQxfffUVhg8fDnd3d6xduxbV1dWYNWsWfH190bp1a8ybNw+TJk3CmDFjAABr1qxB69at9S5qDABjxozBgw8+eMNjbzJBDdJoNAKA0Gg0Zmnvx4PnRId5Pxh9rPz9pFleh4iap7y8XPz111+ivLxcbzkAkx/vvPOO0ddr06aNwX2a6pVXXhHdunUTW7duFVlZWWLVqlVCqVSKpKQkIYQQZ8+eFa1atRLLly8XQghx7733ioEDBwqtViuEEKKqqkosXLhQpKamipMnT4rPP/9ceHp6iq+++kp6jXfffVe4u7uL5cuXi4yMDLF3717xxhtvCCGEKCgoEADEqlWrRF5enigoKDBYp0ajEX5+fuKBBx4QR44cEZs3bxZdu3YVAMT+/fuFEELs3LlTABC9evUSP//8s8jMzBSXLl0Ss2bNEiEhIWLz5s3iyJEjYtKkSaJVq1bi0qVLQgghVq1aJdRqtd7rbdiwQe94Llq0SHh7e4t77rlHHDp0SOzatUsEBQWJBQsWSNtMnz5dtG/fXvzyyy/i4MGD4s477xQ+Pj7iySefNHr8e/bsKR544AFx9OhRcfz4cbF+/XqRnp4uKisrxfLly4VKpRJ5eXkiLy9PlJSUCCGE+OSTT8TmzZtFVlaWSE5OFtHR0WLkyJFCCCGqq6vFN998IwCIjIwMkZeXJ4qKihr1WRvy6KOPikGDBoldu3aJzMxM8dprrwmlUimOHz8uHTs3NzcRGxsrUlNTRVpamujevbuYMGGC1Mbnn38ugoODxTfffCNOnjwpvvnmG+Hn5ydWr14thBAiOztbABBhYWHSNufOnROvvPKK8PPzE99++604evSomDZtmlCpVGL06NFCCCHKysqEWq0W69evl17r/PnzwtXVVezYscPg+zH2cypE4/9+MwjdgLmDUGr2JfHIqr3i9v/+yiBEZMccMQhVVFQIT09PsWfPHr3lkydPFvfff7/09fr164W7u7tITEwUXl5e0h9BY5544gkxduxY6euQkBDx3HPPGd0egNiwYUODbb733nuidevWesf3o48+MhiENm7cKG1TWloq3NzcxNq1a6VlVVVVIiQkRCxdulQI0fgg5OnpKYqLi6Vlc+fOFVFRUUIIIUpKSoRCodD7o3zp0iXh4eHRYBDy8fGRAsHfGarLkNTUVAFACkp1x+Hy5cvSNo39rK93+vRp4eLiInJzc/WWx8TEiPnz50s1AhCZmZnS+hUrVojAwEDp686dO4svvvhCr42XX35ZREdHCyGuBaG6sF0nMDBQvPbaa9LX1dXVon379lIQEqI2fNaFQCGEWLZsmejUqZPQ6XQG35M5ghBPtFpZ/zA/fJLghzOFZRi6dGe99Q42rImI7EhmZibKysrwj3/8Q295VVUV+vbtK3197733YsOGDXj11Vfx3nvvoUuXLnrbr1ixAitXrkROTg7Ky8tRVVWFPn36AKi9ncG5c+cQExPTrFozMjLQq1cvvcuaDBw40OC2199eKSsrC1qtFoMHD5aWubm5YeDAgTh69GiTaggLC4OPj4/0dXBwsHRKKisrC1VVVXqXaPHz80NERESDbT7zzDN49NFH8dlnnyE2Nhb33nsvOnfu3OA+aWlpWLx4MQ4cOIDLly9LN/nNyclBjx49DO7T2M/6eocOHUJNTQ26du2qt7yyshKtW7eWvvb09NSr+frjcuXKFWRlZWHy5MmYMmWKtE11dTXUarVeu9d/bhqNBufPn9f7jF1cXBAZGal3U+MpU6ZgwIAByM3NRdu2bbF69WokJCRY9MKmDEI2YuwzZQ4ism9/v7hrU3h7extdd/To0WZP8CgtLQUA/Pjjj2jbtq3eOqVSKT0vKytDWloaXFxccOLECb3t1q1bhzlz5mDZsmWIjo6Gj48PXnvtNaSkpACA0cHeluTl1bTLisjl8nrH0tAtGP4+eFcmk+n9UTbF4sWLMWHCBPz444/YsmULFi1ahHXr1hm9J+aVK1cQFxeHuLg4rF27Fv7+/sjJyUFcXByqqqqMvk5jP+u/7+Pi4iJ99te7/nvT0HGpO551r/vRRx/Vu47f39ts6ucGAH379kXv3r2xZs0a3H777Thy5Ah+/PHHJrfTFAxCNsLL9hM5JkvN4mrTpk2z2+jRoweUSiVycnIwfPhwo9vNnj0bcrkcW7ZswahRo3DHHXfgtttuAwDs3r0bgwYNwuOPPy5tn5WVJT338fFBWFgYtm/fLg3i/Ts3NzfpXm3GRERE4PPPP0dlZaX0h/v6Ac/GdO7cGQqFArt370aHDh0A1Iac1NRUPPXUUwBqP6OSkhJcuXJF+mNcNwC7sTp37gw3NzekpKSgffv2AIDLly/j+PHjDR5bAOjatSu6du2Kp59+Gvfffz9WrVqFu+++GwqFot5xOXbsGC5duoRXX30VoaGhAIB9+/bpbVN3v7vr923sZ329vn37oqamBgUFBRg6dGij9vm7wMBAhISE4OTJk5g4cWKj91Or1QgMDERqaiqGDRsGoPb9/Pnnn1JvY51HH30Uy5cvR25uLmJjY6XjYikMQnamuf8jJCLn5ePjgzlz5uDpp5+GTqfDkCFDoNFosHv3bqhUKkyaNAk//vgjVq5cieTkZPTr1w9z587FpEmTcPDgQbRq1QpdunTBmjVr8NNPP6Fjx4747LPPkJqaio4dO0qvs3jxYkybNg0BAQEYOXIkSkpKsHv3bsycORMApKA0ePBgKJVKtGrVql6tEyZMwHPPPYepU6ciMTEROTk5eP311wE0/B9FLy8vTJ8+HXPnzoWfnx/at2+PpUuXoqysDJMnTwYAREVFwdPTEwsWLMCsWbOQkpKC1atXN+lYent7Y/LkyZg7dy5at26NgIAAPPfcc5DLjU+2Li8vx9y5c/F///d/6NixI86ePYvU1FSMHTtWOi6lpaXYvn07evfuDU9PT7Rv3x4KhQJvv/02pk2bhsOHD+Pll1/Wa7dDhw6QyWT44YcfMGrUKHh4eDTqs/67rl27YuLEiXjooYewbNky9O3bFxcuXMD27dvRq1cv3HHHHY06Ni+++CJmzZoFtVqN+Ph4VFZWYt++fbh8+TKeeeYZo/vNnDkTS5YsQXh4OLp164a3334bly9frvd5T5gwAXPmzMFHH32ENWvWNKqmZmlwBBGZfbB0ndzLZQYHS3+0K8usr0NEpmloEKY90+l0Yvny5SIiIkK4ubkJf39/ERcXJ3799VdRUFAgAgMDxb///W9p+6qqKhEZGSnGjRsnhKgdhJuQkCDUarXw9fUV06dPF4mJiaJ37956r/P+++9LrxEcHCxmzpwprdu0aZMIDw8Xrq6uokOHDkZr3b17t+jVq5dQKBQiMjJSfPHFFwKAOHbsmBDC8CBhIWo/m5kzZ4o2bdoIpVIpBg8eLPbu3au3zYYNG0R4eLjw8PAQd955p/jwww/rDZb++3t644039OotKSkRDzzwgPD09BSBgYFi6dKlYvjw4UYHS1dWVorx48eL0NBQoVAoREhIiJgxY4be99C0adNE69atBQCxaNEiIYQQX3zxhQgLCxNKpVJER0eLTZs26Q0aF0KIl156SQQFBQmZTCYmTZokhGj4szamblZgWFiY9Nndfffd4uDBg0KIxg00F0KItWvXij59+giFQiFatWolhg0bJr799lshxLXB0tfXL4QQWq1WzJgxQ6hUKtGqVSsxb948ce+994rx48fXq/PBBx8Ufn5+oqKiwuh7EcI8g6VlQrALoiHFxcVQq9XQaDRmvRN9nqYc0Ut21Fv+/B3d8ejQTmZ7HSIyTUVFBbKzs9GxY0fep9BK1q5dK11rxxZjkci6dDodunfvjnHjxtXrBYuJiUHPnj3x1ltvNdhGQz+njf37zVNjdoaxlIicxZo1a9CpUye0bdsWBw4cwLx58zBu3DiGoBbq9OnT+PnnnzF8+HBUVlbinXfeQXZ2NiZMmCBtc/nyZSQlJSEpKUnvIo2WxCBkIzJwsDQRObf8/HwsXLgQ+fn5CA4Oxr333ot//etfti6LLEQul2P16tWYM2cOhBC46aab8Msvv6B79+7SNn379sXly5fxn//854aXKjAXBiE7IziBnoicxLPPPotnn33W1mWQlYSGhmL37t0NbnPq1CnrFHMd3mvMRoxeR4g5iMiucBglkf0yx88ng5CN8MQYkX2ruzhcQxe1IyLbKisrA1D/IpBNwVNjdob/9ySyD66urvD09MSFCxfg5ubW4PVjiMi6hBAoKytDQUEBfH19613VuikYhGyFp8aI7JpMJkNwcDCys7Nx+vRpW5dDRAb4+voiKCioWW0wCNkIZ40R2T+FQoEuXbrw9BiRHXJzc2tWT1AdBiE7w1ljRPZFLpfzgopELRhPetsIZ40RERHZHoOQjfDEGBERke0xCBEREZHTYhCyEZmxc2NERERkNQxCdoZXsSUiIrIeBiEbMdYfxBxERERkPQxCNsIzY0RERLbHIGRn2CFERERkPQxCNmLsytI8NUZERGQ9DEK2wlNjRERENscgZGd4iw0iIiLrYRCyEQ6WJiIisj0GITvDMUJERETWwyBkI0avI2TVKoiIiJwbg5CN8BYbREREtscgZG94boyIiMhqGIRshKfGiIiIbI9ByEZ4ZoyIiMj2GITsDM+MERERWQ+DkI0YvcUGT44RERFZDYOQjfDUGBERke0xCNkZnhojIiKyHgYhIiIicloMQnaGHUJERETWwyBkI8bGCPHUGBERkfUwCNmIsVljREREZD0MQnaG0+eJiIish0HIRoxOn2cOIiIishoGIRvhiTEiIiLbYxCyM+wQIiIish4GIRuR8dLSRERENscgZGcE588TERFZDYOQjRgdK80cREREZDUMQjbCM2NERES2xyBkZ1JPFUJbo7N1GURERE6BQchGjA2WPnBWgzErdqOorMrKFRERETkfBiE7dORcMT767aStyyAiImrxGIRsyEvhYnTdn6eLrFcIERGRk2IQsqFB4W2MruM4ISIiIstjELKhf999M3q3Uxtcx1n0RERElscgZEP+Pkp8N2MIglTu9dbxwopERESWxyBkB4LUBoKQDeogIiJyNgxCdsDQTHp2CBEREVkeg5AdMHRFIeYgIiIiy3OYIFRYWIiJEydCpVLB19cXkydPRmlpaaP2FUJg5MiRkMlk2Lhxo2ULNYHBiyuyS4iIiMjiHCYITZw4EUeOHMG2bdvwww8/YNeuXZg6dWqj9l2+fLnRKznbA/utjIiIqGVztXUBjXH06FFs3boVqamp6N+/PwDg7bffxqhRo/D6668jJCTE6L7p6elYtmwZ9u3bh+DgYGuV3GzsDyIiIrI8h+gRSk5Ohq+vrxSCACA2NhZyuRwpKSlG9ysrK8OECROwYsUKBAUFNeq1KisrUVxcrPewNJ4ZIyIisg2HCEL5+fkICAjQW+bq6go/Pz/k5+cb3e/pp5/GoEGDMHr06Ea/1pIlS6BWq6VHaGioyXU3lszAyTHBPiEiIiKLs2kQSkxMhEwma/Bx7Ngxk9retGkTduzYgeXLlzdpv/nz50Oj0UiPM2fOmPT6TcIeISIiIpuw6Rih2bNnIyEhocFtOnXqhKCgIBQUFOgtr66uRmFhodFTXjt27EBWVhZ8fX31lo8dOxZDhw5FUlKSwf2USiWUSmVj34JZGJw+zyBERERkcTYNQv7+/vD397/hdtHR0SgqKkJaWhoiIyMB1AYdnU6HqKgog/skJibi0Ucf1Vt2880344033sBdd93V/OLNyOAYIeuXQURE5HQcYtZY9+7dER8fjylTpuD999+HVqvFjBkzMH78eGnGWG5uLmJiYrBmzRoMHDgQQUFBBnuL2rdvj44dO1r7LTTI4BghdgkRERFZnEMMlgaAtWvXolu3boiJicGoUaMwZMgQfPjhh9J6rVaLjIwMlJWV2bBK09jxJY6IiIhaNIfoEQIAPz8/fPHFF0bXh4WF3bAXxV57WTh9noiIyDYcpkeoJeP0eSIiIttgELID7BEiIiKyDQYhO8UcREREZHkMQnbA0A1h7XU8ExERUUvCIGQHOGmMiIjINhiE7BT7g4iIiCyPQcgOGLyOEJMQERGRxTEI2QHmICIiIttgELIDHCxNRERkGwxCdoA9QkRERLbBIGQHeEFFIiIi22AQsgu8xQYREZEtMAjZAfYIERER2QaDkB0wOEaIQYiIiMjiGITsgMHrCBEREZHFMQjZAZmhMULsEiIiIrI4BiE7YHCMkPXLICIicjoMQnbAUBDK01Rgy6E89gwRERFZEIOQHTB0agwApq/9Eyt2Zlq5GiIiIufBIGTnPv49GzU69goRERFZAoOQHQhSuxtdV1SmxaXSSitWQ0RE5DwYhOzAHb2C4So3Poee/UFERESWwSBkB/q1b4WPJ/U3up7jpYmIiCyDQchO3BoRgOdGdTe4TsckREREZBEMQnbE2BWmGYOIiIgsg0HIAfBaQkRERJbBIGRH5Ea6hJiDiIiILINByI7w5qtERETWxSBkR4zlIPYIERERWQaDkB2RGTs1xuHSREREFsEgZEeMzhpjDiIiIrIIBiE7YvTUmFWrICIich4MQvbE6KwxRiEiIiJLYBCyI+wRIiIisi4GITvCMUJERETWxSBkR2TsEyIiIrIqBiE7wh4hIiIi62IQsiPsDyIiIrIuBiE7wh4hIiIi62IQsiPGxgjxytJERESWwSBkT9gjREREZFUMQnaEN10lIiKyLgYhO8KbrhIREVkXg5AdYY8QERGRdTEI2RHOGiMiIrIuBiE7YjQI8dQYERGRRTAI2RGj0+eZg4iIiCyCQciOGO8RIiIiIktgEHIAgl1CREREFsEgZEeMT58nIiIiS2AQsiOcPk9ERGRdDEJ2xNgYobOXy6xbCBERkZNgELIjxmaNPbkuHUu3HuNYISIiIjNjELIjxnqEAODdpCz8lVdsvWKIiIicAIOQHfFUuDS4/s/Tl61UCRERkXNgELIjkR1aQeFi/COpquGpMSIiInNiELIjPu5ueO+BfkbXc4wQERGReTEI2ZmY7oH47dkRti6DiIjIKTAI2SFXlwZGTRMREZHZMAg5EJ4ZIyIiMi8GITtk7HpCREREZF4MQg5E8K5jREREZuUwQaiwsBATJ06ESqWCr68vJk+ejNLS0hvul5ycjNtuuw1eXl5QqVQYNmwYysvLrVCx6Rq6sCIRERGZj8MEoYkTJ+LIkSPYtm0bfvjhB+zatQtTp05tcJ/k5GTEx8fj9ttvx969e5GamooZM2ZALneYt62HY4SIiIjMy9XWBTTG0aNHsXXrVqSmpqJ///4AgLfffhujRo3C66+/jpCQEIP7Pf3005g1axYSExOlZREREVapuTmM3oXeqlUQERG1fA7RNZKcnAxfX18pBAFAbGws5HI5UlJSDO5TUFCAlJQUBAQEYNCgQQgMDMTw4cPx+++/N/halZWVKC4u1ntYHU+NERERWYVDBKH8/HwEBAToLXN1dYWfnx/y8/MN7nPy5EkAwOLFizFlyhRs3boV/fr1Q0xMDE6cOGH0tZYsWQK1Wi09QkNDzfdGmomnxoiIiMzLpkEoMTERMpmswcexY8dMalun0wEAHnvsMTz88MPo27cv3njjDURERGDlypVG95s/fz40Go30OHPmjEmv3xycPk9ERGQdNh0jNHv2bCQkJDS4TadOnRAUFISCggK95dXV1SgsLERQUJDB/YKDgwEAPXr00FvevXt35OTkGH09pVIJpVLZiOqtj9PniYiIzMumQcjf3x/+/v433C46OhpFRUVIS0tDZGQkAGDHjh3Q6XSIiooyuE9YWBhCQkKQkZGht/z48eMYOXJk84u3IE6fJyIisg6HGCPUvXt3xMfHY8qUKdi7dy92796NGTNmYPz48dKMsdzcXHTr1g179+4FAMhkMsydOxdvvfUWvv76a2RmZuKFF17AsWPHMHnyZFu+HZNxjBAREZF5OcT0eQBYu3YtZsyYgZiYGMjlcowdOxZvvfWWtF6r1SIjIwNlZWXSsqeeegoVFRV4+umnUVhYiN69e2Pbtm3o3LmzLd5Co7FDiIiIyDpkQrCfoSHFxcVQq9XQaDRQqVRWec3CK1Xo9/K2esvnxkXgiRHhVqmBiIjIkTX277dDnBqjWsysRERE5mVSEBo+fDjWrFlj9/fsclQ8NUZERGQdJgWhvn37Ys6cOQgKCsKUKVPwxx9/mLsuMoAdQkREROZlUhBavnw5zp07h1WrVqGgoADDhg1Djx498Prrr+P8+fPmrtHpcPo8ERGRdZg8RsjV1RX33HMPvvvuO5w9exYTJkzACy+8gNDQUIwZMwY7duwwZ50E3nSViIjI3Jo9WHrv3r1YtGgRli1bhoCAAMyfPx9t2rTBnXfeiTlz5pijRqdj7BYbPDVGRERkXiZdR6igoACfffYZVq1ahRMnTuCuu+7Cl19+ibi4OMiuntdJSEhAfHw8Xn/9dbMW7BR4aoyIiMgqTApC7dq1Q+fOnfHII48gISHB4G0yevXqhQEDBjS7QLqG9xojIiIyL5OC0Pbt2zF06NAGt1GpVNi5c6dJRTk7DpYmIiKyDpPGCN0oBJFlcIwQERGReZnUI9S3b19pLND1ZDIZ3N3dER4ejoSEBIwYMaLZBTojdggRERFZh0k9QvHx8Th58iS8vLwwYsQIjBgxAt7e3sjKysKAAQOQl5eH2NhYfPfdd+au16mxQ4iIiMi8TOoRunjxImbPno0XXnhBb/krr7yC06dP4+eff8aiRYvw8ssvY/To0WYp1JkY6m0DwHNjREREZmZSj9D69etx//3311s+fvx4rF+/HgBw//33IyMjo3nVOSmeGiMiIrIOk4KQu7s79uzZU2/5nj174O7uDgDQ6XTSczIP9gcRERGZl0mnxmbOnIlp06YhLS1NulZQamoqPv74YyxYsAAA8NNPP6FPnz5mK9SZcPo8ERGRdZgUhJ5//nl07NgR77zzDj777DMAQEREBD766CNMmDABADBt2jRMnz7dfJUShwgRERGZWZODUHV1Nf7973/jkUcewcSJE41u5+Hh0azCnJmxe40RERGReTV5jJCrqyuWLl2K6upqS9RDDeAtNoiIiMzLpMHSMTEx+PXXX81dC13F2fNERETWYdIYoZEjRyIxMRGHDh1CZGQkvLy89Nb/85//NEtxRERERJZkUhB6/PHHAQD//e9/662TyWSoqalpXlVkEDuEiIiIzMukIKTT6cxdB12H0+eJiIisw6QxQterqKgwRx3UCBwjREREZF4mBaGamhq8/PLLaNu2Lby9vXHy5EkAwAsvvIBPPvnErAU6I06fJyIisg6TgtC//vUvrF69GkuXLoVCoZCW33TTTfj444/NVhzp4/R5IiIi8zIpCK1ZswYffvghJk6cCBcXF2l57969cezYMbMV56yMjhFiDiIiIjIrk4JQbm4uwsPD6y3X6XTQarXNLsrZ8cQYERGRdZgUhHr06IHffvut3vKvv/4affv2bXZRZBg7hIiIiMzLpOnzCxcuxKRJk5CbmwudTodvv/0WGRkZWLNmDX744Qdz1+h0ZJw/T0REZBUm9QiNHj0a33//PX755Rd4eXlh4cKFOHr0KL7//nv84x//MHeNdJXg/HkiIiKzMqlHCACGDh2Kbdu2mbMWuor9QURERNZhchACgKqqKhQUFNS70nT79u2bVRQZxg4hIiIi8zIpCJ04cQKPPPII9uzZo7dcCMF7jZmB0bvPW7cMIiKiFs+kIJSQkABXV1f88MMPCA4O5uBeM+PxJCIisg6TglB6ejrS0tLQrVs3c9dDDeCpMSIiIvMy+TpCFy9eNHctRERERFZlUhD6z3/+g2effRZJSUm4dOkSiouL9R5kGbzXGBERkXmZdGosNjYWAHDbbbfpjWfhYGnzkcl4KoyIiMjSTApCO3fuNHcd1Ag1OiYjIiIiczLp1Njw4cMhl8vx0UcfITExEeHh4Rg+fDhycnL07kZPpjM0b2xN8mn868e/oGMgIiIiMguTgtA333yDuLg4eHh4YP/+/aisrAQAaDQa/Pvf/zZrgc7K2BT6j37Lxmd/nLZyNURERC2TSUHolVdewfvvv4+PPvoIbm5u0vLBgwfjzz//NFtxzsylgWsJ7cwosGIlRERELZdJQSgjIwPDhg2rt1ytVqOoqKi5NRGAXu3URtdpyrVWrISIiKjlMikIBQUFITMzs97y33//HZ06dWp2UQTMG9kNngrD4604m4yIiMg8TApCU6ZMwZNPPomUlBTIZDKcO3cOa9euxZw5czB9+nRz1+iUBoT5Yfvs4QbXMQcRERGZh0nT5xMTE6HT6RATE4OysjIMGzYMSqUSc+bMwcyZM81do9MKVnsgskMrpJ2+rL+CXUJERERmYVIQkslkeO655zB37lxkZmaitLQUPXr0gLe3t7nrc3qGhkwzBhEREZmHSUGojkKhQI8ePcxVCxnAG9ETERFZjkljhMi2eGaMiIjIPBiE7JzMwMkx3nyViIjIPBiE7J2BU2PsESIiIjIPBiE7Z3CwNIMQERGRWTAI2TlDg6WZg4iIiMyDQcjOGRwjxC4hIiIis2AQsnOcPk9ERGQ5DEJ2zuCpMXYIERERmQWDkJ3j9HkiIiLLYRCyc+wRIiIishwGIQfEHERERGQeDEJ2TmagS4izxoiIiMyDQcjO8e7zRERElsMgZOcMTp9nEiIiIjILhwlChYWFmDhxIlQqFXx9fTF58mSUlpY2uE9+fj4efPBBBAUFwcvLC/369cM333xjpYrNgzmIiIjIchwmCE2cOBFHjhzBtm3b8MMPP2DXrl2YOnVqg/s89NBDyMjIwKZNm3Do0CHcc889GDduHPbv32+lqpuPY4SIiIgsxyGC0NGjR7F161Z8/PHHiIqKwpAhQ/D2229j3bp1OHfunNH99uzZg5kzZ2LgwIHo1KkTnn/+efj6+iItLc3oPpWVlSguLtZ72BJ7hIiIiCzHIYJQcnIyfH190b9/f2lZbGws5HI5UlJSjO43aNAgfPXVVygsLIROp8O6detQUVGBW2+91eg+S5YsgVqtlh6hoaHmfCtNxusIERERWY5DBKH8/HwEBAToLXN1dYWfnx/y8/ON7rd+/XpotVq0bt0aSqUSjz32GDZs2IDw8HCj+8yfPx8ajUZ6nDlzxmzvwzS8sjQREZGl2DQIJSYmQiaTNfg4duyYye2/8MILKCoqwi+//IJ9+/bhmWeewbhx43Do0CGj+yiVSqhUKr2HLfGmq0RERJbjassXnz17NhISEhrcplOnTggKCkJBQYHe8urqahQWFiIoKMjgfllZWXjnnXdw+PBh9OzZEwDQu3dv/Pbbb1ixYgXef/99s7wHW+CpMSIiIvOwaRDy9/eHv7//DbeLjo5GUVER0tLSEBkZCQDYsWMHdDodoqKiDO5TVlYGAJDL9Tu9XFxcoNPpmlm59RgcLM0gREREZBYOMUaoe/fuiI+Px5QpU7B3717s3r0bM2bMwPjx4xESEgIAyM3NRbdu3bB3714AQLdu3RAeHo7HHnsMe/fuRVZWFpYtW4Zt27ZhzJgxNnw3TcNTY0RERJbjEEEIANauXYtu3bohJiYGo0aNwpAhQ/Dhhx9K67VaLTIyMqSeIDc3N2zevBn+/v6466670KtXL6xZswaffvopRo0aZau30WQyQ4Ol2SVERERkFjY9NdYUfn5++OKLL4yuDwsLqxcQunTp4nBXkv47g9PnrV8GERFRi+QwPULOitcRIiIishwGITtn8NQY+4SIiIjMgkHI3hnoETpfXMlxQkRERGbAIGTnjE0aG7p0JzILSqxaCxERUUvDIGTnDN19HgDOXi7HjC/2W7kaIiKiloVByM4pXIx/RMfyS3D5SpUVqyEiImpZGITsXP+wVg2uL9fWWKkSIiKilodByM7d068tYroFGF3PIdNERESmYxCyc0pXF3w8qT/GDwg1uJ6zx4iIiEzHIOQAZDIZugb6GFzHHERERGQ6BiEHwZuvEhERmR+DkIMwloPYI0RERGQ6BiEHYex6QrzdBhERkekYhByEsVNj7BEiIiIyHYOQgzB6asyqVRAREbUsDEKOwtipMXYJERERmYxByEGwR4iIiMj8GIQcBMcIERERmR+DkIOQsU+IiIjI7BiEHAR7hIiIiMyPQchBsD+IiIjI/BiEHAR7hIiIiMyPQchBGBsjxCtLExERmY5ByFGwR4iIiMjsGIQcBG+6SkREZH4MQg6CN10lIiIyPwYhB8EeISIiIvNjEHIQxmaNERERkekYhBwEp88TERGZH4OQgzA2fV7HJERERGQyBiEHYbRHyLplEBERtSgMQg5OsEeIiIjIZAxCDsL49HkiIiIyFYOQg+D0eSIiIvNjEHIQxqfPMwkRERGZikHIQRi96SpzEBERkckYhBwEZ40RERGZH4OQg+AYISIiIvNjEHIQxnqExn2QjKSMAusWQ0RE1EIwCDkM4zcbm7omDblF5VashYiIqGVgEHIQrnLjQaiqRofdJy5asRoiIqKWgUHIQdzcTt3g+qLyKitVQkRE1HIwCDmIQJU7Hhveyeh6DpomIiJqOgYhB5IY3w3vTexncJ2OQYiIiKjJGIQciEwmQ/8wP4PrBK8oRERE1GQMQg7G2JhpnhojIiJqOgYhB2P0LvRMQkRERE3GIORgjPUIcYwQERFR0zEIORjefJWIiMh8GIQcjMzIJ6ZjEiIiImoyBiEHY/Tmq1atgoiIqGVgEHIwcg6WJiIiMhsGIQdj7C70zEFERERNxyDkYIz1CHGMEBERUdMxCLUQjEFERERNxyDkYNgjREREZD4MQg7G2BghdgkRERE1HYOQg2GPEBERkfkwCDkYox1CzEFERERNxiDkYIydGuO9xoiIiJqOQcjBGL37PAcJERERNRmDkAMydAf6jftzUVRWZf1iiIiIHJjDBKF//etfGDRoEDw9PeHr69uofYQQWLhwIYKDg+Hh4YHY2FicOHHCsoVagaFeoctlWtzx1u84U1hmg4qIiIgck8MEoaqqKtx7772YPn16o/dZunQp3nrrLbz//vtISUmBl5cX4uLiUFFRYcFKLc9QjxAA5BaV45Pfs61bDBERkQNztXUBjfXiiy8CAFavXt2o7YUQWL58OZ5//nmMHj0aALBmzRoEBgZi48aNGD9+vKVKtTi1hwIXSysNrks/U2TdYoiIiByYw/QINVV2djby8/MRGxsrLVOr1YiKikJycrLR/SorK1FcXKz3sDcjIvyNrqvW6axYCRERkWNrsUEoPz8fABAYGKi3PDAwUFpnyJIlS6BWq6VHaGioRes0xYuje+KOm4MNrquu4ewxIiKixrJpEEpMTIRMJmvwcezYMavWNH/+fGg0Gulx5swZq75+Y3gqXLFiYj9EdfSrt66GFxQiIiJqNJuOEZo9ezYSEhIa3KZTp04mtR0UFAQAOH/+PIKDr/WenD9/Hn369DG6n1KphFKpNOk1rc1D4VJvGYMQERFR49k0CPn7+8Pf3/h4l+bo2LEjgoKCsH37din4FBcXIyUlpUkzz+yZq4HpY9UMQkRERI3mMGOEcnJykJ6ejpycHNTU1CA9PR3p6ekoLS2VtunWrRs2bNgAoPZaO0899RReeeUVbNq0CYcOHcJDDz2EkJAQjBkzxkbvwrxcDAShnMIynC927MsDEBERWYvDTJ9fuHAhPv30U+nrvn37AgB27tyJW2+9FQCQkZEBjUYjbfPss8/iypUrmDp1KoqKijBkyBBs3boV7u7uVq3dUlzlhnPs0P/sxHsP9ENM90CD64mIiKiWTAjet7whxcXFUKvV0Gg0UKlUti5Hz6wv92PTgXMG1wWr3bEn8Taj9yYjIiJqyRr799thTo1RfT7uxjv08jQVOKfhKTIiIqKGMAg5sGFdGx5oXl5VY6VKiIiIHBODkAO7vUcgZt0WbnT9p3tO4UpltRUrIiIiciwMQg5MJpPhmdsj8Nr/9TK4/rM/TuOhlXtRoWXPEBERkSEMQi1AQ2OF0k5fRvLJS1ashoiIyHEwCLUAAaqGLwdwLK/ESpUQERE5FgahFqB3O1+09/M0ul5bwzvSExERGcIg1AK4yGX4cuotGNqljcH1DEJERESGMQi1EG19PbAyYYDBdW/vyMTOjAIrV0RERGT/GIRaEEM3Ya3z8KpU3LToJ6zbmwNeTJyIiKgWg1ALIpPJoHAx/pGWVlYj8dtD6Dh/M55Zn46M/BKeNiMiIqfmMDddpcbp0NoTJwpKb7jdt3/m4ts/c6Wv2/t5opWXAj5KV7jIZXCRy+CldIWbS2248la6wkPhAk25FlEdW6NtKw/0DFHBzUUOIQSyLpTiYmkVACBI5Y4OrT15nzMiIrJ7DEItzAO3dMCiTUeavF9OYRlyCssate2a5NM33GZgmB8+fCgSvp6KJtdCRERkLbz7/A3Y893njfkuPRdvbDuOU5caF2ws7Y6bg1GurcGgzq3h56WAm4v86kMGuVwGuUwGuQxX/736XF77r+zqMi+FC5SuLlC4ytHGWwEXuYw9TkREZFRj/34zCN2AIwahOqmnCvHhrpPY9td5W5diEXIZpNN4LjIZlG4u8PV0g4tMJi13lf6VS8vqQpaLrDZMucghBSsvhQtc5PLrgtm1MFYX0GTXrasLb+5uLnBzufp6LnIoXeVQubvCQ+GKAB8lVB5uaOXpBk8FO2GJiKyhsX+/+Vu5BRsQ5ocBYX7QlGvxxrbjWL3nlK1LMiudAHQ1Atqa2ix/paoGhVeqbFzVjfn7KK8LaLX/eru7wVvpggAfd3grXeHnpUCASgm1hxu8lK56gc716ritukAm/QtAdjW41T6/GuQgu7rcyDJcC3V1X+NqZ5vs2lOpB67udWqfy3B9x9z1yw3tL7tuO/boEZE9YI/QDThyj5AhuUXl+DXjAg7lavBXXjGCVe64UlWN0spqVGh1qNHpUKMTqNYJFJdrUa6tQYWWM8vI8hoMTVIygxQK63oCXV1kULm7weXq5SPkMhnk8qsBTy6Dr4cb3FyuBUmlmxwqdzcoXeVSj6D8au+gwkUGT4UrXK9u73a1J9HVRQalqxxeSle4yGrbdb3au+gik0HhWjuhQFouu7Ze6SqHu5uL1Y8nkbNjjxAZ1NbXAxOi2jdpn6pqHbQ1Opy6dAVZF67g67Sz2HX8goUqJGclBCCu/0J/rfTMUJ/f+eJKC1VlPnXBTX41eNUFqrpQ5311xmZdkHK5bp27m1wKa3U9ctf3AgJ1p3HrAuC1nj0ZcPXUreFLazTUMWdslbF9ZEb3aGgfY9s3vcfQOnU19PqGVxrdxdb1Gtmrqa/R0E5NrSthUJjVJ9kwCNENKVzlULjK0TNEjZ4havyzdwgA4EJJJQ6eLUJltQ5yGdDaW4mUk5ewJ6v2QUTX1OgEaiCAGsPrL5TYf5gjsrR7+rZjECLH4e+jREz3QL1lA8L8MOO2LnrLNGVaXCitRLVOB221gFang7ZaB22NgIBAjU5ACEAnRO24HyGg0133XFw7TVdSUY0KbQ1qdLXr6k7j6XQCJZValFXV1P7Bubr82nMdqmvEtdfQCdRcbVung7RNWVWNVEvdvzVXnxMRUcvDIEQWp/Z0g9rTzdZlNIsQ9cNa3dfVOnE1nAlU1wiUa2ugKddCU65FcbkWF0srcelKFYrLtais1l0NaLXBrKpGh4ulldCUa5GvqZAGfhMRkXUwCBE1gqxudpaRM95qD/MEvapqHcqqqlFSUY1zReWoEbXh6loPV21PmrZGJwUyCECgNqCJ655D1C0TEID0HLg+yNVuL66uq2sDuLa89vlVV9u6+hR1X10/vuf6/XHd/nWv/fdtr2/j2suI6/bTr6e65mov4NUewQptTW1PHmp79+rem4BAhVaHK5XVUu9gxdWQWq1j4CSiWgxCRHakdjyWAr6eCoT6edq6nBbp+t69utOeNVeDVbm2BpVa3bXTqVd7+ap1AmWV1ais0aGm5upp1aunV2t0Alcqa1BZrX9atm59ubYG2uprwU3a97rn2hqBK1XV0v411wW9ap1AeVWNFCYFANT1SuK68Ku79v6uD7g6AZRXVcNQ9rsWaw0dJyPLje7QwDE3srLJr4FrIbmx+/C0Nt0IgxAROZXre/f+/gvQx92xT+GSeRgNWzYObk0NlA0x/l6a/hrG30vT3jsAeNngorMMQkRERNcxOg3epGuA8sKh9s7whSWIiIiInACDEBERETktBiEiIiJyWgxCRERE5LQYhIiIiMhpMQgRERGR02IQIiIiIqfFIEREREROi0GIiIiInBaDEBERETktBiEiIiJyWgxCRERE5LQYhIiIiMhpMQgRERGR02IQIiIiIqflausCnNn58+dRWFho0r5ubm4IDw83uO7ixYu4cOGCSe3K5XJEREQYXFdUVIS8vDyT2gWAiIgIyOX1s3dJSQnOnj1rcrvh4eFwc3Ort7y8vBynTp0yud2wsDB4eHjUW15VVYWsrCyT2w0NDYW3t3e95TU1NTh+/LjJ7YaEhECtVhtcd+zYMQghTGo3ICAArVu3NrjuxIkTqK6uNqnd1q1bIyAgwOC67OxsVFRUmNSuWq1GSEiIwXU5OTm4cuWKSe16e3sjNDTU4Lrc3FwUFxeb1K67uzs6duxocB1/R9Ti74haLfV3REN1WYWgBmk0GgFAaDQas7f9zDPPCAAmPTp16mS03SVLlpjcrre3t9F2P/74Y5PbBSDKy8sNtrtp06ZmtZuTk2Ow3eTk5Ga1u2/fPoPtZmZmNqvdLVu2GGy3uLi4We2uWbPG6GenVCpNbvf111832m67du1MbnfevHlG2+3Xr5/J7T7yyCNG242LizO53TvvvNNouw888IDJ7UZFRRltl78javF3RK2W+jvi888/N7p/czT27zdPjREREZHTYhAiIiIip8UgRERERE5LJoSJo6OcRHFxMdRqNTQaDVQqlVnbbu6hl8lkDtWusbbZrmXbNUfbbJftWqNdY22zXcu2a462m9uusf2bo7F/vzlrzIYs8cGzXbZrzbbZLttlu47friXbtmTN5sJTY0REROS0GISIiIjIaTEIERERkdNiECIiIiKnxSBERERETotBiIiIiJwWgxARERE5LQYhIiIicloMQkREROS0GISIiIjIaTEIERERkdNiECIiIiKnxZuu3kDdnXOLi4ttXAkRERE1Vt3f7bq/48YwCN1ASUkJACA0NNTGlRAREVFTlZSUQK1WG10vEzeKSk5Op9Ph3Llz8PHxgUwmM1u7xcXFCA0NxZkzZ6BSqczWriPjMamPx6Q+HhN9PB718ZjU54zHRAiBkpIShISEQC43PhKIPUI3IJfL0a5dO4u1r1KpnOabsrF4TOrjMamPx0Qfj0d9PCb1OdsxaagnqA4HSxMREZHTYhAiIiIip8UgZCNKpRKLFi2CUqm0dSl2g8ekPh6T+nhM9PF41MdjUh+PiXEcLE1EREROiz1CRERE5LQYhIiIiMhpMQgRERGR02IQIiIiIqfFIGQjK1asQFhYGNzd3REVFYW9e/fauiSLWLx4MWQymd6jW7du0vqKigo88cQTaN26Nby9vTF27FicP39er42cnBzccccd8PT0REBAAObOnYvq6mprvxWT7dq1C3fddRdCQkIgk8mwceNGvfVCCCxcuBDBwcHw8PBAbGwsTpw4obdNYWEhJk6cCJVKBV9fX0yePBmlpaV62xw8eBBDhw6Fu7s7QkNDsXTpUku/NZPd6JgkJCTU+76Jj4/X26YlHZMlS5ZgwIAB8PHxQUBAAMaMGYOMjAy9bcz1s5KUlIR+/fpBqVQiPDwcq1evtvTbM0ljjsmtt95a7/tk2rRpetu0lGPy3nvvoVevXtIFEaOjo7FlyxZpvbN9f5iVIKtbt26dUCgUYuXKleLIkSNiypQpwtfXV5w/f97WpZndokWLRM+ePUVeXp70uHDhgrR+2rRpIjQ0VGzfvl3s27dP3HLLLWLQoEHS+urqanHTTTeJ2NhYsX//frF582bRpk0bMX/+fFu8HZNs3rxZPPfcc+Lbb78VAMSGDRv01r/66qtCrVaLjRs3igMHDoh//vOfomPHjqK8vFzaJj4+XvTu3Vv88ccf4rfffhPh4eHi/vvvl9ZrNBoRGBgoJk6cKA4fPiy+/PJL4eHhIT744ANrvc0mudExmTRpkoiPj9f7viksLNTbpiUdk7i4OLFq1Spx+PBhkZ6eLkaNGiXat28vSktLpW3M8bNy8uRJ4enpKZ555hnx119/ibffflu4uLiIrVu3WvX9NkZjjsnw4cPFlClT9L5PNBqNtL4lHZNNmzaJH3/8URw/flxkZGSIBQsWCDc3N3H48GEhhPN9f5gTg5ANDBw4UDzxxBPS1zU1NSIkJEQsWbLEhlVZxqJFi0Tv3r0NrisqKhJubm7if//7n7Ts6NGjAoBITk4WQtT+wZTL5SI/P1/a5r333hMqlUpUVlZatHZL+PsffZ1OJ4KCgsRrr70mLSsqKhJKpVJ8+eWXQggh/vrrLwFApKamStts2bJFyGQykZubK4QQ4t133xWtWrXSOybz5s0TERERFn5HzWcsCI0ePdroPi39mBQUFAgA4tdffxVCmO9n5dlnnxU9e/bUe6377rtPxMXFWfotNdvfj4kQtUHoySefNLpPSz8mrVq1Eh9//DG/P5qJp8asrKqqCmlpaYiNjZWWyeVyxMbGIjk52YaVWc6JEycQEhKCTp06YeLEicjJyQEApKWlQavV6h2Lbt26oX379tKxSE5Oxs0334zAwEBpm7i4OBQXF+PIkSPWfSMWkJ2djfz8fL1joFarERUVpXcMfH190b9/f2mb2NhYyOVypKSkSNsMGzYMCoVC2iYuLg4ZGRm4fPmyld6NeSUlJSEgIAARERGYPn06Ll26JK1r6cdEo9EAAPz8/ACY72clOTlZr426bRzhd8/fj0mdtWvXok2bNrjpppswf/58lJWVSeta6jGpqanBunXrcOXKFURHR/P7o5l401Uru3jxImpqavS+GQEgMDAQx44ds1FVlhMVFYXVq1cjIiICeXl5ePHFFzF06FAcPnwY+fn5UCgU8PX11dsnMDAQ+fn5AID8/HyDx6punaOrew+G3uP1xyAgIEBvvaurK/z8/PS26dixY7026ta1atXKIvVbSnx8PO655x507NgRWVlZWLBgAUaOHInk5GS4uLi06GOi0+nw1FNPYfDgwbjpppsAwGw/K8a2KS4uRnl5OTw8PCzxlprN0DEBgAkTJqBDhw4ICQnBwYMHMW/ePGRkZODbb78F0PKOyaFDhxAdHY2Kigp4e3tjw4YN6NGjB9LT0536+6O5GITIokaOHCk979WrF6KiotChQwesX7++xf5QUfONHz9een7zzTejV69e6Ny5M5KSkhATE2PDyizviSeewOHDh/H777/buhS7YeyYTJ06VXp+8803Izg4GDExMcjKykLnzp2tXabFRUREID09HRqNBl9//TUmTZqEX3/91dZlOTyeGrOyNm3awMXFpd5o/vPnzyMoKMhGVVmPr68vunbtiszMTAQFBaGqqgpFRUV621x/LIKCggweq7p1jq7uPTT0/RAUFISCggK99dXV1SgsLHSa49SpUye0adMGmZmZAFruMZkxYwZ++OEH7Ny5E+3atZOWm+tnxdg2KpXKbv9jYuyYGBIVFQUAet8nLemYKBQKhIeHIzIyEkuWLEHv3r3x5ptvOvX3hzkwCFmZQqFAZGQktm/fLi3T6XTYvn07oqOjbViZdZSWliIrKwvBwcGIjIyEm5ub3rHIyMhATk6OdCyio6Nx6NAhvT9627Ztg0qlQo8ePaxev7l17NgRQUFBeseguLgYKSkpesegqKgIaWlp0jY7duyATqeTfvFHR0dj165d0Gq10jbbtm1DRESE3Z4CaoqzZ8/i0qVLCA4OBtDyjokQAjNmzMCGDRuwY8eOeqf0zPWzEh0drddG3Tb2+LvnRsfEkPT0dADQ+z5pScfk73Q6HSorK53y+8OsbD1a2xmtW7dOKJVKsXr1avHXX3+JqVOnCl9fX73R/C3F7NmzRVJSksjOzha7d+8WsbGxok2bNqKgoEAIUTvls3379mLHjh1i3759Ijo6WkRHR0v71035vP3220V6errYunWr8Pf3d6jp8yUlJWL//v1i//79AoD473//K/bv3y9Onz4thKidPu/r6yu+++47cfDgQTF69GiD0+f79u0rUlJSxO+//y66dOmiN1W8qKhIBAYGigcffFAcPnxYrFu3Tnh6etrlVHEhGj4mJSUlYs6cOSI5OVlkZ2eLX375RfTr10906dJFVFRUSG20pGMyffp0oVarRVJSkt5U8LKyMmkbc/ys1E2Pnjt3rjh69KhYsWKF3U6PvtExyczMFC+99JLYt2+fyM7OFt99953o1KmTGDZsmNRGSzomiYmJ4tdffxXZ2dni4MGDIjExUchkMvHzzz8LIZzv+8OcGIRs5O233xbt27cXCoVCDBw4UPzxxx+2Lski7rvvPhEcHCwUCoVo27atuO+++0RmZqa0vry8XDz++OOiVatWwtPTU9x9990iLy9Pr41Tp06JkSNHCg8PD9GmTRsxe/ZsodVqrf1WTLZz504BoN5j0qRJQojaKfQvvPCCCAwMFEqlUsTExIiMjAy9Ni5duiTuv/9+4e3tLVQqlXj44YdFSUmJ3jYHDhwQQ4YMEUqlUrRt21a8+uqr1nqLTdbQMSkrKxO333678Pf3F25ubqJDhw5iypQp9f6j0JKOiaFjAUCsWrVK2sZcPys7d+4Uffr0EQqFQnTq1EnvNezJjY5JTk6OGDZsmPDz8xNKpVKEh4eLuXPn6l1HSIiWc0weeeQR0aFDB6FQKIS/v7+IiYmRQpAQzvf9YU4yIYSwXv8TERERkf3gGCEiIiJyWgxCRERE5LQYhIiIiMhpMQgRERGR02IQIiIiIqfFIEREREROi0GIiIiInBaDEBERETktBiEispqwsDAsX768WW0sXrwYffr0MUs9xpw6dQoymUy6dxURtVy8sjQRmd3q1avx1FNP1bsb9oULF+Dl5QVPT0+T2y4tLUVlZSVat27dzCprJSQkoKioCBs3bpSW1dTU4MKFC2jTpg1cXV3N8jpNtXjxYmzcuJFhjMjCbPMTTkROyd/fv9lteHt7w9vb2wzVGOfi4oKgoCCLvgYR2QeeGiMiPZWVlZg1axYCAgLg7u6OIUOGIDU1VVqflJQEmUyGH3/8Eb169YK7uztuueUWHD58WFr/8MMPQ6PRQCaTQSaTYfHixQDqnxqTyWT44IMPcOedd8LT0xPdu3dHcnIyMjMzceutt8LLywuDBg1CVlaWtM/fT43Vvcb1j7CwMAC1PTuTJ09Gx44d4eHhgYiICLz55pt6bX366af47rvvpH2TkpIMnhr79ddfMXDgQCiVSgQHByMxMRHV1dXS+ltvvRWzZs3Cs88+Cz8/PwQFBUnv25ikpCQMHDgQXl5e8PX1xeDBg3H69GmsXr0aL774Ig4cOCDVtXr1agBAUVERHn30Ufj7+0OlUuG2227DgQMH6h2fDz74AKGhofD09MS4ceOg0WgarIXIWTEIEZGeZ599Ft988w0+/fRT/PnnnwgPD0dcXBwKCwv1tps7dy6WLVuG1NRU+Pv746677oJWq8WgQYOwfPlyqFQq5OXlIS8vD3PmzDH6ei+//DIeeughpKeno1u3bpgwYQIee+wxzJ8/H/v27YMQAjNmzDC6f91r5OXlITMzE+Hh4Rg2bBgAQKfToV27dvjf//6Hv/76CwsXLsSCBQuwfv16AMCcOXMwbtw4xMfHS20MGjSo3mvk5uZi1KhRGDBgAA4cOID33nsPn3zyCV555RW97T799FN4eXkhJSUFS5cuxUsvvYRt27YZrLu6uhpjxozB8OHDcfDgQSQnJ2Pq1KmQyWS47777MHv2bPTs2VOq67777gMA3HvvvSgoKMCWLVuQlpaGfv36ISYmRu/zyczMxPr16/H9999j69at2L9/Px5//HGjx5DIqdnuxvdEZG9KS0uFm5ubWLt2rbSsqqpKhISEiKVLlwohhNi5c6cAINatWydtc+nSJeHh4SG++uorIYQQq1atEmq1ul77HTp0EG+88Yb0NQDx/PPPS18nJycLAOKTTz6Rln355ZfC3d1d+nrRokWid+/e9drW6XTi7rvvFpGRkaKsrMzoe3ziiSfE2LFjpa8nTZokRo8erbdNdna2ACD2798vhBBiwYIFIiIiQuh0OmmbFStWCG9vb1FTUyOEEGL48OFiyJAheu0MGDBAzJs3z2Adly5dEgBEUlKSwfWG3udvv/0mVCqVqKio0FveuXNn8cEHH0j7ubi4iLNnz0rrt2zZIuRyucjLyzP4WkTOjGOEiEiSlZUFrVaLwYMHS8vc3NwwcOBAHD16VG/b6Oho6bmfnx8iIiLqbdMYvXr1kp4HBgYCAG6++Wa9ZRUVFSguLoZKpTLazoIFC5CcnIx9+/bBw8NDWr5ixQqsXLkSOTk5KC8vR1VVVZNnnR09ehTR0dGQyWTSssGDB6O0tBRnz55F+/bt670XAAgODkZBQYHBNv38/JCQkIC4uDj84x//QGxsLMaNG4fg4GCjdRw4cAClpaX1BoqXl5frnT5s37492rZtK30dHR0NnU6HjIwMjn0i+hsGISKyKTc3N+l5XdAwtEyn0xlt4/PPP8cbb7yBpKQkvQCwbt06zJkzB8uWLUN0dDR8fHzw2muvISUlxdxvo17ddbU3VPeqVaswa9YsbN26FV999RWef/55bNu2DbfccovB7UtLSxEcHIykpKR663x9fZtTOpHT4hghIpJ07twZCoUCu3fvlpZptVqkpqaiR48eetv+8ccf0vPLly/j+PHj6N69OwBAoVCgpqbGKjUnJyfj0UcfxQcffFAvQOzevRuDBg3C448/jr59+yI8PFyv56SxtdYN4hbXXW1k9+7d8PHxQbt27ZpVf9++fTF//nzs2bMHN910E7744gujdfXr1w/5+flwdXVFeHi43qNNmzbSdjk5OTh37pz09R9//AG5XI6IiIhm1UrUEjEIEZHEy8sL06dPx9y5c7F161b89ddfmDJlCsrKyjB58mS9bV966SVs374dhw8fRkJCAtq0aYMxY8YAqJ0dVlpaiu3bt+PixYsoKyuzSL35+fm4++67MX78eMTFxSE/Px/5+fm4cOECAKBLly7Yt28ffvrpJxw/fhwvvPCC3gy4uloPHjyIjIwMXLx4EVqttt7rPP744zhz5gxmzpyJY8eO4bvvvsOiRYvwzDPPQC437ddodnY25s+fj+TkZJw+fRo///wzTpw4IYXJsLAwZGdnIz09HRcvXkRlZSViY2MRHR2NMWPG4Oeff8apU6ewZ88ePPfcc9i3b5/Utru7OyZNmoQDBw7gt99+w6xZszBu3DieFiMygEGIiPS8+uqrGDt2LB588EH069cPmZmZ+Omnn9CqVat62z355JOIjIxEfn4+vv/+eygUCgDAoEGDMG3aNNx3333w9/fH0qVLLVLrsWPHcP78eXz66acIDg6WHgMGDAAAPPbYY7jnnntw3333ISoqCpcuXao3e2rKlCmIiIhA//794e/vr9cbVqdt27bYvHkz9u7di969e2PatGmYPHkynn/+eZNr9/T0xLFjxzB27Fh07doVU6dOxRNPPIHHHnsMADB27FjEx8djxIgR8Pf3x5dffgmZTIbNmzdj2LBhePjhh9G1a1eMHz8ep0+flsZXAUB4eDjuuecejBo1Crfffjt69eqFd9991+RaiVoyXlmaiJokKSkJI0aMwOXLlzkuxQ7xitRETcMeISIiInJaDEJERETktHhqjIiIiJwWe4SIiIjIaTEIERERkdNiECIiIiKnxSBERERETotBiIiIiJwWgxARERE5LQYhIiIicloMQkREROS0/h88W+LdOW3vTwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from depolarizing_plugin_vec import DepolarizingPluginVec\n", "\n", "# we instantiate a plugin that turns a perfect qpu into a noisy qpu:\n", "depol = DepolarizingPluginVec(prob_1qb=0.005, prob_2qb=0.001) # 0.005 corresponds to 0.5% probability\n", "qpu = get_default_qpu()\n", "\n", "noisy_qpu = depol | qpu\n", "\n", "n_layers = 4\n", "circ = generate_ansatz(n_layers)\n", "\n", "\n", "res = perform_vqe(circ, 0, noisy_qpu)\n", "optimization_trace = eval(res.meta_data[\"optimization_trace\"])\n", "\n", "plt.plot(optimization_trace, '-', lw=4)\n", "plt.plot([E0]*len(optimization_trace), '--k', lw=3, label=\"exact ground state energy\")\n", "plt.xlabel(\"optimization step\")\n", "plt.ylabel(\"energy\")\n", "plt.legend();\n" ] }, { "cell_type": "markdown", "id": "abbbe1fb-63e4-49e3-8a87-3a82ceb5b798", "metadata": {}, "source": [ "## Quantum phase estimation\n", "\n", "In this second part we turn to QPE.\n", "\n", "As we learned in the lecture, to apply QPE to the estimation of the ground state energy, we need a good input state (namely a state with a large overlap with the ground state). Here, we will assume our input state is the ground state itself. We can decide on an arbitrary input state by using a special gate called a \"state preparation\" gate, that directly loads the vector on the quantum register.\n", "\n", "We also need to slightly redefine the Hamiltonian and pick the evolution time in the $e^{-i(H-\\tilde{E})t}$ unitary so that the phase to be estimated by QPE is comprised within the $[0, 1[$ interval. If we now that $E_0$ is within an energy window $[E_{min},E_{max}]$, then a shift $\\tilde{E} = E_{min}$ and $t = -2\\pi / (E_{max} - E_{min})$ will achieve this condition.\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "4a695784-15d2-4bb0-a78f-c02bb9ba2a48", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|0011> (0.88112570621605-0.4442048383430136j)\n", "|1100> (0.052353622063593674-0.15348827217330527j)\n", "[0. +0.j 0. +0.j 0. +0.j\n", " 0.88112571-0.44420484j 0. +0.j 0. +0.j\n", " 0. +0.j 0. +0.j 0. +0.j\n", " 0. +0.j 0. +0.j 0. +0.j\n", " 0.05235362-0.15348827j 0. +0.j 0. +0.j\n", " 0. +0.j ]\n" ] } ], "source": [ "# test of AbstractGate: to perform time evolutions exactly.\n", "\n", "import scipy as sp\n", "from qat.lang.AQASM import AbstractGate\n", "from qat.lang.AQASM import X\n", "t0 = 1.0\n", "mat_U = sp.linalg.expm(-1j*hamiltonian_qubit.get_matrix() *t0)\n", "U = AbstractGate(\"U\", [], matrix_generator=lambda mat_U=mat_U: mat_U)\n", "\n", "prog = Program()\n", "reg = prog.qalloc(hamiltonian_qubit.nbqbits)\n", "prog.apply(X, reg[2])\n", "prog.apply(X, reg[3])\n", "prog.apply(U(), reg)\n", "circ = prog.to_circ()\n", "res = qpu.submit(circ.to_job())\n", "for sample in res:\n", " print(sample.state, sample.amplitude)\n", "print(mat_U[:,3])" ] }, { "cell_type": "code", "execution_count": 16, "id": "3e510aa3-6e93-4fcd-a246-ac118ea15f40", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 (0.04739577138595119+0.1023897259727182j)\n", "12 (-0.41739102170780124-0.9016954695836505j)\n", "U psi0: [ 0. +0.j 0. +0.j 0. +0.j\n", " 0.04739577+0.10238973j 0. +0.j 0. +0.j\n", " 0. +0.j 0. +0.j 0. +0.j\n", " 0. +0.j 0. +0.j 0. +0.j\n", " -0.41739102-0.90169547j 0. +0.j 0. +0.j\n", " 0. +0.j ]\n" ] } ], "source": [ "# state preparation followed by abstract gate\n", "from qat.qpus import PyLinalg, CLinalg\n", "\n", "StatePreparation = AbstractGate(\"STATE_PREPARATION\", [np.ndarray])\n", "mat_U = sp.linalg.expm(-1j*hamiltonian_qubit.get_matrix() *t0)\n", "U = AbstractGate(\"U\", [], matrix_generator=lambda: mat_U)\n", "\n", "prog = Program()\n", "reg = prog.qalloc(hamiltonian_qubit.nbqbits)\n", "prog.apply(StatePreparation(psi0), reg)\n", "prog.apply(U(), reg)\n", "circ = prog.to_circ()\n", "qpu = PyLinalg()\n", "\n", "res = qpu.submit(circ.to_job())\n", "for sample in res:\n", " print(sample.state.int, sample.amplitude)\n", "\n", "print(\"U psi0:\", mat_U@psi0)" ] }, { "cell_type": "code", "execution_count": 17, "id": "12716626-3b7c-4da0-bcbf-1bec8042051b", "metadata": {}, "outputs": [], "source": [ "from qat.lang.AQASM.qftarith import IQFT\n", "from qat.lang.AQASM import H, QRoutine, RX, Program\n", "from qat.lang.AQASM import CNOT, RZ\n", "\n", "def construct_Pauli_evolution(ops, qbits, theta):\n", " r\"\"\"Implements the quantum routine\n", " \n", " .. math::\n", " R_k(\\theta) = \\exp\\left(-i \\frac{\\theta}{2} P_k\\right)\n", " \n", " with P_k a Pauli string\n", " \n", " Args:\n", " ops (str): Pauli operators (e.g X, Y, ZZ, etc.)\n", " qbits (list): qubits on which they act\n", " theta (Variable): the abstract variable\n", " \n", " Returns:\n", " QRoutine\n", " \n", " Notes:\n", " the indices of the wires of the QRoutine are relative\n", " to the smallest index in qbits (i.e always start at qb=0)\n", " \"\"\"\n", " qrout = QRoutine()\n", " qreg = qrout.new_wires(len(qbits))\n", " with qrout.compute():\n", " for op, qbit in zip(ops, qreg):\n", " if op == \"X\":\n", " qrout.apply(H, qbit)\n", " if op == \"Y\":\n", " qrout.apply(RX(np.pi/2), qbit)\n", " for ind_qb in range(len(qreg)-1):\n", " qrout.apply(CNOT, qreg[ind_qb], qreg[ind_qb+1])\n", " qrout.apply(RZ(theta.real), qreg[-1])\n", " # uncompute() applies U^dagger,\n", " # with U the unitary corresponding to the gates applied within the \"with XX.compute()\" context\n", " qrout.uncompute()\n", " \n", " return qrout\n", "\n", "\n", "def make_controlled_evolution(hamiltonian, t0, n_trotter, order):\n", " \"\"\"contruct controlled-U with :math:`U = \\exp(-i H t0)`\n", "\n", " Args:\n", " hamiltonian (Observable): the Hamiltonian H\n", " t0 (float): the evolution time\n", " n_trotter (int): the number of Trotter slices\n", " order (int): the Trotterization order (1 or 2)\n", "\n", " Returns:\n", " QRoutine: the U routine\n", " \"\"\"\n", " routine = QRoutine()\n", " anc_reg = routine.new_wires(1)\n", " data_reg = routine.new_wires(hamiltonian.nbqbits)\n", " \n", " routine.apply(RZ(-hamiltonian.constant_coeff.real*t0), anc_reg) # controlled-global-phase (up to global phase)\n", " \n", " for _ in range(n_trotter):\n", " if order == 1:\n", " for term in hamiltonian.terms:\n", " theta = 2 * term.coeff * t0 / n_trotter\n", " Rk_routine = construct_Pauli_evolution(term.op, term.qbits, theta)\n", " \n", " routine.apply(Rk_routine.ctrl(), anc_reg,\n", " [data_reg[qb] for qb in term.qbits])\n", " \n", " elif order == 2:\n", " for term in hamiltonian.terms:\n", " theta = term.coeff * t0 / n_trotter\n", " Rk_routine = construct_Pauli_evolution(term.op, term.qbits, theta)\n", " routine.apply(Rk_routine.ctrl(), anc_reg,\n", " [data_reg[qb] for qb in term.qbits])\n", " \n", " for term in reversed(hamiltonian.terms):\n", " theta = term.coeff * t0 / n_trotter\n", " Rk_routine = construct_Pauli_evolution(term.op, term.qbits, theta)\n", " routine.apply(Rk_routine.ctrl(), anc_reg,\n", " [data_reg[qb] for qb in term.qbits])\n", " \n", " return routine\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "b36d91ee-dbe2-403b-a7dd-cb2cb5f6bef8", "metadata": {}, "outputs": [ { "data": { "text/html": [ "Q0Q1Q2Q3Q4Q5Q6HHHRZ [ 0.10]RZ [ 0.34]RZ [ 0.24]RZ [ 0.33]RZ [ 0.33]RZ [ 0.34]RZ [ 0.24]RZ [ 0.34]RX [π/2]HHRX [π/2]RZ [ 0.09]HRX [-π/2]RX [π/2]RX [-π/2]HRX [π/2]HHRZ [- 0.09]RX [-π/2]RX [-π/2]HHHHRX [π/2]RX [π/2]RZ [- 0.09]HHRX [π/2]RX [-π/2]RX [-π/2]HRX [π/2]HRZ [ 0.09]RX [-π/2]HHRX [-π/2]RZ [ 0.35]RZ [- 0.45]RZ [- 0.45]RZ [ 0.20]RZ [ 0.67]RZ [ 0.48]RZ [ 0.66]RZ [ 0.66]RZ [ 0.68]RZ [ 0.48]RZ [ 0.68]RX [π/2]HHRX [π/2]RZ [ 0.18]HRX [-π/2]RX [π/2]RX [-π/2]HRX [π/2]HHRZ [- 0.18]RX [-π/2]RX [-π/2]HHHHRX [π/2]RX [π/2]RZ [- 0.18]HHRX [π/2]RX [-π/2]RX [-π/2]HRX [π/2]HRZ [ 0.18]RX [-π/2]HHRX [-π/2]RZ [ 0.70]RZ [- 0.89]RZ [- 0.89]RZ [ 0.40]RZ [ 1.35]RZ [ 0.96]RZ [ 1.33]RZ [ 1.33]RZ [ 1.37]RZ [ 0.96]RZ [ 1.37]RX [π/2]HHRX [π/2]RZ [ 0.36]HRX [-π/2]RX [π/2]RX [-π/2]HRX [π/2]HHRZ [- 0.36]RX [-π/2]RX [-π/2]HHHHRX [π/2]RX [π/2]RZ [- 0.36]HHRX [π/2]RX [-π/2]RX [-π/2]HRX [π/2]HRZ [ 0.36]RX [-π/2]HHRX [-π/2]RZ [ 1.39]RZ [- 1.78]RZ [- 1.78]QFT [3]†" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from qat.lang.AQASM.qftarith import IQFT\n", "from qat.lang.AQASM import H, QRoutine, RZ, Program\n", "\n", "def build_qpe_routine_for_hamiltonian(hamiltonian, n_phase_bits, t0=1., exact_evolution=False, n_trotter=1, order=1):\n", " \"\"\"Construct the quantum phase estimation routine corresponding to a given Hamiltonian\n", " \n", " Args:\n", " hamiltonian (Observable): a Hamiltonian\n", " n_phase_bits (int): the number of phase bits\n", " t0 (float): the evolution time\n", " exact_evolution (bool, optional): whether to implement U=exp(-i H t0) exactly. Defaults to False\n", " n_trotter (int): the number of Trotter steps\n", " order (int): Trotterization order\n", " \n", " Returns:\n", " QRoutine: a quantum routine for phase estimation with unitary U = exp(-i H t0)\n", " \"\"\"\n", " routine = QRoutine()\n", " phase_reg = routine.new_wires(n_phase_bits)\n", " data_reg = routine.new_wires(hamiltonian.nbqbits)\n", " \n", " # Hadamard wall\n", " for qb in range(n_phase_bits):\n", " routine.apply(H, phase_reg[qb])\n", " \n", " # controlled unitaries\n", " for j_ind in range(n_phase_bits):\n", " \n", " if exact_evolution:\n", " mat_U = sp.linalg.expm(-1j*hamiltonian.get_matrix() * 2**j_ind * t0)\n", " U = AbstractGate(f\"U_{j_ind}\", [], matrix_generator=lambda mat_U=mat_U: mat_U)\n", " routine.apply(U().ctrl(), phase_reg[j_ind], data_reg)\n", " else:\n", " routine.apply(make_controlled_evolution(hamiltonian, 2**j_ind * t0, n_trotter, order),\n", " phase_reg[j_ind], data_reg)\n", "\n", " # now apply inverse QFT\n", " routine.apply(IQFT(n_phase_bits), phase_reg)\n", " \n", " return routine\n", "\n", "qpe_routine = build_qpe_routine_for_hamiltonian(hamiltonian_qubit, 3, t0=1., n_trotter=1)\n", "qpe_routine.display(depth=0)" ] }, { "cell_type": "code", "execution_count": 19, "id": "a3781dc4-916b-429f-83f1-24f00b67ed39", "metadata": {}, "outputs": [], "source": [ "def perform_qpe(qpu, hamiltonian, psi0, n_phase_bits, exact_evolution=False,\n", " n_trotter=10, nbshots=0, t0=1.0, order=1, verbose=False):\n", " \"\"\"\n", " Args:\n", " qpu (QPU): a QPU\n", " hamiltonian (Observable): a Hamiltonian\n", " psi0 (np.array): an eigenvector of H\n", " n_phase_bits (int): number of bits for the phase\n", " exact_evolution (bool, optional): whether to implement U=exp(-i H t0) exactly. Defaults to False\n", " n_trotter (int, optional): number of trotter slices. Defaults to 10\n", " nbshots (int, optional): number of shots.\n", " Defaults to 0 (corresponding to an infinite number of shots)\n", " t0 (float, optional): time in U = exp(- i H t0). Defaults to 1.\n", " order (int, optional): Trotterization order. Defaults to 1.\n", " verbose (bool, optional): for verbose output. Defaults to False.\n", " \n", " Returns:\n", " np.array: the vector of probabilities (frequencies) of obtaining each output (from 0 to 2^{m-1})\n", " \"\"\"\n", " # we prepare the initial state |0...0>|psi0> of the register\n", " phase_reg_in = np.zeros((2**n_phase_bits,))\n", " phase_reg_in[0] = 1.0 # |0...0>\n", " psi_init = np.kron(phase_reg_in, psi0) \n", " \n", " # we initialize the program\n", " prog = Program()\n", " phase_reg = prog.qalloc(n_phase_bits)\n", " data_reg = prog.qalloc(hamiltonian.nbqbits)\n", "\n", " # we use a StatePreparation gate to prepare psi_init\n", " # this is somewhat of a trick: this assumes we can prepare exactly the ground state\n", " # if we don't want to cheat we can replace the StatePreparation routine\n", " # by a routine (gates) that prepare an approximate ground state\n", " prog.apply(StatePreparation(psi_init), phase_reg, data_reg)\n", "\n", " # we call the main QPE routine\n", " pea_routine = build_qpe_routine_for_hamiltonian(hamiltonian, n_phase_bits, t0=t0,\n", " exact_evolution=exact_evolution,\n", " n_trotter=n_trotter, order=order)\n", " prog.apply(pea_routine, phase_reg, data_reg)\n", "\n", " # we generate the corresponding circuit and execute it\n", " circ = prog.to_circ()\n", "\n", " res = qpu.submit(circ.to_job(nbshots=nbshots, qubits=phase_reg)) #measure only phase register\n", "\n", " # we store the output probabilities in a vector\n", " probs = np.zeros(2**n_phase_bits)\n", "\n", " for sample in res:\n", " probs[sample.state.int] = sample.probability\n", "\n", "\n", " return probs" ] }, { "cell_type": "code", "execution_count": 20, "id": "c47ecb16-e463-4890-84af-a2a0df1335ae", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "min, max: -1.1372701746609029 0.9201067191670376\n", "t0 : 2.055090204895486\n", "expected phase (with floating point precision): 0.8364611176955737\n" ] } ], "source": [ "eigvals, eigvecs = np.linalg.eigh(hamiltonian_qubit.get_matrix())\n", "print(\"min, max:\", min(eigvals), max(eigvals))\n", "psi0 = eigvecs[:, np.argmin(eigvals)]\n", "\n", "Emin = min(eigvals) - 0.5 # lower than lowest eigval\n", "Emax = max(eigvals) + 0.5 # higher than highest eigval\n", "\n", "hamiltonian_qubit_offset = hamiltonian_qubit - Emax # this way all eigvals are negative, so phase - E t is positive\n", "t0 = 2*np.pi/ abs(Emin - Emax) # ensures phi = -E t / 2pi is within [0, 1[\n", "print(\"t0 :\", t0)\n", "\n", "# expected phase?\n", "exp_phase = -(E0 - Emax)*t0 / (2*np.pi)\n", "print(\"expected phase (with floating point precision):\", exp_phase)" ] }, { "cell_type": "code", "execution_count": 21, "id": "04706b58-6827-41bd-8215-0cd08aeeab53", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "estimated energy = -1.1595550350002868\n", "E0 = -1.1372701746609029\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import itertools\n", "qpu = PyLinalg()\n", "n_phase_bits = 6\n", "n_trotter = 20\n", "\n", "probs = perform_qpe(qpu, hamiltonian_qubit_offset, psi0, n_phase_bits, exact_evolution=False,\n", " n_trotter=n_trotter, t0=t0, order=1, verbose=False)\n", "\n", "indmax = np.argmax(probs)\n", "phase = indmax / 2**n_phase_bits\n", "energy = - 2*np.pi*phase/t0 + Emax\n", "\n", "print(\"estimated energy =\", energy)\n", "print(\"E0 = \", E0)\n", "\n", "plt.plot([exp_phase, exp_phase], [0, max(probs)], '--k', lw=4, label = \"exact phase\")\n", "\n", "plt.plot(np.linspace(0, 1, 2**n_phase_bits, endpoint=False), probs, '-o', lw=4, label=\"%s phase bits\"%n_phase_bits)\n", "\n", "\n", "plt.legend()\n", "plt.xlabel(\"value\")\n", "plt.ylabel(\"probability\")\n", "plt.grid();\n" ] }, { "cell_type": "markdown", "id": "d6be4ab0-cc24-4167-92f1-2b8a6691bba1", "metadata": {}, "source": [ "### Influence of the number of phase bits" ] }, { "cell_type": "code", "execution_count": 22, "id": "8c63fa80-6af9-4e57-815b-b25b657f60c3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4] energy: -1.0640120070681638\n", "[6] energy: -1.1595550350002868\n", "[8] energy: -1.135669278017256\n", "[10] energy: -1.1386549976401348\n" ] } ], "source": [ "n_phase_bits_list = [4, 6, 8, 10]\n", "energy_list = []\n", "for n_phase_bits in n_phase_bits_list:\n", " n_trotter = 30\n", " probs = perform_qpe(qpu, hamiltonian_qubit_offset, psi0, n_phase_bits, exact_evolution=True,\n", " n_trotter=10, t0=t0, order=1, verbose=False)\n", "\n", " indmax = np.argmax(probs)\n", " phase = indmax / 2**n_phase_bits\n", " energy = - 2*np.pi*phase/t0 + Emax\n", " print(f\"[{n_phase_bits}] energy: {energy}\")\n", " energy_list.append(energy)\n" ] }, { "cell_type": "code", "execution_count": 23, "id": "378440fd-fc04-42dd-84ca-b8d005ce0641", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(n_phase_bits_list, abs(np.array(energy_list)-E0), '-o', lw=3)\n", "plt.xlabel(\"number of phase bits\")\n", "plt.ylabel(\"energy\")\n", "plt.grid()\n", "plt.yscale(\"log\")" ] }, { "cell_type": "code", "execution_count": null, "id": "a3d49d20-d3cf-4f6b-a2f7-c64749754fb7", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "5468f260-50bb-44eb-b136-c905e33070b5", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10.12" } }, "nbformat": 4, "nbformat_minor": 5 }