From cccc05b4ed0ebe9885a9850be8ec9e4a48b4a2e5 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Mon, 19 Feb 2024 01:38:43 +0300 Subject: [PATCH 01/17] add first draft --- .../tutorials/adapt-vqe-draft.ipynb | 799 ++++++++++++++++++ 1 file changed, 799 insertions(+) create mode 100644 quantum_enablement/tutorials/adapt-vqe-draft.ipynb diff --git a/quantum_enablement/tutorials/adapt-vqe-draft.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft.ipynb new file mode 100644 index 0000000..a0fcd94 --- /dev/null +++ b/quantum_enablement/tutorials/adapt-vqe-draft.ipynb @@ -0,0 +1,799 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit ADAPT-VQE tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the molecule\n", + "We start by defining the molecule using ``pyscf``. As an example we select the $H_2$ molecule and build it by providing its geometry.\n", + "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyscf import ao2mo, gto, mcscf, scf\n", + "\n", + "distance = 0.735\n", + "a = distance / 2\n", + "mol = gto.Mole()\n", + "mol.build(\n", + " verbose=0,\n", + " atom=[\n", + " [\"H\", (0, 0, -a)],\n", + " [\"H\", (0, 0, a)],\n", + " ],\n", + " basis=\"sto-6g\",\n", + " spin=0,\n", + " charge=0,\n", + " symmetry=\"Dooh\",\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nuclear energy: 0.7199689944489797\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", + " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Electronic energy: -1.8455976628764188\n", + "Total energy: -1.125628668427439\n", + "Total energy - nuclear energy: -1.8455976628764188\n" + ] + } + ], + "source": [ + "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", + "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", + "print(f\"Total energy: {mol.energy_tot()}\")\n", + "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "range(0, 2)\n" + ] + } + ], + "source": [ + "active_space = range(mol.nelectron // 2 - 1, mol.nelectron // 2 + 1)\n", + "print(active_space)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the fermionic Hamiltonian\n", + "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "mf = scf.RHF(mol)\n", + "E1 = mf.kernel()\n", + "mx = mcscf.CASCI(mf, ncas=2, nelecas=(1, 1))\n", + "mo = mx.sort_mo(active_space, base=0)\n", + "E2 = mx.kernel(mo)[:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "h1e, ecore = mx.get_h1eff()\n", + "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map the fermionic Hamiltonian to a qubit operator\n", + "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", + "\n", + "import numpy as np\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "\n", + "def cholesky(V, eps):\n", + " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", + " # see https://arxiv.org/abs/1808.02625\n", + " # see https://arxiv.org/abs/2104.08957\n", + " no = V.shape[0]\n", + " chmax, ng = 20 * no, 0\n", + " W = V.reshape(no**2, no**2)\n", + " L = np.zeros((no**2, chmax))\n", + " Dmax = np.diagonal(W).copy()\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " while vmax > eps:\n", + " L[:, ng] = W[:, nu_max]\n", + " if ng > 0:\n", + " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", + " L[:, ng] /= np.sqrt(vmax)\n", + " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", + " ng += 1\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " L = L[:, :ng].reshape((no, no, ng))\n", + " print(\n", + " \"accuracy of Cholesky decomposition \",\n", + " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", + " )\n", + " return L, ng\n", + "\n", + "\n", + "def identity(n):\n", + " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", + "\n", + "\n", + "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", + " c_list = []\n", + " if mapping == \"jordan_wigner\":\n", + " for p in range(n):\n", + " if p == 0:\n", + " l, r = \"I\" * (n - 1), \"\"\n", + " elif p == n - 1:\n", + " l, r = \"\", \"Z\" * (n - 1)\n", + " else:\n", + " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", + " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, 0.5j)])\n", + " c_list.append(cp)\n", + " else:\n", + " raise ValueError(\"Unsupported mapping.\")\n", + " d_list = [cp.adjoint() for cp in c_list]\n", + " return c_list, d_list\n", + "\n", + "\n", + "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", + " ncas, _ = h1e.shape\n", + "\n", + " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", + " Exc = []\n", + " for p in range(ncas):\n", + " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", + " for r in range(p + 1, ncas):\n", + " Excp.append(\n", + " C[p] @ D[r]\n", + " + C[ncas + p] @ D[ncas + r]\n", + " + C[r] @ D[p]\n", + " + C[ncas + r] @ D[ncas + p]\n", + " )\n", + " Exc.append(Excp)\n", + "\n", + " # low-rank decomposition of the Hamiltonian\n", + " Lop, ng = cholesky(h2e, 1e-6)\n", + " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", + "\n", + " H = ecore * identity(2 * ncas)\n", + " # one-body term\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " H += t1e[p, r] * Exc[p][r - p]\n", + " # two-body term\n", + " for g in range(ng):\n", + " Lg = 0 * identity(2 * ncas)\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " Lg += Lop[p, r, g] * Exc[p][r - p]\n", + " H += 0.5 * Lg @ Lg\n", + "\n", + " return H.chop().simplify()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy of Cholesky decomposition 6.655392125243921e-17\n", + "SparsePauliOp(['IIII', 'IIIZ', 'IZII', 'IIZI', 'ZIII', 'IZIZ', 'IIZZ', 'ZIIZ', 'IZZI', 'ZZII', 'ZIZI', 'YYYY', 'XXYY', 'YYXX', 'XXXX'],\n", + " coeffs=[-0.09820182+0.j, -0.1740751 +0.j, -0.1740751 +0.j, 0.2242933 +0.j,\n", + " 0.2242933 +0.j, 0.16891402+0.j, 0.1210099 +0.j, 0.16631441+0.j,\n", + " 0.16631441+0.j, 0.1210099 +0.j, 0.17504456+0.j, 0.04530451+0.j,\n", + " 0.04530451+0.j, 0.04530451+0.j, 0.04530451+0.j])\n" + ] + } + ], + "source": [ + "H = build_hamiltonian(ecore, h1e, h2e)\n", + "print(H)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outline of the ADAPT-VQE algorithm\n", + "https://arxiv.org/abs/1812.11173 \n", + "\n", + "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + "\n", + "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + "\n", + "3. Define the following conditions for termination: CONVERGED, CYCLICITY, MAXIMUM.\n", + " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", + " - CYCLICITY: Aborted due to a cyclic selection of evolution operators.\n", + " - MAXIMUM: Maximum number of iterations reached.\n", + " \n", + "4. while not TERMINATE (CONVERGED or CYCLICITY or MAXIMUM):\n", + " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", + " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", + " - Run VQE over all parameters $\\theta_i$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial state\n", + "We initate the quantum computer to the Hartree-Fock state." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", + " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", + "\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + "\n", + " Returns:\n", + " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", + "\n", + " Raises:\n", + " ValueError: If the total number of particles is larger than the number of orbitals.\n", + " \"\"\"\n", + " # validate the input\n", + " assert num_spatial_orbitals >= 1\n", + " num_alpha, num_beta = num_particles\n", + "\n", + " if any(n > num_spatial_orbitals for n in num_particles):\n", + " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", + "\n", + " half_orbitals = num_spatial_orbitals\n", + " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", + " bitstr[:num_alpha] = True\n", + " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", + "\n", + " return bitstr.tolist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "num_spatial_orbitals = mol.nao\n", + "num_particles = mol.nelec\n", + "\n", + "# Get the Hartree-Fock initial state in bitsting representation\n", + "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", + "\n", + "# Get the corresponding circuit in Jordan-Wigner transform\n", + "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", + "for i, hf_bit in enumerate(hf_bitstring):\n", + " if hf_bit:\n", + " hf_circuit.x(i)\n", + "\n", + "hf_circuit.draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator pool\n", + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[SparsePauliOp(['IIXY', 'IIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['XYII', 'YXII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j])]\n" + ] + } + ], + "source": [ + "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "\n", + "qubit_mapper = JordanWignerMapper()\n", + "\n", + "# Define the pool of operators as those generated by the UCC ansatz\n", + "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", + "excitation_pool = ucc.operators # TODO\n", + "print(excitation_pool)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient of the excitation operators\n", + "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. Note that the following computation requires the operators from the pool to be anti-Hermitian, and should be replaced with an appropriate alternative method if this is not the case." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", + " \"\"\"\n", + " Computes the gradients for all available excitation operators.\n", + " Args:\n", + " ansatz: ansatz built so far.\n", + " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", + " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", + " estimator: an instance of the Qiskit Estimator primitive\n", + " params: parameters to be assigned to the ansatz, if any.\n", + " Returns:\n", + " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", + " \"\"\"\n", + " # The excitations operators are applied later as exp(i*theta*excitation).\n", + " # For this commutator, we need to explicitly pull in the imaginary phase.\n", + " if params is not None:\n", + " ansatz_opt = ansatz.assign_parameters(params)\n", + " else:\n", + " ansatz_opt = ansatz\n", + " commutators = [(hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", + " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", + " gradients = estimator.run(ansatz_list, commutators).result().values\n", + "\n", + " return gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.+0.j 0.+0.j 0.+0.36243609j]\n", + "SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j])\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from qiskit.primitives import Estimator\n", + "\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(gradients)\n", + "max_operator = excitation_pool[max_index]\n", + "print(max_operator)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expand the Ansatz\n", + "We found that the third operator in the pool, which is the double-excitation operator in this case, has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` for small problems." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import MatrixExponential, SuzukiTrotter, LieTrotter\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run VQE\n", + "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.86454711]\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -1.1459778377914749\n", + " x: [ 1.683e+00]\n", + " nfev: 22\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 22 F =-1.145978E+00 MAXCV = 0.000000E+00\n", + " X = 1.682718E+00\n", + "\n", + "-1.8659468322404544\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "nuclear_repulsion = mol.energy_nuc()\n", + "electron_energy = getattr(res, 'fun') - nuclear_repulsion\n", + "print(electron_energy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.68274281]\n" + ] + } + ], + "source": [ + "# Optimal parameters so far\n", + "x_opt = getattr(res, 'x')\n", + "print(x_opt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Another iteration of the algorithm\n", + "We now compute the gradients again to see if we need another iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.54074396e-32-1.37268649e-16j -8.47409176e-33-2.04540239e-16j\n", + " 6.00890143e-32+4.04451708e-04j]\n", + "Found maximum gradient 0.00040445170842217 at index 2\n", + "Maximum gradient is below the threshold: True\n" + ] + } + ], + "source": [ + "gradient_threshold = 1e-3\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(gradients)\n", + "\n", + "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", + "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the maximum gradient is below the threshold, we do not append another operator to the ansatz, and the algorithm terminates." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Putting it all together\n", + "Now we automate the algorithm in a single loop." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 24 F =-1.145978E+00 MAXCV = 0.000000E+00\n", + " X = 4.824114E+00\n", + "Electron energy: -1.8659468327452657\n" + ] + } + ], + "source": [ + "# Define the conditions for termination\n", + "gradient_threshold = 1e-3\n", + "cyclic = False # TODO\n", + "max_iter = 10\n", + "terminate = False\n", + "\n", + "# Initiate the problem\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "excitation_pool = ucc.operators # TODO\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "params = None\n", + "\n", + "iter = 0\n", + "operator_list = []\n", + "while not terminate:\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(gradients)\n", + " max_operator = excitation_pool[max_index]\n", + " # Terminate if the operators are cyclic\n", + " if cyclic: # TODO\n", + " terminate = True \n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + " x_opt = getattr(res, 'x')\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " terminate = True\n", + " \n", + "nuclear_repulsion = mol.energy_nuc()\n", + "electron_energy = getattr(res, 'fun') - nuclear_repulsion\n", + "print(f\"Electron energy:\", electron_energy)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From c00e68f409c17414deed1c13c6119151d794729a Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Wed, 21 Feb 2024 01:20:42 +0300 Subject: [PATCH 02/17] identify pyscf/JW Hamiltonian energy mismatch --- .../tutorials/adapt-vqe-draft-H2.ipynb | 825 ++++++++++++++++++ 1 file changed, 825 insertions(+) create mode 100644 quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb new file mode 100644 index 0000000..36a6b7f --- /dev/null +++ b/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb @@ -0,0 +1,825 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit ADAPT-VQE tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the molecule\n", + "We start by defining the molecule using ``pyscf``. As an example we select the $H_2$ molecule and build it by providing its geometry.\n", + "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyscf import ao2mo, gto, mcscf, scf\n", + "\n", + "distance = 0.735\n", + "a = distance / 2\n", + "mol = gto.Mole()\n", + "mol.build(\n", + " verbose=0,\n", + " atom=[\n", + " [\"H\", (0, 0, -a)],\n", + " [\"H\", (0, 0, a)],\n", + " ],\n", + " basis=\"sto-6g\",\n", + " spin=0,\n", + " charge=0,\n", + " symmetry=\"Dooh\",\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nuclear energy: 0.7199689944489797\n", + "Electronic energy: -1.8455976628764188\n", + "Total energy: -1.125628668427439\n", + "Total energy - nuclear energy: -1.8455976628764188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", + " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" + ] + } + ], + "source": [ + "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", + "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", + "print(f\"Total energy: {mol.energy_tot()}\")\n", + "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "range(0, 2)\n" + ] + } + ], + "source": [ + "active_space = range(mol.nelectron // 2 - 1, mol.nelectron // 2 + 1)\n", + "print(active_space)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the fermionic Hamiltonian\n", + "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mf = scf.RHF(mol)\n", + "E1 = mf.kernel()\n", + "mx = mcscf.CASCI(mf, ncas=2, nelecas=(1, 1))\n", + "mo = mx.sort_mo(active_space, base=0)\n", + "E2 = mx.kernel(mo)[:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "h1e, ecore = mx.get_h1eff()\n", + "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map the fermionic Hamiltonian to a qubit operator\n", + "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", + "\n", + "import numpy as np\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "\n", + "def cholesky(V, eps):\n", + " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", + " # see https://arxiv.org/abs/1808.02625\n", + " # see https://arxiv.org/abs/2104.08957\n", + " no = V.shape[0]\n", + " chmax, ng = 20 * no, 0\n", + " W = V.reshape(no**2, no**2)\n", + " L = np.zeros((no**2, chmax))\n", + " Dmax = np.diagonal(W).copy()\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " while vmax > eps:\n", + " L[:, ng] = W[:, nu_max]\n", + " if ng > 0:\n", + " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", + " L[:, ng] /= np.sqrt(vmax)\n", + " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", + " ng += 1\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " L = L[:, :ng].reshape((no, no, ng))\n", + " print(\n", + " \"accuracy of Cholesky decomposition \",\n", + " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", + " )\n", + " return L, ng\n", + "\n", + "\n", + "def identity(n):\n", + " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", + "\n", + "\n", + "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", + " c_list = []\n", + " if mapping == \"jordan_wigner\":\n", + " for p in range(n):\n", + " if p == 0:\n", + " l, r = \"I\" * (n - 1), \"\"\n", + " elif p == n - 1:\n", + " l, r = \"\", \"Z\" * (n - 1)\n", + " else:\n", + " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", + " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, 0.5j)])\n", + " c_list.append(cp)\n", + " else:\n", + " raise ValueError(\"Unsupported mapping.\")\n", + " d_list = [cp.adjoint() for cp in c_list]\n", + " return c_list, d_list\n", + "\n", + "\n", + "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", + " ncas, _ = h1e.shape\n", + "\n", + " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", + " Exc = []\n", + " for p in range(ncas):\n", + " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", + " for r in range(p + 1, ncas):\n", + " Excp.append(\n", + " C[p] @ D[r]\n", + " + C[ncas + p] @ D[ncas + r]\n", + " + C[r] @ D[p]\n", + " + C[ncas + r] @ D[ncas + p]\n", + " )\n", + " Exc.append(Excp)\n", + "\n", + " # low-rank decomposition of the Hamiltonian\n", + " Lop, ng = cholesky(h2e, 1e-6)\n", + " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", + "\n", + " H = ecore * identity(2 * ncas)\n", + " # one-body term\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " H += t1e[p, r] * Exc[p][r - p]\n", + " # two-body term\n", + " for g in range(ng):\n", + " Lg = 0 * identity(2 * ncas)\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " Lg += Lop[p, r, g] * Exc[p][r - p]\n", + " H += 0.5 * Lg @ Lg\n", + "\n", + " return H.chop().simplify()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy of Cholesky decomposition 6.655392125243921e-17\n", + "SparsePauliOp(['IIII', 'IIIZ', 'IZII', 'IIZI', 'ZIII', 'IZIZ', 'IIZZ', 'ZIIZ', 'IZZI', 'ZZII', 'ZIZI', 'YYYY', 'XXYY', 'YYXX', 'XXXX'],\n", + " coeffs=[-0.09820182+0.j, -0.1740751 +0.j, -0.1740751 +0.j, 0.2242933 +0.j,\n", + " 0.2242933 +0.j, 0.16891402+0.j, 0.1210099 +0.j, 0.16631441+0.j,\n", + " 0.16631441+0.j, 0.1210099 +0.j, 0.17504456+0.j, 0.04530451+0.j,\n", + " 0.04530451+0.j, 0.04530451+0.j, 0.04530451+0.j])\n" + ] + } + ], + "source": [ + "H = build_hamiltonian(ecore, h1e, h2e)\n", + "print(H)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Remark\n", + "Compare with the exact ground state energy below. There is a mismatch with this and the pyscf computed energies." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1459778538543868\n" + ] + } + ], + "source": [ + "from qiskit_algorithms import NumPyMinimumEigensolver\n", + "\n", + "exact_solver = NumPyMinimumEigensolver()\n", + "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", + "print(exact_result.eigenvalue)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outline of the ADAPT-VQE algorithm\n", + "https://arxiv.org/abs/1812.11173 \n", + "\n", + "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + "\n", + "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + "\n", + "3. Define the following conditions for termination: CONVERGED, CYCLICITY, MAXIMUM.\n", + " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", + " - CYCLICITY: Aborted due to a cyclic selection of evolution operators.\n", + " - MAXIMUM: Maximum number of iterations reached.\n", + " \n", + "4. while not TERMINATE (CONVERGED or CYCLICITY or MAXIMUM):\n", + " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", + " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", + " - Run VQE over all parameters $\\theta_i$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial state\n", + "We initate the quantum computer to the Hartree-Fock state." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", + " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", + "\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + "\n", + " Returns:\n", + " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", + "\n", + " Raises:\n", + " ValueError: If the total number of particles is larger than the number of orbitals.\n", + " \"\"\"\n", + " # validate the input\n", + " assert num_spatial_orbitals >= 1\n", + " num_alpha, num_beta = num_particles\n", + "\n", + " if any(n > num_spatial_orbitals for n in num_particles):\n", + " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", + "\n", + " half_orbitals = num_spatial_orbitals\n", + " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", + " bitstr[:num_alpha] = True\n", + " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", + "\n", + " return bitstr.tolist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mol.nelec\n", + "\n", + "# Get the Hartree-Fock initial state in bitsting representation\n", + "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", + "\n", + "# Get the corresponding circuit in Jordan-Wigner transform\n", + "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", + "for i, hf_bit in enumerate(hf_bitstring):\n", + " if hf_bit:\n", + " hf_circuit.x(i)\n", + "\n", + "hf_circuit.draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator pool\n", + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[SparsePauliOp(['IIXY', 'IIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['XYII', 'YXII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j])]\n" + ] + } + ], + "source": [ + "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "\n", + "qubit_mapper = JordanWignerMapper()\n", + "\n", + "# Define the pool of operators as those generated by the UCC ansatz\n", + "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", + "excitation_pool = ucc.operators # TODO\n", + "print(excitation_pool)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient of the excitation operators\n", + "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. Note that the following computation requires the operators from the pool to be anti-Hermitian, and should be replaced with an appropriate alternative method if this is not the case." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", + " \"\"\"\n", + " Computes the gradients for all available excitation operators.\n", + " Args:\n", + " ansatz: ansatz built so far.\n", + " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", + " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", + " estimator: an instance of the Qiskit Estimator primitive\n", + " params: parameters to be assigned to the ansatz, if any.\n", + " Returns:\n", + " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", + " \"\"\"\n", + " # The excitations operators are applied later as exp(i*theta*excitation).\n", + " # For this commutator, we need to explicitly pull in the imaginary phase.\n", + " if params is not None:\n", + " ansatz_opt = ansatz.assign_parameters(params)\n", + " else:\n", + " ansatz_opt = ansatz\n", + " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", + " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", + " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", + " gradients = estimator.run(ansatz_list, commutators).result().values\n", + "\n", + " return gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0. 0. -0.36243609]\n", + "Found operator SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.362436085015165 at index 2.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from qiskit.primitives import Estimator\n", + "\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "max_operator = excitation_pool[max_index]\n", + "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expand the Ansatz\n", + "We found that the third operator in the pool, which is the double-excitation operator in this case, has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` for small problems." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import MatrixExponential, SuzukiTrotter, LieTrotter\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run VQE\n", + "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.44440489]\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -1.1459778287234819\n", + " x: [ 4.824e+00]\n", + " nfev: 22\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + "Found ground energy: -1.1459778287234819, exact energy: -1.1459778538543868, difference: 2.513090491262915e-08\n", + "\n", + " NFVALS = 22 F =-1.145978E+00 MAXCV = 0.000000E+00\n", + " X = 4.824088E+00\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.82408771]\n" + ] + } + ], + "source": [ + "# Optimal parameters so far\n", + "x_opt = getattr(res, 'x')\n", + "print(x_opt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Another iteration of the algorithm\n", + "We now compute the gradients again to see if we need another iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0. 0.00040531]\n", + "Found maximum gradient 0.00040530591672278266 at index 2\n", + "Maximum gradient is below the threshold: True\n" + ] + } + ], + "source": [ + "gradient_threshold = 1e-3\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "\n", + "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", + "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the maximum gradient is below the threshold, we do not append another operator to the ansatz, and the algorithm terminates." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Putting it all together\n", + "Now we automate the algorithm in a single loop." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 24 F =-1.145978E+00 MAXCV = 0.000000E+00\n", + " X = 4.824100E+00\n", + "Found ground energy: -1.14597783349519, exact energy: -1.1459778538543868, difference: 2.03591967729011e-08\n" + ] + } + ], + "source": [ + "# Define the conditions for termination\n", + "gradient_threshold = 1e-3\n", + "max_iter = 10\n", + "terminate = False\n", + "\n", + "# Initiate the problem\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "excitation_pool = ucc.operators # TODO\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "params = None\n", + "\n", + "iter = 0\n", + "operator_list = []\n", + "while not terminate:\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + " x_opt = getattr(res, 'x')\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " terminate = True\n", + " \n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From d130e76e51085737a984282e056c7f3383bac9e9 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Wed, 21 Feb 2024 04:09:02 +0300 Subject: [PATCH 03/17] add LiH example first draft --- .../tutorials/adapt-vqe-draft-LiH.ipynb | 1072 +++++++++++++++++ .../tutorials/adapt-vqe-draft.ipynb | 799 ------------ 2 files changed, 1072 insertions(+), 799 deletions(-) create mode 100644 quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb delete mode 100644 quantum_enablement/tutorials/adapt-vqe-draft.ipynb diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb new file mode 100644 index 0000000..bc89972 --- /dev/null +++ b/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb @@ -0,0 +1,1072 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit ADAPT-VQE tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the molecule\n", + "We start by defining the molecule using ``pyscf``. As an example we select the LiH molecule and build it by providing its geometry.\n", + "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pyscf import ao2mo, gto, mcscf, scf\n", + "\n", + "# LiH\n", + "distance = 0.735\n", + "mol = gto.Mole()\n", + "mol.build(\n", + " verbose=0,\n", + " atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n", + " basis=\"sto-6g\",\n", + " spin=0,\n", + " charge=0,\n", + " symmetry=\"Coov\",\n", + ")\n", + "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nuclear energy: 2.159906983346939\n", + "Electronic energy: -9.788591664808054\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", + " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total energy: -7.628684681461115\n", + "Total energy - nuclear energy: -9.788591664808054\n" + ] + } + ], + "source": [ + "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", + "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", + "print(f\"Total energy: {mol.energy_tot()}\")\n", + "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the fermionic Hamiltonian\n", + "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mf = scf.RHF(mol)\n", + "E1 = mf.kernel()\n", + "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", + "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", + "E2 = mx.kernel(mo)[:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "h1e, ecore = mx.get_h1eff()\n", + "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map the fermionic Hamiltonian to a qubit operator\n", + "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", + "\n", + "import numpy as np\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "\n", + "def cholesky(V, eps):\n", + " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", + " # see https://arxiv.org/abs/1808.02625\n", + " # see https://arxiv.org/abs/2104.08957\n", + " no = V.shape[0]\n", + " chmax, ng = 20 * no, 0\n", + " W = V.reshape(no**2, no**2)\n", + " L = np.zeros((no**2, chmax))\n", + " Dmax = np.diagonal(W).copy()\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " while vmax > eps:\n", + " L[:, ng] = W[:, nu_max]\n", + " if ng > 0:\n", + " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", + " L[:, ng] /= np.sqrt(vmax)\n", + " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", + " ng += 1\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " L = L[:, :ng].reshape((no, no, ng))\n", + " print(\n", + " \"accuracy of Cholesky decomposition \",\n", + " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", + " )\n", + " return L, ng\n", + "\n", + "\n", + "def identity(n):\n", + " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", + "\n", + "\n", + "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", + " c_list = []\n", + " if mapping == \"jordan_wigner\":\n", + " for p in range(n):\n", + " if p == 0:\n", + " l, r = \"I\" * (n - 1), \"\"\n", + " elif p == n - 1:\n", + " l, r = \"\", \"Z\" * (n - 1)\n", + " else:\n", + " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", + " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, 0.5j)])\n", + " c_list.append(cp)\n", + " else:\n", + " raise ValueError(\"Unsupported mapping.\")\n", + " d_list = [cp.adjoint() for cp in c_list]\n", + " return c_list, d_list\n", + "\n", + "\n", + "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", + " ncas, _ = h1e.shape\n", + "\n", + " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", + " Exc = []\n", + " for p in range(ncas):\n", + " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", + " for r in range(p + 1, ncas):\n", + " Excp.append(\n", + " C[p] @ D[r]\n", + " + C[ncas + p] @ D[ncas + r]\n", + " + C[r] @ D[p]\n", + " + C[ncas + r] @ D[ncas + p]\n", + " )\n", + " Exc.append(Excp)\n", + "\n", + " # low-rank decomposition of the Hamiltonian\n", + " Lop, ng = cholesky(h2e, 1e-6)\n", + " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", + "\n", + " H = ecore * identity(2 * ncas)\n", + " # one-body term\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " H += t1e[p, r] * Exc[p][r - p]\n", + " # two-body term\n", + " for g in range(ng):\n", + " Lg = 0 * identity(2 * ncas)\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " Lg += Lop[p, r, g] * Exc[p][r - p]\n", + " H += 0.5 * Lg @ Lg\n", + "\n", + " return H.chop().simplify()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy of Cholesky decomposition 2.7755575615628914e-16\n", + "The Hamiltonian consists of 276 10-qubit Pauli operators.\n" + ] + } + ], + "source": [ + "H = build_hamiltonian(ecore, h1e, h2e)\n", + "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Remark\n", + "Compare with the exact ground state energy below. There is a mismatch with this and the pyscf computed energies." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.646812245579224\n" + ] + } + ], + "source": [ + "from qiskit_algorithms import NumPyMinimumEigensolver\n", + "\n", + "exact_solver = NumPyMinimumEigensolver()\n", + "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", + "print(exact_result.eigenvalue)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outline of the ADAPT-VQE algorithm\n", + "This algorithm was first introduced in https://arxiv.org/abs/1812.1117.\n", + "\n", + "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + "\n", + "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + "\n", + "3. Define the following conditions for termination: CONVERGED, MAXIMUM.\n", + " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", + " - MAXIMUM: Maximum number of iterations reached.\n", + " \n", + "4. while not TERMINATE (CONVERGED or MAXIMUM):\n", + " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", + " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", + " - Run VQE over all parameters $\\theta_i$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial state\n", + "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we do with the help of the function below." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", + " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", + "\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + "\n", + " Returns:\n", + " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", + "\n", + " Raises:\n", + " ValueError: If the total number of particles is larger than the number of orbitals.\n", + " \"\"\"\n", + " # validate the input\n", + " assert num_spatial_orbitals >= 1\n", + " num_alpha, num_beta = num_particles\n", + "\n", + " if any(n > num_spatial_orbitals for n in num_particles):\n", + " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", + "\n", + " half_orbitals = num_spatial_orbitals\n", + " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", + " bitstr[:num_alpha] = True\n", + " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", + "\n", + " return bitstr.tolist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mol.nelec\n", + "\n", + "# Get the Hartree-Fock initial state in boolean bitstring representation\n", + "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", + "\n", + "# Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an X-gate as indicated by the boolean list\n", + "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", + "for i, hf_bit in enumerate(hf_bitstring):\n", + " if hf_bit:\n", + " hf_circuit.x(i)\n", + "\n", + "hf_circuit.draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator pool\n", + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The excitation pool consists of 54 operators.\n" + ] + } + ], + "source": [ + "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "\n", + "qubit_mapper = JordanWignerMapper()\n", + "\n", + "# Define the pool of operators as the single and double excitation operators generated by the UCC ansatz\n", + "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", + "excitation_pool = ucc.operators # TODO\n", + "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient of the excitation operators\n", + "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", + " \"\"\"\n", + " Computes the gradients for all available excitation operators.\n", + " Args:\n", + " ansatz: ansatz built so far.\n", + " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", + " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", + " estimator: an instance of the Qiskit Estimator primitive\n", + " params: parameters to be assigned to the ansatz, if any.\n", + " Returns:\n", + " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", + " \"\"\"\n", + " # The excitations operators are applied later as exp(i*theta*excitation).\n", + " # For this commutator, we need to explicitly pull in the imaginary phase.\n", + " if params is not None:\n", + " ansatz_opt = ansatz.assign_parameters(params)\n", + " else:\n", + " ansatz_opt = ansatz\n", + " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", + " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", + " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", + " gradients = estimator.run(ansatz_list, commutators).result().values\n", + "\n", + " return gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0. 0. -0.3773396 0. 0. -0.08933881\n", + " 0. 0. -0.3773396 0. 0. -0.08933881\n", + " 0. 0. -0.05904723 0. 0. -0.04093015\n", + " 0. 0. 0. 0. -0.05904723 0.\n", + " 0. -0.04093015 0. 0. 0. -0.24891225\n", + " 0. 0. 0.05362656 -0.04093015 0. 0.\n", + " -0.08729688 0. 0. 0. -0.04093015 0.\n", + " 0. -0.08729688 0. 0. 0. 0.05362656\n", + " 0. 0. -0.05430852 0. 0. 0. ]\n", + "Found operator SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) with maximum gradient 0.37733960483964873 at index 2.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from qiskit.primitives import Estimator\n", + "\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "max_operator = excitation_pool[max_index]\n", + "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expand the Ansatz\n", + "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter, MatrixExponential\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run VQE\n", + "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-4.339808448288726\n" + ] + } + ], + "source": [ + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "\n", + "hf_energy = estimator.run(hf_circuit, H).result().values[0] # TODO something is wrong here\n", + "print(hf_energy)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2.03535564]\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -4.9237835278935576\n", + " x: [ 1.883e+00]\n", + " nfev: 22\n", + " maxcv: 0.0\n", + "\n", + "Found ground energy: -4.9237835278935576, exact energy: -7.646812245579224, difference: 2.7230287176856667\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 22 F =-4.923784E+00 MAXCV = 0.000000E+00\n", + " X = 1.883200E+00\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.88320018]\n" + ] + } + ], + "source": [ + "# Optimal parameters so far\n", + "x_opt = getattr(res, 'x')\n", + "print(x_opt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Another iteration of the algorithm\n", + "We now compute the gradients again to see if we need another iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.00000000e+00 0.00000000e+00 1.13378270e-04 0.00000000e+00\n", + " 0.00000000e+00 -3.52174396e-02 0.00000000e+00 0.00000000e+00\n", + " -2.30153061e-01 0.00000000e+00 0.00000000e+00 -1.12519121e-01\n", + " 0.00000000e+00 0.00000000e+00 1.13947934e-03 0.00000000e+00\n", + " 0.00000000e+00 1.04682381e-03 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 1.13947934e-03 0.00000000e+00\n", + " 0.00000000e+00 1.04682381e-03 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 8.63356013e-02 0.00000000e+00 0.00000000e+00\n", + " 2.85501592e-02 -4.09301450e-02 0.00000000e+00 0.00000000e+00\n", + " -8.72968838e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " -4.09301450e-02 0.00000000e+00 0.00000000e+00 -8.72968838e-02\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 -9.55896595e-03\n", + " 0.00000000e+00 0.00000000e+00 -3.52730485e-03 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00]\n", + "Found maximum gradient 0.23015306140726227 at index 8\n", + "Maximum gradient is below the threshold: False\n" + ] + } + ], + "source": [ + "gradient_threshold = 1e-3\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "\n", + "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", + "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the maximum gradient is not below the threshold, we append the operator at index 8 to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Initiate the list of operators with the first one \n", + "operator_list = [max_operator]\n", + "# Append the second operator\n", + "operator_list.append(excitation_pool[max_index])\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.44339671 0.04100537]\n", + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -5.433843342342847\n", + " x: [ 1.817e+00 1.817e+00]\n", + " nfev: 34\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 34 F =-5.433843E+00 MAXCV = 0.000000E+00\n", + " X = 1.817188E+00 1.817200E+00\n", + "\n", + "Found ground energy: -5.433843342342847, exact energy: -7.646812245579224, difference: 2.2129689032363773\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Putting it all together\n", + "Now we automate the algorithm in a single loop." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0\n", + "Maximum gradient: 0.37733960483964873\n", + "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 2\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -4.923783304405997\n", + " Iterations: 3\n", + " Function evaluations: 8\n", + " Gradient evaluations: 3\n", + "Result at iter 0: -4.923783304405997\n", + "Iter: 1\n", + "Maximum gradient: 0.22987808370878116\n", + "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.433843335377542\n", + " Iterations: 6\n", + " Function evaluations: 19\n", + " Gradient evaluations: 6\n", + "Result at iter 1: -5.433843335377542\n", + "Iter: 2\n", + "Maximum gradient: 0.17401184266509448\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 29\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.441845269731562\n", + " Iterations: 14\n", + " Function evaluations: 59\n", + " Gradient evaluations: 14\n", + "Result at iter 2: -5.441845269731562\n", + "Iter: 3\n", + "Maximum gradient: 0.08729688376396207\n", + "Operator: SparsePauliOp(['IIYYIIIXYI', 'IIXYIIIYYI', 'IIXXIIIXYI', 'IIYXIIIYYI', 'IIXYIIIXXI', 'IIYYIIIYXI', 'IIYXIIIXXI', 'IIXXIIIYXI'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 36\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.605545493042757\n", + " Iterations: 11\n", + " Function evaluations: 59\n", + " Gradient evaluations: 11\n", + "Result at iter 3: -5.605545493042757\n", + "Iter: 4\n", + "Maximum gradient: 0.09489516148503484\n", + "Operator: SparsePauliOp(['IIIIIXZZYI', 'IIIIIYZZXI'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 5\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.6111067246105835\n", + " Iterations: 8\n", + " Function evaluations: 48\n", + " Gradient evaluations: 8\n", + "Result at iter 4: -5.6111067246105835\n", + "Iter: 5\n", + "Maximum gradient: 0.085286662389115\n", + "Operator: SparsePauliOp(['YZZZYXZZYI', 'XZZZYYZZYI', 'XZZZXXZZYI', 'YZZZXYZZYI', 'XZZZYXZZXI', 'YZZZYYZZXI', 'YZZZXXZZXI', 'XZZZXYZZXI'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 47\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.46383951373802\n", + " Iterations: 33\n", + " Function evaluations: 243\n", + " Gradient evaluations: 33\n", + "Result at iter 5: -5.46383951373802\n", + "Iter: 6\n", + "Maximum gradient: 0.0534286166603873\n", + "Operator: SparsePauliOp(['IIYYIIIXYI', 'IIXYIIIYYI', 'IIXXIIIXYI', 'IIYXIIIYYI', 'IIXYIIIXXI', 'IIYYIIIYXI', 'IIYXIIIXXI', 'IIXXIIIYXI'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 36\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.6095832248433535\n", + " Iterations: 27\n", + " Function evaluations: 219\n", + " Gradient evaluations: 27\n", + "Result at iter 6: -5.6095832248433535\n", + "Iter: 7\n", + "Maximum gradient: 0.08838249655239569\n", + "Operator: SparsePauliOp(['XZZYIIIIII', 'YZZXIIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 11\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.596307498372947\n", + " Iterations: 31\n", + " Function evaluations: 290\n", + " Gradient evaluations: 31\n", + "Result at iter 7: -5.596307498372947\n", + "Iter: 8\n", + "Maximum gradient: 0.18563356064787884\n", + "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 2\n", + "Iteration limit reached (Exit mode 9)\n", + " Current function value: -5.613222522794777\n", + " Iterations: 50\n", + " Function evaluations: 506\n", + " Gradient evaluations: 50\n", + "Result at iter 8: -5.613222522794777\n", + "Iter: 9\n", + "Maximum gradient: 0.1081115913882267\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 29\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.6147891313592915\n", + " Iterations: 38\n", + " Function evaluations: 424\n", + " Gradient evaluations: 38\n", + "Result at iter 9: -5.6147891313592915\n", + "Iter: 10\n", + "Maximum gradient: 0.11693575049004674\n", + "Operator: SparsePauliOp(['YZZYIXZZZY', 'XZZYIYZZZY', 'XZZXIXZZZY', 'YZZXIYZZZY', 'XZZYIXZZZX', 'YZZYIYZZZX', 'YZZXIXZZZX', 'XZZXIYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 32\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.620018276708998\n", + " Iterations: 43\n", + " Function evaluations: 523\n", + " Gradient evaluations: 43\n", + "Result at iter 10: -5.620018276708998\n", + "Iter: 11\n", + "Maximum gradient: 0.05020975876455552\n", + "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 14\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.47602247370904\n", + " Iterations: 36\n", + " Function evaluations: 474\n", + " Gradient evaluations: 36\n", + "Result at iter 11: -5.47602247370904\n", + "Iter: 12\n", + "Maximum gradient: 0.041370697521550454\n", + "Operator: SparsePauliOp(['IYZYIIXZYI', 'IXZYIIYZYI', 'IXZXIIXZYI', 'IYZXIIYZYI', 'IXZYIIXZXI', 'IYZYIIYZXI', 'IYZXIIXZXI', 'IXZXIIYZXI'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 43\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.606529759551997\n", + " Iterations: 35\n", + " Function evaluations: 498\n", + " Gradient evaluations: 35\n", + "Result at iter 12: -5.606529759551997\n", + "Iter: 13\n", + "Maximum gradient: 0.0950683034684355\n", + "Operator: SparsePauliOp(['IIIIIXZZYI', 'IIIIIYZZXI'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 5\n", + "Iteration limit reached (Exit mode 9)\n", + " Current function value: -5.587383353624025\n", + " Iterations: 50\n", + " Function evaluations: 754\n", + " Gradient evaluations: 50\n", + "Result at iter 13: -5.587383353624025\n", + "Iter: 14\n", + "Maximum gradient: 0.2015978680722992\n", + "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 2\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[23], line 31\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;66;03m# Run VQE on the current ansatz\u001b[39;00m\n\u001b[1;32m 30\u001b[0m x0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mpi \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandom(ansatz\u001b[38;5;241m.\u001b[39mnum_parameters)\n\u001b[0;32m---> 31\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mminimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcost_func\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mansatz\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mH\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mslsqp\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmaxiter\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m50\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdisp\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mResult at iter \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28miter\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mgetattr\u001b[39m(res,\u001b[38;5;250m \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfun\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 33\u001b[0m x_opt \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(res, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_minimize.py:722\u001b[0m, in \u001b[0;36mminimize\u001b[0;34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[0m\n\u001b[1;32m 719\u001b[0m res \u001b[38;5;241m=\u001b[39m _minimize_cobyla(fun, x0, args, constraints, callback\u001b[38;5;241m=\u001b[39mcallback,\n\u001b[1;32m 720\u001b[0m bounds\u001b[38;5;241m=\u001b[39mbounds, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions)\n\u001b[1;32m 721\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m meth \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mslsqp\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 722\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43m_minimize_slsqp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjac\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbounds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 723\u001b[0m \u001b[43m \u001b[49m\u001b[43mconstraints\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallback\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallback\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 724\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m meth \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrust-constr\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m 725\u001b[0m res \u001b[38;5;241m=\u001b[39m _minimize_trustregion_constr(fun, x0, args, jac, hess, hessp,\n\u001b[1;32m 726\u001b[0m bounds, constraints,\n\u001b[1;32m 727\u001b[0m callback\u001b[38;5;241m=\u001b[39mcallback, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions)\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_slsqp_py.py:441\u001b[0m, in \u001b[0;36m_minimize_slsqp\u001b[0;34m(func, x0, args, jac, bounds, constraints, maxiter, ftol, iprint, disp, eps, callback, finite_diff_rel_step, **unknown_options)\u001b[0m\n\u001b[1;32m 438\u001b[0m c \u001b[38;5;241m=\u001b[39m _eval_constraint(x, cons)\n\u001b[1;32m 440\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m: \u001b[38;5;66;03m# gradient evaluation required\u001b[39;00m\n\u001b[0;32m--> 441\u001b[0m g \u001b[38;5;241m=\u001b[39m append(\u001b[43mwrapped_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;241m0.0\u001b[39m)\n\u001b[1;32m 442\u001b[0m a \u001b[38;5;241m=\u001b[39m _eval_con_normals(x, cons, la, n, m, meq, mieq)\n\u001b[1;32m 444\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m majiter \u001b[38;5;241m>\u001b[39m majiter_prev:\n\u001b[1;32m 445\u001b[0m \u001b[38;5;66;03m# call callback if major iteration has incremented\u001b[39;00m\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_optimize.py:416\u001b[0m, in \u001b[0;36m_clip_x_for_func..eval\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 414\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21meval\u001b[39m(x):\n\u001b[1;32m 415\u001b[0m x \u001b[38;5;241m=\u001b[39m _check_clip_x(x, bounds)\n\u001b[0;32m--> 416\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:284\u001b[0m, in \u001b[0;36mScalarFunction.grad\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39marray_equal(x, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mx):\n\u001b[1;32m 283\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_update_x_impl(x)\n\u001b[0;32m--> 284\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 285\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:267\u001b[0m, in \u001b[0;36mScalarFunction._update_grad\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 265\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_update_grad\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg_updated:\n\u001b[0;32m--> 267\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_grad_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg_updated \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:181\u001b[0m, in \u001b[0;36mScalarFunction.__init__..update_grad\u001b[0;34m()\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_update_fun()\n\u001b[1;32m 180\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mngev \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m--> 181\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg \u001b[38;5;241m=\u001b[39m \u001b[43mapprox_derivative\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun_wrapped\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf0\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfinite_diff_options\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_numdiff.py:519\u001b[0m, in \u001b[0;36mapprox_derivative\u001b[0;34m(fun, x0, method, rel_step, abs_step, f0, bounds, sparsity, as_linear_operator, args, kwargs)\u001b[0m\n\u001b[1;32m 516\u001b[0m use_one_sided \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 518\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m sparsity \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 519\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_dense_difference\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun_wrapped\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mh\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 520\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_one_sided\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 521\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m issparse(sparsity) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(sparsity) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_numdiff.py:590\u001b[0m, in \u001b[0;36m_dense_difference\u001b[0;34m(fun, x0, f0, h, use_one_sided, method)\u001b[0m\n\u001b[1;32m 588\u001b[0m x \u001b[38;5;241m=\u001b[39m x0 \u001b[38;5;241m+\u001b[39m h_vecs[i]\n\u001b[1;32m 589\u001b[0m dx \u001b[38;5;241m=\u001b[39m x[i] \u001b[38;5;241m-\u001b[39m x0[i] \u001b[38;5;66;03m# Recompute dx as exactly representable number.\u001b[39;00m\n\u001b[0;32m--> 590\u001b[0m df \u001b[38;5;241m=\u001b[39m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m-\u001b[39m f0\n\u001b[1;32m 591\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m method \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3-point\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m use_one_sided[i]:\n\u001b[1;32m 592\u001b[0m x1 \u001b[38;5;241m=\u001b[39m x0 \u001b[38;5;241m+\u001b[39m h_vecs[i]\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_numdiff.py:470\u001b[0m, in \u001b[0;36mapprox_derivative..fun_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 467\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m xp\u001b[38;5;241m.\u001b[39misdtype(x\u001b[38;5;241m.\u001b[39mdtype, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreal floating\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 468\u001b[0m x \u001b[38;5;241m=\u001b[39m xp\u001b[38;5;241m.\u001b[39mastype(x, x0\u001b[38;5;241m.\u001b[39mdtype)\n\u001b[0;32m--> 470\u001b[0m f \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39matleast_1d(\u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 471\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m f\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 472\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`fun` return value has \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 473\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmore than 1 dimension.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:145\u001b[0m, in \u001b[0;36mScalarFunction.__init__..fun_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnfev \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 142\u001b[0m \u001b[38;5;66;03m# Send a copy because the user may overwrite it.\u001b[39;00m\n\u001b[1;32m 143\u001b[0m \u001b[38;5;66;03m# Overwriting results in undefined behaviour because\u001b[39;00m\n\u001b[1;32m 144\u001b[0m \u001b[38;5;66;03m# fun(self.x) will change self.x, with the two no longer linked.\u001b[39;00m\n\u001b[0;32m--> 145\u001b[0m fx \u001b[38;5;241m=\u001b[39m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 146\u001b[0m \u001b[38;5;66;03m# Make sure the function returns a true scalar\u001b[39;00m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39misscalar(fx):\n", + "Cell \u001b[0;32mIn[15], line 2\u001b[0m, in \u001b[0;36mcost_func\u001b[0;34m(params, ansatz, H, estimator)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcost_func\u001b[39m(params, ansatz, H, estimator):\n\u001b[0;32m----> 2\u001b[0m energy \u001b[38;5;241m=\u001b[39m \u001b[43mestimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mansatz\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mH\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameter_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mvalues[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m energy\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/primitives/primitive_job.py:55\u001b[0m, in \u001b[0;36mPrimitiveJob.result\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Return the results of the job.\"\"\"\u001b[39;00m\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_submitted()\n\u001b[0;32m---> 55\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_future\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/concurrent/futures/_base.py:453\u001b[0m, in \u001b[0;36mFuture.result\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 450\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_state \u001b[38;5;241m==\u001b[39m FINISHED:\n\u001b[1;32m 451\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__get_result()\n\u001b[0;32m--> 453\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_condition\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 455\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_state \u001b[38;5;129;01min\u001b[39;00m [CANCELLED, CANCELLED_AND_NOTIFIED]:\n\u001b[1;32m 456\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m CancelledError()\n", + "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/threading.py:320\u001b[0m, in \u001b[0;36mCondition.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m: \u001b[38;5;66;03m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[39;00m\n\u001b[1;32m 319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 320\u001b[0m \u001b[43mwaiter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43macquire\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 321\u001b[0m gotit \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 322\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# Define the conditions for termination\n", + "gradient_threshold = 1e-3\n", + "max_iter = 10\n", + "terminate = False\n", + "\n", + "# Initiate the problem\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "excitation_pool = ucc.operators # TODO\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "params = None\n", + "\n", + "iter = 0\n", + "operator_list = []\n", + "while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, 'x')\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " terminate = True\n", + " \n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/quantum_enablement/tutorials/adapt-vqe-draft.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft.ipynb deleted file mode 100644 index a0fcd94..0000000 --- a/quantum_enablement/tutorials/adapt-vqe-draft.ipynb +++ /dev/null @@ -1,799 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit ADAPT-VQE tutorial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the molecule\n", - "We start by defining the molecule using ``pyscf``. As an example we select the $H_2$ molecule and build it by providing its geometry.\n", - "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyscf import ao2mo, gto, mcscf, scf\n", - "\n", - "distance = 0.735\n", - "a = distance / 2\n", - "mol = gto.Mole()\n", - "mol.build(\n", - " verbose=0,\n", - " atom=[\n", - " [\"H\", (0, 0, -a)],\n", - " [\"H\", (0, 0, a)],\n", - " ],\n", - " basis=\"sto-6g\",\n", - " spin=0,\n", - " charge=0,\n", - " symmetry=\"Dooh\",\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nuclear energy: 0.7199689944489797\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", - " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Electronic energy: -1.8455976628764188\n", - "Total energy: -1.125628668427439\n", - "Total energy - nuclear energy: -1.8455976628764188\n" - ] - } - ], - "source": [ - "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", - "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", - "print(f\"Total energy: {mol.energy_tot()}\")\n", - "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "range(0, 2)\n" - ] - } - ], - "source": [ - "active_space = range(mol.nelectron // 2 - 1, mol.nelectron // 2 + 1)\n", - "print(active_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate the fermionic Hamiltonian\n", - "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "mf = scf.RHF(mol)\n", - "E1 = mf.kernel()\n", - "mx = mcscf.CASCI(mf, ncas=2, nelecas=(1, 1))\n", - "mo = mx.sort_mo(active_space, base=0)\n", - "E2 = mx.kernel(mo)[:2]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "h1e, ecore = mx.get_h1eff()\n", - "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Map the fermionic Hamiltonian to a qubit operator\n", - "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", - "\n", - "import numpy as np\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "\n", - "\n", - "def cholesky(V, eps):\n", - " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", - " # see https://arxiv.org/abs/1808.02625\n", - " # see https://arxiv.org/abs/2104.08957\n", - " no = V.shape[0]\n", - " chmax, ng = 20 * no, 0\n", - " W = V.reshape(no**2, no**2)\n", - " L = np.zeros((no**2, chmax))\n", - " Dmax = np.diagonal(W).copy()\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " while vmax > eps:\n", - " L[:, ng] = W[:, nu_max]\n", - " if ng > 0:\n", - " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", - " L[:, ng] /= np.sqrt(vmax)\n", - " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", - " ng += 1\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " L = L[:, :ng].reshape((no, no, ng))\n", - " print(\n", - " \"accuracy of Cholesky decomposition \",\n", - " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", - " )\n", - " return L, ng\n", - "\n", - "\n", - "def identity(n):\n", - " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", - "\n", - "\n", - "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", - " c_list = []\n", - " if mapping == \"jordan_wigner\":\n", - " for p in range(n):\n", - " if p == 0:\n", - " l, r = \"I\" * (n - 1), \"\"\n", - " elif p == n - 1:\n", - " l, r = \"\", \"Z\" * (n - 1)\n", - " else:\n", - " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", - " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, 0.5j)])\n", - " c_list.append(cp)\n", - " else:\n", - " raise ValueError(\"Unsupported mapping.\")\n", - " d_list = [cp.adjoint() for cp in c_list]\n", - " return c_list, d_list\n", - "\n", - "\n", - "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", - " ncas, _ = h1e.shape\n", - "\n", - " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", - " Exc = []\n", - " for p in range(ncas):\n", - " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", - " for r in range(p + 1, ncas):\n", - " Excp.append(\n", - " C[p] @ D[r]\n", - " + C[ncas + p] @ D[ncas + r]\n", - " + C[r] @ D[p]\n", - " + C[ncas + r] @ D[ncas + p]\n", - " )\n", - " Exc.append(Excp)\n", - "\n", - " # low-rank decomposition of the Hamiltonian\n", - " Lop, ng = cholesky(h2e, 1e-6)\n", - " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", - "\n", - " H = ecore * identity(2 * ncas)\n", - " # one-body term\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " H += t1e[p, r] * Exc[p][r - p]\n", - " # two-body term\n", - " for g in range(ng):\n", - " Lg = 0 * identity(2 * ncas)\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " Lg += Lop[p, r, g] * Exc[p][r - p]\n", - " H += 0.5 * Lg @ Lg\n", - "\n", - " return H.chop().simplify()" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "accuracy of Cholesky decomposition 6.655392125243921e-17\n", - "SparsePauliOp(['IIII', 'IIIZ', 'IZII', 'IIZI', 'ZIII', 'IZIZ', 'IIZZ', 'ZIIZ', 'IZZI', 'ZZII', 'ZIZI', 'YYYY', 'XXYY', 'YYXX', 'XXXX'],\n", - " coeffs=[-0.09820182+0.j, -0.1740751 +0.j, -0.1740751 +0.j, 0.2242933 +0.j,\n", - " 0.2242933 +0.j, 0.16891402+0.j, 0.1210099 +0.j, 0.16631441+0.j,\n", - " 0.16631441+0.j, 0.1210099 +0.j, 0.17504456+0.j, 0.04530451+0.j,\n", - " 0.04530451+0.j, 0.04530451+0.j, 0.04530451+0.j])\n" - ] - } - ], - "source": [ - "H = build_hamiltonian(ecore, h1e, h2e)\n", - "print(H)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Outline of the ADAPT-VQE algorithm\n", - "https://arxiv.org/abs/1812.11173 \n", - "\n", - "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", - "\n", - "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", - "\n", - "3. Define the following conditions for termination: CONVERGED, CYCLICITY, MAXIMUM.\n", - " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", - " - CYCLICITY: Aborted due to a cyclic selection of evolution operators.\n", - " - MAXIMUM: Maximum number of iterations reached.\n", - " \n", - "4. while not TERMINATE (CONVERGED or CYCLICITY or MAXIMUM):\n", - " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", - " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", - " - Run VQE over all parameters $\\theta_i$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initial state\n", - "We initate the quantum computer to the Hartree-Fock state." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", - " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", - "\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - "\n", - " Returns:\n", - " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", - "\n", - " Raises:\n", - " ValueError: If the total number of particles is larger than the number of orbitals.\n", - " \"\"\"\n", - " # validate the input\n", - " assert num_spatial_orbitals >= 1\n", - " num_alpha, num_beta = num_particles\n", - "\n", - " if any(n > num_spatial_orbitals for n in num_particles):\n", - " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", - "\n", - " half_orbitals = num_spatial_orbitals\n", - " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", - " bitstr[:num_alpha] = True\n", - " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", - "\n", - " return bitstr.tolist()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "num_spatial_orbitals = mol.nao\n", - "num_particles = mol.nelec\n", - "\n", - "# Get the Hartree-Fock initial state in bitsting representation\n", - "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", - "\n", - "# Get the corresponding circuit in Jordan-Wigner transform\n", - "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", - "for i, hf_bit in enumerate(hf_bitstring):\n", - " if hf_bit:\n", - " hf_circuit.x(i)\n", - "\n", - "hf_circuit.draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operator pool\n", - "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[SparsePauliOp(['IIXY', 'IIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['XYII', 'YXII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j])]\n" - ] - } - ], - "source": [ - "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", - "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", - "\n", - "qubit_mapper = JordanWignerMapper()\n", - "\n", - "# Define the pool of operators as those generated by the UCC ansatz\n", - "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", - "excitation_pool = ucc.operators # TODO\n", - "print(excitation_pool)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Gradient of the excitation operators\n", - "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. Note that the following computation requires the operators from the pool to be anti-Hermitian, and should be replaced with an appropriate alternative method if this is not the case." - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", - " \"\"\"\n", - " Computes the gradients for all available excitation operators.\n", - " Args:\n", - " ansatz: ansatz built so far.\n", - " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", - " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", - " estimator: an instance of the Qiskit Estimator primitive\n", - " params: parameters to be assigned to the ansatz, if any.\n", - " Returns:\n", - " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", - " \"\"\"\n", - " # The excitations operators are applied later as exp(i*theta*excitation).\n", - " # For this commutator, we need to explicitly pull in the imaginary phase.\n", - " if params is not None:\n", - " ansatz_opt = ansatz.assign_parameters(params)\n", - " else:\n", - " ansatz_opt = ansatz\n", - " commutators = [(hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", - " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", - " gradients = estimator.run(ansatz_list, commutators).result().values\n", - "\n", - " return gradients" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.+0.j 0.+0.j 0.+0.36243609j]\n", - "SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j])\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "from qiskit.primitives import Estimator\n", - "\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(gradients)\n", - "max_operator = excitation_pool[max_index]\n", - "print(max_operator)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Expand the Ansatz\n", - "We found that the third operator in the pool, which is the double-excitation operator in this case, has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` for small problems." - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import MatrixExponential, SuzukiTrotter, LieTrotter\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", - "ansatz.decompose().draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run VQE\n", - "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [], - "source": [ - "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", - " return energy" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1.86454711]\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -1.1459778377914749\n", - " x: [ 1.683e+00]\n", - " nfev: 22\n", - " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 22 F =-1.145978E+00 MAXCV = 0.000000E+00\n", - " X = 1.682718E+00\n", - "\n", - "-1.8659468322404544\n" - ] - } - ], - "source": [ - "from scipy.optimize import minimize\n", - "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "nuclear_repulsion = mol.energy_nuc()\n", - "electron_energy = getattr(res, 'fun') - nuclear_repulsion\n", - "print(electron_energy)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1.68274281]\n" - ] - } - ], - "source": [ - "# Optimal parameters so far\n", - "x_opt = getattr(res, 'x')\n", - "print(x_opt)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another iteration of the algorithm\n", - "We now compute the gradients again to see if we need another iteration." - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-1.54074396e-32-1.37268649e-16j -8.47409176e-33-2.04540239e-16j\n", - " 6.00890143e-32+4.04451708e-04j]\n", - "Found maximum gradient 0.00040445170842217 at index 2\n", - "Maximum gradient is below the threshold: True\n" - ] - } - ], - "source": [ - "gradient_threshold = 1e-3\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(gradients)\n", - "\n", - "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", - "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since the maximum gradient is below the threshold, we do not append another operator to the ansatz, and the algorithm terminates." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Putting it all together\n", - "Now we automate the algorithm in a single loop." - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 24 F =-1.145978E+00 MAXCV = 0.000000E+00\n", - " X = 4.824114E+00\n", - "Electron energy: -1.8659468327452657\n" - ] - } - ], - "source": [ - "# Define the conditions for termination\n", - "gradient_threshold = 1e-3\n", - "cyclic = False # TODO\n", - "max_iter = 10\n", - "terminate = False\n", - "\n", - "# Initiate the problem\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "excitation_pool = ucc.operators # TODO\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "params = None\n", - "\n", - "iter = 0\n", - "operator_list = []\n", - "while not terminate:\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(gradients)\n", - " max_operator = excitation_pool[max_index]\n", - " # Terminate if the operators are cyclic\n", - " if cyclic: # TODO\n", - " terminate = True \n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - " x_opt = getattr(res, 'x')\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " terminate = True\n", - " \n", - "nuclear_repulsion = mol.energy_nuc()\n", - "electron_energy = getattr(res, 'fun') - nuclear_repulsion\n", - "print(f\"Electron energy:\", electron_energy)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "quantum", - "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.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 333fb4044a1e36d26d16eb2d353fbf020fe65b39 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Wed, 21 Feb 2024 04:11:06 +0300 Subject: [PATCH 04/17] add LiH example first draft --- .../tutorials/adapt-vqe-draft-LiH.ipynb | 308 +++++++----------- 1 file changed, 119 insertions(+), 189 deletions(-) diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb index bc89972..7635872 100644 --- a/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -98,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -116,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -214,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -241,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -291,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -333,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -351,7 +351,7 @@ "
" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -384,7 +384,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -417,7 +417,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -456,7 +456,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -504,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -522,7 +522,7 @@ "
" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -552,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -563,7 +563,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -585,14 +585,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[2.03535564]\n" + "[6.02213084]\n" ] } ], @@ -611,7 +611,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -621,16 +621,16 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -4.9237835278935576\n", - " x: [ 1.883e+00]\n", - " nfev: 22\n", + " fun: -4.923783523364006\n", + " x: [ 5.025e+00]\n", + " nfev: 21\n", " maxcv: 0.0\n", "\n", - "Found ground energy: -4.9237835278935576, exact energy: -7.646812245579224, difference: 2.7230287176856667\n", + "Found ground energy: -4.923783523364006, exact energy: -7.646812245579224, difference: 2.7230287222152185\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 22 F =-4.923784E+00 MAXCV = 0.000000E+00\n", - " X = 1.883200E+00\n" + " NFVALS = 21 F =-4.923784E+00 MAXCV = 0.000000E+00\n", + " X = 5.024761E+00\n" ] } ], @@ -655,14 +655,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[1.88320018]\n" + "[5.02476053]\n" ] } ], @@ -682,28 +682,28 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00000000e+00 0.00000000e+00 1.13378270e-04 0.00000000e+00\n", - " 0.00000000e+00 -3.52174396e-02 0.00000000e+00 0.00000000e+00\n", - " -2.30153061e-01 0.00000000e+00 0.00000000e+00 -1.12519121e-01\n", - " 0.00000000e+00 0.00000000e+00 1.13947934e-03 0.00000000e+00\n", - " 0.00000000e+00 1.04682381e-03 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 1.13947934e-03 0.00000000e+00\n", - " 0.00000000e+00 1.04682381e-03 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 8.63356013e-02 0.00000000e+00 0.00000000e+00\n", - " 2.85501592e-02 -4.09301450e-02 0.00000000e+00 0.00000000e+00\n", + "[ 0.00000000e+00 0.00000000e+00 1.56651207e-04 0.00000000e+00\n", + " 0.00000000e+00 -3.52131951e-02 0.00000000e+00 0.00000000e+00\n", + " -2.30166573e-01 0.00000000e+00 0.00000000e+00 -1.12516025e-01\n", + " 0.00000000e+00 0.00000000e+00 1.14001307e-03 0.00000000e+00\n", + " 0.00000000e+00 1.04716987e-03 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 1.14001307e-03 0.00000000e+00\n", + " 0.00000000e+00 1.04716987e-03 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 8.63302657e-02 0.00000000e+00 0.00000000e+00\n", + " 2.85469220e-02 -4.09301450e-02 0.00000000e+00 0.00000000e+00\n", " -8.72968838e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", " -4.09301450e-02 0.00000000e+00 0.00000000e+00 -8.72968838e-02\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 -9.55896595e-03\n", - " 0.00000000e+00 0.00000000e+00 -3.52730485e-03 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 -9.55865762e-03\n", + " 0.00000000e+00 0.00000000e+00 -3.52638828e-03 0.00000000e+00\n", " 0.00000000e+00 0.00000000e+00]\n", - "Found maximum gradient 0.23015306140726227 at index 8\n", + "Found maximum gradient 0.23016657332645868 at index 8\n", "Maximum gradient is below the threshold: False\n" ] } @@ -730,7 +730,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -748,7 +748,7 @@ "
" ] }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -765,27 +765,27 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0.44339671 0.04100537]\n", + "[6.19409048 0.7891094 ]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -5.433843342342847\n", - " x: [ 1.817e+00 1.817e+00]\n", - " nfev: 34\n", + " fun: -5.433843336865546\n", + " x: [ 4.959e+00 1.817e+00]\n", + " nfev: 44\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 34 F =-5.433843E+00 MAXCV = 0.000000E+00\n", - " X = 1.817188E+00 1.817200E+00\n", + " NFVALS = 44 F =-5.433843E+00 MAXCV = 0.000000E+00\n", + " X = 4.958797E+00 1.817251E+00\n", "\n", - "Found ground energy: -5.433843342342847, exact energy: -7.646812245579224, difference: 2.2129689032363773\n" + "Found ground energy: -5.433843336865546, exact energy: -7.646812245579224, difference: 2.2129689087136786\n" ] } ], @@ -812,7 +812,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -824,178 +824,108 @@ "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 2\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -4.923783304405997\n", + " Current function value: -4.923783532820581\n", " Iterations: 3\n", - " Function evaluations: 8\n", + " Function evaluations: 7\n", " Gradient evaluations: 3\n", - "Result at iter 0: -4.923783304405997\n", + "Result at iter 0: -4.923783532820581\n", "Iter: 1\n", - "Maximum gradient: 0.22987808370878116\n", + "Maximum gradient: 0.2301214121960488\n", "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.433843335377542\n", - " Iterations: 6\n", - " Function evaluations: 19\n", - " Gradient evaluations: 6\n", - "Result at iter 1: -5.433843335377542\n", + " Current function value: -5.433843344005466\n", + " Iterations: 7\n", + " Function evaluations: 21\n", + " Gradient evaluations: 7\n", + "Result at iter 1: -5.433843344005466\n", "Iter: 2\n", - "Maximum gradient: 0.17401184266509448\n", + "Maximum gradient: 0.1740084374703947\n", "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 29\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.441845269731562\n", - " Iterations: 14\n", - " Function evaluations: 59\n", - " Gradient evaluations: 14\n", - "Result at iter 2: -5.441845269731562\n", + " Current function value: -5.441845141112326\n", + " Iterations: 13\n", + " Function evaluations: 56\n", + " Gradient evaluations: 13\n", + "Result at iter 2: -5.441845141112326\n", "Iter: 3\n", - "Maximum gradient: 0.08729688376396207\n", + "Maximum gradient: 0.08729688376396214\n", "Operator: SparsePauliOp(['IIYYIIIXYI', 'IIXYIIIYYI', 'IIXXIIIXYI', 'IIYXIIIYYI', 'IIXYIIIXXI', 'IIYYIIIYXI', 'IIYXIIIXXI', 'IIXXIIIYXI'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 36\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.605545493042757\n", + " Current function value: -5.605545082186456\n", " Iterations: 11\n", - " Function evaluations: 59\n", + " Function evaluations: 60\n", " Gradient evaluations: 11\n", - "Result at iter 3: -5.605545493042757\n", + "Result at iter 3: -5.605545082186456\n", "Iter: 4\n", - "Maximum gradient: 0.09489516148503484\n", - "Operator: SparsePauliOp(['IIIIIXZZYI', 'IIIIIYZZXI'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 5\n", + "Maximum gradient: 0.09496027998502402\n", + "Operator: SparsePauliOp(['XZZYIIIIII', 'YZZXIIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.6111067246105835\n", - " Iterations: 8\n", - " Function evaluations: 48\n", - " Gradient evaluations: 8\n", - "Result at iter 4: -5.6111067246105835\n", + " Current function value: -5.611106832114836\n", + " Iterations: 12\n", + " Function evaluations: 75\n", + " Gradient evaluations: 12\n", + "Result at iter 4: -5.611106832114836\n", "Iter: 5\n", - "Maximum gradient: 0.085286662389115\n", - "Operator: SparsePauliOp(['YZZZYXZZYI', 'XZZZYYZZYI', 'XZZZXXZZYI', 'YZZZXYZZYI', 'XZZZYXZZXI', 'YZZZYYZZXI', 'YZZZXXZZXI', 'XZZZXYZZXI'],\n", + "Maximum gradient: 0.08516009231217672\n", + "Operator: SparsePauliOp(['YZZYIXZZZY', 'XZZYIYZZZY', 'XZZXIXZZZY', 'YZZXIYZZZY', 'XZZYIXZZZX', 'YZZYIYZZZX', 'YZZXIXZZZX', 'XZZXIYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 47\n", + " 0.125+0.j, 0.125+0.j]) at index 32\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.46383951373802\n", + " Current function value: -5.613187854614306\n", " Iterations: 33\n", - " Function evaluations: 243\n", + " Function evaluations: 248\n", " Gradient evaluations: 33\n", - "Result at iter 5: -5.46383951373802\n", + "Result at iter 5: -5.613187854614306\n", "Iter: 6\n", - "Maximum gradient: 0.0534286166603873\n", + "Maximum gradient: 0.07890391790336519\n", + "Operator: SparsePauliOp(['IIIIIXZZYI', 'IIIIIYZZXI'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 5\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -5.476360123617924\n", + " Iterations: 20\n", + " Function evaluations: 161\n", + " Gradient evaluations: 20\n", + "Result at iter 6: -5.476360123617924\n", + "Iter: 7\n", + "Maximum gradient: 0.04230738432879399\n", "Operator: SparsePauliOp(['IIYYIIIXYI', 'IIXYIIIYYI', 'IIXXIIIXYI', 'IIYXIIIYYI', 'IIXYIIIXXI', 'IIYYIIIYXI', 'IIYXIIIXXI', 'IIXXIIIYXI'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 36\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.6095832248433535\n", - " Iterations: 27\n", - " Function evaluations: 219\n", - " Gradient evaluations: 27\n", - "Result at iter 6: -5.6095832248433535\n", - "Iter: 7\n", - "Maximum gradient: 0.08838249655239569\n", - "Operator: SparsePauliOp(['XZZYIIIIII', 'YZZXIIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 11\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.596307498372947\n", - " Iterations: 31\n", - " Function evaluations: 290\n", - " Gradient evaluations: 31\n", - "Result at iter 7: -5.596307498372947\n", + " Current function value: -5.617043472544331\n", + " Iterations: 47\n", + " Function evaluations: 428\n", + " Gradient evaluations: 47\n", + "Result at iter 7: -5.617043472544331\n", "Iter: 8\n", - "Maximum gradient: 0.18563356064787884\n", - "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 2\n", - "Iteration limit reached (Exit mode 9)\n", - " Current function value: -5.613222522794777\n", - " Iterations: 50\n", - " Function evaluations: 506\n", - " Gradient evaluations: 50\n", - "Result at iter 8: -5.613222522794777\n", - "Iter: 9\n", - "Maximum gradient: 0.1081115913882267\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 29\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.6147891313592915\n", - " Iterations: 38\n", - " Function evaluations: 424\n", - " Gradient evaluations: 38\n", - "Result at iter 9: -5.6147891313592915\n", - "Iter: 10\n", - "Maximum gradient: 0.11693575049004674\n", - "Operator: SparsePauliOp(['YZZYIXZZZY', 'XZZYIYZZZY', 'XZZXIXZZZY', 'YZZXIYZZZY', 'XZZYIXZZZX', 'YZZYIYZZZX', 'YZZXIXZZZX', 'XZZXIYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 32\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.620018276708998\n", - " Iterations: 43\n", - " Function evaluations: 523\n", - " Gradient evaluations: 43\n", - "Result at iter 10: -5.620018276708998\n", - "Iter: 11\n", - "Maximum gradient: 0.05020975876455552\n", - "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + "Maximum gradient: 0.08671927407648883\n", + "Operator: SparsePauliOp(['YZZYIXZZYI', 'XZZYIYZZYI', 'XZZXIXZZYI', 'YZZXIYZZYI', 'XZZYIXZZXI', 'YZZYIYZZXI', 'YZZXIXZZXI', 'XZZXIYZZXI'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 14\n", + " 0.125+0.j, 0.125+0.j]) at index 50\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.47602247370904\n", - " Iterations: 36\n", - " Function evaluations: 474\n", - " Gradient evaluations: 36\n", - "Result at iter 11: -5.47602247370904\n", - "Iter: 12\n", - "Maximum gradient: 0.041370697521550454\n", - "Operator: SparsePauliOp(['IYZYIIXZYI', 'IXZYIIYZYI', 'IXZXIIXZYI', 'IYZXIIYZYI', 'IXZYIIXZXI', 'IYZYIIYZXI', 'IYZXIIXZXI', 'IXZXIIYZXI'],\n", + " Current function value: -5.619143389628584\n", + " Iterations: 49\n", + " Function evaluations: 496\n", + " Gradient evaluations: 49\n", + "Result at iter 8: -5.619143389628584\n", + "Iter: 9\n", + "Maximum gradient: 0.08597224074262962\n", + "Operator: SparsePauliOp(['YZZZYXZZYI', 'XZZZYYZZYI', 'XZZZXXZZYI', 'YZZZXYZZYI', 'XZZZYXZZXI', 'YZZZYYZZXI', 'YZZZXXZZXI', 'XZZZXYZZXI'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 43\n", + " 0.125+0.j, 0.125+0.j]) at index 47\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.606529759551997\n", - " Iterations: 35\n", - " Function evaluations: 498\n", - " Gradient evaluations: 35\n", - "Result at iter 12: -5.606529759551997\n", - "Iter: 13\n", - "Maximum gradient: 0.0950683034684355\n", - "Operator: SparsePauliOp(['IIIIIXZZYI', 'IIIIIYZZXI'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 5\n", - "Iteration limit reached (Exit mode 9)\n", - " Current function value: -5.587383353624025\n", - " Iterations: 50\n", - " Function evaluations: 754\n", - " Gradient evaluations: 50\n", - "Result at iter 13: -5.587383353624025\n", - "Iter: 14\n", - "Maximum gradient: 0.2015978680722992\n", - "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 2\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[23], line 31\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;66;03m# Run VQE on the current ansatz\u001b[39;00m\n\u001b[1;32m 30\u001b[0m x0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mpi \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandom(ansatz\u001b[38;5;241m.\u001b[39mnum_parameters)\n\u001b[0;32m---> 31\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mminimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcost_func\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mansatz\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mH\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mslsqp\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmaxiter\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m50\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdisp\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mResult at iter \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28miter\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mgetattr\u001b[39m(res,\u001b[38;5;250m \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfun\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 33\u001b[0m x_opt \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(res, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_minimize.py:722\u001b[0m, in \u001b[0;36mminimize\u001b[0;34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[0m\n\u001b[1;32m 719\u001b[0m res \u001b[38;5;241m=\u001b[39m _minimize_cobyla(fun, x0, args, constraints, callback\u001b[38;5;241m=\u001b[39mcallback,\n\u001b[1;32m 720\u001b[0m bounds\u001b[38;5;241m=\u001b[39mbounds, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions)\n\u001b[1;32m 721\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m meth \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mslsqp\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 722\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43m_minimize_slsqp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjac\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbounds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 723\u001b[0m \u001b[43m \u001b[49m\u001b[43mconstraints\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallback\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallback\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 724\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m meth \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrust-constr\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m 725\u001b[0m res \u001b[38;5;241m=\u001b[39m _minimize_trustregion_constr(fun, x0, args, jac, hess, hessp,\n\u001b[1;32m 726\u001b[0m bounds, constraints,\n\u001b[1;32m 727\u001b[0m callback\u001b[38;5;241m=\u001b[39mcallback, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions)\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_slsqp_py.py:441\u001b[0m, in \u001b[0;36m_minimize_slsqp\u001b[0;34m(func, x0, args, jac, bounds, constraints, maxiter, ftol, iprint, disp, eps, callback, finite_diff_rel_step, **unknown_options)\u001b[0m\n\u001b[1;32m 438\u001b[0m c \u001b[38;5;241m=\u001b[39m _eval_constraint(x, cons)\n\u001b[1;32m 440\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m: \u001b[38;5;66;03m# gradient evaluation required\u001b[39;00m\n\u001b[0;32m--> 441\u001b[0m g \u001b[38;5;241m=\u001b[39m append(\u001b[43mwrapped_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;241m0.0\u001b[39m)\n\u001b[1;32m 442\u001b[0m a \u001b[38;5;241m=\u001b[39m _eval_con_normals(x, cons, la, n, m, meq, mieq)\n\u001b[1;32m 444\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m majiter \u001b[38;5;241m>\u001b[39m majiter_prev:\n\u001b[1;32m 445\u001b[0m \u001b[38;5;66;03m# call callback if major iteration has incremented\u001b[39;00m\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_optimize.py:416\u001b[0m, in \u001b[0;36m_clip_x_for_func..eval\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 414\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21meval\u001b[39m(x):\n\u001b[1;32m 415\u001b[0m x \u001b[38;5;241m=\u001b[39m _check_clip_x(x, bounds)\n\u001b[0;32m--> 416\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:284\u001b[0m, in \u001b[0;36mScalarFunction.grad\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39marray_equal(x, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mx):\n\u001b[1;32m 283\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_update_x_impl(x)\n\u001b[0;32m--> 284\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 285\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:267\u001b[0m, in \u001b[0;36mScalarFunction._update_grad\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 265\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_update_grad\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg_updated:\n\u001b[0;32m--> 267\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_grad_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg_updated \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:181\u001b[0m, in \u001b[0;36mScalarFunction.__init__..update_grad\u001b[0;34m()\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_update_fun()\n\u001b[1;32m 180\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mngev \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m--> 181\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg \u001b[38;5;241m=\u001b[39m \u001b[43mapprox_derivative\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun_wrapped\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf0\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfinite_diff_options\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_numdiff.py:519\u001b[0m, in \u001b[0;36mapprox_derivative\u001b[0;34m(fun, x0, method, rel_step, abs_step, f0, bounds, sparsity, as_linear_operator, args, kwargs)\u001b[0m\n\u001b[1;32m 516\u001b[0m use_one_sided \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 518\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m sparsity \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 519\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_dense_difference\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun_wrapped\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mh\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 520\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_one_sided\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 521\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m issparse(sparsity) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(sparsity) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_numdiff.py:590\u001b[0m, in \u001b[0;36m_dense_difference\u001b[0;34m(fun, x0, f0, h, use_one_sided, method)\u001b[0m\n\u001b[1;32m 588\u001b[0m x \u001b[38;5;241m=\u001b[39m x0 \u001b[38;5;241m+\u001b[39m h_vecs[i]\n\u001b[1;32m 589\u001b[0m dx \u001b[38;5;241m=\u001b[39m x[i] \u001b[38;5;241m-\u001b[39m x0[i] \u001b[38;5;66;03m# Recompute dx as exactly representable number.\u001b[39;00m\n\u001b[0;32m--> 590\u001b[0m df \u001b[38;5;241m=\u001b[39m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m-\u001b[39m f0\n\u001b[1;32m 591\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m method \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3-point\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m use_one_sided[i]:\n\u001b[1;32m 592\u001b[0m x1 \u001b[38;5;241m=\u001b[39m x0 \u001b[38;5;241m+\u001b[39m h_vecs[i]\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_numdiff.py:470\u001b[0m, in \u001b[0;36mapprox_derivative..fun_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 467\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m xp\u001b[38;5;241m.\u001b[39misdtype(x\u001b[38;5;241m.\u001b[39mdtype, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreal floating\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 468\u001b[0m x \u001b[38;5;241m=\u001b[39m xp\u001b[38;5;241m.\u001b[39mastype(x, x0\u001b[38;5;241m.\u001b[39mdtype)\n\u001b[0;32m--> 470\u001b[0m f \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39matleast_1d(\u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 471\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m f\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 472\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`fun` return value has \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 473\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmore than 1 dimension.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py:145\u001b[0m, in \u001b[0;36mScalarFunction.__init__..fun_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnfev \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 142\u001b[0m \u001b[38;5;66;03m# Send a copy because the user may overwrite it.\u001b[39;00m\n\u001b[1;32m 143\u001b[0m \u001b[38;5;66;03m# Overwriting results in undefined behaviour because\u001b[39;00m\n\u001b[1;32m 144\u001b[0m \u001b[38;5;66;03m# fun(self.x) will change self.x, with the two no longer linked.\u001b[39;00m\n\u001b[0;32m--> 145\u001b[0m fx \u001b[38;5;241m=\u001b[39m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 146\u001b[0m \u001b[38;5;66;03m# Make sure the function returns a true scalar\u001b[39;00m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39misscalar(fx):\n", - "Cell \u001b[0;32mIn[15], line 2\u001b[0m, in \u001b[0;36mcost_func\u001b[0;34m(params, ansatz, H, estimator)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcost_func\u001b[39m(params, ansatz, H, estimator):\n\u001b[0;32m----> 2\u001b[0m energy \u001b[38;5;241m=\u001b[39m \u001b[43mestimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mansatz\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mH\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameter_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mvalues[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m energy\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/primitives/primitive_job.py:55\u001b[0m, in \u001b[0;36mPrimitiveJob.result\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Return the results of the job.\"\"\"\u001b[39;00m\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_submitted()\n\u001b[0;32m---> 55\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_future\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/concurrent/futures/_base.py:453\u001b[0m, in \u001b[0;36mFuture.result\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 450\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_state \u001b[38;5;241m==\u001b[39m FINISHED:\n\u001b[1;32m 451\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__get_result()\n\u001b[0;32m--> 453\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_condition\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 455\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_state \u001b[38;5;129;01min\u001b[39;00m [CANCELLED, CANCELLED_AND_NOTIFIED]:\n\u001b[1;32m 456\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m CancelledError()\n", - "File \u001b[0;32m/opt/anaconda3/envs/quantum/lib/python3.10/threading.py:320\u001b[0m, in \u001b[0;36mCondition.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m: \u001b[38;5;66;03m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[39;00m\n\u001b[1;32m 319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 320\u001b[0m \u001b[43mwaiter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43macquire\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 321\u001b[0m gotit \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 322\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + " Current function value: -5.6205950479012605\n", + " Iterations: 30\n", + " Function evaluations: 332\n", + " Gradient evaluations: 30\n", + "Result at iter 9: -5.6205950479012605\n", + "Found ground energy: -5.6205950479012605, exact energy: -7.646812245579224, difference: 2.0262171976779637\n" ] } ], From d08caab5d67314f85b722501704afd836afa79ce Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Wed, 21 Feb 2024 21:39:13 +0300 Subject: [PATCH 05/17] add H2 comparison script to debug the Hamiltonian --- .../tutorials/adapt-vqe-draft-H2.ipynb | 102 +-- .../adapt-vqe-draft-H2_compare.ipynb | 593 ++++++++++++++++++ 2 files changed, 651 insertions(+), 44 deletions(-) create mode 100644 quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb index 36a6b7f..6fe212f 100644 --- a/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb @@ -24,7 +24,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -60,10 +60,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Nuclear energy: 0.7199689944489797\n", - "Electronic energy: -1.8455976628764188\n", - "Total energy: -1.125628668427439\n", - "Total energy - nuclear energy: -1.8455976628764188\n" + "Nuclear energy: 0.7199689944489797\n" ] }, { @@ -73,6 +70,15 @@ "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Electronic energy: -1.8455976628764188\n", + "Total energy: -1.125628668427439\n", + "Total energy - nuclear energy: -1.8455976628764188\n" + ] } ], "source": [ @@ -270,14 +276,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "-1.1459778538543868\n" + "Exact ground state: -1.1459778538543897\n" ] } ], @@ -286,7 +292,7 @@ "\n", "exact_solver = NumPyMinimumEigensolver()\n", "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", - "print(exact_result.eigenvalue)" + "print(f\"Exact ground state: {exact_result.eigenvalue}\")" ] }, { @@ -321,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -363,7 +369,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -381,7 +387,7 @@ "
" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -414,7 +420,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -451,7 +457,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -490,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -531,7 +537,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -549,7 +555,7 @@ "
" ] }, - "execution_count": 20, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -579,7 +585,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -590,7 +596,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -601,14 +607,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.44440489]\n" + "[3.22106593]\n" ] } ], @@ -627,7 +633,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -637,16 +643,16 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -1.1459778287234819\n", + " fun: -1.1459778429846779\n", " x: [ 4.824e+00]\n", - " nfev: 22\n", + " nfev: 26\n", " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", "\n", - "Found ground energy: -1.1459778287234819, exact energy: -1.1459778538543868, difference: 2.513090491262915e-08\n", + "Found ground energy: -1.1459778429846779, exact energy: -1.1459778538543897, difference: 1.086971179731222e-08\n", + " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 22 F =-1.145978E+00 MAXCV = 0.000000E+00\n", - " X = 4.824088E+00\n" + " NFVALS = 26 F =-1.145978E+00 MAXCV = 0.000000E+00\n", + " X = 4.824293E+00\n" ] } ], @@ -661,23 +667,16 @@ "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." - ] - }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[4.82408771]\n" + "[4.82429327]\n" ] } ], @@ -697,15 +696,15 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0. 0. 0.00040531]\n", - "Found maximum gradient 0.00040530591672278266 at index 2\n", + "[ 0. 0. -0.00026656]\n", + "Found maximum gradient 0.00026655562367891746 at index 2\n", "Maximum gradient is below the threshold: True\n" ] } @@ -740,19 +739,28 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", + "Iter: 0\n", + "Maximum gradient: 0.362436085015165\n", + "Operator: SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 2\n", + "Result at iter 0: -1.1459778408064227\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 24 F =-1.145978E+00 MAXCV = 0.000000E+00\n", - " X = 4.824100E+00\n", - "Found ground energy: -1.14597783349519, exact energy: -1.1459778538543868, difference: 2.03591967729011e-08\n" + " NFVALS = 22 F =-1.145978E+00 MAXCV = 0.000000E+00\n", + " X = 4.824301E+00\n", + "\n", + "Iter: 1\n", + "Maximum gradient: 0.0002920451757324385\n", + "Terminating: converged\n", + "Found ground energy: -1.1459778408064227, exact energy: -1.1459778538543897, difference: 1.3047966929136123e-08\n" ] } ], @@ -772,27 +780,33 @@ "iter = 0\n", "operator_list = []\n", "while not terminate:\n", + " print(f\"Iter: {iter}\")\n", " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", " # Check convergence\n", " if max_gradient > gradient_threshold:\n", " # Find the operator with the largest gradient\n", " max_index = np.argmax(np.abs(gradients))\n", " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", " # Grow the ansatz\n", " operator_list.append(max_operator)\n", " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", " # Run VQE on the current ansatz\n", " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", " x_opt = getattr(res, 'x')\n", " params = x_opt\n", " # Terminate if maximum number of iterations reached\n", " iter += 1\n", " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration\")\n", " terminate = True\n", " # Terminate if converged\n", " else:\n", + " print(\"Terminating: converged\")\n", " terminate = True\n", " \n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb new file mode 100644 index 0000000..57c1134 --- /dev/null +++ b/quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb @@ -0,0 +1,593 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit ADAPT-VQE tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the molecule\n", + "We start by defining the molecule using ``pyscf``. As an example we select the $H_2$ molecule and build it by providing its geometry.\n", + "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the fermionic Hamiltonian\n", + "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map the fermionic Hamiltonian to a qubit operator\n", + "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exact ground state: -1.857275030202378\n" + ] + } + ], + "source": [ + "from qiskit_nature.second_q.drivers import PySCFDriver\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "from qiskit_nature.units import DistanceUnit\n", + "from qiskit_algorithms import NumPyMinimumEigensolver\n", + "\n", + "driver = PySCFDriver(\n", + " atom=\"H 0 0 0; H 0 0 0.735\",\n", + " basis=\"sto3g\",\n", + " unit=DistanceUnit.ANGSTROM,\n", + ")\n", + "\n", + "# Electronic structure problem\n", + "problem = driver.run()\n", + "\n", + "mapper = JordanWignerMapper()\n", + "\n", + "fermionic_op = problem.hamiltonian.second_q_op()\n", + "qubit_op = mapper.map(fermionic_op)\n", + "H = qubit_op\n", + "\n", + "exact_solver = NumPyMinimumEigensolver()\n", + "exact_result = exact_solver.compute_minimum_eigenvalue(qubit_op)\n", + "print(f\"Exact ground state: {exact_result.eigenvalue}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outline of the ADAPT-VQE algorithm\n", + "https://arxiv.org/abs/1812.11173 \n", + "\n", + "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + "\n", + "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + "\n", + "3. Define the following conditions for termination: CONVERGED, CYCLICITY, MAXIMUM.\n", + " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", + " - CYCLICITY: Aborted due to a cyclic selection of evolution operators.\n", + " - MAXIMUM: Maximum number of iterations reached.\n", + " \n", + "4. while not TERMINATE (CONVERGED or CYCLICITY or MAXIMUM):\n", + " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", + " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", + " - Run VQE over all parameters $\\theta_i$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial state\n", + "We initate the quantum computer to the Hartree-Fock state." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit_nature.second_q.circuit.library import HartreeFock\n", + "\n", + "num_spatial_orbitals = problem.num_spatial_orbitals\n", + "num_particles = problem.num_particles\n", + "\n", + "hf_circuit = HartreeFock(num_spatial_orbitals, num_particles, mapper)\n", + "hf_circuit.draw(output='mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hartree-Fock energy: -1.8369679912029837 is 0.020307038999394234 above the exact ground state.\n" + ] + } + ], + "source": [ + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "hf_energy = estimator.run(hf_circuit, qubit_op).result().values[0]\n", + "print(f\"Hartree-Fock energy: {hf_energy} is {hf_energy - exact_result.eigenvalue} above the exact ground state.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator pool\n", + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[SparsePauliOp(['IIXY', 'IIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['XYII', 'YXII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j])]\n" + ] + } + ], + "source": [ + "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "\n", + "qubit_mapper = JordanWignerMapper()\n", + "\n", + "# Define the pool of operators as those generated by the UCC ansatz\n", + "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", + "excitation_pool = ucc.operators # TODO\n", + "print(excitation_pool)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient of the excitation operators\n", + "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. Note that the following computation requires the operators from the pool to be anti-Hermitian, and should be replaced with an appropriate alternative method if this is not the case." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", + " \"\"\"\n", + " Computes the gradients for all available excitation operators.\n", + " Args:\n", + " ansatz: ansatz built so far.\n", + " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", + " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", + " estimator: an instance of the Qiskit Estimator primitive\n", + " params: parameters to be assigned to the ansatz, if any.\n", + " Returns:\n", + " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", + " \"\"\"\n", + " # The excitations operators are applied later as exp(i*theta*excitation).\n", + " # For this commutator, we need to explicitly pull in the imaginary phase.\n", + " if params is not None:\n", + " ansatz_opt = ansatz.assign_parameters(params)\n", + " else:\n", + " ansatz_opt = ansatz\n", + " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", + " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", + " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", + " gradients = estimator.run(ansatz_list, commutators).result().values\n", + "\n", + " return gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0. 0. -0.3618624]\n", + "Found operator SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.36186239956846256 at index 2.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from qiskit.primitives import Estimator\n", + "\n", + "ansatz = hf_circuit\n", + "hamiltonian = qubit_op\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "max_operator = excitation_pool[max_index]\n", + "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expand the Ansatz\n", + "We found that the third operator in the pool, which is the double-excitation operator in this case, has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` for small problems." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import MatrixExponential, SuzukiTrotter, LieTrotter\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run VQE\n", + "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5.06246655]\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -1.8572749998063154\n", + " x: [ 6.172e+00]\n", + " nfev: 20\n", + " maxcv: 0.0\n", + "\n", + "Found ground energy: -1.8572749998063154, exact energy: -1.857275030202378, difference: 3.039606255583749e-08\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 20 F =-1.857275E+00 MAXCV = 0.000000E+00\n", + " X = 6.171553E+00\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, qubit_op, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6.17155327]\n" + ] + } + ], + "source": [ + "# Optimal parameters so far\n", + "x_opt = getattr(res, 'x')\n", + "print(x_opt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Another iteration of the algorithm\n", + "We now compute the gradients again to see if we need another iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0. 0. -0.0004455]\n", + "Found maximum gradient 0.00044549942989826306 at index 2\n", + "Maximum gradient is below the threshold: True\n" + ] + } + ], + "source": [ + "gradient_threshold = 1e-3\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "\n", + "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", + "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the maximum gradient is below the threshold, we do not append another operator to the ansatz, and the algorithm terminates." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Putting it all together\n", + "Now we automate the algorithm in a single loop." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0\n", + "Maximum gradient: 0.36186239956846256\n", + "Operator: SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 2\n", + "Result at iter 0: -1.8572750106208789\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 24 F =-1.857275E+00 MAXCV = 0.000000E+00\n", + " X = 3.029715E+00\n", + "\n", + "Iter: 1\n", + "Maximum gradient: 0.0003575701706209026\n", + "Terminating: converged\n", + "Found ground energy: -1.8572750106208789, exact energy: -1.857275030202378, difference: 1.958149908887208e-08\n" + ] + } + ], + "source": [ + "# Define the conditions for termination\n", + "gradient_threshold = 1e-3\n", + "max_iter = 10\n", + "terminate = False\n", + "\n", + "# Initiate the problem\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "excitation_pool = ucc.operators # TODO\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "params = None\n", + "\n", + "iter = 0\n", + "operator_list = []\n", + "while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, 'x')\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration\")\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " print(\"Terminating: converged\")\n", + " terminate = True\n", + " \n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 090a3f246c6989ffd3a6d455877acbde36819fff Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Thu, 22 Feb 2024 02:45:27 +0300 Subject: [PATCH 06/17] add LiH comparison script to debug the Hamiltonian --- .../tutorials/adapt-vqe-draft-H2.ipynb | 2 +- .../tutorials/adapt-vqe-draft-LiH.ipynb | 325 +++---- .../adapt-vqe-draft-LiH_compare.ipynb | 852 ++++++++++++++++++ 3 files changed, 998 insertions(+), 181 deletions(-) create mode 100644 quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb index 6fe212f..6b45b29 100644 --- a/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb @@ -396,7 +396,7 @@ "from qiskit import QuantumCircuit\n", "\n", "num_spatial_orbitals = mx.ncas\n", - "num_particles = mol.nelec\n", + "num_particles = mx.nelecas\n", "\n", "# Get the Hartree-Fock initial state in bitsting representation\n", "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb index 7635872..3697462 100644 --- a/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb @@ -25,7 +25,7 @@ "from pyscf import ao2mo, gto, mcscf, scf\n", "\n", "# LiH\n", - "distance = 0.735\n", + "distance = 1.56\n", "mol = gto.Mole()\n", "mol.build(\n", " verbose=0,\n", @@ -33,14 +33,13 @@ " basis=\"sto-6g\",\n", " spin=0,\n", " charge=0,\n", - " symmetry=\"Coov\",\n", - ")\n", - "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}" + " symmetry=\"Coov\", \n", + " )\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -48,21 +47,7 @@ "output_type": "stream", "text": [ "Nuclear energy: 2.159906983346939\n", - "Electronic energy: -9.788591664808054\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", - " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Electronic energy: -9.788591664808054\n", "Total energy: -7.628684681461115\n", "Total energy - nuclear energy: -9.788591664808054\n" ] @@ -85,20 +70,21 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "mf = scf.RHF(mol)\n", "E1 = mf.kernel()\n", "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", + "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n", "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", "E2 = mx.kernel(mo)[:2]" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -116,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -214,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -241,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -291,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -333,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -346,12 +332,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 9, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -360,7 +346,7 @@ "from qiskit import QuantumCircuit\n", "\n", "num_spatial_orbitals = mx.ncas\n", - "num_particles = mol.nelec\n", + "num_particles = mx.nelecas\n", "\n", "# Get the Hartree-Fock initial state in boolean bitstring representation\n", "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", @@ -384,14 +370,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The excitation pool consists of 54 operators.\n" + "The excitation pool consists of 24 operators.\n" ] } ], @@ -417,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -456,24 +442,19 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0. 0. -0.3773396 0. 0. -0.08933881\n", - " 0. 0. -0.3773396 0. 0. -0.08933881\n", - " 0. 0. -0.05904723 0. 0. -0.04093015\n", - " 0. 0. 0. 0. -0.05904723 0.\n", - " 0. -0.04093015 0. 0. 0. -0.24891225\n", - " 0. 0. 0.05362656 -0.04093015 0. 0.\n", - " -0.08729688 0. 0. 0. -0.04093015 0.\n", - " 0. -0.08729688 0. 0. 0. 0.05362656\n", - " 0. 0. -0.05430852 0. 0. 0. ]\n", + "[ 0.11860637 0. 0. -0.50320326 0.11860637 0.\n", + " 0. -0.50320326 -0.01824441 0. 0. 0.05000378\n", + " 0. -0.05904723 0. 0. 0. 0.\n", + " -0.05904723 0. 0.05000378 0. 0. -0.24891225]\n", "Found operator SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) with maximum gradient 0.37733960483964873 at index 2.\n" + " coeffs=[ 0.5+0.j, -0.5+0.j]) with maximum gradient 0.5032032649865356 at index 3.\n" ] } ], @@ -504,7 +485,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -517,12 +498,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 13, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -552,7 +533,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -563,14 +544,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "-4.339808448288726\n" + "-1.8451098406948427\n" ] } ], @@ -585,14 +566,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[6.02213084]\n" + "[4.70183548]\n" ] } ], @@ -611,7 +592,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -621,16 +602,16 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -4.923783523364006\n", - " x: [ 5.025e+00]\n", - " nfev: 21\n", + " fun: -2.445616758804025\n", + " x: [ 5.109e+00]\n", + " nfev: 23\n", " maxcv: 0.0\n", - "\n", - "Found ground energy: -4.923783523364006, exact energy: -7.646812245579224, difference: 2.7230287222152185\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 21 F =-4.923784E+00 MAXCV = 0.000000E+00\n", - " X = 5.024761E+00\n" + "Found ground energy: -2.445616758804025, exact energy: -7.646812245579224, difference: 5.201195486775199\n", + "\n", + " NFVALS = 23 F =-2.445617E+00 MAXCV = 0.000000E+00\n", + " X = 5.109262E+00\n" ] } ], @@ -655,14 +636,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[5.02476053]\n" + "[5.10926204]\n" ] } ], @@ -682,28 +663,20 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00000000e+00 0.00000000e+00 1.56651207e-04 0.00000000e+00\n", - " 0.00000000e+00 -3.52131951e-02 0.00000000e+00 0.00000000e+00\n", - " -2.30166573e-01 0.00000000e+00 0.00000000e+00 -1.12516025e-01\n", - " 0.00000000e+00 0.00000000e+00 1.14001307e-03 0.00000000e+00\n", - " 0.00000000e+00 1.04716987e-03 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 1.14001307e-03 0.00000000e+00\n", - " 0.00000000e+00 1.04716987e-03 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 8.63302657e-02 0.00000000e+00 0.00000000e+00\n", - " 2.85469220e-02 -4.09301450e-02 0.00000000e+00 0.00000000e+00\n", - " -8.72968838e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " -4.09301450e-02 0.00000000e+00 0.00000000e+00 -8.72968838e-02\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 -9.55865762e-03\n", - " 0.00000000e+00 0.00000000e+00 -3.52638828e-03 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00]\n", - "Found maximum gradient 0.23016657332645868 at index 8\n", + "[-2.71803101e-02 0.00000000e+00 0.00000000e+00 -1.56259518e-04\n", + " 8.01303580e-02 0.00000000e+00 0.00000000e+00 -3.24241889e-01\n", + " -4.67959339e-03 0.00000000e+00 0.00000000e+00 2.65885485e-02\n", + " 0.00000000e+00 -6.34635076e-04 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 -6.34635076e-04 0.00000000e+00\n", + " -3.36275956e-02 0.00000000e+00 0.00000000e+00 1.41573354e-01]\n", + "Found maximum gradient 0.32424188915026975 at index 7\n", "Maximum gradient is below the threshold: False\n" ] } @@ -725,30 +698,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Since the maximum gradient is not below the threshold, we append the operator at index 8 to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." + "Since the maximum gradient is not below the threshold, we append the operator at index 7 to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 28, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 20, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -765,27 +730,27 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[6.19409048 0.7891094 ]\n", + "[0.41750104 3.36633583]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -5.433843336865546\n", - " x: [ 4.959e+00 1.817e+00]\n", - " nfev: 44\n", + " fun: -2.956190636470729\n", + " x: [ 1.899e+00 5.040e+00]\n", + " nfev: 36\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 44 F =-5.433843E+00 MAXCV = 0.000000E+00\n", - " X = 4.958797E+00 1.817251E+00\n", + " NFVALS = 36 F =-2.956191E+00 MAXCV = 0.000000E+00\n", + " X = 1.898789E+00 5.040352E+00\n", "\n", - "Found ground energy: -5.433843336865546, exact energy: -7.646812245579224, difference: 2.2129689087136786\n" + "Found ground energy: -2.956190636470729, exact energy: -7.646812245579224, difference: 4.690621609108495\n" ] } ], @@ -812,7 +777,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -820,112 +785,110 @@ "output_type": "stream", "text": [ "Iter: 0\n", - "Maximum gradient: 0.37733960483964873\n", + "Maximum gradient: 0.5032032649865356\n", "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 2\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -4.923783532820581\n", - " Iterations: 3\n", - " Function evaluations: 7\n", - " Gradient evaluations: 3\n", - "Result at iter 0: -4.923783532820581\n", + " Current function value: -2.4456165112244785\n", + " Iterations: 5\n", + " Function evaluations: 14\n", + " Gradient evaluations: 5\n", + "Result at iter 0: -2.4456165112244785\n", "Iter: 1\n", - "Maximum gradient: 0.2301214121960488\n", + "Maximum gradient: 0.32407092356738126\n", "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 8\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.433843344005466\n", - " Iterations: 7\n", - " Function evaluations: 21\n", - " Gradient evaluations: 7\n", - "Result at iter 1: -5.433843344005466\n", + " Current function value: -2.956190499905813\n", + " Iterations: 6\n", + " Function evaluations: 18\n", + " Gradient evaluations: 6\n", + "Result at iter 1: -2.956190499905813\n", "Iter: 2\n", - "Maximum gradient: 0.1740084374703947\n", + "Maximum gradient: 0.12976104001624783\n", "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 29\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.441845141112326\n", - " Iterations: 13\n", - " Function evaluations: 56\n", - " Gradient evaluations: 13\n", - "Result at iter 2: -5.441845141112326\n", + " Current function value: -2.9612309090295854\n", + " Iterations: 8\n", + " Function evaluations: 34\n", + " Gradient evaluations: 8\n", + "Result at iter 2: -2.9612309090295854\n", "Iter: 3\n", - "Maximum gradient: 0.08729688376396214\n", - "Operator: SparsePauliOp(['IIYYIIIXYI', 'IIXYIIIYYI', 'IIXXIIIXYI', 'IIYXIIIYYI', 'IIXYIIIXXI', 'IIYYIIIYXI', 'IIYXIIIXXI', 'IIXXIIIYXI'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 36\n", + "Maximum gradient: 0.031641552187096696\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.605545082186456\n", - " Iterations: 11\n", - " Function evaluations: 60\n", - " Gradient evaluations: 11\n", - "Result at iter 3: -5.605545082186456\n", + " Current function value: -2.965954068698521\n", + " Iterations: 13\n", + " Function evaluations: 67\n", + " Gradient evaluations: 13\n", + "Result at iter 3: -2.965954068698521\n", "Iter: 4\n", - "Maximum gradient: 0.09496027998502402\n", - "Operator: SparsePauliOp(['XZZYIIIIII', 'YZZXIIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 11\n", + "Maximum gradient: 0.035411760167576585\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.611106832114836\n", - " Iterations: 12\n", - " Function evaluations: 75\n", - " Gradient evaluations: 12\n", - "Result at iter 4: -5.611106832114836\n", + " Current function value: -2.9617004469024106\n", + " Iterations: 14\n", + " Function evaluations: 88\n", + " Gradient evaluations: 14\n", + "Result at iter 4: -2.9617004469024106\n", "Iter: 5\n", - "Maximum gradient: 0.08516009231217672\n", - "Operator: SparsePauliOp(['YZZYIXZZZY', 'XZZYIYZZZY', 'XZZXIXZZZY', 'YZZXIYZZZY', 'XZZYIXZZZX', 'YZZYIYZZZX', 'YZZXIXZZZX', 'XZZXIYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 32\n", + "Maximum gradient: 0.037296931333022955\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.613187854614306\n", - " Iterations: 33\n", - " Function evaluations: 248\n", - " Gradient evaluations: 33\n", - "Result at iter 5: -5.613187854614306\n", + " Current function value: -2.970037220201674\n", + " Iterations: 13\n", + " Function evaluations: 92\n", + " Gradient evaluations: 13\n", + "Result at iter 5: -2.970037220201674\n", "Iter: 6\n", - "Maximum gradient: 0.07890391790336519\n", - "Operator: SparsePauliOp(['IIIIIXZZYI', 'IIIIIYZZXI'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 5\n", + "Maximum gradient: 0.023284289617794322\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.476360123617924\n", + " Current function value: -2.97218210651401\n", " Iterations: 20\n", - " Function evaluations: 161\n", + " Function evaluations: 162\n", " Gradient evaluations: 20\n", - "Result at iter 6: -5.476360123617924\n", + "Result at iter 6: -2.97218210651401\n", "Iter: 7\n", - "Maximum gradient: 0.04230738432879399\n", - "Operator: SparsePauliOp(['IIYYIIIXYI', 'IIXYIIIYYI', 'IIXXIIIXYI', 'IIYXIIIYYI', 'IIXYIIIXXI', 'IIYYIIIYXI', 'IIYXIIIXXI', 'IIXXIIIYXI'],\n", + "Maximum gradient: 0.020475779688605242\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 36\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.617043472544331\n", - " Iterations: 47\n", - " Function evaluations: 428\n", - " Gradient evaluations: 47\n", - "Result at iter 7: -5.617043472544331\n", + " Current function value: -2.975517805532193\n", + " Iterations: 21\n", + " Function evaluations: 192\n", + " Gradient evaluations: 21\n", + "Result at iter 7: -2.975517805532193\n", "Iter: 8\n", - "Maximum gradient: 0.08671927407648883\n", - "Operator: SparsePauliOp(['YZZYIXZZYI', 'XZZYIYZZYI', 'XZZXIXZZYI', 'YZZXIYZZYI', 'XZZYIXZZXI', 'YZZYIYZZXI', 'YZZXIXZZXI', 'XZZXIYZZXI'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 50\n", + "Maximum gradient: 0.006992957360345902\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.619143389628584\n", - " Iterations: 49\n", - " Function evaluations: 496\n", - " Gradient evaluations: 49\n", - "Result at iter 8: -5.619143389628584\n", + " Current function value: -2.97005663642165\n", + " Iterations: 15\n", + " Function evaluations: 152\n", + " Gradient evaluations: 15\n", + "Result at iter 8: -2.97005663642165\n", "Iter: 9\n", - "Maximum gradient: 0.08597224074262962\n", - "Operator: SparsePauliOp(['YZZZYXZZYI', 'XZZZYYZZYI', 'XZZZXXZZYI', 'YZZZXYZZYI', 'XZZZYXZZXI', 'YZZZYYZZXI', 'YZZZXXZZXI', 'XZZZXYZZXI'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 47\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -5.6205950479012605\n", - " Iterations: 30\n", - " Function evaluations: 332\n", - " Gradient evaluations: 30\n", - "Result at iter 9: -5.6205950479012605\n", - "Found ground energy: -5.6205950479012605, exact energy: -7.646812245579224, difference: 2.0262171976779637\n" + "Maximum gradient: 0.024276965466989174\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Iteration limit reached (Exit mode 9)\n", + " Current function value: -2.976671400910034\n", + " Iterations: 50\n", + " Function evaluations: 557\n", + " Gradient evaluations: 50\n", + "Result at iter 9: -2.976671400910034\n", + "Terminating: reached maximum iteration.\n", + "Found ground energy: -2.976671400910034, exact energy: -7.646812245579224, difference: 4.67014084466919\n" ] } ], @@ -967,9 +930,11 @@ " # Terminate if maximum number of iterations reached\n", " iter += 1\n", " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration.\")\n", " terminate = True\n", " # Terminate if converged\n", " else:\n", + " print(\"Terminating: converged.\")\n", " terminate = True\n", " \n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb new file mode 100644 index 0000000..81597a4 --- /dev/null +++ b/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb @@ -0,0 +1,852 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit ADAPT-VQE tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the molecule\n", + "We start by defining the molecule using ``pyscf``. As an example we select the LiH molecule and build it by providing its geometry.\n", + "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the fermionic Hamiltonian\n", + "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map the fermionic Hamiltonian to a qubit operator\n", + "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 2)\n", + "6\n", + "(1, 1)\n", + "5\n", + "276\n" + ] + } + ], + "source": [ + "from qiskit_nature.second_q.drivers import PySCFDriver\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "from qiskit_nature.second_q.transformers import ActiveSpaceTransformer\n", + "from qiskit_nature.units import DistanceUnit\n", + "\n", + "\n", + "driver = PySCFDriver(\n", + " atom=\"Li 0 0 0; H 0 0 1.59\",\n", + " basis=\"sto3g\",\n", + " unit=DistanceUnit.ANGSTROM,\n", + ")\n", + "\n", + "# Full problem\n", + "full_problem = driver.run()\n", + "print(full_problem.num_particles)\n", + "print(full_problem.num_spatial_orbitals)\n", + "\n", + "as_transformer = ActiveSpaceTransformer(\n", + " num_electrons=2,\n", + " num_spatial_orbitals=5,\n", + " active_orbitals=[1, 2, 3, 4, 5],\n", + ")\n", + "\n", + "as_problem = as_transformer.transform(full_problem)\n", + "print(as_problem.num_particles)\n", + "print(as_problem.num_spatial_orbitals)\n", + "\n", + "mapper = JordanWignerMapper()\n", + "fermionic_op = as_problem.hamiltonian.second_q_op()\n", + "qubit_op = mapper.map(fermionic_op)\n", + "\n", + "H = qubit_op\n", + "\n", + "print(len(H))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0803168169635073\n" + ] + } + ], + "source": [ + "from qiskit_algorithms import NumPyMinimumEigensolver\n", + "\n", + "exact_solver = NumPyMinimumEigensolver()\n", + "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", + "print(exact_result.eigenvalue)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outline of the ADAPT-VQE algorithm\n", + "This algorithm was first introduced in https://arxiv.org/abs/1812.1117.\n", + "\n", + "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + "\n", + "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + "\n", + "3. Define the following conditions for termination: CONVERGED, MAXIMUM.\n", + " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", + " - MAXIMUM: Maximum number of iterations reached.\n", + " \n", + "4. while not TERMINATE (CONVERGED or MAXIMUM):\n", + " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", + " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", + " - Run VQE over all parameters $\\theta_i$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial state\n", + "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we do with the help of the function below." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit_nature.second_q.circuit.library import HartreeFock\n", + "\n", + "num_spatial_orbitals = as_problem.num_spatial_orbitals\n", + "num_particles = as_problem.num_particles\n", + "\n", + "hf_circuit = HartreeFock(num_spatial_orbitals, num_particles, mapper)\n", + "hf_circuit.draw(output='mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hartree-Fock energy: -1.0602464292560696 is 0.020070387707437742 above the exact ground state.\n" + ] + } + ], + "source": [ + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "hf_energy = estimator.run(hf_circuit, qubit_op).result().values[0]\n", + "print(f\"Hartree-Fock energy: {hf_energy} is {hf_energy - exact_result.eigenvalue} above the exact ground state.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator pool\n", + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The excitation pool consists of 24 operators.\n" + ] + } + ], + "source": [ + "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "\n", + "qubit_mapper = JordanWignerMapper()\n", + "\n", + "# Define the pool of operators as the single and double excitation operators generated by the UCC ansatz\n", + "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", + "excitation_pool = ucc.operators # TODO\n", + "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient of the excitation operators\n", + "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. " + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", + " \"\"\"\n", + " Computes the gradients for all available excitation operators.\n", + " Args:\n", + " ansatz: ansatz built so far.\n", + " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", + " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", + " estimator: an instance of the Qiskit Estimator primitive\n", + " params: parameters to be assigned to the ansatz, if any.\n", + " Returns:\n", + " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", + " \"\"\"\n", + " # The excitations operators are applied later as exp(i*theta*excitation).\n", + " # For this commutator, we need to explicitly pull in the imaginary phase.\n", + " if params is not None:\n", + " ansatz_opt = ansatz.assign_parameters(params)\n", + " else:\n", + " ansatz_opt = ansatz\n", + " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", + " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", + " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", + " gradients = estimator.run(ansatz_list, commutators).result().values\n", + "\n", + " return gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 2.36926453e-08 0.00000000e+00 0.00000000e+00 1.35356602e-09\n", + " 2.36926453e-08 0.00000000e+00 0.00000000e+00 1.35356606e-09\n", + " -2.59287260e-02 0.00000000e+00 0.00000000e+00 6.89637005e-02\n", + " 0.00000000e+00 -4.69553018e-02 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 -4.69553018e-02 0.00000000e+00\n", + " 6.89637005e-02 0.00000000e+00 0.00000000e+00 -2.47637434e-01]\n", + "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.24763743394926327 at index 23.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from qiskit.primitives import Estimator\n", + "\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "max_operator = excitation_pool[max_index]\n", + "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expand the Ansatz\n", + "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABfgAAAKxCAYAAAAPTs3EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8XElEQVR4nOzdd5gV5f034M/SpCuIigYEFFABAcWGxoKBRFTU2CNiiTFqgpqIYDRvoqlGxRI0scVuROxRMZaILUQNSrASCxEUYdUVLCAIy+77h5FfVhbYRXbXs9z3dXFdMPPMzPfMmTlz+JxnnikqLy8vDwAAAAAAUFAa1HUBAAAAAABA9Qn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgADWq6wKoXHl5eT4pW1LXZVRZ8wYNU1RUtMrLl5cnZYtXY0EAAAAAAHWkQePkS8SlVSbg/4r6pGxJ2kx4qK7LqLK5uw9Ki4arfjiVLU4eGbMaCwIAAAAAqCMDTkoaNqn57RiiBwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACtAaEfCXlJRk1KhR6dq1a5o2bZqOHTvm5JNPzvz583PMMcekqKgol1xySV2XCQAAAAAAVdaorguoaVOmTMngwYNTXFycFi1apEePHpk1a1bGjBmTadOmZc6cOUmSvn371m2hNWTJ1dem7OZb0vCUH6XBHt+sMK+8vDxLRv4k5VOnptElY1LUpXPdFFlFZWVlufPvv8/4py5P8dzpWafFetmlz8E58lu/TLMmLeq6PAAAAACAWlWve/CXlJRkyJAhKS4uzogRIzJ79uxMnjw5xcXFOeecczJ+/PhMmjQpRUVF6d27d12XWyMaDBuadO6UJZdfmfL3SirMK7vjrpQ//0IaDDv8Kx/uJ8ml9/w4l91zSjbeoEeG73dxdul9UO76+5j8/OohKSsrq+vyAAAAAABqVb0O+E866aTMnDkzw4cPz+jRo9OqVaul80aNGpU+ffqktLQ0nTt3TuvWreuw0ppT1LhxGo0ckSxcmCUXXLR0evlbM1N27fUp2nyzNDjogLorsIqmF7+Uv0y8OF/vtX/OOvKO7Ln9sTl+nwty/JALMmXaI3n0uZvrukQAAAAAgFpVbwP+qVOnZty4cWnXrl3OPvvsStv069cvSdKnT58K0994443ss88+adWqVdq0aZMjjjgi77//fo3XXFOKunVNg0MPTvmzk1M2/q8pX7IkS84dnZSXp+HIESlq2LCuS1ypR6aMTXl5efbf+UcVpu+5/bFp2rh5/jb5xropDAAAAACgjtTbMfjHjh2bsrKyDB06NC1btqy0TbNmzZJUDPg//vjjDBgwIG3bts3YsWOzYMGCjBo1KnvvvXcmTpyYBg0K8zeRBkO/k7Inn86SK/+UBtP+k/JXXk2D738vRR071HVpVfLKW5PSoKhBNtt4uwrTmzRumk026ptX35pUR5UBAAAAANSNehvwT5gwIUkyYMCA5baZOXNmkooB/xVXXJG33347jz/+eDbeeOMkSYcOHbLjjjvm7rvvzn777VdzRdegokaN0mjkKSk98Ucpu3d8inr1TIP996vrsqrs/Y9mpXWLdmnSaK1l5rVb+2t5ecY/srh0URo3alIH1QEAAAAA1L56G/DPmDEjSdKpU6dK55eWlmbixIlJKgb89957b77+9a8vDfeTpH///tlkk01yzz33rFLAv80226S4uLhay5Q3aZJc/odqb2uFWrRIGjdOSktTtO02KVqNdyN079Y9RYsWrfLyTRo1yxXDX1vu/E8XfZLGlYT7ny3b9LM2iz8R8AMAAAAAda5b925ZVLqgyu3bt2+fZ555ptrbqbcB//z585MkCxZUvhPHjRuXkpKStGrVKl26dFk6/eWXX85BBx20TPuePXvm5ZdfXqVaiouL8/bbb1dvoaZrpfEqba1y5eXlWXL+hUnp4mTjjim76eY02HWXFG204WpZ/6zZs5KFn67y8k0bN1/h/LWaNM+Cee9WOm9R6cLP2qxkHQAAAAAAtWH2rFlZuPiTGt9OvQ3427dvn7lz52by5Mnp379/hXmzZ8/OyJEjkyS9e/dOUVHR0nlz587NOuuss8z62rZtm1deeWWVa6mu8iZN8t4qba1yZXfdnfLnnk+Do49Mg/47pPSHJ2bJ+Rem4ehzKrz+VbXRhht96R78K7Ju643y5jsvZ1Hpp8sM01Py4dtZu0U7vfcBAAAAgK+EDTfaqNo9+FdFvQ34Bw4cmKlTp+acc87JoEGD0r179yTJpEmTMmzYsJSUlCRJ+vbtW+O1rMqtFfOXlKbNhIdWy/bL3347ZVdfm6LNuqfBwQemqGHDNDh8aMquuS5ld92dht/e90tv49XXXk2Lhqt+OC1ZlDwyZvnzN+u4bZ599cG88uY/s+UmOy+dvmjxwvxn1pRsuckuq7xtAAAAAIDV6bVXX0vDWuiPvPoGYf+KGTVqVNZdd9289dZb6dmzZ7bccst069Yt2223XTbZZJPsvvvuSSqOv58kbdq0yQcffLDM+ubMmZO2bdvWRumrVXlZWZacd0FSVpaGI09JUcOGSfJZ0N+9W8quvjbls2bXcZUrt1ufQ1JUVJQ7nriowvT7nr4yCxd/kt23Glo3hQEAAAAA1JF6G/B36NAhTzzxRPbaa680bdo006dPT9u2bXP55Zdn/PjxefXVV5MsG/BvscUWlY61//LLL2eLLbaoldpXp7Lb7kj5y1PT4MjDU/Q/Dw4uatgwDU89JSlbkiXnX5jy8vI6rHLlumy4ZfbZ8Yf5+4t35Kzr9s99T/8pl90zIpfdc0p6b7Jrdt/qsLouEQAAAACgVtXbIXqSz8L6e++9d5np8+bNy/Tp09OgQYP06tWrwry99947Z5xxRmbOnJkOHTokSZ5++ulMmzYt5513Xq3UvbqUv/lmyq67IUVbbJ4GB+y/zPyizp1W+1A9NemEfS7KBm06576nr8g/p45P6xbtst9OJ+bIb/0yDRrU29+qAAAAAAAqVVT+Ve+6XQOefvrp7LDDDtlss83y73//u8K8jz76KFtuuWXatWuXX/ziF1m4cGFGjRqV9dZbL08++WStBcmrcwz+2jB390E1OgY/AAAAAEChGHBSjMFfU1544YUkyw7PkyStW7fOhAkTsuGGG+bQQw/N9773vey4446599579RIHAAAAAOAro14P0bM8Kwr4k2TTTTetdGgfAAAAAAD4qlgju6SvLOAHAAAAAICvujWyB/+ECRPqugQAAAAAAPhS1sge/AAAAAAAUOgE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAa1XUBVK55g4aZu/ugui6jypo3aFjXJQAAAAAArFEE/F9RRUVFadHQ2wMAAAAAQOUM0QMAAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVojQj4S0pKMmrUqHTt2jVNmzZNx44dc/LJJ2f+/Pk55phjUlRUlEsuuaSuywQAAAAAgCprVNcF1LQpU6Zk8ODBKS4uTosWLdKjR4/MmjUrY8aMybRp0zJnzpwkSd++feu2UFZq7ISz89rbk/PazGdTPOeNbNCmU248Y3pdlwUAAAAAUCfqdQ/+kpKSDBkyJMXFxRkxYkRmz56dyZMnp7i4OOecc07Gjx+fSZMmpaioKL17967rclmJq/96Rqa8PiEbrbtpWjVrU9flAAAAAADUqXod8J900kmZOXNmhg8fntGjR6dVq1ZL540aNSp9+vRJaWlpOnfunNatW9dhpVTF9T+Zljt+8X7O+f5DWbf1RnVdDgAAAABAnaq3Af/UqVMzbty4tGvXLmeffXalbfr165ck6dOnz9Jpn/8gsN1222WttdZKUVFRrdTLym247iZ1XQIAAAAAwFdGvQ34x44dm7KysgwdOjQtW7astE2zZs2SVAz4X3/99dx+++1p3759tt1221qpFQAAAAAAqqveBvwTJkxIkgwYMGC5bWbOnJmkYsC/yy67ZPbs2bn77rszcODAmi0SAAAAAABWUaO6LqCmzJgxI0nSqVOnSueXlpZm4sSJSSoG/A0arP7fPLbZZpsUFxev9vXWJ00aNcsVw1+r6zIAAAAAAL60bt27ZVHpgiq3b9++fZ555plqb6feBvzz589PkixYUPlOHDduXEpKStKqVat06dKlRmspLi7O22+/XaPbKHRNGzev6xIAAAAAAFaL2bNmZeHiT2p8O/U24G/fvn3mzp2byZMnp3///hXmzZ49OyNHjkyS9O7du8YfpNu+ffsaXX990KRRs7ouAQAAAABgtdhwo42q3YN/VdTbgH/gwIGZOnVqzjnnnAwaNCjdu3dPkkyaNCnDhg1LSUlJkqRv3741Xsuq3FqxplmyKHlkTF1XAQAAAADw5b326mtp2KTmt1NvH7I7atSorLvuunnrrbfSs2fPbLnllunWrVu22267bLLJJtl9992TVBx/HwAAAAAACkW97cHfoUOHPPHEExk5cmQee+yxTJ8+PT169Mjll1+eY489NptuumkSAX8heejZG/Lu3M8envzB/PdSumRR/vy3XydJ1m/TKYP6DavL8gAAAAAAalW9DfiTZIsttsi99967zPR58+Zl+vTpadCgQXr16lUHlbEq7v/nVXn+P49VmHbtAz9LkvTeZFcBPwAAAACwRqnXAf/yvPTSSykvL0/37t3TvHnzZebfdtttSZKXX365wr87d+6cbbbZpvYKpYLzT3i0rksAAAAAAPjKWCMD/hdeeCHJ8ofnOeiggyr995FHHplrr722RmsDAAAAAICqEPBXory8vDbLAQAAAACAamtQ1wXUhZUF/AAAAAAA8FW3RvbgnzBhQl2XAAAAAAAAX8oa2YMfAAAAAAAKnYAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAK0BoR8JeUlGTUqFHp2rVrmjZtmo4dO+bkk0/O/Pnzc8wxx6SoqCiXXHJJXZfJCsx879Vc+8DPc+LFO+TAs9bLPv+vVY67oG/+/PBvsmDR/LouDwAAAACg1jWq6wJq2pQpUzJ48OAUFxenRYsW6dGjR2bNmpUxY8Zk2rRpmTNnTpKkb9++dVsoK3T/pKtz9z/+kP499sk3thqahg0b57lpj+Ta+/9fHn/ulow58ams1bhZXZcJAAAAAFBr6nXAX1JSkiFDhqS4uDgjRozImWeemVatWiVJzj333Jx22mlp1KhRioqK0rt37zqulhXZecsD850Bp6dFs7WXThvS//h8rV233PTwb/LXf16V/XYaXocVAgAAAADUrno9RM9JJ52UmTNnZvjw4Rk9evTScD9JRo0alT59+qS0tDSdO3dO69at67BSVmazjttUCPc/t1ufQ5Ik04tfrO2SAAAAAADqVL0N+KdOnZpx48alXbt2Ofvssytt069fvyRJnz59lk677bbbcsABB6RTp05p3rx5Nt988/z0pz/NvHnzaqVuque9D2cmSdq03KCOKwEAAAAAqF31NuAfO3ZsysrKMnTo0LRs2bLSNs2afTZm+/8G/KNHj07Dhg3z29/+Nn/9619zwgkn5NJLL80ee+yRsrKyWqmdqllStiR//tuv0rBBo+y+1WF1XQ4AAAAAQK2qt2PwT5gwIUkyYMCA5baZOfOz3t//G/Dfc889WW+99Zb+e9ddd816662XoUOH5u9//3t22WWXGqqY6rr07h/l5RlP5ruDf5uO629W1+UAAAAAANSqehvwz5gxI0nSqVOnSueXlpZm4sSJSSoG/P8b7n9um222SZK8/fbbq1TLNttsk+Li4lVadk3RpFGzXDH8tSq3v/b+n+UvEy/JXtt/P9/Z/fQarAwAAAAAoHq6de+WRaULqty+ffv2eeaZZ6q9nXob8M+fPz9JsmBB5Ttx3LhxKSkpSatWrdKlS5cVruuRRx5JkmyxxRarVEtxcfEq/ziwpmjauHmV217/4Fn588O/zre2PTonH3BZDVYFAAAAAFB9s2fNysLFn9T4duptwN++ffvMnTs3kydPTv/+/SvMmz17dkaOHJkk6d27d4qKipa7nrfffjs/+9nPsscee6Rv376rXAsr1qRRsyq1u/7Bs3LDQ7/IoH5H5pQD/7TC9w4AAAAAoC5suNFG1e7BvyrqbcA/cODATJ06Neecc04GDRqU7t27J0kmTZqUYcOGpaSkJElWGNrPmzcv++67b5o0aZKrr756lWtZlVsr1jRLFiWPjFlxmxse+mVueOgXGbj1sJx68NVp0KDePiMaAAAAAChgr736Who2qfnt1NuAf9SoUbnpppvy1ltvpWfPntl8882zcOHCvP766xk8eHA6d+6cBx54oML4+/9rwYIFGTJkSN5444088cQT2XDDDWv5FfC//jLxD7n+wTOz/jobZ+tuAzPhXzdVmN+m1Qbp131QHVUHAAAAAFD76m3A36FDhzzxxBMZOXJkHnvssUyfPj09evTI5ZdfnmOPPTabbrppklQa8C9evDgHHnhgnnnmmTz88MPp0aNHbZfPF7zy1qQkybsfvJlzxx25zPzem+wq4AcAAAAA1ihF5eXl5XVdRG2bN29eWrdunaKionz88cdp3vz/HvBaVlaWQw89NHfffXfuu+++7L777nVY6ZqjKkP0AAAAAAAUggEnxRA9NeWll15KeXl5unfvXiHcT5If/vCHufXWW/OTn/wkzZs3z1NPPbV03qabbpr11luvtssFAAAAAIBlrJFPKX3hhReSVD48z1//+tckye9+97v079+/wp/x48fXap0AAAAAALA8a2QP/hUF/NOnT6/lagAAAAAAoPr04AcAAAAAgAK0RvbgnzBhQl2XAAAAAAAAX8oa2YMfAAAAAAAKnYAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAK0BoR8JeUlGTUqFHp2rVrmjZtmo4dO+bkk0/O/Pnzc8wxx6SoqCiXXHJJXZcJAAAAAABV1qiuC6hpU6ZMyeDBg1NcXJwWLVqkR48emTVrVsaMGZNp06Zlzpw5SZK+ffvWbaGs0FvvvpIb//bLvPb25Lz/0awsWbI466+zcbbbfM8ctNvIrNt6w7ouEQAAAACgVtXrgL+kpCRDhgxJcXFxRowYkTPPPDOtWrVKkpx77rk57bTT0qhRoxQVFaV37951XC0r8t6HMzPno9nZqde3s97aHdKwQaO8UfxCxj99RR557uZc9uMpadNy/bouEwAAAACg1hSVl5eX13URNeWwww7L2LFjM3z48Fx88cXLzO/bt2+ee+65dOnSJf/5z3/qoEI+t2RR8siY6i/32HO35tc3Hpzv7XlODhkwavUXBgAAAABQTQNOSho2qfnt1Nsx+KdOnZpx48alXbt2Ofvssytt069fvyRJnz59lk574oknMnDgwGy44YZZa6210qFDhxxyyCGZOnVqrdRN9WzQplOSZN6CuXVcCQAAAABA7aq3Q/SMHTs2ZWVlGTp0aFq2bFlpm2bNmiWpGPDPnTs3W265ZY477risv/76mTlzZs4+++z0798/L774Yjp06FAr9VO5RYsXZsGieVm0eGFmvPNy/nTfaUmS7Tbfs44rAwAAAACoXfU24J8wYUKSZMCAActtM3PmzCQVA/599tkn++yzT4V22267bTbbbLPcfvvtOfnkk2ugWqrqvn/+KX+468Sl/27fpnN+8p0bs+UmO9dhVQAAAAAAta/eBvwzZsxIknTq1KnS+aWlpZk4cWKSigF/ZdZdd90kSaNGq7a7ttlmmxQXF6/SsmuKJo2a5Yrhr6203U4998vG622eBYvm5fW3/5UnX747H84vqYUKAQAAAACqplv3bllUuqDK7du3b59nnnmm2tuptwH//PnzkyQLFlS+E8eNG5eSkpK0atUqXbp0WWb+kiVLUlZWlhkzZuT0009P+/btc/DBB69SLcXFxXn77bdXadk1RdPGzavUbr11OmS9dT4bJmmnXvtl5y0PyPAx2+bTxZ/kO7ufXpMlAgAAAABUyexZs7Jw8Sc1vp16G/C3b98+c+fOzeTJk9O/f/8K82bPnp2RI0cmSXr37p2ioqJllt91112X9vDv2rVrJkyYkPXWW2+Va2HFmjRqtkrLbbJR72z6ta1yzz/+KOAHAAAAAL4SNtxoo2r34F8V9TbgHzhwYKZOnZpzzjkngwYNSvfu3ZMkkyZNyrBhw1JS8tmwLn379q10+auuuioffPBB3njjjZx33nn55je/mYkTJ2bjjTeudi2rcmvFmmbJouSRMau27KLFC/LxJ3NWb0EAAAAAAKvotVdfS8MmNb+dBjW/iboxatSorLvuunnrrbfSs2fPbLnllunWrVu22267bLLJJtl9992TLH/8/c022yzbb799Dj300Dz88MP5+OOPc+6559bmS+B/zPmo8mcYTHn9kUwvfjGbd9qhlisCAAAAAKhb9bYHf4cOHfLEE09k5MiReeyxxzJ9+vT06NEjl19+eY499thsuummSVb+gN0kWWedddK1a9e8/vrrNV02yzHmjhPy/sez07fr7tlgnU5ZVLowr818No8+d3OardUqx+19fl2XCAAAAABQq+ptwJ8kW2yxRe69995lps+bNy/Tp09PgwYN0qtXr5Wu5913380rr7yS7bffvibKpAoGbPWdPPTs9Xn42Rvywfz3UpSibNCmU/ba4bgcvOvIrN+m+kMnAQAAAAAUsnod8C/PSy+9lPLy8nTv3j3NmzevMO/www9P165d07dv36yzzjp57bXXcuGFF6ZRo0b58Y9/XEcVs2ufg7Nrn4PrugwAAAAAgK+MNTLgf+GFF5JUPjzPDjvskOuvvz6///3vs3DhwnTs2DEDBgzIGWeckU6dOtV2qQAAAAAAUCkB/xcMHz48w4cPr+2SAAAAAACgWhrUdQF1YUUBPwAAAAAAFII1sgf/hAkT6roEAAAAAAD4UtbIHvwAAAAAAFDoBPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCA6n3AX1JSklGjRqVr165p2rRpOnbsmJNPPjnz58/PMccck6KiolxyySV1XSarYOGiTzLs7E0yaGRRLr5zeF2XAwAAAABQqxrVdQE1acqUKRk8eHCKi4vTokWL9OjRI7NmzcqYMWMybdq0zJkzJ0nSt2/fui2UVXLdAz/Ph/Pfq+syAAAAAADqRL3twV9SUpIhQ4akuLg4I0aMyOzZszN58uQUFxfnnHPOyfjx4zNp0qQUFRWld+/edV0u1fTazMm54+8X5YhBv6jrUgAAAAAA6kS9DfhPOumkzJw5M8OHD8/o0aPTqlWrpfNGjRqVPn36pLS0NJ07d07r1q3rsFKqa0nZklx427HZdrM98vUt96/rcgAAAAAA6kS9DPinTp2acePGpV27djn77LMrbdOvX78kSZ8+fZa7nsGDB6eoqChnnXVWTZTJKrrj8Qvz1rv/zvD9PDsBAAAAAFhz1cuAf+zYsSkrK8vQoUPTsmXLSts0a9YsyfID/ltuuSVTpkypqRJZRbPnvJHrHzwzQwf9PO3bdq7rcgAAAAAA6ky9fMjuhAkTkiQDBgxYbpuZM2cmqTzg/+ijj/KjH/0oo0ePzuGHH/6l69lmm21SXFz8pddTnzVp1CxXDH9tpe1+f/vxab/uJjlwl1NqoSoAAAAAgOrr1r1bFpUuqHL79u3b55lnnqn2duplwD9jxowkSadOnSqdX1pamokTJyapPOD/6U9/mu7du2fo0KGrJeAvLi7O22+//aXXU581bdx8pW3+9uyNmfzaQ7nghMfTqGHjWqgKAAAAAKD6Zs+alYWLP6nx7dTLgH/+/PlJkgULKv+FZNy4cSkpKUmrVq3SpUuXCvOeeeaZXHnllXn22WdXWz3t27dfbeuqr5o0arbC+YtKP83l95yS7TbfM21atc/bJa8nSUo+/OyHk/kLP8zbJa9n7Rbt0rLZOjVdLgAAAADAcm240UbV7sG/KuplwN++ffvMnTs3kydPTv/+/SvMmz17dkaOHJkk6d27d4qKipbOW7JkSY477rgMHz48PXv2XG31rMqtFWuaJYuSR8Ysf/6ixQvywfz38vTU8Xl66vhl5j88+cY8PPnGfH+v83LQbqfWYKUAAAAAACv22quvpWGTmt9OvQz4Bw4cmKlTp+acc87JoEGD0r179yTJpEmTMmzYsJSUlCRJ+vbtW2G5Sy65JO+8807OOuusWq6YlWnapEV+NuzWZaZ/OO+9jLnzB9l2sz2yx3bHZJMNe9dBdQAAAAAAta9eBvyjRo3KTTfdlLfeeis9e/bM5ptvnoULF+b111/P4MGD07lz5zzwwAMVxt8vKSnJz372s4wePTqlpaX54IMPls5buHBhPvjgg7Ru3ToNGjSog1dEo4aNs0vvA5eZXjxnepJkw3U3rXQ+AAAAAEB9VS/T6g4dOuSJJ57IXnvtlaZNm2b69Olp27ZtLr/88owfPz6vvvpqkooP2J05c2Y+/vjjHHfccWnTps3SP0lyzjnnpE2bNnnzzTfr5PUAAAAAAMAXFZWXl5fXdRG1ad68eWndunWKiory8ccfp3nz5kunVzZW/oABA3LkkUfmqKOOyg477JCmTZvWdslrhJWNwQ8AAAAAUCgGnBRj8NeEl156KeXl5enevfvScD9JWrZsmd12263SZTp37rzceQAAAAAAUBfq5RA9K/LCCy8kqTg8DwAAAAAAFJo1rgd/dQP+NWwEIwAAAAAACoQe/AAAAAAAUIDWuB78EyZMqOsSAAAAAADgS1vjevADAAAAAEB9IOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIAC1KiuC6By5eXl+aRsSV2XUWXNGzRMUVFRXZcBAAAAALDGEPB/RX1StiRtJjxU12VU2dzdB6VFQ4cTAAAAAEBtMUQPAAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUoDUi4C8pKcmoUaPStWvXNG3aNB07dszJJ5+c+fPn55hjjklRUVEuueSSui6zRiy5+tos/uaeKbv/wWXmlZeXp/TU07J4r31S/sb02i+umgaNLKr0z5Cftqzr0gAAAAAAal2jui6gpk2ZMiWDBw9OcXFxWrRokR49emTWrFkZM2ZMpk2bljlz5iRJ+vbtW7eF1pAGw4am7Kmns+TyK1PUb+sUrddu6byyO+5K+fMvpMF3j0pRl851V2Q1bNll5+y5/fcrTGvUsHEdVQMAAAAAUHfqdcBfUlKSIUOGpLi4OCNGjMiZZ56ZVq1aJUnOPffcnHbaaWnUqFGKiorSu3fvOq62ZhQ1bpxGI0ek9KQfZ8kFF6XR2b9OkpS/NTNl116fos03S4ODDqjjKquufdtNMrDf4XVdBgAAAABAnavXQ/ScdNJJmTlzZoYPH57Ro0cvDfeTZNSoUenTp09KS0vTuXPntG7dug4rrVlF3bqmwaEHp/zZySkb/9eUL1mSJeeOTsrL03DkiBQ1bFjXJVbL4tJFWfDpvLouAwAAAACgTtXbgH/q1KkZN25c2rVrl7PPPrvSNv369UuS9OnTZ+m0Rx99NEVFRcv8KfQhfBoM/U6yySZZcuWfUvaHy1L+yqtpcNQRKerYoa5Lq5YnXrgte/+0efb5f61y0Fnr55K7Tsz8BR/WdVkAAAAAALWu3g7RM3bs2JSVlWXo0KFp2bLyh7A2a9YsScWA/3N/+MMfsvXWWy/9d4sWLWqm0FpS1KhRGo08JaUn/ihl945PUa+eabD/fnVdVrVs3nG77NL7oGzUrms+WfhR/vnv+/KXiZfk+WmP5ffD/5Fma3nYLgAAAACw5qi3Af+ECROSJAMGDFhum5kzZyapPODv0aNHdthhh5oprq60aJE0bpyUlqZo221S1KCwbuC4+KSnK/x70DZHpMuGvXPN/T/NHX//fYZ+46d1VBkAAAAAQO2rtwH/jBkzkiSdOnWqdH5paWkmTpyYpPKAf3XaZpttUlxcXK1lyps0SS7/w2qroby8PEvOvzApXZxs3DFlN92cBrvukqKNNlwt6+/erXuKFi1a5eWbNGqWK4a/Vu3lDt5tZG586Bf559TxAn4AAAAA4CuhW/duWVS6oMrt27dvn2eeeaba26m3Af/8+fOTJAsWVL4Tx40bl5KSkrRq1SpdunRZZv4hhxySkpKSrLvuutlnn33yu9/9Lu3atVulWoqLi/P2229Xb6Gma6XxKm2tcmV33Z3y555Pg6OPTIP+O6T0hydmyfkXpuHoc1JUVPSl1z9r9qxk4aervHzTxs1XablGDRtn3dYb5cP5Jau8bT7zz3//NT+7ZkiuHPFiNl5/85W2P/y3nbNBm845/4RHv/S2Fy1emO+et3l232povjv4N196fQAAAAB89Vx694/z9NTx+dOpL6VRw8ZVnleIZs+alYWLP6nx7dTbgL99+/aZO3duJk+enP79+1eYN3v27IwcOTJJ0rt37woB99prr52RI0dml112ScuWLfPkk0/m7LPPzlNPPZVnnnkmTZs2XaVaqqu8SZO8V+2llrOut99O2dXXpmiz7mlw8IEpatgwDQ4fmrJrrkvZXXen4bf3/dLb2GjDjb50D/5VsWjxwrz34cxs0ameDadUy5YsKc3l94zIN7YaWqVwf3nueOKitGi6Tr617VHVWu62xy/IvAUf5KBdT02S3PX3i/OHv5yUo/f4TQ77xhnLtP/okzk5dnTPNGnUNJef8nx+ds2QPP+fx1a6nWGDzswR3zwr1z94Vm546Bcrbd97k11z/gmP5rlpj+bUy5Y/3Nf/eui88vzy+gMz8cU7c/4Jj6VXl68v0+bFN/6eEZfump16fTs/P+K2XPXXM3LzhLMz4qCrssd2363Qtry8PKdeNiBTZzyZP/zo2XRp3yvn3nxUHnr2upXWMqjfkRl16LV5YNK1GX3L0Sttv0GbTrnxjOkpnjM9w85e9ofPytxw+hu5a+LFuf3xC3L6YX/O7lsdtkybt0tez/EX9EnnDbfMRT+cmIYNGlZp3V/WwkWf5LgL+2T+gg9y5akvpU3L9SvMn/HOyznhoq2zWcdtc/7xj6VBgwYZNLJqP3iOPv6R9Nl0t4y4dLcaO/Z+dfQ9Oe6C3llUujBXnvpSWjdvu0y7mx7+ba65/6f54b5jcvvjF1St7X4Xp0v7XtU6ppPU6L7p32OfnHTJDumz6YD87tgHKm33kyu/leemPZIxw59Ktw5bV9qmJhT6+dm+beeMf+qKXHT7cRk68Gc56lu/XKbd78YOy8OTb8zZ33sg22z2zcz5qDjfO79n1mmxXi798b+yVuOK1+jJrz2cn1w5KAP6fienH/bnVarp8N92zjtzZ6y0/akHX5NvbXtUtfbr0Xv8Osee3yvrrdMxfzz52TRu1GSZdhfe9v3c9/SV+dXR92SHHntXqfYv67J7RlTrs/LI321aY/toVY69JPntnw/Lo8/dnN8d+1C27vaNCu0+Xbwgx1/YNx/OL8mfRryUx5+/dY26lteWNe387Nt194K+lp9/wqMpKyvLiMt2zStvTcqlP/pXOm2wRYV2cz9+J8ee3ystmq2Ty3/8XJo2WbWOT9X13gczq/VefDi/pMavV9U59lq3WDc/v2af7Ln9sfnxgVcs02Zx6aL84Pf98t4Hb+WH+12cc28+okptrxzxYq65//8V/LW8tlT3s7I+nJ/VfS9q+nqVVP97+jOvPJjT//StDNx6WE77zvXLtLv2/p/lzw//Oj8+8Irsuf2xVVr36rKm7d9tNxtc0J/F39r2qLxR/GJ+eFG/bNGpf0Yf/8gynYj/+s+rcsGt38t3dj9jaYfOQ3Y7LeOfujz3PHlpvv31kyq0X9G8QrThRhtVuwf/qqi3Af/AgQMzderUnHPOORk0aFC6d++eJJk0aVKGDRuWkpLPenz37du3wnJbbbVVttpqq6X/3m233dKrV6/ss88+GTt2bI4+euUn0hetyq0V85eUps2Eh6q93BeVl5VlyXkXJGVlaTjylBQ1/CxYa3DwgSmf+I+UXX1tGmy/3ZcequfV115Ni4arfjgtWZQ8Mmb58z+a/35at1h3menXPvCzLCkrzQ5bDFnlbZM89vytefPdqTlj6NgqL3P1qFdSlIof3Hc8cVE2aNO5WgH/p4sX5NbHzsu3tj06rZq3SZLsu9PwTHzprtz40C+ywxZ7Z5ONeldY5uI7f5i5897JecdNSPOmrXLYN36awdt9r9L1L17yaS6755Qs+PTj9Oi0Y5Lk6732z0brdl1uTbc+Njr/mf3c0i+pG6+/RU479Ibltn/63+Pz6JSb07PzTkmSk/a/NC+88UTOG3dULjvluTRr8n8P6V646JOcN+6otG7RLicfcFmS5IhBZ+Wpl+/JZfeckn7dv5n11umwtP0dT1yU5//zWI4ZfHa6tO+VJNl7h+OydbeBldZSnvJc89cz8t6HM5fW33uTXVZY/0PPXpfJr/0tvTp/1n7tluutsP0rb/0zd028OF9r1y3rtFw/393jN5n077/mkrtOTJ9NB2Td1v/3eVJWVpbzxh2V8pRn1CHX1Vq4nyRNmzTPyIOvyYhLd82Y20/ImUfevnTekiWlOefmI9KwQaOMPPjaNPjvM0lW9Lpnz/lPrn/wzKzdol06rLdZktTosde8aaucesg1GXn57rn4jh/kp4ffXKHtG7NfyI0P/SJbdf1G9t1peLpsuGXV2u74w3ww791qHdM1vW+6ddg6h+3+01z/0Fm558nLMqT/8RXa3/vk5Xn21QdzxDd/UavhflL452eS7LXD9/PEC7fn5glnZ6ee+1XYh39/4c48PPnG7LXDcUsDgbat22f4fhfn7JuG5pq//jTH73PB0vbzF36U82/5btq0ap8f7nfxKtd0wj4XZcGn8ypt//GCObn8nhFp2KBRunfol6R6+3W9dTrkB/v+PueNOyrXPfjzfG/P31VoP+mVB3Lf01fmW9seXWvhfpJqf1bW5D5Kqn/sJcnwb1+S56Y9kgtuPSZXnPJCmjdttXTen+77SWa+92rOGDo2bVu3X+Ou5bVlTTw/C/laniQNGjTIqQdfk+Mv6JPzxh2Z3w9/ssL3oYtuPy4ffzInZx15V62F+0mq/V7Mfv8/NX69qs6x12XDLfPNbY7KfU9fma/32j/bbr5HhfbXP3hmphe/mFGHXJdB/YZlyusTqtR2vXU61ItreW2p7mdlfTg/q/te1PT1Kqn+ft1ms29mz+2PzX1PX5mdex+YHXvus7T9K29Nys2P/C7bdP9WrYf7yZq5fwv5szhJurTvlcMHnZlr7v9p7pp4cYVQ/p25M3LZPaekS/stM2zQmUunt23dPrv1PTQ3P/K77NP/B2n4P3niiuYVotdefS0Nl/3dZrUrKi8vL6/5zdS+mTNnpm/fvnn//ffTqFGjbL755lm4cGFef/31DB48OGVlZXnggQdyxRVX5NhjV/yhVV5enlatWuXII4/MH/6w+sbFX5HVFfAvueW2lP3p6jT43tFpePBBFeaVT5+R0h+emKLNN//SQ/XM3X1QjQb8l97940yd8VT6dB2Q9dfZOAs/nZd//vu+TJn2SDbfePuMPv6RZXowUXU//uPO+WThR7n8lOe+1HpWZdiez3/NvfRHk9P1a//349o7c2fk+xf0zoZtN8klJ/1z6a1ZT7xwR355/QHZf+cf5YR9Llzp+s+/9Xu5/59X5Yhv/iLDBv18pe3/9uyNOefmYdm628D89nv3rzSQnvHO1Jx08fZpulbLXHry5LRt/dmvrRNfvCtnXfftDOn/g5y0//99blxy14n5y8RL8osj78qOvf7v7pnXZk7OiRdvn75dd1/ag/mtd1/JCRdtlS4b9q5yz/cbH/pVrnvw5/nWtkfn1IOvXmn756Y9mtOuGJSO62+eMSc+VeFLeWXmfvxOfvD7fpm/8MOMGf5UOrfvmSR55a1ncvIl/bPNZt/Kr79779L2tz52fq6499ScsM9F2X/nk1dazxd93iPq894Eq+Kyu0/J7U9cWKHX7A0P/iLXP3RWhu93Sfbd6YcrXcfCRZ/k5Ev6Z/o7L+V3xz6YrbruvtJlVtex98e//Ch3/v33+X+H35Jd+3z2Ob5kSWmGX7xdZr0/LVee8kLWb7Nxtdsuz/KO6ZreN0uWlObES3bIzPdeyeWnPJ8N237W0+SduTPy/fO3TIf1NsuY4U+u0he8QSOLlvbsWhWFfn4mybsfvJXvn79lhd5BH8x7L8ee3ytNm7TIFac8n2Zrtaywvl9cd0D+8dJdFXrlnTfu6Dz4zLX59XfvzfZb7LXS17CimipTVlaWM64anGdfffCzUGabI1a6jeXt1zOv3S9PTb03F/7g7+nx3zv95i/4MMee3ytFRQ1yxYgX0qJp65Wu/4sO/23n9N5kt4w69NpqL7s6PitX5z5anhUde/946e6cee2+FXrCPjft0Yy8fPd8fcsD8vNhty5tu6Zdy6vq896Gn/cMXBVr2vlZ6NfyJLnz72Pyx7+cXOGulgefuS7njTsqB+16ar6/93krXX9lvux3pdXxWbk6r1eVWd6xN3/hR/n++VumrHxJrhzxYlo2WydJ8u83/5mT/7Bj+m8xJGcddWe1265IoV3Lq+rLfFdaHZ+VhXZ+rq73YnVdr5ZnRfv1k4Uf5/sXbJnFpZ8uvQN40eKFOeGirTPn49m5csSLabf211b6GirzZb4rJWvm/i3kz+IkWVK2JCdf0j8zil/KZac8l6+165ry8vKMumJgXnzjiVx84tMV8p4kmfL6Ixl5+e75+bDbsnPvA6o8r9AMOCm1EvA3qPlN1I0OHTrkiSeeyF577ZWmTZtm+vTpadu2bS6//PKMHz8+r776apLqPWB3dYxVX5vK33wzZdfdkKItNk+DA/ZfZn5R505pcPjQlL/wYsruursOKqy6PpvsluZNW+ehZ67LpXf/KNc/eGY++mROjt7jNzn/+EcLOtxfVPppbnr4t/ne6J7Z8/Sm2e9n6+RnVw/J62//a2mb9z6Ymf3PXDfHju6VTxdXvLXn7JuG5pujGmTyq39bOm3QyKKce/NRmfzq33LixTtk7zOa5+BftM8f/nLyMr/EzvmoOC++8fdst/me1ar78N92zohLd6uwzXfmzsjz/3ksg0YWLf1TPGf6Ctfz+HO3pm2r9st82G/QplNOGHJhps2akhsf+uzWvA/nl2TMHSek43qb5buDf7vSGu/5x6W5/59XZYceQ3L4wJ+ttP3rb/8rF93+/WzQplN+OvTmlX4BmL/gw5x13X5ZXPppzhx2e4UvADv12i8Dtx6We5+6NJNfezjJZxfcu//xhwzqd8QyX3K7ddg6h+5+ep599cGMf+qKLClbknNvPuKzi2IVe74/PfW+3PDQWeneYZuc9O0/rrT9u3PfzK9vODjN1mqZs468c6VfAEqXLM4vbzgwJR++nVMPvqbCF4DNOm6TQ3c/PU9PHZ+//vOqJJ8FoNfe///SZ9Pd6vTWuqMH/yYd1uueS+46MXM+Ks5rMyfnpgm/Sd+uu2efHX9QpXWcf8t385/Zz+d7e55Tpf9wrM5j75g9z07H9TbLxXf+IHM/fidJctPDv8nrb/8rJ+xzUYXAvjptK7OiY3p5Vte+adiwUU479PqULlmc0eOOTnl5ecrLyzP6lu+mdMnijDr0+jrrvVHo52eSrL9Oxxw/5IJML34x1z90VpJkzB0n5MP57+XUg6+u9D9JJx1waVo1b5vzbjk6Cxd9kidfvicPPnNtvrXt0VUKD1dWU2Wu+utn+3nfnYZXKTxc0X790YFXpFWzNjlv3JFLr51/vPtHKfno7Zx6yDWrFO5/Wavjs3J17qPKrOzY27HnPhm49bDc9/SVmfTKA/lk4ccZPe7orN1ivZy8/6UV2q5p1/LatKadn4V+LU+S/XY6Mb032TU3PvSLvFH8Yt77YGb++JeTs/H6W+Sob/2qSq+hJnzZz8rVfb2qzPKOvRZNW2fEwVfn/Y9m5ZK7Tkzy2RCu5407Kq2btc3JB16+Sm2XpxCv5bVhdXxWFtr5uTrei9V5vVqeFe3X5k1b5ZSDrsrcee/kkjuHJ0muvv+nefPdqfnBPr9f5XB/dVgT928hfxYnScMGDTPykOuypHxJRt9ydMrKyvKXiZdkyusTctg3/t8yeU+SbLnJLmnapEUef/7Was2jcoV9n8NKbLHFFrn33nuXmT5v3rxMnz49DRo0SK9evVa6nrvvvjvz58/PdtttVxNl1piijTdO4/F/WWGbht85JA2/c0gtVbTqduy1b53+J6qmlC5ZnDP+tEdenv6PfKPfsOy74/DMX/hh7nv6yvzoDzvl/BMez2Ydt8l663TIqQdfkzOv3TeX/uVH+dF/v4De/8+rM+FfN+XQAT/J1t0r3kb6+tuT88QLt2XP7Y/NoH5HZMq0R3LX38dkevGLOefYh5bexvz5mIabdfxyx/dph96Qy+75cVq3aJfDdv/p0ulrt1xvucssKVuSl2ZMTN9NK/8St8d2383EF+/MzY/8Lv177pNbHj0vH33yfn519D0r/VHnxTcm5o93n5wO63XPTw69YaU/0H04vyRnXfftJMlZR95Z6ZBQ/6u8vDy/G3t4Zr73ak7a/9L06Nx/mTY/3G9Mnpv2SM6/5bv5/fAnM/qW76Zd66/lh/tWfrvK4QN/lidfujtX3Htqps2akn+/9c8ct/f56bj+ZiusJUlmvvdafjd2aFo3XzdnHnlHmjRe8fNCFi1emLOu3z8fffJ+fnn0Pflau+Xf1vi5P/7lR3nxjb/nkAGnZZfeB1Za/9NT781l95ySvpsOyHnjjkqjho1z6sHX1OkPpGs1bpaRh1yXH//x6zn/1mPy7gdvpkmjpjn14KurVNctj56XR58bl936HJKDdh2x0var+9hbq3GzjDz0uvzoDzvlotuPy7BBZ+WmCb/JDj2GZI9tj17ltl9UlWP6i1b3vum0QY8c/a1f54rxI3PHExelUcMmmfL6hHx/79HLjIla2wr9/Ew++0x94oXbc8uj56a0dFGeeOH27LfTiemz6W6Vtm/Tcv2c+O0/5tc3Hpwxd5yQZ199MOut3SEnDFl5j+uq1vS/Hnvu1tzy6Lnp1eXrOX7IBSttv7L92qbl+jlp/0vzqxsOyp/u+0m26f7NPPjMtdl3p+FVCg9qypf5rFzd++iLqnrs/XC/MZkybUIuvPV72XKTXVI8d3p+fsTtWbtFu2XarmnX8tqypp2fhX4tTz7rLHbqIdfkuAt659ybj0jr5u2yYNG8jDr0upWemzXpy3xW1tT16n+t7Njbuts3MqT/D3L3P/6Qr/faPy/P+EfefHdqfj7stmWe2VCdtl9UqNfy2vJlPisL9fz8Mu9FTVyvvqgq+3Xrbt/I3juckHue/GParf213PnERenfY58q/Yhb09a0/Vvon8VJ0mmDz34Qu3L8qPzx7pPzwD+vTrevbZ3Ddl/2WUzJZz8KbNZx20qfs7GieVSu3vbgX5GXXnop5eXl6datW5o3rzjO4eGHH56f//znueuuu/K3v/0tv/rVr3L44Yenb9++OfTQQ+uoYuqrv0y8JM9NezS/OPrujDjoTxmy4wk5dPef5NIf/yutW7TLFfeeurTtjj33yX47nZjxT1+Rx5+/LW++++/84a4Ts8XGO1Taq+CN4hfyk+/cmBP2uTD77PiD/HzYrdnv6ydlyusT8tjztyxtN+Odl5MkG6276Zd6LQP7HZ6mTVqkTcsNMrDf4Uv/rOiX43c/eDMLPp23wm3/+MAr06Lp2vnpVXvm8edvzaEDfpLNN17xjxElH87Kr244MI0brZWzjrwzLZqtvcL2S8qW5Nc3HJx35s7IyQdcXumvy1903YNn5qmp92aPbb+7zHjhn2vZbJ2cctBVefeDN3P8hX3yztzpGXHw1cutp1HDxhl16HVZVLow9zx5aXp1+Xr23/lHK61lwafzctZ1++WTTz/OTw8fl/XX6bjSZS66/bi8NvPZDBt0VrbfYuV3b9w/6Zrc8+Qfs3W3QTl6j9+soP7rs7j005x48faZ+uZTOW7IBas8tM7q1KPTDjlwlxH557/vy/TiF3PckPOzQZtOK11u8qt/y1V/PT1d2m+ZUw6+aqXta+rY22Lj7XPIbqflHy/9JT+5clCar9U6Pz5g2YfEVbft/6rKMf2/amrfHLDLKenV5eu55v6f5k/3nZYtu+ycA3b+8UrXX9MK/fz83I8PvDIt1mqd2x4/Pxu165pjvjDO5xft2ueg7Nrn4Dz07PWZ83FxTjnoqpUe19WtKfnsORGjbzk667beKD87/NalQ7ksT1X36y69D8zuWx2Wv0y8OOfcfES+1q5bvrfnOSutpyat6mdlTe2j/1XVY69ls3Xy4wOvzHsfzsyEf92U3bc6LDtvuezdop9bk67ltWlNOz8L/VqeJBu27ZJj9zw3r7/9r0x+7aEcsttp2azjtiutqaat6mdlTV6vkqofe8fudW42atc1F9x6TG5//IJ8Y6uhyx3SoTptP1fo1/LasKqflYV+fq7Ke1FT16v/VZ39euze52bDtpvk1sdGp0WzdfKjA1Z+N0ttWdP2b6F/FifJgbuMSI9O/fOXiZdkSVlpRh563Qrvwt5w3U0z5+PifDT//WrNY1lrZMD/wgsvJKl8eJ6ePXvmzjvvzBFHHJHBgwfn6quvzrHHHptHH300TZrUwqBJrFEennxjOq6/ebp36JcP55cs/VO6ZFH6dRuUF6f/vcKQPMfufV66fm2rXHjbsfnV9QemYcPGOWPo2Eo/MDuut1l26rVfhWmHDvhJkmTii/83vuSH899LkrRq3rYGXuGKfThv5dtu2/qzB8V9OL8kndv3qvBglsosLl2UX15/QOZ8XJyRB1+bThv0WGkdV947MlOmPZL9djoxg/oNW2n7f7z4l9z08K+zWcdtc+L+K749d5vNvpm9tv9+Ppxfkj23Ozb9ug9aYfsWTddO40ZrJUm223zPpXdarMh5447KjHdezrF7npu+XQestP2dfx+Th569Pv177JOhA//fStu/8takjLnjhLRv0zk/HTp2hbc3dvnve/Th/JL06/7N7Ll95Q/FqkzpksUVzoMP55dkwaLPhpSat2DuMvOqa50Wn91N0rBBo2yz2R4raZ0Uz5me3/z50DRfq1WVbnOs6WNv2KAz07l9r3w4vyQ/3O/iFd42Wp22SfWO6aRm902DBg0y6pDrUl5enrKyJRl5yLVVOg8+9/EnlR8rny76ZJnpi0o/rfJ6k8I/P5PPHj691n8fErfVprtX6YGOa//33Fm7Rbv06LTyHk3VrenjT+bmrOu+nSVLFufnw26r0i3R1dmvw/e7JOu0WD8ffzInow65rloPsZy/4MNljpuy8rIsXvLpMtMXLvqkyuut7mdlTe+jpPrHXqvmbdOg6LNzYPstVvyw4jXtWv6/FpUue6x8+t9j5YvTP/5kbpXX+7k17fws9Gt5UvHu1h1Wcu58UU1+V6rue1HT16vqHHtNmzTPaYdcn48XzM3aLdZb+pDpL9v2c/XhWv6/auq7UnU/K+vD+bkq70VNXq+S6u/Xxg2bpPl/h3/p3mGbKn3O/6+a+q6UrJn7t5A/i5PP/i/3eb6zUbuu2Xj9Fd+F3br5Z3dXzJ33brXmsax6PUTP8qwo4D/99NNz+umn13ZJrKHefHdqPl28IAeetfxhbD6cX7K0l0iTRmvljMPG5nvn98z0d17K6Yf9ebk9/ir7IF239YZp2WydzH7/P/8z9bNbGstT8UFvi0sX5eNP5lSY1mytlqt1bMfPb6dc2bO+P/8Pa7ev9Vtpr7FL7hqeqW8+lUMH/KRKD2OZ8K+bcvsTF2bLLjvnuCHnr7T9m+/+O+eMOyJrN2+Xnx9xe5r8N+xbkS069c/4p6/IFiv5j/dn440fndLSRdl4/S1y099+nV17H5yN2i3/DoebHv5tnnjh9uzW99AcuOspK63l+f88nsvvGZEO63XPad9Z+S2tc+e9m19ct38aFDXImUfesdLbG5P/e7+qEjT8r5emT8ypl1X+n6YTLtp6mWnVeTjhjHem5toHfpbO7XvlrXf/nQtvPTZnH3v/ctsvXPRJzrru25m3YG5+9d17V/gefK6mj73GjZqk29f6ZXrxiyvdt9VpW91jujb2zYbrbpI2rTZY+vfqOOGirfLO3BnLTL/lsfNyy2MVH5B26sHX5FvbHlWl9daX8/OPfzk5JR++nU027JO//vNPGdjviPTqstNy2//r9Qm558k/ZtON+mbarCm54t5Tlw4TtzpqKisry9k3HZZZ70/LyftfVqVboqu7X1s1b5OO62+eufPeqdL6/9fPr9230luDH51ycx6dcnOFadV9OGFVPytrYx9V99hbtHhhzrv5yLRotk6aNmmRy+85JdtutkdaNW+z3GXWlGv5Fz3yr7EZfUvlQ6R98fvfBm065cYzpld53Wva+VkfruVz5737WbDStks++uT9XHT7cfnDyc+kcaOqdSSrye9K1Xkvavp6tSrH3udtOq6/+Qo/i6rbtj5cy7+opr4rJVX/rKwv52d134uavl6tyn79899+nWmzpmTTjfrm2VcfzIR/jc3uW31npct9ria/K62J+7fQP4vvn3RNnp46ful3k1sePTff2X0FGet/s6BKa1/RPJYh4Ic6VF5eni7tt1zhWKaf91T63NNTx6esbEmSzx4cs/tWh32pGtb5by+Fjz+ZU+F205dn/GOZ/0BU94K8Mp/3Ovt4wZyVtKya8U9dkfuevjL9un+zSreaTZv1XC689di0W/tr+dmwld9yPn/hRznrum/n00Wf5Jff/0uVbs+tjrsmXpznpj2ao/f4TXbsuW9+cNHWGX3rd3P+8Y9WelGb9O/7c90DP8smG/bOiINWfkvrex/MzK9uOChrNW6Ws468a6UP6lmypDS/uuGgvPfhzJx26A1Vur3xy9hkwz4559iHKkx79tUHc8tj5+Un37kxbVpusErrXVK2JOeNOzINihrkrCPvzIPPXJubHv5N/vrPqzJ4u2MqXebC247NtFlTctS3fpXtNh+80m3U9LFXU1blmK7pffNl/eQ7f86iLzyM/LQrB2Xg1sMyqF/F8S47VeFhUp+rD+fnP166Ow89e3323P7YHPWtX+V7o3vm/Fu/m8t+PKXSsdA/Wfhxzr/lu2nTcoOce9zD+eNdJ2X801dkl94HLfPcl1Wt6ZoH/l8mvXJ/9tjumOzd/7iVtq/ufv2yjhtyfuZ9oVf178Yenk026pODdx1ZYXp1f4yqqpreR9U99pLk6r+ekbfeeyWnH/bnrN1ivfzkym/mD385KT/5zg1Vek0rUujX8i/aZrNvLXNte+jZ6/O3yTcsM73JSp5J8L/WtPOzvlzLf3/78fn4kzk568g78+a7/86Ftx2bP//tVzlqj6o9ZLemvitVR21cr6p77NWU+nAtr0xNfVeqjvpwflb3vaiN61V19+trMydn7ITfpl/3b+asI+/M8Rf2zR/uOjFbdd19aWeblamp70r274p9FT+L3/3grVx294/TuX2vjBn+ZH5y5Tdzw0O/yI49913uHTcf/TcL+mLutbJ5LGuNDPgnTJhQ1yVAkuRr7brlw/nvpW/X3as01MOrM5/N1X89PVt3G5S1W7TLbY+fn627Dco2m31zmbZvvjt1mWnvfzQ78xZ8UOHC2rn9Zw+afrvktWy60f/96FXZfyBWdkEuSvV+WV1vnY5p3rR13i55rVrLVeblGU/lD3edmPZtu+SMoWNXuj8/+mTOZ7ealZXmZ8NuW+kFtry8POfefETeevffOX7IBav9QVYz33stV993ejbruG0OGXBaGjZomGHfPCtX//WM3DXx4nz76ydVaD+rZFrOvumwtGi6ds484o6V3rq3qPTT/OL6/fPBvHfz8yNur9IDSy+755S88J/Hs9/XT8rAfod/qddXFa2at1kmlHjvw5lJkp6dd1rlsfxvfuR3eeWtSfnBvr/P19p1zeEDf55/vPSXXHbPKenX/ZvLfJm77bELMuFfN2XHnvvmsG/8dDlr/T81fezVlFU5pmt636wOy+vVs+G6m1QaelVFfTg/P5r/fi667fvZoE2nHLf3+WnetFV+uN/FOfumw3LNX3+a4/dZ9ofmy+45Je/MnZFfHPWXtG7eNj/Yb0z+9frDueC27+WKU15I86atvlRNT7xwR8Y98rvPbon+9h9W2r66+3V16N6h3zLTmjRumratNlzl46k6anofrcqx98J/nsidf/99vt5r/6WdDPba/vtLw+Ude+5TtRdXiUK/lldm3dYbZt3WG1aY9uL0vyfJlzqG1rTzsz5cyx+e/OdMfPHOHLDzj9Ory9fTq8vX8/jzt+bmR36XnXp9O906LNsD/4tq6rtSVdXG9aq6x15NqS/X8srUxHel6qgP52d134vauF5Vd78uKv005958RJo2aZFTDvpTmjZpnlMPvjojLt01v7/jhJx15B0rXUdSM9+V7N+Vr/ur+Fl8/i3HZOGi+Rl1yGcPpx5x8NU5/oI+OW/cUfn98CcrHQ5oVsnraduqfaV3E6xoHstaI8fgh6+KQf2OyJyPi3P745V/GZv78TtL/77g03n5zZ8PTctmbfKT79yQkw+4LO3bdMm5Nx9R6Zhkb733Sia+eFeFaeMe+ewBLTv23G/ptN6b7JokmTrjqQptP/8PxP/+WVnA33StlssM67MiDRs0zJZdds6/33y6ystUZs5Hxfnl9QekQYOGOfOIO9J6Jc8TWFK2JL+58dAUz3kjP9h3THp02mGl27jxb7/KP176Swb0/U4O2GX1PvCzrKws5407KkvKl2TkIdctvfAdvNuodO+wTa6+7/TMKpm2tP2CRfNz1nXfzvyFH+Ynh/25SrcGXnzHD/LKW5M+u6V1BQ9C/NxDz96QuyZenC277Jzj91757Y1fVf+Z9Xz+/NAv03uTXbPfTicm+Wz4mpGHXJtPF32SC289tkL7Ka8/kivvG5WO622WUYdev9LbAWvj2Ksp1T2ma3rffFXVl/Pz4jt/mA/mv5tTDrpqafC3+1bfyU4998udf/99XnxjYoX2k/59/2e3Qm89bGlg27p525y8/2V5Z+6MCg+BX5WaZrzzcs4bd2TWbt4uZx5xx0pviV6V/VroamMfVffYW7BofkbfcnRaNW+bkw64dOn07+89Ouuvs3F+f/txqzSOfFL41/LatKadn/XhWv7+R7Pzh7tOTIf1uufowf/X+/iUg/6UtZo0z3njjsri0kUrXU9dq+nrVXWPvZpSX67lX0X15fyszntRG9er6u7XJLn+wTMz/Z2XcvyQC5b+SNqry9ez39dPysQX78yEf41d6Tpqiv27Yl/Fz+J7nrwsk197KIfufvrSH8S+1q5rjh7827zy1qTc8ui5yyyzpGxJXp35zNJMqqrzqNwa2YMfviq+vfPJefa1h3LF+JH517QJ2WrT3dO8aeu8+8Gb+ddrD6dJ46YZffwjSZLf33FCZr8/Lb895v6lv0ifMXRsfvzHr+e8m4/Mb465r8KFpkv7LfO7sYdnz+2PzdfadcuUaY/kiedvS+9Nds1ufQ5Z2m6dluulz6a75Z//vi/HDRn9pV7PFhvvkPsnXZVr7/9ZNt5gixQVNcgOPYas8MEzu/Q+KE9PHZ9/v/nPbL7xdqu03V/ecGDe/2hWdur17UwvfjHTi1+stF2bVhukX/dBuf7BMzP5tYfScf3N07RJi/zt2RuXu+6B/Q7PM688mBseOitrNW6WPpvutsL2/boPqnaP7NsePz8vz/hHvrfnORV+fW/YoGFGHnLtMkOB/P624/JG8Qvp1eXr+Wj++8utp9laLbNTr/1y39N/yv2Trs46LdfPxutvscL6d9ry2yl+/z+56Lbvp0FRg/TvuW8e+cLYif+rZ+cda2xYii+rdMninDvuyDRs2DinHnJNhfOje4d+OWTAaRVu73//o9n59Y0Hp6xsSb6+5QF58qW7l7vuTTbsnU026l3jx15Nqe4xXVZeVuP75quqPpyfjz13ax59blyG9D8hW3f7RoU2Jx9wWV5444kKtzzPW/BBLrjte1m39Ub54X5jKrTfsde++cZWQysMBfLG7BeqVVObVu1z5rX7ZcGn8zKg73fy3LRHl9t+o3U3TY/O/au9XwvdwkWf1Pg+qu6x16xJi1x576jMen9a/t/h49Km5fpL5zdv2iqnHPSnLzVUT6Ffy2vLmnZ+1pdr+YW3HZv5Cz/Mr787vsLQEuuv0zHH7X1+tYfqqQs1fb1alWOvptSHa/lXUX05P6v7XtT09WpVvqe/POOp3PrY6Gy3+Z7ZY7vvVmjz3cG/zdNTx6+2oWSqy/5dsa/iZ/HsOW/kyvEjs8mGfXL4wJ9VaPPtr5+Uv79we6VD9Tz/n8eycNH87NL7oGXWvaJ5VE7AD3WoUcPG+c13x+fuJ/+Yvz17Q65/8MwkSdu1N8rmHbfLoH5HJkkeeub6PDz5xhy826gKw/FsvvF2OXqP3+TK8aNy2+MX5KBdRyyd1/VrW+f4IRfkmvt/mnufvCzNm7bOvjsNz3f3+O0ytzUO6X9Cfn3jIXl15rOV3mJXVUcP/k0+/mRO7v7HHzJv4QcpLy/PDae/kWZtlx/w79bnkFx2zyn52+QbVjngf2n6Z7/gT3zxzkx88c7ltuu9ya7p131QXnzjs1vj33r33znn5mErXPfAfofn5Rn/SHl5eT5dvCAX3b7isedGH/9ItS7Snz8wbouNd8iB//P+fa5z+57LDAXy+a39L77x96WvpTIbtOmUnXrtt7TNB/PezbnjjlxhPTd0eSOvznw2i0oXJskyvQC/6NSDr/nKBvw3/u1XmTZrSk789h+yYdsuy8z/4u39s9+flg/nlyRJxk747QrXPWzQmdlko941fuzVlOoe00lqfN98FdWH87PpWi1z8Z0/SPu2XXLsXsv2nGnTaoNlbnn+w10npeTDt/Pr745Py2brLLPMF4cCqW5NfTbdbenQbPc9fWXue/rK5bYf1O/I9Ojcv9r7tdB9MO/dGt9H1T32pr7/VO596tLs0vug7Nrn4GXa9Os+6EsN1VPI1/LatKadn/XhWn7/P6/O01PH5+BdR1YaSu+5/feqPVRPXajp69WqHHs1pT5cy7+KZr73SsGfn+3W6VDt96Kmr1dJ9b6nf229bhk97qg0X6tVfnzgsufZWo2brbahZKpr7rx37d+V+Kp9Fm/RaYeMHnd0Fpd+mlGHXrfMsw+KioqWO1TP3569IW1btc+OPfddZt0rmkflisrL//tYYr5S5i8pTZsJD6284VfE3N0HpUXDVf+9aMmi5JExK29H1QwaWZRB/Y7MqEOvrVL7JWVLcvwFfbLpRn3zk8OW/wtwTbl5wu8y9pGzc8PpbxTsMB4AAAAArNicj4pzxO82yTF7/m6Z55mtaF4hGnBS0rBJzW/HGPxAGjZomO/vPTqPTBmbGe8s+3Demrb/zj9Kq2ZtcutjX26IIAAAAAC+um5+5Hdpt3aHDOl/QrXmsXx68H9F6cHPl1HdHvwAAAAAwOqjBz8AAAAAALBcHrIL9dBD57kxBwAAAADqOz34AQAAAACgAAn4AQAAAACgAAn4AQAAAACgABmD/yuqeYOGmbv7oLouo8qaN2hY1yUAAAAAAKxRBPxfUUVFRWnR0NsDAAAAAEDlDNEDAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFqN4H/CUlJRk1alS6du2apk2bpmPHjjn55JMzf/78HHPMMSkqKsoll1xS12UCAAAAAEC1NKrrAmrSlClTMnjw4BQXF6dFixbp0aNHZs2alTFjxmTatGmZM2dOkqRv3751WyhV9tEnczL24d/mHy/dlfc+nJnma7VK5/a9cuQ3f5ktN9m5rssDAAAAAKg19TbgLykpyZAhQ1JcXJwRI0bkzDPPTKtWrZIk5557bk477bQ0atQoRUVF6d27dx1XS1W8M3dGTr10tyxYNC97bHdMOrTrnvkLP8x/Zj+fko/eruvyAAAAAABqVb0N+E866aTMnDkzw4cPz+jRoyvMGzVqVG666aY899xz6dKlS1q3bl1HVVIdvxt7eJaUlebyU57Puq03rOtyAAAAAADqVL0cg3/q1KkZN25c2rVrl7PPPrvSNv369UuS9OnTZ5l5d955Z3bccce0aNEia6+9dnbaaae89NJLNVozK/b8fx7Pi2/8PQfvNirrtt4wpUsWZ+GiT+q6LAAAAACAOlMve/CPHTs2ZWVlGTp0aFq2bFlpm2bNmiVZNuAfM2ZMRowYkR//+Mf51a9+lU8//TRPP/10FixYUON1s3z//Pd9SZL119k4P7t6SP75yl9TVrYkX2vXLYcP/HkG9ju8jisEAAAAAKhd9TLgnzBhQpJkwIABy20zc+bMJBUD/mnTpmXkyJG58MILM3z48KXT99xzzxqqlKqa+e4rSZILbzs2G7XrllGHXJfFSxbl9sfOzzk3D0tp2eLsse3RdVwlAAAAAEDtqZcB/4wZM5IknTp1qnR+aWlpJk6cmKRiwH/11VencePGOfbYY1drPdtss02Ki4tX6zrrmyaNmuWK4a8td/4nn36cJGm2VquMPv6RNG7UJEmyU8/9csTvNsk1fz0j3+x3ZBo0qJejTgEAAAAABaRb925ZVFr1UWHat2+fZ555ptrbqZcB//z585NkucPqjBs3LiUlJWnVqlW6dOmydPo//vGPbLbZZrnxxhvz61//Om+99Va6deuWn//85/nOd76zyvUUFxfn7bffXuXl1wRNGzdf4fy1Gn82pNKArb6zNNxPklbN26R/j33y0LPX5633XkmnDbao0ToBAAAAAFZm9qxZWbi45p8hWi8D/vbt22fu3LmZPHly+vfvX2He7NmzM3LkyCRJ7969U1RUVGHe22+/ndNPPz3nnHNOOnbsmKuuuiqHHXZY1ltvvQwcOHCV62HFmjRqtsL57dbukCRp02rZfdm29YZJknkL5q7+wgAAAAAAqmnDjTaqdg/+VVEvA/6BAwdm6tSpOeecczJo0KB07949STJp0qQMGzYsJSUlSZK+fftWWK6srCzz5s3LDTfckP322y9J8o1vfCMvv/xyfvWrX61ywL8qt1asaZYsSh4Zs/z5m228Xe596rKUfDhzmXklH3w2bZ2W69dUeQAAAAAAVfbaq6+lYZOVt/uy6uWA5aNGjcq6666bt956Kz179syWW26Zbt26Zbvttssmm2yS3XffPUnF8feTpG3btklSIcgvKirKwIED8+KLL9beC2AZO/XcL83XapWHJ9+YBZ/OWzr9/Y9mZ+JLd6XDet3ztXZd67BCAAAAAIDaVS8D/g4dOuSJJ57IXnvtlaZNm2b69Olp27ZtLr/88owfPz6vvvpqkmUD/p49ey53nQsXLqzRmlmxVs3b5Pt7j07Jh2/npIt3yG2PXZCbJ/wuJ128Q0qXLMoP9724rksEAAAAAKhVReXl5eV1XURtmjdvXlq3bp2ioqJ8/PHHad78/x7uevfdd2fffffN7bffnv333z/JZ8P29O3bN23bts2jjz5aR1XXfysboudzT7xwR2559NxMn/1Ciho0yBYb98+wQWemV5edar5IAAAAAIAqGHBSamWInno5Bv+KvPTSSykvL0/37t0rhPtJMmTIkOy88875/ve/n/fffz8bb7xx/vSnP+Wll17KQw89VEcV87923nL/7Lzl/nVdBgAAAABAnVvjAv4XXnghybLD8ySfjbd/991357TTTssZZ5yRjz76KH369Ml99923dNx+AAAAAAD4KhDwf8E666yTyy+/PJdffnltlgUAAAAAANVSLx+yuyIrC/gBAAAAAKAQrHE9+CdMmFDXJQAAAAAAwJe2xvXgBwAAAACA+kDADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABWiNCPhLSkoyatSodO3aNU2bNk3Hjh1z8sknZ/78+TnmmGNSVFSUSy65pK7LZAWuf/CsDBpZtNw/e5zWuK5LBAAAAACoVY3quoCaNmXKlAwePDjFxcVp0aJFevTokVmzZmXMmDGZNm1a5syZkyTp27dv3RbKCn291/7ZaN2uy0x/Y/bzueWx87JDjyF1UBUAAAAAQN2p1wF/SUlJhgwZkuLi4owYMSJnnnlmWrVqlSQ599xzc9ppp6VRo0YpKipK796967haVmSTjXpnk42WfY8uuu24JMng7Y6p7ZIAAAAAAOpUvR6i56STTsrMmTMzfPjwjB49emm4nySjRo1Knz59Ulpams6dO6d169Z1WCmrYsGi+XnkuZuz3todss1me9R1OQAAAAAAtareBvxTp07NuHHj0q5du5x99tmVtunXr1+SpE+fPkun7bbbbikqKqr0z/HHH18rtVM1jz93az5Z+FG+uc1RadigYV2XAwAAAABQq+rtED1jx45NWVlZhg4dmpYtW1baplmzZkkqBvx//OMf89FHH1VoN378+Pz617/O3nvvXXMFU233T7oqRUVF+dZ2363rUgAAAAAAal29DfgnTJiQJBkwYMBy28ycOTNJxYC/R48ey7T7zW9+k/XWWy977GEYmK+Kt959JS++8fds1fUb2bBtl7ouBwAAAACg1tXbgH/GjBlJkk6dOlU6v7S0NBMnTkxSMeD/ovfeey/3339/fvCDH6RRo1XbXdtss02Ki4tXadk1RZNGzXLF8Neq3P7+f16VJBm8/fdqqiQAAAAAgFXSrXu3LCpdUOX27du3zzPPPFPt7dTbgH/+/PlJkgULKt+J48aNS0lJSVq1apUuXZbfA3zs2LEpLS3NsGHDVrmW4uLivP3226u8/JqgaePmVW67ZElpHnr2+rRuvm526vXtGqwKAAAAAKD6Zs+alYWLP6nx7dTbgL99+/aZO3duJk+enP79+1eYN3v27IwcOTJJ0rt37xQVFS13PTfccEO22GKLbLPNNl+qFlasSaNmVW775Mv3ZO68d/Ltr5+cJo3WqsGqAAD4qrr+wbNy6ICfpEnjpjn35qPS9Wt9s//OP6rWOia+eFfatGqfHp12WGnbByZdmz/efXK+1q5b/njyZz2r5s57N+eOPSKz5kxLk4Zr5cT9/5jem+ySJDn7pqH512sPZ7e+h+YH+15U3ZcHAECB23Cjjardg39V1NuAf+DAgZk6dWrOOeecDBo0KN27d0+STJo0KcOGDUtJSUmSpG/fvstdx7///e8888wz+e1vf/ulalmVWyvWNEsWJY+MqVrb+yf9d3ie7Y6pwYoAAPgqu+GhX2T/nX+UJo2brvI6Jr54V7p+rW+VAv4k6bvpgPziqLuW/vuq+36SLTrtkLOPvT+vvDUpZ1337dxw+htp1LBxTj/sz7n+wbMyb8EHq1wfAACF67VXX0vDJjW/nXob8I8aNSo33XRT3nrrrfTs2TObb755Fi5cmNdffz2DBw9O586d88ADD6xw/P0bbrghRUVFGTp0aC1WzoqUfDgrk165P5t33C5dNtyyrssBAKAOXHT78UmSH/9x5zQoaph1194ob74zNSMv/0be++CtdG7fKz8denMaN2qS0iWLc+0DP8uU1ydkcemidFive350wOV5ecaTeerluzP5tYfywKRrs+9Ow7PDFnvntzd9J58s/CiLShemz6YD8sN9x6RBgwaV1vHYc7fkutNeT5Js1nHbrNt6ozw/7bFs3X1gre0LAADWbJV/U60HOnTokCeeeCJ77bVXmjZtmunTp6dt27a5/PLLM378+Lz66qtJlv+A3fLy8vz5z3/Obrvtlo033rg2S2cFHnzm2pSVLfFwXQCANdiPDrgsSXLhD57I5adMyTot1s+0WVPyq6PvyVUjp2bux+/kiRduT5Lc8uh5adq4RS456Z+5/JQp6dJ+y1xz///L9lvsmR167JODdxuZy0+Zkj23/15aNlsnvzr6nvzxR8/m8lOezztzp+ex52+ptIaP5r+fJUsWp23r/7uVeoM2nfPuB2/W/A4AAID/qrc9+JNkiy22yL333rvM9Hnz5mX69Olp0KBBevXqVemyjz/+eGbMmJEzzzyzpsukGg77xhk57Btn1HUZAAB8xezU69tp2qR5kmTzjbfL7PenJUn+8dJdmb/ww6WBf+mSRdmgbedK11FWXpYrx5+Wl6b/PeXl5flg3rvp3L5XBvQ9tFZeAwAAVFe9DviX56WXXkp5eXm6d++e5s2bV9rmhhtuSLNmzXLggQfWcnUAAEB1/e9Y/A2KGmZJWWmSz+7M/eG+F2ebzb650nXc/vgF+WD+u7n4xKfTpHHTXHb3KVm0eGGlbVu3WDcNGzTKnI+Kl/bif2fu9Ky/jrt/AQCoPfV2iJ4VeeGFF5Isf3iehQsX5rbbbst+++2XVq1a1WZpAABAFTRfq1XmL/xwpe127LVf7njiwixc9EmSZOGiTzK9+KUkSYumrTN/wf+t4+MFc9O2Vfs0adw0cz4qzuPP37rCde/c+6Dc+9RnwwW98taklHz4dnpvuuuqviQAAKi2NbIH/8oC/qZNm+aDDz6oxYoAAIDqOHCXETntikFZq3HzrLv2Rsttd+hup+WG0k9z4sXbpyhFSZJDBpyWzu17ZmC/YTlv3FGZ+NJd2WfHH2b/r5+cX95wYL43umfWbb1Rtuq24oflHrvXOfnd2GE58pxuadywSX7ynRvTqGHj1fo6AQBgRYrKy8vL67qI2rb77rvnkUceyb333pu99tqrrsshyZJFySNj6roKAACo3AOTrs0/Xrorvzjqriovc/2DZ2Xegg/yg30vqrG6AAD4ahpwUtKwSc1vZ40comfChAkpLy8X7gMAAFWyVuNmmTZrSn7w+22q1P7sm4bm4ck3pnnT1jVcGQAAa7I1sgc/Xz168AMAAAAA9YUe/AAAAAAAwHIJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoADV+4C/pKQko0aNSteuXdO0adN07NgxJ598cubPn59jjjkmRUVFueSSS+q6TAAAAAAAqJZGdV1ATZoyZUoGDx6c4uLitGjRIj169MisWbMyZsyYTJs2LXPmzEmS9O3bt24LpUoWfDovd/59TB6ZMjbvzJ2exg3XSof1umfP7b+fb25zZIqKiuq6RAAAAACAWlNve/CXlJRkyJAhKS4uzogRIzJ79uxMnjw5xcXFOeecczJ+/PhMmjQpRUVF6d27d12Xy0qUlZXljKsG57oHfpbNOm6b4/Y+P0MH/r+UlS3J6FuOzp/u+0ldlwgAAAAAUKuKysvLy+u6iJpw2GGHZezYsRk+fHguvvjiZeb37ds3zz33XLp06ZL//Oc/dVAh/2vJouSRMcuf//L0J3PyH3bM/jv/KCfsc+HS6YtLF+W7522ejz+Zk7t+9UHNFwoAAAAAsBIDTkoaNqn57dTLHvxTp07NuHHj0q5du5x99tmVtunXr1+SpE+fPhWmP/HEE/nGN76Rdu3aZZ111skOO+yQO+64o8ZrZsXmf/pRkmTd1htVmN64UZOs3aJdmjZpURdlAQAAAADUmXoZ8I8dOzZlZWUZOnRoWrZsWWmbZs2aJakY8D/33HMZNGhQGjZsmGuvvTbjxo1Lx//f3r0GaVnedxz/7YFlWV2NQnRFGQLCpgILm4goSU3EApURM2o8BYOGSRyJB3SGARLN1MZoEMeGhKopyaStMwG71YwYoIcEsYTBjIUYHYK0IhHDabUbqAGC4sL2hS3tlpPgsE/u3c/nDTPXfd1z/599+eV+rqdPn1x11VVZtGhRh8zOwf1RnxE5sceH8vf/8mCWvfRE3tz+m/zmzX/LD/7hq1m36Re5Yeyfl3pEAAAAAIAO1Sl/ZHfp0qVJklGjRh1yz6ZNm5K0D/xNTU0pKyvLggULUlNTkyQZPXp0+vfvn3nz5mX8+PHHcWoOp7bmlNz7hR/nW09+Kff98Jr96zXda/NnN/wonxxyeemGAwAAAAAogU4Z+F9//fUkSd++fQ96vbW1NStWrEjSPvDv2bMnVVVV+9/uT5KKiorU1tZm3759xzzP8OHD09zcfMz3dwVVlT3yvdvWHXZPj+4n5iOnD8nIQZ/JoL6fyI7d2/Lj5x7JzPkT8vUvPJ1z68d00LQAAAAAAIc2sH5g9rTuft/76+rqsmrVqqN+TqcM/Lt27UqS7N598D9gU1NTWlpaUltbm379+u1fnzhxYh555JFMnTo1M2bMSGVlZebOnZt169bl0UcfPeZ5mpubs3nz5mO+vyuo7lZz2OuvbV2dOx7+RCZ/ZnYuGzl5//qoxs/lpr8YktlP3pTHvrI+FeUVx3tUAAAAAIDD2rplS95+9/fH/TmdMvDX1dVl+/bteeGFFzJy5Mh217Zu3Zpp06YlSYYOHZqysrL914YNG5ZnnnkmV155ZWbPnp0kOeGEE/LEE0/kU5/61Aeah8Orquxx2Os/Wj47e1rfzqeHXt1uvbqqJuefc2meXvFw3ti2Ib17nX08xwQAAAAAOKIzevc+6jf4j0WnDPyjR4/O2rVrM2vWrIwZMyb19fVJkpUrV2bixIlpaWlJkjQ2Nra7b926dbn22mtz3nnn5ZZbbklFRUXmzZuX6667LosWLcrFF198TPMcy1crupq9e5Jn5xz6estb730DYm/b3gPv3dv63r/7Wo/LbAAAAAAAR2PdK+tSUXX8n1N+/B/R8aZPn56ePXtm48aNGTx4cBoaGjJw4MCMGDEi/fv33x/q/+/5+0ly1113paamJk899VTGjRuXsWPH5rHHHsv555+fqVOnluKj8N/6nj4oSfKTlX/bbn3n7v/Mcy8/ndoep6R3rwElmAwAAAAAoDQ6ZeA/66yzsnz58lx66aWprq7Ohg0bcuqpp2bu3LlZvHhxXnnllSQHBv7Vq1dn2LBhqaxs/8WG4cOHZ+3atR02Pwe68sI7U1tzan7wj1/JA49PzMKf/1XmP/PNfHn2x7Ltd1vzhUvuc/4+AAAAANCllLW1tbWVeoiOtHPnzpx00kkpKyvLjh07UlPzvz/uetFFF2XLli15+eWX20X+iy66KBs3bsz69etLMXKXcKQjepJkS8v6/HDJvfnlq89k+4430r1bj5zduzFXXHhnLmy4smMGBQAAAAA4glFT0iFH9HTKM/gPZ82aNWlra0t9fX27uJ8kt956a6655ppcccUVufnmm1NRUZH58+dn2bJl+c53vlOiifkfvXudnenXPVbqMQAAAAAA/iB0ucC/evXqJAcez5MkV199dRYuXJhZs2blxhtvzN69e1NfX5958+ZlwoQJHT0qAAAAAAAcksD//4wfPz7jx4/vyJEAAAAAAOCodcof2T2cIwV+AAAAAAAogi73Bv/SpUtLPQIAAAAAAHxgXe4NfgAAAAAA6AwEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCAukTgb2lpyfTp0zNgwIBUV1enT58+ueOOO7Jr16588YtfTFlZWR5++OFSjwkAAAAAAO9bZakHON5efPHFjBs3Ls3NzTnhhBMyaNCgbNmyJXPmzMn69euzbdu2JEljY2NpB+WItu94I4/95J7869rF2b7zjZxSW5dPDrkiN479ek7s8aFSjwcAAAAA0KE6deBvaWnJZZddlubm5kydOjX33HNPamtrkyQPPvhgZsyYkcrKypSVlWXo0KElnpbD2b7zzdz+l+fnt7/bkksvuDkfOX1INrzxqyz6+Xez+tc/y7dvXZHqqppSjwkAAAAA0GE6deCfMmVKNm3alNtuuy0PPfRQu2vTp0/P/Pnz89JLL6Vfv3456aSTSjQl78fjz3wzb2x/PV+dMD8Xf+xz+9cH9f1EZs6fkB/97Fu5fvTXSjghAAAAAEDH6rRn8K9duzZNTU3p1atXZs6cedA95557bpJk2LBh7daXLFmSCy64INXV1TnttNMyefLkvPXWW8d9Zg7tpfXPpnu3HhnVeF279YuGXZuqyur888q/KdFkAAAAAACl0WkD/+OPP559+/bl+uuvz4knnnjQPT169EjSPvAvW7Ysl1xySc4888w89dRTuf/++/Pkk0/m8ssvT1tbW4fMzoHebX0nVZXVKSsra7deXl6e7t16ZOu2X+etXS0lmg4AAAAAoON12iN6li5dmiQZNWrUIfds2rQpSfvAf++992bgwIF54oknUl7+3v9/9OzZM5/97GezePHijB8//jhOzaH0PX1wNv7Hv+fVzS9mwJmN+9df3fxiduzeniR5c/tvcvIJvUo0IQAAAABAx+q0gf/1119PkvTt2/eg11tbW7NixYok7QP/888/n0mTJu2P+0kyduzYJMmCBQuOKfAPHz48zc3NR31fV1JV2SPfu23dIa9feeGdeW7Ngtz3w2vy5c98O/3qhmTDG2vy3R/fmcqKbmnd+27eeff3HTgxAAAAAMDBDawfmD2tu9/3/rq6uqxateqon9NpA/+uXbuSJLt3H/yP2NTUlJaWltTW1qZfv3771ysqKlJVVdVub7du3VJWVpY1a9Yc0yzNzc3ZvHnzMd3bVVR3qzns9Yb+F+au6/8ujz49JV/760uTJOXlFRk34kvpe/rgrPjVU6np7oeSAQAAAIDS27plS97ugBeSO23gr6ury/bt2/PCCy9k5MiR7a5t3bo106ZNS5IMHTq03bnu9fX1ef7559vtX7lyZdra2rJt27ZjnoXDq6rsccQ9nx52df644cq8tnV1dr+zI2ed9tGccuJpuW3OiFSUV6Z3rwEdMCkAAAAAwOGd0bv3Ub/Bfyw6beAfPXp01q5dm1mzZmXMmDGpr69P8l6snzhxYlpa3vtB1sbGxnb3TZkyJTfccEPuu+++TJ48OZs2bcott9ySioqKdsf2HI1j+WpFV7N3T/LsnCPvqyivaHcG/7bfNefVzb/M0P6fTnXV4b8FAAAAAADQEda9si4VVUfe90EdW7EugOnTp6dnz57ZuHFjBg8enIaGhgwcODAjRoxI//79c/HFFydpf/5+knz+85/PjBkz8o1vfCMf/vCHM3z48IwaNSqNjY0544wzSvFROIR9+/blkaenZF/b3kz4k7tLPQ4AAAAAQIfqtG/wn3XWWVm+fHmmTZuWZcuWZcOGDRk0aFDmzp2bm266KWeffXaSAwN/WVlZHnjggdx999157bXXcuaZZ+bkk09Oz549c/vtt5fio5Bk9zs7c9ucEfnkkCtSd2q/7Hr7rTz74uNZt+kXmXTJ/WkcMKrUIwIAAAAAdKhOG/iT5JxzzsmiRYsOWN+5c2c2bNiQ8vLyDBky5KD31tbWZujQoUmS73//+9m9e3cmTZp0XOfl0CorqtK/97A8+8v5+e2OranuVpP6Puflm1/6p5z30T8t9XgAAAAAAB2uUwf+Q1mzZk3a2tpSX1+fmpr257avWrUqP/3pT/Pxj388ra2tWbJkSebMmZOHHnpo/1v/dLxulVW5+/rHSz0GAAAAAMAfjC4Z+FevXp3kwON5kqR79+5ZuHBhZs6cmdbW1jQ0NKSpqSlXXXVVR48JAAAAAACHJPD/Pw0NDXnuuec6eiQAAAAAADgq5aUeoBQOF/gBAAAAAKAIuuQb/EuXLi31CAAAAAAA8IF0yTf4AQAAAACg6AR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACqisra2trdRDQFtbsu/dUk8BAAAAAPDBlXdLysqO/3MEfgAAAAAAKCBH9AAAAAAAQAEJ/AAAAAAAUEACPwAAAAAAFJDADwAAAAAABSTwAwAAAABAAQn8AAAAAABQQAI/AAAAAAAUkMAPAAAAAAAFJPADAAAAAEABCfwAAAAAAFBAAj8AAAAAABSQwA8AAAAAAAUk8AMAAAAAQAEJ/AAAAAAAUEACPwAAAAAAFJDADwAAAAAABSTwAwAAAABAAQn8AAAAAABQQAI/AAAAAAAUkMAPAAAAAAAFJPADAAAAAEABCfwAAAAAAFBAAj8AAAAAABSQwA8AAAAAAAUk8AMAAAAAQAH9F2bxnQFWTxAbAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter, MatrixExponential\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run VQE\n", + "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5.68938058]\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -1.0747029335397233\n", + " x: [ 6.167e+00]\n", + " nfev: 23\n", + " maxcv: 0.0\n", + "\n", + "Found ground energy: -1.0747029335397233, exact energy: -1.0803168169635073, difference: 0.005613883423783994\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 23 F =-1.074703E+00 MAXCV = 0.000000E+00\n", + " X = 6.166820E+00\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6.16681964]\n" + ] + } + ], + "source": [ + "# Optimal parameters so far\n", + "x_opt = getattr(res, 'x')\n", + "print(x_opt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Another iteration of the algorithm\n", + "We now compute the gradients again to see if we need another iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.00733676 0. 0. -0.00194228 0.00733676 0.\n", + " 0. -0.00194228 -0.01948449 0. 0. 0.07359726\n", + " 0. -0.04177782 0. 0. 0. 0.\n", + " -0.04177782 0. 0.07359726 0. 0. 0.00029312]\n", + "Found maximum gradient 0.07359726356645548 at index 11\n", + "Maximum gradient is below the threshold: False\n" + ] + } + ], + "source": [ + "gradient_threshold = 1e-3\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "\n", + "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", + "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAAAV1CAYAAABDPR50AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD8UElEQVR4nOzdeXRV5d024DthkFlBVLQgoIIKCChOqFWx0KoVtc4Vcai1aotaB7Dat9W+HayKQ9HWqXWuinNVrNWKI1Wr4ix1oIIiBI3gQAQhJN8fvvIZCYREQjjhutbKWrD3s/f5ZZ89nJx7P88uqqysrAwAAAAAAAAUmOKGLgAAAAAAAADqQtAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFqWlDF0D1Kisr82nFwoYuY5m1Km6SoqKiOi9fWZlULFiOBQEAAAAANJDiZsnX+LoUqAVB10rq04qFaT/+gYYuY5nN3mVIWjep++5UsSB5aMxyLAgAAAAAoIEMOj5p0ryhq4BVg6ELAQAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEirRNBVWlqaUaNGZaONNkqLFi3SpUuXnHDCCSkrK8uRRx6ZoqKiXHzxxQ1dJgAAAAAAALXQtKELqG/PP/98dtttt5SUlKR169bp1atXpk+fnjFjxmTy5MmZNWtWkqR///4NW2g9WXjl1am46eY0OemnKd7121XmVVZWZuHIn6Vy0qQ0vXhMirp3a5gil1FFRUXuePwPGffkZSmZPSVrtF4rO/Y7IId953/Tsnnrhi4PAAAAAABYwRp1j67S0tIMHTo0JSUlOfnkkzNjxoxMnDgxJSUlOfvsszNu3Lg8/fTTKSoqSt++fRu63HpRPHxY0q1rFl52RSrfL60yr+L2O1P54kspHn7ISh9yJckld5+YS+8+Keuv0ysj9r4oO/bdP3c+Pia/vHJoKioqGro8AAAAAABgBWvUQdfxxx+fadOmZcSIERk9enTatm27aN6oUaPSr1+/lJeXp1u3bmnXrl0DVlp/ipo1S9ORJyfz5mXh+Rcuml75zrRUXH1tijbZOMX779twBS6jKSWv5G8TLsoOffbJmYfdnt23OSrH7Hl+jhl6fp6f/FAefuGmhi4RAAAAAABYwRpt0DVp0qSMHTs2HTt2zFlnnVVtmwEDBiRJ+vXrV2X6W2+9lT333DNt27ZN+/btc+ihh+aDDz6o95rrS1GPjVJ80AGpfHZiKsb9PZULF2bhOaOTyso0GXlyipo0aegSa/TQ8zemsrIy+3zzp1Wm777NUWnRrFX+OfH6hikMAAAAAABoMI32GV033nhjKioqMmzYsLRp06baNi1btkxSNej65JNPMmjQoHTo0CE33nhj5s6dm1GjRmWPPfbIhAkTUlxcmNlg8bDvp+KJp7Lwij+nePJ/U/na6yn+0Q9T1KVzQ5e2TF575+kUFxVn4/W3rjK9ebMW2WC9/nn9nacbqDIAAAAAAKChNNqga/z48UmSQYMGLbHNtGnTklQNui6//PK8++67efTRR7P++usnSTp37pztttsud911V/bee+/6K7oeFTVtmqYjT0r5cT9NxT3jUtSnd4r32buhy1pmH3w8Pe1ad0zzpqstNq/j6t/Iq1P/lQXl89OsafMGqA4AAAAAAKiNysrKfPrpp0mSVq1apaioqE7rabRB19SpU5MkXbt2rXZ+eXl5JkyYkKRq0HXPPfdkhx12WBRyJcnAgQOzwQYb5O67765T0LXlllumpKSkVstUNm+eXPbHWr/WUrVunTRrlpSXp2irLVO0HHun9ezRM0Xz59d5+eZNW+byEW8scf5n8z9Ns2pCrs+XbfF5mwWfCroAAAAAgAbXo2ePzC+f29BlwEqtoqIiM2bMSJL0798/zz33XJ3W02iDrrKysiTJ3LnVn0zGjh2b0tLStG3bNt27d180/dVXX83++++/WPvevXvn1VdfrVMtJSUleffdd2u3UIvV0qxOr1a9ysrKLDzvgqR8QbJ+l1TccFOKd9oxReutu1zWP33G9GTeZ3VevkWzVkudv1rzVpk7571q580vn/d5mxrWAQAAAACwIsyYPj3zFnza0GVAwZg5c2adl220QVenTp0ye/bsTJw4MQMHDqwyb8aMGRk5cmSSpG/fvlW6w82ePTtrrLHGYuvr0KFDXnvttTrXUluVzZvn/Tq9WvUq7rwrlS+8mOIjDkvxwG1T/pPjsvC8C9Jk9Nl17g74Zeutu97X7tG1NGu2Wy9vz3w188s/W2z4wtKP3s3qrTvqzQUAAAAArBTWXW89PbqgBl/u0bXOOuvUeT2NNugaPHhwJk2alLPPPjtDhgxJz549kyRPP/10hg8fntLS0iSfd4erb88880ytlylbWJ724x9YLq9f+e67qbjy6hRt3DPFB+yXoiZNUnzIsFRcdU0q7rwrTb6319d+jdffeD2tm9R9d1o4P3lozJLnb9xlqzz7+v157e1/Z7MNvrlo+vwF8/Lf6c9nsw12rPNrAwAAAAAsT2+8/kaauC8flqqsrCxt2rRJkjz++ON1Xs/ye0jTSmbUqFFZc801884776R3797ZbLPN0qNHj2y99dbZYIMNsssuuySp+nyuJGnfvn0+/PDDxdY3a9asdOjQYUWUvlxVVlRk4bnnJxUVaTLypBQ1aZIknwdePXuk4sqrUzl9RgNXWbOd+x2YoqKi3P7YhVWm3/vUFZm34NPssvmwhikMAAAAAABoMI026OrcuXMee+yxfPe7302LFi0yZcqUdOjQIZdddlnGjRuX119/PcniQdemm25a7bO4Xn311Wy66aYrpPblqeLW21P56qQUH3ZIitZff9H0oiZN0uSUk5KKhVl43gWprKxswCpr1n3dzbLndj/J4y/fnjOv2Sf3PvXnXHr3ybn07pPSd4OdssvmBzd0iQAAAAAAwArWaIcuTD4Pre65557Fps+ZMydTpkxJcXFx+vTpU2XeHnvskdNPPz3Tpk1L586dkyRPPfVUJk+enHPPPXeF1L28VL79diquuS5Fm26S4n33WWx+Ubeuy30Iw/p07J4XZp323XLvU5fn35PGpV3rjtl7++Ny2Hf+N8XFjTazBQAAAAAAlqCocmXvylMPnnrqqWy77bbZeOON85///KfKvI8//jibbbZZOnbsmF/96leZN29eRo0albXWWitPPPHECgtUluczulaE2bsMqddndAEAAAAAFIpBx8czuqAGX35G15w5c9K6des6rWeV7Abz0ksvJVl82MIkadeuXcaPH5911103Bx10UH74wx9mu+22yz333KPXEAAAAAAAwEqkUQ9duCRLC7qSZMMNN6x2yEMAAAAAAABWHqtkF6Wagi4AAAAAAABWfqtkj67x48c3dAkAAAAAAAB8Tatkjy4AAAAAAAAKn6ALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCA1begCqF6r4iaZvcuQhi5jmbUqbtLQJQAAAAAAAKsYQddKqqioKK2beHsAAAAAAACWxNCFAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkFaJoKu0tDSjRo3KRhttlBYtWqRLly454YQTUlZWliOPPDJFRUW5+OKLG7pMAAAAAAAAaqFpQxdQ355//vnstttuKSkpSevWrdOrV69Mnz49Y8aMyeTJkzNr1qwkSf/+/Ru2UGp04/iz8sa7E/PGtGdTMuutrNO+a64/fUpDlwUAAAAAADSQRt2jq7S0NEOHDk1JSUlOPvnkzJgxIxMnTkxJSUnOPvvsjBs3Lk8//XSKiorSt2/fhi6XGlz599Pz/Jvjs96aG6Zty/YNXQ4AAAAAANDAGnXQdfzxx2fatGkZMWJERo8enbZt2y6aN2rUqPTr1y/l5eXp1q1b2rVr14CVsiyu/dnk3P6rD3L2jx7Imu3Wa+hyAAAAAACABtZog65JkyZl7Nix6dixY84666xq2wwYMCBJ0q9fv0XTvgjGtt5666y22mopKipaIfVSs3XX3KChSwAAAAAAAFYijTbouvHGG1NRUZFhw4alTZs21bZp2bJlkqpB15tvvpnbbrstnTp1ylZbbbVCagUAAAAAAKD2Gm3QNX78+CTJoEGDlthm2rRpSaoGXTvuuGNmzJiRu+66K4MHD67fIgEAAAAAAKizpg1dQH2ZOnVqkqRr167Vzi8vL8+ECROSVA26iouXf/a35ZZbpqSkZLmvtzFp3rRlLh/xRkOXAQAAAADwtfXo2SPzy+c2dBmwUquoqFj07x122CHPPfdcndbTaIOusrKyJMncudWfTMaOHZvS0tK0bds23bt3r9daSkpK8u6779braxS6Fs1aNXQJAAAAAADLxYzp0zNvwacNXQYUjJkzZ9Z52UYbdHXq1CmzZ8/OxIkTM3DgwCrzZsyYkZEjRyZJ+vbtm6KionqvhaVr3rRlQ5cAAAAAALBcrLveenp0QQ0qKioyY8aMJMk666xT5/U02qBr8ODBmTRpUs4+++wMGTIkPXv2TJI8/fTTGT58eEpLS5Mk/fv3r/dannnmmXp/jUK3cH7y0JiGrgIAAAAA4Ot74/U30qR5Q1cBK7eysrK0adMmSfL444/XeT3L/4FUK4lRo0ZlzTXXzDvvvJPevXtns802S48ePbL11ltngw02yC677JKk6vO5AAAAAAAAKByNtkdX586d89hjj2XkyJF55JFHMmXKlPTq1SuXXXZZjjrqqGy44YZJBF2F5IFnr8t7s6cmST4sez/lC+fnr//8TZJk7fZdM2TA8IYsDwAAAAAAWMEabdCVJJtuumnuueeexabPmTMnU6ZMSXFxcfr06dMAlVEX9/37L3nxv49UmXb1P36RJOm7wU6CLgAAAAAAWMU06qBrSV555ZVUVlamZ8+eadWq1WLzb7311iTJq6++WuX/3bp1y5ZbbrniCqWK8459uKFLAAAAAAAAViKrZND10ksvJVnysIX7779/tf8/7LDDcvXVV9drbQAAAAAAACwbQVc1KisrV2Q5AAAAAAAA1EFxQxfQEGoKugAAAAAAAFj5rZI9usaPH9/QJQAAAAAAAPA1rZI9ugAAAAAAACh8gi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAK0ioRdJWWlmbUqFHZaKON0qJFi3Tp0iUnnHBCysrKcuSRR6aoqCgXX3xxQ5fJUkx7//Vc/Y9f5riLts1+Z66VPf+nbY4+v3/++uBvM3d+WUOXBwAAAAAANICmDV1AfXv++eez2267paSkJK1bt06vXr0yffr0jBkzJpMnT86sWbOSJP3792/YQlmq+56+Mnf9648Z2GvPfGvzYWnSpFlemPxQrr7vf/LoCzdnzHFPZrVmLRu6TAAAAAAAYAVq1EFXaWlphg4dmpKSkpx88sk544wz0rZt2yTJOeeck1NPPTVNmzZNUVFR+vbt28DVsjTf3Gy/fH/QaWndcvVF04YOPCbf6NgjNzz42/z933/J3tuPaMAKAQAAAACAFa1RD114/PHHZ9q0aRkxYkRGjx69KORKklGjRqVfv34pLy9Pt27d0q5duwaslJps3GXLKiHXF3bud2CSZErJyyu6JAAAAAAAoIE12qBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12/RtFtvvTX77rtvunbtmlatWmWTTTbJz3/+88yZM2eF1E3tvP/RtCRJ+zbrNHAlAAAAAADAitZog64bb7wxFRUVGTZsWNq0aVNtm5YtP3+m05eDrtGjR6dJkyb53e9+l7///e859thjc8kll2TXXXdNRUXFCqmdZbOwYmH++s9fp0lx0+yy+cENXQ4AAAAAALCCNdpndI0fPz5JMmjQoCW2mTbt895AXw667r777qy11lqL/r/TTjtlrbXWyrBhw/L4449nxx13rKeKqa1L7vppXp36RH6w2+/SZe2NG7ocAAAAAABgBWu0QdfUqVOTJF27dq12fnl5eSZMmJCkatD15ZDrC1tuuWWS5N13361TLVtuuWVKSkrqtOyqonnTlrl8xBvL3P7q+36Rv024ON/d5kf5/i6n1WNlAAAAAAC106Nnj8wvn9vQZcBK7cuj6O2www557rnn6rSeRht0lZWVJUnmzq3+ZDJ27NiUlpambdu26d69+1LX9dBDDyVJNt100zrVUlJSUueQbFXRolmrZW577f1n5q8P/ibf2eqInLDvpfVYFQAAAABA7c2YPj3zFnza0GVAwZg5c2adl220QVenTp0ye/bsTJw4MQMHDqwyb8aMGRk5cmSSpG/fvikqKlriet5999384he/yK677pr+/fvXuRaWrnnTlsvU7tr7z8x1D/wqQwYclpP2+/NS3zsAAAAAgIaw7nrr6dEFNaioqMiMGTOSJOuss06d19Nog67Bgwdn0qRJOfvsszNkyJD07NkzSfL0009n+PDhKS0tTZKlhldz5szJXnvtlebNm+fKK6+scy3PPPNMnZddVSycnzw0Zultrnvgf3PdA7/K4C2G55QDrkxxcfGKKQ4AAAAAoBbeeP2NNGne0FXAyq2srCxt2rRJkjz++ON1Xk+jDbpGjRqVG264Ie+880569+6dTTbZJPPmzcubb76Z3XbbLd26dcs//vGPKs/n+rK5c+dm6NCheeutt/LYY49l3XXXXcG/AV/2twl/zLX3n5G111g/W/QYnPHP3VBlfvu262RAzyENVB0AAAAAANAQGm3Q1blz5zz22GMZOXJkHnnkkUyZMiW9evXKZZddlqOOOiobbrhhklQbdC1YsCD77bdfnnnmmTz44IPp1avXii6fr3jtnaeTJO99+HbOGXvYYvP7brCToAsAAAAAAFYxRZWVlZUNXcSKNmfOnLRr1y5FRUX55JNP0qpVq0XzKioqctBBB+Wuu+7Kvffem1122aUBK111LMvQhQAAAAAAhWDQ8TF0IdTgy0MXzpkzJ61bt67Tehptj66leeWVV1JZWZmePXtWCbmS5Cc/+UluueWW/OxnP0urVq3y5JNPLpq34YYbZq211lrR5QIAAAAAAFCN4oYuoCG89NJLSaoftvDvf/97kuT3v/99Bg4cWOVn3LhxK7ROAAAAAAAAlmyV7NG1tKBrypQpK7gaAAAAAAAA6kKPLgAAAAAAAArSKtmja/z48Q1dAgAAAAAAAF/TKtmjCwAAAAAAgMIn6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIK0SgRdpaWlGTVqVDbaaKO0aNEiXbp0yQknnJCysrIceeSRKSoqysUXX9zQZQIAAAAAAFALTRu6gPr2/PPPZ7fddktJSUlat26dXr16Zfr06RkzZkwmT56cWbNmJUn69+/fsIWyVO+891qu/+f/5o13J+aDj6dn4cIFWXuN9bP1Jrtn/51HZs126zZ0iQAAAAAAwArWqIOu0tLSDB06NCUlJTn55JNzxhlnpG3btkmSc845J6eeemqaNm2aoqKi9O3bt4GrZWne/2haZn08I9v3+V7WWr1zmhQ3zVslL2XcU5fnoRduyqUnPp/2bdZu6DIBAAAAAIAVqFEHXccff3ymTZuWESNGZPTo0VXmjRo1KjfccENeeOGFdO/ePe3atWugKlkWW/T4Vrbo8a3Fpm/Wfcf85voDcv/TV+fAQaMaoDIAAAAAAKChNNpndE2aNCljx45Nx44dc9ZZZ1XbZsCAAUmSfv36LZr22GOPZfDgwVl33XWz2mqrpXPnzjnwwAMzadKkFVI3tbNO+65JkjlzZzdwJQAAAAAAwIrWaHt03XjjjamoqMiwYcPSpk2batu0bNkySdWga/bs2dlss81y9NFHZ+211860adNy1llnZeDAgXn55ZfTuXPnFVI/1Zu/YF7mzp+T+QvmZerMV/Pne09Nkmy9ye4NXBkAAAAAALCiNdqga/z48UmSQYMGLbHNtGnTklQNuvbcc8/sueeeVdpttdVW2XjjjXPbbbflhBNOqIdqWVb3/vvP+eOdxy36f6f23fKz71+fzTb4ZgNWBQAAAAAANIRGG3RNnTo1SdK1a9dq55eXl2fChAlJqgZd1VlzzTWTJE2b1m1zbbnllikpKanTsquK5k1b5vIRb9TYbvvee2f9tTbJ3Plz8ua7z+WJV+/KR2WlK6BCAAAAAIBl06Nnj8wvn9vQZcBKraKiYtG/d9hhhzz33HN1Wk+jDbrKysqSJHPnVn8yGTt2bEpLS9O2bdt07959sfkLFy5MRUVFpk6dmtNOOy2dOnXKAQccUKdaSkpK8u6779Zp2VVFi2atlqndWmt0zlprfD585PZ99s43N9s3I8Zslc8WfJrv73JafZYIAAAAALBMZkyfnnkLPm3oMqBgzJw5s87LNtqgq1OnTpk9e3YmTpyYgQMHVpk3Y8aMjBw5MknSt2/fFBUVLbb8TjvttKjH10YbbZTx48dnrbXWqnMtLF3zpi3rtNwG6/XNht/YPHf/60+CLgAAAABgpbDueuvp0QU1qKioyIwZM5Ik66yzTp3X02iDrsGDB2fSpEk5++yzM2TIkPTs2TNJ8vTTT2f48OEpLf18uLv+/ftXu/xf/vKXfPjhh3nrrbdy7rnn5tvf/nYmTJiQ9ddfv9a1PPPMM3X+PVYVC+cnD42p27LzF8zNJ5/OWr4FAQAAAADU0Ruvv5EmzRu6Cli5lZWVpU2bNkmSxx9/vM7rKV5eBa1sRo0alTXXXDPvvPNOevfunc022yw9evTI1ltvnQ022CC77LJLkiU/n2vjjTfONttsk4MOOigPPvhgPvnkk5xzzjkr8lfgS2Z9XP0zzp5/86FMKXk5m3TddgVXBAAAAAAANLRG26Orc+fOeeyxxzJy5Mg88sgjmTJlSnr16pXLLrssRx11VDbccMMkSw66vmyNNdbIRhttlDfffLO+y2YJxtx+bD74ZEb6b7RL1lmja+aXz8sb057Nwy/clJartc3Re5zX0CUCAAAAAAArWKMNupJk0003zT333LPY9Dlz5mTKlCkpLi5Onz59alzPe++9l9deey3bbLNNfZTJMhi0+ffzwLPX5sFnr8uHZe+nKEVZp33XfHfbo3PATiOzdvvaDykJAAAAAAAUtkYddC3JK6+8ksrKyvTs2TOtWrWqMu+QQw7JRhttlP79+2eNNdbIG2+8kQsuuCBNmzbNiSee2EAVs1O/A7JTvwMaugwAAAAAAGAlskoGXS+99FKS6oct3HbbbXPttdfmD3/4Q+bNm5cuXbpk0KBBOf3009O1a9cVXSoAAAAAAABLIOj6ihEjRmTEiBEruiQAAAAAAABqqbihC2gISwu6AAAAAAAAKAyrZI+u8ePHN3QJAAAAAAAAfE2rZI8uAAAAAAAACp+gCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgILU6IOu0tLSjBo1KhtttFFatGiRLl265IQTTkhZWVmOPPLIFBUV5eKLL27oMqmDefM/zfCzNsiQkUW56I4RDV0OAAAAAACwgjVt6ALq0/PPP5/ddtstJSUlad26dXr16pXp06dnzJgxmTx5cmbNmpUk6d+/f8MWSp1c849f5qOy9xu6DAAAAAAAoIE02h5dpaWlGTp0aEpKSnLyySdnxowZmThxYkpKSnL22Wdn3Lhxefrpp1NUVJS+ffs2dLnU0hvTJub2xy/MoUN+1dClAAAAAAAADaTRBl3HH398pk2blhEjRmT06NFp27btonmjRo1Kv379Ul5enm7duqVdu3YNWCm1tbBiYS649ahstfGu2WGzfRq6HAAAAAAAoIE0yqBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12+J69ltt91SVFSUM888sz7KpI5uf/SCvPPefzJib89WAwAAAACAVVmjDLpuvPHGVFRUZNiwYWnTpk21bVq2bJlkyUHXzTffnOeff76+SqSOZsx6K9fef0aGDfllOnXo1tDlAAAAAAAADahpQxdQH8aPH58kGTRo0BLbTJs2LUn1QdfHH3+cn/70pxk9enQOOeSQr13PlltumZKSkq+9nsasedOWuXzEGzW2+8Ntx6TTmhtkvx1PWgFVAQAAAADUXo+ePTK/fG5DlwErtYqKikX/3mGHHfLcc8/VaT2NMuiaOnVqkqRr167Vzi8vL8+ECROSVB90/fznP0/Pnj0zbNiw5RJ0lZSU5N133/3a62nMWjRrVWObfz57fSa+8UDOP/bRNG3SbAVUBQAAAABQezOmT8+8BZ82dBlQMGbOnFnnZRtl0FVWVpYkmTu3+sR87NixKS0tTdu2bdO9e/cq85555plcccUVefbZZ5dbPZ06dVpu62qsmjdtudT588s/y2V3n5StN9k97dt2yrulbyZJSj/6PEAsm/dR3i19M6u37pg2Ldeo73IBAAAAAJZo3fXW06MLalBRUZEZM2YkSdZZZ506r6dRBl2dOnXK7NmzM3HixAwcOLDKvBkzZmTkyJFJkr59+6aoqGjRvIULF+boo4/OiBEj0rt37+VWzzPPPLPc1tVYLZyfPDRmyfPnL5ibD8vez1OTxuWpSeMWm//gxOvz4MTr86Pvnpv9dz6lHisFAAAAAFi6N15/I02aN3QVsHIrKytLmzZtkiSPP/54ndfTKIOuwYMHZ9KkSTn77LMzZMiQ9OzZM0ny9NNPZ/jw4SktLU2S9O/fv8pyF198cWbOnJkzzzxzBVdMTVo0b51fDL9lsekfzXk/Y+74cbbaeNfsuvWR2WDdvg1QHQAAAAAA0BAaZdA1atSo3HDDDXnnnXfSu3fvbLLJJpk3b17efPPN7LbbbunWrVv+8Y9/VHk+V2lpaX7xi19k9OjRKS8vz4cffrho3rx58/Lhhx+mXbt2KS4uboDfiKZNmmXHvvstNr1k1pQkybprbljtfAAAAAAAoPFqlKlN586d89hjj+W73/1uWrRokSlTpqRDhw657LLLMm7cuLz++utJUiXomjZtWj755JMcffTRad++/aKfJDn77LPTvn37vP322w3y+wAAAAAAALC4osrKysqGLmJFmjNnTtq1a5eioqJ88sknadWq1aLp1T1La9CgQTnssMNy+OGHZ9ttt02LFi1WdMmrhJqe0QUAAAAAUCgGHR/P6IIafPkZXXPmzEnr1q3rtJ5GOXTh0rzyyiuprKxMz549F4VcSdKmTZvsvPPO1S7TrVu3Jc4DAAAAAACgYTTKoQuX5qWXXkpSddhCAAAAAAAACs8q16OrtkHXKjayIwAAAAAAQMHQowsAAAAAAICCtMr16Bo/fnxDlwAAAAAAAMBysMr16AIAAAAAAKBxEHQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkJo2dAFUr7KyMp9WLGzoMpZZq+ImKSoqaugyAAAAAACAVYigayX1acXCtB//QEOXscxm7zIkrZvYnQAAAAAAgBXH0IUAAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUpFUi6CotLc2oUaOy0UYbpUWLFunSpUtOOOGElJWV5cgjj0xRUVEuvvjihi6zXiy88uos+Pbuqbjv/sXmVVZWpvyUU7Pgu3um8q0pK764Whoysqjan6E/b9PQpQEAAAAAAA2gaUMXUN+ef/757LbbbikpKUnr1q3Tq1evTJ8+PWPGjMnkyZMza9asJEn//v0bttB6Ujx8WCqefCoLL7siRQO2SNFaHRfNq7j9zlS++FKKf3B4irp3a7gia2Gz7t/M7tv8qMq0pk2aNVA1AAAAAABAQ2rUQVdpaWmGDh2akpKSnHzyyTnjjDPStm3bJMk555yTU089NU2bNk1RUVH69u3bwNXWj6JmzdJ05MkpP/7ELDz/wjQ96zdJksp3pqXi6mtTtMnGKd5/3wauctl16rBBBg84pKHLAAAAAAAAVgKNeujC448/PtOmTcuIESMyevToRSFXkowaNSr9+vVLeXl5unXrlnbt2jVgpfWrqMdGKT7ogFQ+OzEV4/6eyoULs/Cc0UllZZqMPDlFTZo0dIm1sqB8fuZ+NqehywAAAAAAABpYow26Jk2alLFjx6Zjx44566yzqm0zYMCAJEm/fv0WTXv44YdTVFS02E+hD21YPOz7yQYbZOEVf07FHy9N5Wuvp/jwQ1PUpXNDl1Yrj710a/b4eavs+T9ts/+Za+fiO49L2dyPGrosAAAAAACgATTaoQtvvPHGVFRUZNiwYWnTpk21bVq2bJmkatD1hT/+8Y/ZYostFv2/devW9VPoClLUtGmajjwp5cf9NBX3jEtRn94p3mfvhi6rVjbpsnV27Lt/1uu4UT6d93H+/Z9787cJF+fFyY/kDyP+lZarVf8+AwAAAAAAjVOjDbrGjx+fJBk0aNAS20ybNi1J9UFXr169su2229ZPcQ2ldeukWbOkvDxFW22ZouLC6tB30fFPVfn/kC0PTfd1++aq+36e2x//Q4Z96+cNVBkAAAAAANAQGm3QNXXq1CRJ165dq51fXl6eCRMmJKk+6Fqettxyy5SUlNRqmcrmzZPL/rjcaqisrMzC8y5Iyhck63dJxQ03pXinHVO03rrLZf09e/RM0fz5dV6+edOWuXzEG7Ve7oCdR+b6B36Vf08aJ+gCAAAAAFYKPXr2yPzyuQ1dBqzUKioqFv17hx12yHPPPVen9TTaoKusrCxJMndu9SeTsWPHprS0NG3btk337t0Xm3/ggQemtLQ0a665Zvbcc8/8/ve/T8eOHetUS0lJSd59993aLdRitTSr06tVr+LOu1L5wospPuKwFA/cNuU/OS4Lz7sgTUafnaKioq+9/ukzpifzPqvz8i2atarTck2bNMua7dbLR2WldX5tPvfv//w9v7hqaK44+eWsv/YmNbY/5Hfdsk77bjnv2Ie/9mvPXzAvPzh3k+yy+bD8YLfffu31AQAAALDyueSuE/PUpHH58ymvpGmTZss8rxDNmD498xZ82tBlQMGYOXNmnZdttEFXp06dMnv27EycODEDBw6sMm/GjBkZOXJkkqRv375Vgp7VV189I0eOzI477pg2bdrkiSeeyFlnnZUnn3wyzzzzTFq0aFGnWmqrsnnzvF/rpZawrnffTcWVV6do454pPmC/FDVpkuJDhqXiqmtSceddafK9vb72a6y37npfu0dXXcxfMC/vfzQtm3ZtZMNMrmALF5bnsrtPzrc2H7ZMIdeS3P7YhWndYo18Z6vDa7XcrY+enzlzP8z+O52SJLnz8Yvyx78dnyN2/W0O/tbpi7X/+NNZOWp07zRv2iKXnfRifnHV0Lz430dqfJ3hQ87Iod8+M9fef2aue+BXNbbvu8FOOe/Yh/PC5IdzyqVLHgb1yx44tzL/e+1+mfDyHTnv2EfSp/sOi7V5+a3Hc/IlO2X7Pt/LLw+9NX/5++m5afxZOXn/v2TXrX9QpW1lZWVOuXRQJk19In/86bPp3qlPzrnp8Dzw7DU11jJkwGEZddDV+cfTV2f0zUfU2H6d9l1z/elTUjJrSoaftfgNANW57rS3cueEi3Lbo+fntIP/ml02P3ixNu+Wvpljzu+Xbutulgt/MiFNipss07q/rnnzP83RF/RL2dwPc8Upr6R9m7WrzJ8689Uce+EW2bjLVjnvmEdSXFycISOXLfgffcxD6bfhzjn5kp3rbd/79RF35+jz+2Z++bxcccoradeqw2Ltbnjwd7nqvp/nJ3uNyW2Pnr9sbfe+KN079anVPp2kXrfNwF575viLt02/DQfl90f9o9p2P7viO3lh8kMZM+LJ9Oi8RbVt6kOhH5+dOnTLuCcvz4W3HZ1hg3+Rw7/zv4u1+/2Nw/PgxOtz1g//kS03/nZmfVySH57XO2u0XiuXnPhcVmtW9Ro98Y0H87MrhmRQ/+/ntIP/WqeaDvldt8ycPbXG9qcccFW+s9XhtdquR+z6mxx1Xp+stUaX/OmEZ9OsafPF2l1w649y71NX5NdH3J1te+2xTLV/XZfefXKtzpWH/X7DettGddn3kuR3fz04D79wU35/1APZose3qrT7bMHcHHNB/3xUVpo/n/xKHn3xllXqWr6irGrHZ/+Ndinoa/l5xz6cioqKnHzpTnntnadzyU+fS9d1Nq3SbvYnM3PUeX3SuuUauezEF9Kied1uAKyt9z+cVqv34qOy0nq/XtVm32vXes388qo9s/s2R+XE/S5frM2C8vn58R8G5P0P38lP9r4o59x06DK1veLkl3PVff9T8NfyFaW258rGcHzW9r2o7+tVUvvP6c+8dn9O+/N3MniL4Tn1+9cu1u7q+36Rvz74m5y43+XZfZujlmndy8uqtn232ni3gj4Xf2erw/NWycv5yYUDsmnXgRl9zEOL3Uz/93//Jeff8sN8f5fTF93YfODOp2bck5fl7icuyfd2OL5K+6XNK0TrrreeHl1Qg4qKisyYMSNJss4669R5PY026Bo8eHAmTZqUs88+O0OGDEnPnj2TJE8//XSGDx+e0tLPewD179+/ynKbb755Nt9880X/33nnndOnT5/sueeeufHGG3PEETVfUL7qmWeeqfUyZQvL0378A7Ve7qsqKyqy8Nzzk4qKNBl5UoqafP4Fc/EB+6Vywr9SceXVKd5m6689hOHrb7ye1k3qvjstnJ88NGbJ8z8u+yDtWq+52PSr//GLLKwoz7abDq3za5M88uItefu9STl92I3LvMyVo15LUap+gLn9sQuzTvtutQq6PlswN7c8cm6+s9URaduqfZJkr+1HZMIrd+b6B36VbTfdIxus17fKMhfd8ZPMnjMz5x49Pq1atM3B3/p5dtv6h9Wuf8HCz3Lp3Sdl7mefpFfX7ZIkO/TZJ+utudESa7rlkdH574wXFv2xtv7am+bUg65bYvun/jMuDz9/U3p32z5Jcvw+l+Sltx7LuWMPz6UnvZCWzVsvajtv/qc5d+zhade6Y07Y99IkyaFDzsyTr96dS+8+KQN6fjtrrdF5UfvbH7swL/73kRy521np3qlPkmSPbY/OFj0GV1tLZSpz1d9Pz/sfTVtUf98Ndlxq/Q88e00mvvHP9On2efvV26y11PavvfPv3DnhonyjY4+s0Wbt/GDX3+bp//w9F995XPptOChrtvv/55OKioqcO/bwVKYyow68ZoWFXEnSonmrjDzgqpx8yU4Zc9uxOeOw2xbNW7iwPGffdGiaFDfNyAOuTvH/PbNwab/3jFn/zbX3n5HVW3dM57U2TpJ63fdatWibUw68KiMv2yUX3f7j/PyQm6q0fWvGS7n+gV9l842+lb22H5Hu6262bG23+0k+nPNerfbp+t42PTpvkYN3+XmufeDM3P3EpRk68Jgq7e954rI8+/r9OfTbv1qhIVdS+Mdnknx32x/lsZduy03jz8r2vfeusg0ff+mOPDjx+nx326MXfTHWoV2njNj7opx1w7Bc9fef55g9z1/Uvmzexznv5h+kfdtO+cneF9W5pmP3vDBzP5tTbftP5s7KZXefnCbFTdOz84Aktduua63ROT/e6w85d+zhueb+X+aHu/++SvunX/tH7n3qinxnqyNWWMiVpNbnyvrcRknt970kGfG9i/PC5Idy/i1H5vKTXkqrFm0XzfvzvT/LtPdfz+nDbkyHdp1WuWv5irIqHp+FfC1PkuLi4pxywFU55vx+OXfsYfnDiCeqfB668Laj88mns3LmYXeusJArSa3fixkf/Lfer1e12fe6r7tZvr3l4bn3qSuyQ599stUmu1Zpf+39Z2RKycsZdeA1GTJgeJ5/c/wytV1rjc6N4lq+otT2XNkYjs/avhf1fb1Kar9dt9z429l9m6Ny71NX5Jt998t2vfdc1P61d57OTQ/9Plv2/M4KD7mSVXP7FvK5OEm6d+qTQ4ackavu+3nunHBRlXBq5uypufTuk9K902YZPuSMRdM7tOuUnfsflJse+n32HPjjNPnS94lLm1eI3nj9jTRZPL8EvqSsrCxt2rRJkjz++ON1Xk9RZWVl5fIqamUybdq09O/fPx988EGaNm2aTTbZJPPmzcubb76Z3XbbLRUVFfnHP/6Ryy+/PEcdtfSLd2VlZdq2bZvDDjssf/zj8ntu1tIsr6Br4c23puLPV6b4h0ekyQH7V5lXOWVqyn9yXIo22eRrD2E4e5ch9Rp0XXLXiZk09cn022hQ1l5j/cz7bE7+/Z978/zkh7LJ+ttk9DEPLXZHK8vuxD99M5/O+ziXnfTC11pPXYYz/OLunkt+OjEbfeP/h8wzZ0/Nj87vm3U7bJCLj//3oi7rj710e/732n2zzzd/mmP3vKDG9Z93yw9z37//kkO//asMH/LLGtv/89nrc/ZNw7NFj8H53Q/vqzGYmTpzUo6/aJu0WK1NLjlhYjq0+7wH54SX78yZ13wvQwf+OMfv8//PGxffeVz+NuHi/OqwO7Ndn//fm/KNaRNz3EXbpP9Guyzq0fLOe6/l2As3T/d1+y5zT6jrH/h1rrn/l/nOVkfklAOurLH9C5MfzqmXD0mXtTfJmOOerPLHaXVmfzIzP/7DgJTN+yhjRjyZbp16J0lee+eZnHDxwGy58Xfymx/cs6j9LY+cl8vvOSXH7nlh9vnmCTXW81Vf3CH7xd1ldXHpXSfltscuqNKL4rr7f5VrHzgzI/a+OHtt/5Ma1zFv/qc54eKBmTLzlfz+qPuz+Ua71LjM8tr3/vS3n+aOx/+Q/znk5uzU7/Pz+MKF5Rlx0daZ/sHkXHHSS1m7/fq1brskS9qn63vbLFxYnuMu3jbT3n8tl530Ytbt8PmdhzNnT82PztssndfaOGNGPFGnP3SGjCxadKdvXRT68Zkk7334Tn503mZV7hb9cM77Oeq8PmnRvHUuP+nFtFytTZX1/eqaffOvV+6scpf2uWOPyP3PXJ3f/OCebLPpd2v8HZZWU3UqKipy+l92y7Ov3//5l5NbHlrjayxpu55x9d55ctI9ueDHj6fX//X8Lpv7UY46r0+Kiopz+ckvpXWLdjWu/6sO+V239N1g54w66OpaL7s8zpXLcxstydL2vX+9clfOuHqvKj0jXpj8cEZetkt22Gzf/HL4LYvarmrX8mX1xd3nX9wpXher2vFZ6NfyJLnj8TH5099OqNLL8f5nrsm5Yw/P/judkh/tcW6N66/O1/2stDzOlcvzelWdJe17ZfM+zo/O2ywVlQtzxckvp03LNZIk/3n73znhj9tl4KZDc+bhd9S67dIU2rV8WX2dz0rL41xZaMfn8novltf1akmWtl0/nfdJfnT+ZllQ/tmiESHmL5iXYy/cIrM+mZErTn45HVf/Ro2/Q3W+zmelZNXcvoV8Lk6ShRULc8LFAzO15JVcetIL+UbHjVJZWZlRlw/Oy289louOe6rK9z1J8vybD2XkZbvkl8NvzTf77rvM8wrNoOMj6IIafDnomjNnTlq3Xvr5a0mKl2dRK5POnTvnsccey3e/+920aNEiU6ZMSYcOHXLZZZdl3Lhxef3115Mk/fr1W+Z1Lo9nWa1IlW+/nYprrkvRppukeN99Fptf1K1rig8ZlsqXXk7FnXc1QIXLrt8GO6dVi3Z54JlrcsldP82195+Rjz+dlSN2/W3OO+bhgg655pd/lhse/F1+OLp3dj+tRfb+xRr5xZVD8+a7///Be+9/OC37nLFmjhrdJ58tqNrl+awbhuXbo4oz8fV/Lpo2ZGRRzrnp8Ex8/Z857qJts8fprXLArzrlj387YbE7c2Z9XJKX33o8W2+ye63qPuR33XLyJTtXec2Zs6fmxf8+kiEjixb9lMyastT1PPrCLenQttNiH3rWad81xw69IJOnP5/rH/h8yIKPykoz5vZj02WtjfOD3X5XY413/+uS3Pfvv2TbXkNzyOBf1Nj+zXefy4W3/SjrtO+anw+7qcYPwmVzP8qZ1+ydBeWf5Yzht1X5ILx9n70zeIvhuefJSzLxjQeTfP7B865//TFDBhy62B97PTpvkYN2OS3Pvn5/xj15eRZWLMw5Nx36+YfDZewJ9dSke3PdA2emZ+ctc/z3/lRj+/dmv53fXHdAWq7WJmcedkeNH4TLFy7I/163X0o/ejenHHBVlQ/CG3fZMgftclqemjQuf//3X5J8HgRcfd//pN+GOzfokANH7PbbdF6rZy6+87jM+rgkb0ybmBvG/zb9N9ole27342Vax3k3/yD/nfFifrj72cv0h/fy3PeO3P2sdFlr41x0x48z+5PPxyq+4cHf5s13n8uxe15YJbiqTdvqLG2fXpLltW2aNGmaUw+6NuULF2T02CNSWVmZysrKjL75BylfuCCjDrq2we7mK/TjM0nWXqNLjhl6fqaUvJxrHzgzSTLm9mPzUdn7OeWAK6v9suD4fS9J21Ydcu7NR2Te/E/zxKt35/5nrs53tjpimb5Er6mm6vzl759v5722H7FMX6Ivbbv+dL/L07Zl+5w79rBF184/3fXTlH78bk458Ko6hVxf1/I4Vy7PbVSdmva97XrvmcFbDM+9T12Rp1/7Rz6d90lGjz0iq7deKyfsc0mVtqvatXxFWtWOz0K/lifJ3tsfl74b7JTrH/hV3ip5Oe9/OC1/+tsJWX/tTXP4d369TL9Dffi658rlfb2qzpL2vdYt2uXkA67MBx9Pz8V3Hpfk86Htzx17eNq17JAT9rusTm2XpBCv5SvC8jhXFtrxuTzei+V5vVqSpW3XVi3a5qT9/5LZc2bm4jtGJEmuvO/nefu9Sfnxnn+oc8i1PKyK27eQz8VJ0qS4SUYeeE0WVi7M6JuPSEVFRf424eI8/+b4HPyt/1ns+54k2WyDHdOiees8+uIttZoHsCSF3f+zBptuumnuueeexabPmTMnU6ZMSXFxcfr06VPjeu66666UlZVl6623ro8y603R+uun2bi/LbVNk+8fmCbfP3AFVVR32/XZq0G/TKgv5QsX5PQ/75pXp/wr3xowPHttNyJl8z7KvU9dkZ/+cfucd+yj2bjLlllrjc455YCrcsbVe+WSv/00P/2/P8Tu+/eVGf/cDTlo0M+yRc+qw2u8+e7EPPbSrdl9m6MyZMCheX7yQ7nz8TGZUvJyzj7qgUXDu3wx5vnGXb7e/n3qQdfl0rtPTLvWHXPwLj9fNH31NmstcZmFFQvzytQJ6b9h9X/M7Lr1DzLh5Tty00O/z8Dee+bmh8/Nx59+kF8fcXeN4ebLb03In+46IZ3X6pmfHXRdjUH1R2WlOfOa7yVJzjzsjmqHyvyyysrK/P7GQzLt/ddz/D6XpFe3gYu1+cneY/LC5Idy3s0/yB9GPJHRN/8gHdt9Iz/Zq/rui4cM/kWeeOWuXH7PKZk8/fn8551/5+g9zkuXtTdeai1JMu39N/L7G4elXas1c8Zht6d5s6U/T3D+gnk589p98vGnH+R/j7g73+i45OEevvCnv/00L7/1eA4cdGp27LtftfU/NemeXHr3Sem/4aCcO/bwNG3SLKcccFWD3iiwWrOWGXngNTnxTzvkvFuOzHsfvp3mTVvklAOuXKa6bn743Dz8wtjs3O/A7L/TyTW2X9773mrNWmbkQdfkp3/cPhfednSGDzkzN4z/bbbtNTS7bnVEndt+1bLs01+1vLdN13V65Yjv/CaXjxuZ2x+7ME2bNM/zb47Pj/YYvdgzE1a0Qj8+k8/PqY+9dFtufviclJfPz2Mv3Za9tz8u/Tbcudr27dusneO+96f85voDMub2Y/Ps6/dnrdU759ihNffAWdaavuyRF27JzQ+fkz7dd8gxQ8+vsX1N27V9m7Vz/D6X5NfX7Z8/3/uzbNnz27n/mauz1/YjlulLtPrydc6Vy3sbfdWy7ns/2XtMnp88Phfc8sNstsGOKZk9Jb889Las3rrjYm1XtWv5irKqHZ+Ffi1PPr9p8pQDr8rR5/fNOTcdmnatOmbu/DkZddA1NR6b9enrnCvr63r1ZTXte1v0+FaGDvxx7vrXH7NDn33y6tR/5e33JuWXw29d7JlutWn7VYV6LV9Rvs65slCPz6/zXtTH9eqrlmW7btHjW9lj22Nz9xN/SsfVv5E7HrswA3vtuUw3M9S3VW37Fvq5OEm6rvN5MHzFuFH5010n5B//vjI9vrFFDt5l8We1Jp+HYxt32ara5/AtbR7AkjTaHl1L88orr6SysjI9evRIq1ZVx0E/5JBD8stf/jJ33nln/vnPf+bXv/51DjnkkPTv3z8HHXRQA1VMY/W3CRfnhckP51dH3JWT9/9zhm53bA7a5We55MTn0q51x1x+zymL2m7Xe8/svf1xGffU5Xn0xVvz9nv/yR/vPC6brr9ttXeZvVXyUn72/etz7J4XZM/tfpxfDr8le+9wfJ5/c3weefHmRe2mznw1SbLemht+rd9l8IBD0qJ567Rvs04GDzhk0c/S7iR678O3M/ezOUt97RP3uyKtW6yen/9l9zz64i05aNDPssn6Sw/lSj+anl9ft1+aNV0tZx52R1q3XH2p7RdWLMxvrjsgM2dPzQn7Xlbt3UZfdc39Z+TJSfdk161+sNjzhL7QpuUaOWn/v+S9D9/OMRf0y8zZU3LyAVcusZ6mTZpl1EHXZH75vNz9xCXp032H7PPNn9ZYy9zP5uTMa/bOp599kp8fMjZrr9GlxmUuvO3ovDHt2Qwfcma22bTm3nz3PX1V7n7iT9mix5Acsetvl1L/tVlQ/lmOu2ibTHr7yRw99Pw6Dzm4PPXqum322/Hk/Ps/92ZKycs5euh5Wad91xqXm/j6P/OXv5+W7p02y0kH/KXG9vW17226/jY5cOdT869X/pafXTEkrVZrlxP3Xfxh6rVt+2XLsk9/WX1tm313PCl9uu+Qq+77ef5876nZrPs3s+83T6xx/fWt0I/PL5y43xVpvVq73ProeVmv40Y58ivPAfiqnfrtn536HZAHnr02sz4pyUn7/6XG/bq2NSWfP0du9M1HZM126+UXh9yyaIi7JVnW7bpj3/2yy+YH528TLsrZNx2ab3TskR/ufnaN9dSnup4r62sbfdmy7nttWq6RE/e7Iu9/NC3jn7shu2x+cL652eKjB3xhVbqWr0ir2vFZ6NfyJFm3Q/cctfs5efPd5zLxjQdy4M6nZuMuW9VYU32r67myPq9XybLve0d995ys13GjnH/Lkbnt0fPzrc2HLXGoq9q0/UKhX8tXhLqeKwv9+KzLe1Ff16svq812PWqPc7Juhw1yyyOj07rlGvnpvjX3blxRVrXtW+jn4iTZb8eT06vrwPxtwsVZWFGekQdds9RROdZdc8PM+qQkH5d9UKt5ANVZJYOul156KUn1wxb27t07d9xxRw499NDstttuufLKK3PUUUfl4YcfTvPmBlVl+Xpw4vXpsvYm6dl5QD4qK130U75wfgb0GJKXpzxeZajCo/Y4Nxt9Y/NccOtR+fW1+6VJk2Y5fdiN1X5w6LLWxtm+z95Vph006GdJkgkv///x5z8qez9J0rZVh3r4DZfuozk1v3aHdp8/UP2jstJ069SnygNMq7OgfH7+99p9M+uTkow84Op0XadXjXVccc/IPD/5oey9/XEZMmB4je3/9fLfcsODv8nGXbbKcfssfdiSLTf+dr67zY/yUVlpdt/6qAzoOWSp7Vu3WD3Nmq6WJNl6k90X9bxbmnPHHp6pM1/NUbufk/4bDaqx/R2Pj8kDz16bgb32zLDB/1Nj+9feeTpjbj82ndp3y8+H3bjUYR+6/9979FFZaQb0/HZ236b6h0dXp3zhgirHwUdlpZk7//OhNufMnb3YvNpao/XnvQubFDfNlhvvWkPrpGTWlPz2rwel1Wptl2n4h/re94YPOSPdOvXJR2Wl+cneFy11OI3atE1qt08n9bttiouLM+rAa1JZWZmKioUZeeDVy3QcfOGTT6vfVz6b/+li0+eXf7bM600K//hMkhbNW2W1/3uY+uYb7rLowepLs/r/HTurt+6YXl1rvsO1tjV98unsnHnN97Jw4YL8cvityzRUTG2264i9L84ardfOJ5/OyqgDr1mm3/kLZXM/Wmy/qaisyIKFny02fd78T5d5vbU9V9b3Nkpqv++1bdUhxUWfHwPbbLrHUtuuatfyL5tfvvi+8tn/7Stfnf7Jp7OXeb1fWNWOz0K/lidVRzvYtoZj56vq87NSbd+L+r5e1Wbfa9G8VU498Np8Mnd2Vm+9Vn6y90XLpe0XGsO1/Mvq67NSbc+VjeH4rMt7UZ/Xq6T227VZk+Zp9X/D4vXsvOUynee/rL4+KyWr5vYt5HNx8vnfcl98v7Nex42y/tpLH5WjXavPe9vNnvNereYBVKdRD124JEsLuk477bScdtppK7okVlFvvzcpny2Ym/3OXPLwfh+VlS66a7B509Vy+sE35ofn9c6Uma/ktIP/usQ7wKv7QLFmu3XTpuUamfHBf7809fOhHipT9YHoC8rn55NPZ1WZ1nK1Nst17PcvhpmorFz6w9i/+OKmxzcG1HgX8cV3jsikt5/MQYN+tkwPLR3/3A257bELsln3b+booefV2P7t9/6Ts8cemtVbdcwvD70tzf/vS++l2bTrwIx76vJsWsMXUJ8/j+iIlJfPz/prb5ob/vmb7NT3gKzXcck93m548Hd57KXbsnP/g7LfTifVWMuL/300l919cjqv1TOnfr/moT5mz3kvv7pmnxQXFeeMw26vcdiH5P+/X8vyhduXvTJlQk65tPovD469cIvFpj1w7tL3my+bOnNSrv7HL9KtU5+8895/csEtR+Wso+5bYvt58z/Nmdd8L3Pmzs6vf3DPUt+DL9T3vtesafP0+MaATCl5ucZtW5u2td2nV8S2WXfNDdK+7TqL/l0bx164eWbOnrrY9JsfOTc3P1L1QeKnHHBVvrPV4cu03sZyfP7pbyek9KN3s8G6/fL3f/85gwccmj7dt19i++feHJ+7n/hTNlyvfyZPfz6X33PKouFzl0dNFRUVOeuGgzP9g8k5YZ9Ll2momNpu17at2qfL2ptk9pyZy7T+L/vl1XtVO2TKw8/flIefv6nKtOFDzsih3z5zmde9rOfKFbGNarvvzV8wL+fedFhat1wjLZq3zmV3n5StNt41bVu1X+Iyq8q1/Kseeu7GjL65+qFjv/r5b532XXP96VOWed2r2vHZGK7ls+e89/kXjB265+NPP8iFtx2dP57wTJo1XbYbKuvzs1Jt3ov6vl7VZd/7ok2XtTdZ6rmotm0bw7X8q+rrs1Ky7OfKxnJ81va9qO/rVV2261//+ZtMnv58Nlyvf559/f6Mf+7G7LL592tc7gv1+VlpVdy+hX4uvu/pq/LUpHGLPpvc/PA5+f4uS/mO9f++C6q29qXNA6iGoAsaUGVlZbp32mypzzr44s7VLzw1aVwqKhYm+fwBq7tsfvDXqmGN/7tr7ZNPZ1UZhuPVqf9a7A/p2n4wrckXdyF/MndWDS2XzbgnL8+9T12RAT2/vUxd8CdPfyEX3HJUOq7+jfxieM1D8ZTN+zhnXvO9fDb/0/zvj/62TMOW1MadEy7KC5MfzhG7/jbb9d4rP75wi4y+5Qc575iHq/1w9/R/7ss1//hFNli3b07ev+ahPt7/cFp+fd3+Wa1Zy5x52J01PtB24cLy/Pq6/fP+R9Ny6kHXLdOwD1/HBuv2y9lHPVBl2rOv35+bHzk3P/v+9WnfZp06rXdhxcKcO/awFBcV58zD7sj9z1ydGx78bf7+779kt62PrHaZC249KpOnP5/Dv/PrbL3JbjW+Rn3ve/WlLvt0fW+br+tn3/9r5n+pJ2ySnHrFkAzeYniGDKg6Hn7XZXjo8hcaw/H5r1fuygPPXpvdtzkqh3/n1/nh6N4575Yf5NITn6/2WUmfzvsk5938g7Rvs07OOfrB/OnO4zPuqcuzY9/9F3suZF1ruuof/5OnX7svu259ZPYYeHSN7Wu7Xb+uo4eelzlf6WXz+xsPyQbr9csBO42sMr22oeyyqu9tVNt9L0mu/Pvpeef913LawX/N6q3Xys+u+Hb++Lfj87PvX7dMv9PSFPq1/Ku23Pg7i13bHnj22vxz4nWLTW9ewzPLvmxVOz4by7X8D7cdk08+nZUzD7sjb7/3n1xw61H56z9/ncN3XXwY8urU12el2lgR16va7nv1pTFcy6tTX5+VaqMxHJ+1fS9WxPWqttv1jWkTc+P432VAz2/nzMPuyDEX9M8f7zwum2+0y6KbzmpSX5+VbN+lWxnPxe99+E4uvevEdOvUJ2NGPJGfXfHtXPfAr7Jd772W2APz4//7Luir33vVNA+gOqtk0DV+/PiGLgGSJN/o2CMflb2f/hvtskxDYL0+7dlc+ffTskWPIVm9dcfc+uh52aLHkGy58bcXa/v2e5MWm/bBxzMyZ+6HVT5gduvUJ0nybukb2XC9/x/+VveHdE0fTItSuztt1lqjS1q1aJd3S9+o1XLVeXXqk/njncelU4fuOX3YjTVuz48/nfV5F/yK8vxi+K01ftCsrKzMOTcdmnfe+0+OGXr+cn/g87T338iV956WjbtslQMHnZomxU0y/Ntn5sq/n547J1yU7+1wfJX200sn56wbDk7rFqvnjENvr3FIg/nln+VX1+6TD+e8l18eelu6rrP0IQSS5NK7T8pL/300e+9wfAYPOORr/X7Lom2r9ot9Off+R9OSJL27bV/nZ33d9NDv89o7T+fHe/0h3+i4UQ4Z/Mv865W/5dK7T8qAnt9e7I+aWx85P+OfuyHb9d4rB3/r5zWuv773vfpSl326vrfN8rCkuzzXXXODar/8XRaN4fj8uOyDXHjrj7JO+645eo/z0qpF2/xk74ty1g0H56q//zzH7Ln4DReX3n1SZs6eml8d/re0a9UhP957TJ5788Gcf+sPc/lJL6VVi7Zfq6bHXro9Yx/6/edDxXzvjzW2r+12XR56dh6w2LTmzVqkQ9t167w/1UZ9b6O67Hsv/fex3PH4H7JDn30W3Wzz3W1+tChk2a73nsv2y1Wj0K/l1Vmz3bpZs926Vaa9POXxJPla+9Cqdnw2hmv5gxP/mgkv35F9v3li+nTfIX2675BHX7wlNz30+2zf53vp0XnxHllfVV+flZbVirhe1Xbfqy+N5Vpenfr4rFQbjeH4rO17sSKuV7XdrvPLP8s5Nx2aFs1b56T9/5wWzVvllAOuzMmX7JQ/3H5szjzs9hrXkdTPZyXbt+Z1r4zn4vNuPjLz5pdl1IHXpHmzFjn5gCtzzPn9cu7Yw/OHEU9UO0zi9NI306Ftp2p7ly1tHkB1VslndMHKYsiAQzPrk5Lc9mj1f5TM/mTmon/P/WxOfvvXg9KmZfv87PvX5YR9L02n9t1zzk2HVjtm8Tvvv5YJL99ZZdrYhz5/kOl2vfdeNK3vBjslSSZNfbJK2y/+kP7yT01BV4vV2iw23OHSNCluks26fzP/efupZV6mOrM+Lsn/Xrtvioub5IxDb0+7Gp43trBiYX57/UEpmfVWfrzXmPTqum2Nr3H9P3+df73ytwzq//3su+OJX6ver6qoqMi5Yw/PwsqFGXngNYs+AB6w86j07Lxlrrz3tEwvnbyo/dz5ZTnzmu+lbN5H+dnBf12mIRMuuv3Hee2dpz8f6mOzfWps/8Cz1+XOCRdls+7fzDF71Dzsw8rqv9NfzF8f+N/03WCn7L39cUk+H9Zv5IFX57P5n+aCW46q0v75Nx/KFfeOSpe1Ns6og66tcZiEFbHv1Zfa7tP1vW1WVo3l+Lzojp/kw7L3ctL+f1n0Bfgum38/2/feO3c8/oe8/NaEKu2f/s99nw8Rs8XwRcFFu1YdcsI+l2bm7Km5/J5TvlZNU2e+mnPHHpbVW3XMGYfeXuNQMXXZroVuRWyj2u57c+eXZfTNR6Rtqw45ft9LFk3/0R6js/Ya6+cPtx1dp+dMJYV/LV+RVrXjszFcyz/4eEb+eOdx6bxWzxyx2//vjXLS/n/Oas1b5dyxh2dB+fwa19PQ6vt6Vdt9r740lmv5yqixHJ+1eS9WxPWqtts1Sa69/4xMmflKjhl6/qKbBfp03yF773B8Jrx8R8Y/d2ON66gvtu/SrYzn4rufuDQT33ggB+1y2qJg+BsdN8oRu/0ur73zdG5++JzFlllYsTCvT3tm0XdSyzoPYElWyR5dsLL43jdPyLNvPJDLx43Mc5PHZ/MNd0mrFu3y3odv57k3HkzzZi0y+piHkiR/uP3YzPhgcn535H2L7lA6fdiNOfFPO+Tcmw7Lb4+8t8oHru6dNsvvbzwku29zVL7RsUeen/xQHnvx1vTdYKfs3O/ARe3WaLNW+m24c/79n3tz9NDRX+v32XT9bXPf03/J1ff9Iuuvs2mKioqzba+hS31A6459989Tk8blP2//O5usv3WdXvd/r9svH3w8Pdv3+V6mlLycKSUvV9uufdt1MqDnkFx7/xmZ+MYD6bL2JmnRvHX++ez1S1z34AGH5JnX7s91D5yZ1Zq1TL8Nd15q+wE9h9S6h86tj56XV6f+Kz/c/ewqd2M1KW6SkQdevdgQaX+49ei8VfJS+nTfIR+XfbDEelqu1ibb99k79z7159z39JVZo83aWX/tTZda//abfS8lH/w3F976oxQXFWdg773y0FfGVv+y3t22q7fhur6u8oULcs7Yw9KkSbOccuBVVY6Pnp0H5MBBp1YZ9uiDj2fkN9cfkIqKhdlhs33zxCt3LXHdG6zbNxus17fe9736Utt9uqKyot63zcqqMRyfj7xwSx5+YWyGDjw2W/T4VpU2J+x7aV5667EqQ8HMmfthzr/1h1mz3Xr5yd5jqrTfrs9e+dbmw6oMkfbWjJdqVVP7tp1yxtV7Z+5nczKo//fzwuSHl9h+vTU3TK9uA2u9XQvdvPmf1vs2qu2+17J561xxz6hM/2By/ueQsWnfZu1F81u1aJuT9v/z1xrCsNCv5SvKqnZ8NpZr+QW3HpWyeR/lNz8YV2XIrbXX6JKj9ziv1kMYNoT6vl7VZd+rL43hWr4yaizHZ23fi/q+XtXlc/qrU5/MLY+Mztab7J5dt/5BlTY/2O13eWrSuOU2xF5t2b5LtzKei2fMeitXjBuZDdbtl0MG/6JKm+/tcHwef+m2aocwfPG/j2Te/LLs2Hf/xda9tHkASyLoggbUtEmz/PYH43LXE3/KP5+9Ltfef0aSpMPq62WTLltnyIDDkiQPPHNtHpx4fQ7YeVSVYQo3WX/rHLHrb3PFuFG59dHzs/9OJy+at9E3tsgxQ8/PVff9PPc8cWlatWiXvbYfkR/s+rvFhnsYOvDY/Ob6A/P6tGerHXpgWR2x22/zyaezcte//pg58z5MZWVlrjvtrbTssOSga+d+B+bSu0/KPydeV+eg65Upn9/RNeHlOzLh5TuW2K7vBjtlQM8hefmtz4cMeue9/+Tsm4Yvdd2DBxySV6f+K5WVlflswdxceNvSx6YefcxDtfqw+sWD1Tddf9vs96X37wvdOvVebIi0L4Y8evmtxxf9LtVZp33XbN9n70VtPpzzXs4Ze9hS67mu+1t5fdqzmV8+L0kWuyv8q0454KqVNui6/p+/zuTpz+e47/0x63bovtj8rw57NOODyfmorDRJcuP43y113cOHnJEN1utb7/tefantPp2k3rfNyqgxHJ8tVmuTi+74cTp16J6jvrv4nZTt266z2FAwf7zz+JR+9G5+84NxadNyjcWW+eoQabWtqd+GOy8asvbep67IvU9dscT2QwYcll7dBtZ6uxa6D+e8V+/bqLb73qQPnsw9T16SHfvun536HbBYmwE9h3ytIQwL+Vq+Iq1qx2djuJbf9+8r89SkcTlgp5HVhjO7b/PDWg9h2BDq+3pVl32vvjSGa/nKaNr7rxX88dlxjc61fi/q+3qV1O5z+jfW6pHRYw9Pq9Xa5sT9Fj/OVmvWcrkNsVdbs+e8Z/vWYGU7F2/adduMHntEFpR/llEHXbPYs9GKioqWOIThP5+9Lh3adsp2vfdabN1LmwewJEWVlZWVDV0EiytbWJ724x+oueFKYvYuQ9K6Sd1z04Xzk4fG1NyOZTNkZFGGDDgsow66epnaL6xYmGPO75cN1+ufnx285DuC6stN43+fGx86K9ed9lbBDm8GAAAAwNLN+rgkh/5+gxy5++8Xe97x0uYVokHHJ02aN3QVsHIrKytLmzZtkiRz5sxJ69ZL7jCxNJ7RBaRJcZP8aI/Reej5GzN15qQV/vr7fPOnaduyfW555OsNnQgAAADAyuumh36fjqt3ztCBx9ZqHsDS6NG1ktKji6+jtj26AAAAAIDlR48uqJkeXQAAAAAAAKzS6t4FB1hpPXCujpoAAAAAADR+enQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAXJM7pWUq2Km2T2LkMauoxl1qq4SUOXAAAAAAAArGIEXSupoqKitG7i7QEAAAAAAFgSQxcCAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBavRBV2lpaUaNGpWNNtooLVq0SJcuXXLCCSekrKwsRx55ZIqKinLxxRc3dJkAAAAAAADUUtOGLqA+Pf/889ltt91SUlKS1q1bp1evXpk+fXrGjBmTyZMnZ9asWUmS/v37N2yhLLOPP52VGx/8Xf71yp15/6NpabVa23Tr1CeHfft/s9kG32zo8gAAAAAAgBWo0QZdpaWlGTp0aEpKSnLyySfnjDPOSNu2bZMk55xzTk499dQ0bdo0RUVF6du3bwNXy7KYOXtqTrlk58ydPye7bn1kOnfsmbJ5H+W/M15M6cfvNnR5AAAAAADACtZog67jjz8+06ZNy4gRIzJ69Ogq80aNGpUbbrghL7zwQrp375527do1UJXUxu9vPCQLK8pz2UkvZs126zZ0OQAAAAAAQANrlM/omjRpUsaOHZuOHTvmrLPOqrbNgAEDkiT9+vVbbN4dd9yR7bbbLq1bt87qq6+e7bffPq+88kq91szSvfjfR/PyW4/ngJ1HZc1266Z84YLMm/9pQ5cFAAAAAAA0oEbZo+vGG29MRUVFhg0bljZt2lTbpmXLlkkWD7rGjBmTk08+OSeeeGJ+/etf57PPPstTTz2VuXPn1nvdLNm//3NvkmTtNdbPL64cmn+/9vdUVCzMNzr2yCGDf5nBAw5p4AoBAAAAAIAVrVEGXePHj0+SDBo0aIltpk2blqRq0DV58uSMHDkyF1xwQUaMGLFo+u67715PlbKspr33WpLkgluPynode2TUgddkwcL5ue2R83L2TcNTXrEgu251RANXCQAAAAAArEiNMuiaOnVqkqRr167Vzi8vL8+ECROSVA26rrzyyjRr1ixHHXXUcq1nyy23TElJyXJdZ2PTvGnLXD7ijSXO//SzT5IkLVdrm9HHPJRmTZsnSbbvvXcO/f0Guervp+fbAw5LcXGjHI0TAAAAACggPXr2yPxyo4TB0lRUVCz69w477JDnnnuuTutplEFXWVlZkixxuMGxY8emtLQ0bdu2Tffu3RdN/9e//pWNN944119/fX7zm9/knXfeSY8ePfLLX/4y3//+9+tcT0lJSd599906L78qaNGs1VLnr9bs86EmB23+/UUhV5K0bdU+A3vtmQeevTbvvP9auq6zab3WCQAAAABQkxnTp2fegk8bugwoGDNnzqzzso0y6OrUqVNmz56diRMnZuDAgVXmzZgxIyNHjkyS9O3bN0VFRVXmvfvuuznttNNy9tlnp0uXLvnLX/6Sgw8+OGuttVYGDx5c53pYuuZNWy51fsfVOydJ2rddfFt2aLdukmTO3NnLvzAAAAAAgFpad7319OiCGlRUVGTGjBlJknXWWafO62mUQdfgwYMzadKknH322RkyZEh69uyZJHn66aczfPjwlJaWJkn69+9fZbmKiorMmTMn1113Xfbee+8kybe+9a28+uqr+fWvf13noOuZZ56p8++yqlg4P3lozJLnb7z+1rnnyUtT+tG0xeaVfvj5tDXarF1f5QEAAAAALLM3Xn8jTZrX3A5WZWVlZWnTpk2S5PHHH6/zehrlA41GjRqVNddcM++880569+6dzTbbLD169MjWW2+dDTbYILvsskuSqs/nSpIOHTokSZVAq6ioKIMHD87LL7+84n4BFrN9773TarW2eXDi9Zn72ZxF0z/4eEYmvHJnOq/VM9/ouFEDVggAAAAAAKxojTLo6ty5cx577LF897vfTYsWLTJlypR06NAhl112WcaNG5fXX389yeJBV+/evZe4znnz5tVrzSxd21bt86M9Rqf0o3dz/EXb5tZHzs9N43+f4y/aNuUL5+cne13U0CUCAAAAAAArWFFlZWVlQxexIs2ZMyft2rVLUVFRPvnkk7Rq1WrRvLvuuit77bVXbrvttuyzzz5JPh/OsH///unQoUMefvjhBqq68atp6MIvPPbS7bn54XMyZcZLKSouzqbrD8zwIWekT/ft679IAAAAAIBlMOj4GLoQavDloQvnzJmT1q1b12k9jfIZXUvzyiuvpLKyMj179qwSciXJ0KFD881vfjM/+tGP8sEHH2T99dfPn//857zyyit54IEHGqhivuybm+2Tb262T0OXAQAAAAAArARWuaDrpZdeSrL4sIXJ58/juuuuu3Lqqafm9NNPz8cff5x+/frl3nvvXfRcLwAAAAAAAFYOgq6vWGONNXLZZZflsssuW5FlAQAAAAAAUEvFDV3AilZT0AUAAAAAAEBhWOV6dI0fP76hSwAAAAAAAGA5WOV6dAEAAAAAANA4CLoAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSKtE0FVaWppRo0Zlo402SosWLdKlS5eccMIJKSsry5FHHpmioqJcfPHFDV0mS3Ht/WdmyMiiJf7semqzhi4RAAAAAABYwZo2dAH17fnnn89uu+2WkpKStG7dOr169cr06dMzZsyYTJ48ObNmzUqS9O/fv2ELZal26LNP1ltzo8WmvzXjxdz8yLnZttfQBqgKAAAAAABoSI066CotLc3QoUNTUlKSk08+OWeccUbatm2bJDnnnHNy6qmnpmnTpikqKkrfvn0buFqWZoP1+maD9RZ/jy689egkyW5bH7miSwIAAAAAABpYox668Pjjj8+0adMyYsSIjB49elHIlSSjRo1Kv379Ul5enm7duqVdu3YNWCl1MXd+WR564aastXrnbLnxrg1dDgAAAAAAsII12qBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12/RtJ133jlFRUXV/hxzzDErpHaWzaMv3JJP532cb295eJoUN2nocgAAAAAAgBWs0Q5deOONN6aioiLDhg1LmzZtqm3TsmXLJFWDrj/96U/5+OOPq7QbN25cfvOb32SPPfaov4Kptfue/kuKioryna1/0NClAAAAAAAADaDRBl3jx49PkgwaNGiJbaZNm5akatDVq1evxdr99re/zVprrZVdd63b8HhbbrllSkpK6rTsqqJ505a5fMQby9z+nfdey8tvPZ7NN/pW1u3QvR4rAwAAAAConR49e2R++dyGLgNWahUVFYv+vcMOO+S5556r03oabdA1derUJEnXrl2rnV9eXp4JEyYkqRp0fdX777+f++67Lz/+8Y/TtGndNldJSUnefffdOi27qmjRrFWt2t/3778kSXbb5of1UQ4AAAAAQJ3NmD498xZ82tBlQMGYOXNmnZdttEFXWVlZkmTu3OpT87Fjx6a0tDRt27ZN9+5L7hF04403pry8PMOHD69zLZ06darzsquK5k1bLnPbhQvL88Cz16ZdqzWzfZ/v1WNVAAAAAAC1t+566+nRBTWoqKjIjBkzkiTrrLNOndfTaIOuTp06Zfbs2Zk4cWIGDhxYZd6MGTMycuTIJEnfvn1TVFS0xPVcd9112XTTTbPlllvWuZZnnnmmzsuuKhbOTx4as2xtn3j17syeMzPf2+GENG+6Wv0WBgDASuna+8/MQYN+lubNWuScmw7PRt/on32++dNarWPCy3emfdtO6dV12xrb/uPpq/Onu07INzr2yJ9O+Pzz/ew57+WcGw/N9FmT07zJajlunz+l7wY7JknOumFYnnvjwezc/6D8eK8La/vrAQBQ4N54/Y00ad7QVcDKraysLG3atEmSPP7443VeT/HyKmhlM3jw4CTJ2Wefnddff33R9KeffjqDBg1KaWlpkqR///5LXMd//vOfPPPMM1+rNxfL331P/9+whVsf2cCVAADQUK574FeZXz7va61jwst35j9vP7nM7ftvOGhRyJUkf7n3Z9m067a55tQ3csqBV+WsGw5O+cIFSZLTDv5r9hh4zNeqDwAAgJo12h5do0aNyg033JB33nknvXv3ziabbJJ58+blzTffzG677ZZu3brlH//4x1Kfz3XdddelqKgow4YNW4GVszSlH03P06/dl026bJ3u627W0OUAANAALrzt8wDpxD99M8VFTbLm6uvl7ZmTMvKyb+X9D99Jt0598vNhN6VZ0+YpX7ggV//jF3n+zfFZUD4/ndfqmZ/ue1lenfpEnnz1rkx844H84+mrs9f2I7Ltpnvkdzd8P5/O+zjzy+el34aD8pO9xqS4uPr7Ax954eZcc+qbSZKNu2yVNdutlxcnP5Iteg5eYdsCAABgVddoe3R17tw5jz32WL773e+mRYsWmTJlSjp06JDLLrss48aNW9TLa0lBV2VlZf76179m5513zvrrr78iS2cp7n/m6lRULMxu2/ywoUsBAKCB/HTfS5MkF/z4sVx20vNZo/XamTz9+fz6iLvzl5GTMvuTmXnspduSJDc/fG5aNGudi4//dy476fl077RZrrrvf7LNprtn21575oCdR+ayk57P7tv8MG1arpFfH3F3/vTTZ3PZSS9m5uwpeeTFm6ut4eOyD7Jw4YJ0aPf/n8e7Tvtuee/Dt+t/AwAAALBIo+3RlSSbbrpp7rnnnsWmz5kzJ1OmTElxcXH69OlT7bKPPvpopk6dmjPOOKO+y6QWDv7W6Tn4W6c3dBkAAKxktu/zvbRo3ipJssn6W2fGB5OTJP965c6UzftoUfBVvnB+1unQrdp1VFRW5Ipxp+aVKY+nsrIyH855L9069cmg/getkN8BAACA2mvUQdeSvPLKK6msrEzPnj3TqlWrattcd911admyZfbbb78VXB0AAFBbzZu1WPTv4qImWVhRnuTzkRp+stdF2XLjb9e4jtsePT8flr2Xi457Ks2btcild52U+Quqfw5Yu9Zrpklx08z6uGRRr66Zs6dk7TWMBgEAALAiNdqhC5fmpZdeSrLkYQvnzZuX/8fencdZVdf/A38Nm+xuqKAgi4AKCCjumoqBSS6ZuaXikplahBWCpl/TVlNxQ8utzF1xN5dSEzUiMxQxF1IkURFQJ1BhBNnm9wc5vyaGZZCZ4YzP5+PBQznnc85938vnnnPufd3P59x111056KCD0qpVq9osDQAAWAXN12mVsvkfrrTdrr0Oyj1jL8n8BR8nSeYv+DhTZ76cJGnRtHXK5v3/fcyZNzsbtGqbJo2bZtZHM/Pnf9y5wn1/ofehefBvS6dRfPXt8Sn98J303mLP1X1KAAAArIbP5YiulQVdTZs2zQcffFCLFQEAANVxyB7Dcvo1A7NO4+bZcN1Nl9vuiL1Oz02LPsl3L98pJSlJkhze//R0atszA/oNzoWjj8u4l+/Lgbt+Jwfvfmp+ctMh+ebIntmw9abZttuAFdZw4n7n55e3Dc6x53dL44ZNcsbXb06jho3X6PMEAABgxUrKy8vL67qI2rb33nvniSeeyIMPPpj99tuvrsshyeIFyROj6roKAACo2iPjr89fX74vPz7uvlXe5sZHz83ceR/k21+5tMbqAgBg7dR/aNKwSV1XAWu3srKytGzZMkkyd+7ctGjRYrX287mcunDMmDEpLy8XcgEAAKtkncbNMmX6xHz7su1Xqf15tx6VxyfcnOZNW9dwZQAAAJ9vn8sRXax9jOgCAAAAAOoLI7pg5YzoAgAAAAAA4HNN0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIVU74Ou0tLSjBgxIl27dk3Tpk3ToUOHnHrqqSkrK8sJJ5yQkpKSXHHFFXVdJgAAAAAAANXUqK4LqEkTJ07MoEGDMnPmzLRo0SI9evTI9OnTM2rUqEyZMiWzZs1KkvTt27duC2WVzPtkbu79y6g8MfG2vDt7aho3XCftN+qeL+/0reyz/bEpKSmp6xIBAAAAAIBaVG9HdJWWluaAAw7IzJkzM2zYsMyYMSMTJkzIzJkzc/755+ehhx7K+PHjU1JSkt69e9d1uazEkiVLcuZvB+WGR87Olh12yEn7X5SjBvxflixZnJF3HJ/fPHxGXZcIAAAAAADUsnobdA0dOjTTpk3LkCFDMnLkyLRq1api3YgRI9KnT58sWrQonTp1SuvWreuwUlbFP996Ji+98ZcctPvQnHbYddlv52/l4C98Lxd/e2zabtA5D/3t6rouEQAAAAAAqGX1MuiaNGlSRo8enTZt2uS8886rsk2/fv2SJH369Km0fOzYsfniF7+YNm3aZL311svOO++ce+65p8ZrZsXKPvkoSbJh600rLW/cqEnWbdEmTZu0qIuyAAAAAACAOlQvg67bbrstS5YsyVFHHZWWLVtW2aZZs2ZJKgddL7zwQgYOHJiGDRvm+uuvz+jRo9OhQ4cccsghefDBB2uldqq2VYcd07LZernjyQvy1At35r3Zb+Wt9/6Z3z78w0ye9lyO2efcui4RAAAAAACoZY3quoCaMGbMmCRJ//79l9tm2rRpSSoHXaNHj05JSUnuu+++NG/ePEkyYMCAdOnSJbfcckv233//GqyaFWnVfP385Ljf5+K7vpmf3XxYxfLm67TKj465O7v1OqjuigMAAAAAAOpEvQy63nzzzSRJx44dq1y/aNGijBs3LknloGvBggVp0qRJxWivJGnYsGFatWqVJUuWrHY922+/fWbOnLna238eNGnULNcMmbzCNs3WaZlOm/TKLj0OTI+Ou2bOvFn5/V9/lfNuPTI/Pu7+9Os+sJaqBQAAAABYvm7du2XBonl1XQas1f47d9l9993z/PPPr9Z+6mXQVVZWliSZN6/qA8no0aNTWlqaVq1apXPnzhXLBw8enF/96lcZNmxYTj/99DRq1ChXX311Jk+enF//+terXc/MmTPzzjvvrPb2nwdNGzdf4fo3ZryYU6/YNScfeEkO2OXkiuX9+349J17UK5fcdWJuOGNKGjZoWNOlAgAAAACs0Izp0zN/4cd1XQYUxrvvvrva29bLoKtt27aZPXt2JkyYkF122aXSuhkzZmT48OFJkt69e6ekpKRiXZ8+ffL444/n4IMPziWXXJIkadGiRe68887ssccen6keVqxJo2YrXH/32EuyYNH87Nn70ErLmzZpnp223i/3j7si786amk3bbFGTZQIAAAAArFS7TTc1ogtWYsmSJZkxY0aSZJNNNlnt/dTLoGvAgAGZNGlSzj///AwcODDdu3dPkowfPz6DBw9OaWlpkqRv376Vtps8eXIOP/zw7LDDDvn2t7+dhg0b5pZbbskRRxyRBx98MHvvvfdq1fPss89+pufzebB4QfLEqOWvL/1w6Yi4xeWLl9128aKl/12yqEZqAwAAAACojsmvTU7DJnVdBazdysrK0rJlyyTJX/7yl9XeT4M1VdDaZMSIEdlwww3z9ttvp2fPntlmm23SrVu37LjjjunSpUtFYPXf9+dKkjPPPDPNmzfPvffem0GDBmWfffbJDTfckJ122inDhg2ri6fCf3TcpEeS5NHx11daPnfeB/nrK/enVbP1s2mbrnVQGQAAAAAAUFfqZdDVvn37jB07Nvvtt1+aNm2aqVOnZoMNNsjVV1+dhx56KK+99lqSZYOuF198MX369EmjRpUHum2//faZNGlSrdXPsg7+wvfSqvkG+e0fzsgvbxucB56+Krc+/ouccsm2mfXRjBy378/cnwsAAAAAAD5nSsrLy8vruojaNHfu3LRu3TolJSWZM2dOmjdvXrFur732yvTp0/PKK69UCrv22muvvP3225kyZUpdlPy5sLKpC5NkeumU3Pynn+T51x/P7DnvZp3GzbLFpn3z1S98L1/Y5uDaKRQAAAAAYCX6D42pC2El/nvqwrlz56ZFixartZ96eY+uFXn55ZdTXl6e7t27Vwq5kuQ73/lODjvssHz1q1/NSSedlIYNG+bWW2/NU089lcsuu6yOKuZTm7bZIiOOuKGuywAAAAAAANYSn7ug68UXX0yy7LSFSXLooYfmgQceyPnnn59jjz02ixcvTvfu3XPLLbfkyCOPrO1SAQAAAAAAWAFB1//Yf//9s//++9dmSQAAAAAAAKyGBnVdQG1bWdAFAAAAAABAMXzuRnSNGTOmrksAAAAAAABgDfjcjegCAAAAAACgfhB0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKKTPRdBVWlqaESNGpGvXrmnatGk6dOiQU089NWVlZTnhhBNSUlKSK664oq7LBAAAAAAAoBoa1XUBNW3ixIkZNGhQZs6cmRYtWqRHjx6ZPn16Ro0alSlTpmTWrFlJkr59+9ZtoazU7Dnv5oZHz8nfJz2U2XPfzfqt2ma3Xl/Nsfv8OC2brVfX5QEAAAAAALWsXgddpaWlOeCAAzJz5swMGzYs55xzTlq1apUkueCCC3L66aenUaNGKSkpSe/eveu4WlZk9tz38t3Ld8q/P5qe/XY+KZ026ZWp776UB5++Mi/+68+59Dvj0rRJ87ouEwAAAAAAqEX1OugaOnRopk2bliFDhmTkyJGV1o0YMSK33nprXnjhhXTu3DmtW7euoypZFbc9/ou8O/vN/PDIW7P3tl+vWN6j464579Yjc/efL85RA/6vDisEAAAAAABqW729R9ekSZMyevTotGnTJuedd16Vbfr165ck6dOnT6Xlf/rTn7LzzjunadOm2XjjjXPyySfnww8/rPGaWb4XpjyRdRo3S/++R1Ravlefw9OkUdM8Mv53dVQZAAAAAABQV+pt0HXbbbdlyZIlOeqoo9KyZcsq2zRr1ixJ5aDrqaeeyr777pvNNtss9957b37+85/nrrvuykEHHZTy8vJaqZ1lLVz0SZo0apqSkpJKyxs0aJB1GjfLjFn/yodlpXVUHQAAAAAAUBfq7dSFY8aMSZL0799/uW2mTZuWpHLQ9ZOf/CTdunXLnXfemQYNluaAG264Yb72ta/loYceyv7771+DVbM8HTfpmbfffzWvvzMxXTfrW7H89XcmZs682UmS92a/lXVbtKmjCgEAAAAAgNpWb4OuN998M0nSsWPHKtcvWrQo48aNS1I56HrmmWdy/PHHV4RcSbLPPvskSe67777VCrq23377zJw5s9rbfZ40adQs1wyZvNz1B3/he/nry/flZzcfllMOvDSd2/bK1HdfzpW//14aNWycRYsX5pOFH9dixQAAAAAAVevWvVsWLJpX12XAWm3JkiUV/7/77rvn+eefX6391Nugq6ysLEkyb17VB5PRo0entLQ0rVq1SufOnSuWN2zYME2aNKnUtnHjxikpKcnLL7+8WrXMnDkz77zzzmpt+3nRtHHzFa7fpssXcuZRt+fX9w/N/123X5KkQYOGGbTjN9Nxk54Z99K9ab5O69ooFQAAAABghWZMn575fpgPq+zdd99d7W3rbdDVtm3bzJ49OxMmTMguu+xSad2MGTMyfPjwJEnv3r0r3fepe/fueeaZZyq1Hz9+fMrLyzNr1qzVroUVa9Ko2Urb7Nnn0Oy+zcF5Y8aLmffJnLTfeMus33LjDBm1Yxo2aJRN23SthUoBAAAAAFas3aabGtEFK1FeXp7y8vIkSbt27VZ7P/U26BowYEAmTZqU888/PwMHDkz37t2TLA2tBg8enNLS0iRJ3759K203dOjQHHPMMfnZz36Wk08+OdOmTcu3v/3tNGzYsNJ0htXx7LPPfqbn8nmweEHyxKiVt2vYoGGle3TN+mhmXn/n+fTusmeaNlnxqDAAAAAAgNow+bXJadhk5e2Az271kpsCGDFiRDbccMO8/fbb6dmzZ7bZZpt069YtO+64Y7p06ZK99947SeX7cyXJ0UcfndNPPz0//elPs9FGG2X77bdP//7907dv38+UKLLmLVmyJL+6f2iWlC/OkV88q67LAQAAAAAAalm9HdHVvn37jB07NsOHD89TTz2VqVOnpkePHrn66qtz4oknZosttkiybNBVUlKSX/7ylznrrLPyxhtvZLPNNsu6666bDTfcMN/97nfr4qmQZN4nczNk1I7ZrddX03aDzimb/2GemHhbJk97Lsfv+/P07dq/rksEAAAAAABqWb0NupJk6623zoMPPrjM8rlz52bq1Klp0KBBevXqVeW2rVq1Su/evZMk1157bebNm5fjjz++Rutl+Ro1bJIum/bJE8/fmn/PmZGmjZune4cd8otv/jE7bPmlui4PAAAAAACoA/U66Fqel19+OeXl5enevXuaN698X6dnn302jz32WLbbbrssWrQof/rTnzJq1KiMHDmyYhQYta9xoyY566jb6roMAAAAAABgLfK5DLpefPHFJMtOW5gk66yzTh544IGcd955WbRoUbbZZpuMHj06hxxySG2XCQAAAAAAwAoIuv7HNttsk7/+9a+1XRIAAAAAAADV1KCuC6gLKwq6AAAAAAAAKIbP5YiuMWPG1HUJAAAAAAAAfEafyxFdAAAAAAAAFJ+gCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEgl5eXl5XVdBJSXJ0sW1nUVAAAAAACfXYPGSUlJXVcBnw+CLgAAAAAAAArJ1IUAAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCalTXBVC7ysuTJQvrugoAAAAA6kKDxklJSV1XAQBrjqDrc2bJwuSJUXVdBQAAAAB1of/QpGGTuq4CANYcUxcCAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIX0uQi6SktLM2LEiHTt2jVNmzZNhw4dcuqpp6asrCwnnHBCSkpKcsUVV9R1mQAAAAAAAFRDo7ouoKZNnDgxgwYNysyZM9OiRYv06NEj06dPz6hRozJlypTMmjUrSdK3b9+6LXQtsWTJktz7l8vy0N+uzszZU7Nei42yR5/DcuyXfpJmTVrUdXkAAAAAAAAV6vWIrtLS0hxwwAGZOXNmhg0blhkzZmTChAmZOXNmzj///Dz00EMZP358SkpK0rt377oud61w5QPfz1UP/CCbb9IjQw66PHv0PjT3/WVUfnTdAVmyZEldlwcAAAAAAFChXo/oGjp0aKZNm5YhQ4Zk5MiRldaNGDEit956a1544YV07tw5rVu3rqMq1x5TZ76c+8ddnt17HZxzjr27YnnbDTrnV/cPzZMv3J69tz2yDisEAAAAAAD4/+rtiK5JkyZl9OjRadOmTc4777wq2/Tr1y9J0qdPn0rL33jjjRx44IFp1apV1l9//RxzzDH597//XeM117UnJt6W8vLyHPyF71Va/uWdTkzTxs3zpwk3101hAAAAAAAAVai3Qddtt92WJUuW5KijjkrLli2rbNOsWbMklYOuOXPmpH///pk2bVpuu+22XHPNNRk7dmz233//ej9136tvj0+DkgbZcvMdKy1v0rhpumzaN6+9Pb6OKgMAAAAAAFhWvZ26cMyYMUmS/v37L7fNtGnTklQOuq655pq88847+fOf/5zNN988SdK+ffvsuuuu+f3vf5+DDjpolWsoLy/Pxx9/nCRp3rx5SkpKqvs0atW/P5qe1i3apEmjdZZZ12bdzfLKm3/NwkUL0rhRkzqoDgAAAAAAoLJ6G3S9+eabSZKOHTtWuX7RokUZN25ckspB14MPPpjdd9+9IuRKkl122SVdunTJAw88UK2g6+OPP64YTdauXbs0aFD3A+iaNGqWa4ZMrnLdJws+TuMqQq6l2zVd2mbhx4IuAAAAgILq1r1bFiyaV9dlAEAlbdu2zbPPPrta29bboKusrCxJMm9e1Sfu0aNHp7S0NK1atUrnzp0rlr/yyis59NBDl2nfs2fPvPLKK6tdz4wZM1Z72zWpaePmy123TpPmmTf3vSrXLVg0f2mbFWwPAAAAwNptxvTpmb/w47ouAwDWmHobdLVt2zazZ8/OhAkTsssuu1RaN2PGjAwfPjxJ0rt370pTCs6ePTvrrbfeMvvbYIMN8uqrr652PWvTiK7l2bD1pnnr3VeyYNEny0xfWPrhO1m3RRujuQAAAAAKrN2mmxrRBcBap23btqu9bb0NugYMGJBJkybl/PPPz8CBA9O9e/ckyfjx4zN48OCUlpYmSfr27Vsr9UyePDktWrSolcdakcULkidGVb1uyw475LnXHs2rb/0923T5QsXyBQvn51/TJ2abLnvUUpUAAAAA1ITJr01OQ79jBqAeqfshRjVkxIgR2XDDDfP222+nZ8+e2WabbdKtW7fsuOOO6dKlS/bee+8kle/PlSTrr79+Pvjgg2X2N2vWrGywwQa1UXqd2avP4SkpKck9Yy+ttPzhZ67N/IUfZ+9tj6qbwgAAAAAAAKpQb4Ou9u3bZ+zYsdlvv/3StGnTTJ06NRtssEGuvvrqPPTQQ3nttdeSLBt0bb311lXei+uVV17J1ltvXSu115XO7bbJgbt+J3956Z6ce8PBefiZ3+SqB4blqgd+kN5d9sze2x5Z1yUCAAAAAABUqLdTFyZLQ6sHH3xwmeVz587N1KlT06BBg/Tq1avSuv333z9nnnlmpk2blvbt2ydJnnnmmUyZMiUXXnhhrdRdl0458NJssn6nPPzMNfn7pIfSukWbHLTbd3Psl36yVtxjDAAAAAAA4FMl5eXl5XVdRG175plnsvPOO2fLLbfMP//5z0rrPvroo2yzzTZp06ZNfvzjH2f+/PkZMWJENtpoozz99NPVCnvKysrSsmXLJEvDtbX9Hl0AAAAA1G/9h8Y9ugCoVz6XQ3RefPHFJMtOW5gkrVu3zpgxY9KuXbscccQR+eY3v5ldd901Dz74oBFNAAAAAAAAa5F6PXXh8qwo6EqSLbbYosopDwEAAAAAAFh7fC6HKK0s6AIAAAAAAGDt97kc0TVmzJi6LgEAAAAAAIDP6HM5ogsAAAAAAIDiE3QBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhfS5CLpKS0szYsSIdO3aNU2bNk2HDh1y6qmnpqysLCeccEJKSkpyxRVX1HWZa4XbxpyXn9x0aAaf1yUDh5fk6F90quuSAAAAAAAAqtSorguoaRMnTsygQYMyc+bMtGjRIj169Mj06dMzatSoTJkyJbNmzUqS9O3bt24LXUtc94cz06r5Bum22XYpm/dBXZcDAAAAAACwXPU66CotLc0BBxyQmTNnZtiwYTnnnHPSqlWrJMkFF1yQ008/PY0aNUpJSUl69+5dx9WuHW48Y0rabdglSXLiyF6Zt2BuHVcEAAAAAABQtXo9deHQoUMzbdq0DBkyJCNHjqwIuZJkxIgR6dOnTxYtWpROnTqldevWdVjp2uPTkAsAAAAAAGBtV2+DrkmTJmX06NFp06ZNzjvvvCrb9OvXL0nSp0+fimWfBmM77rhj1llnnZSUlNRKvQAAAAAAAFRPvQ26brvttixZsiRHHXVUWrZsWWWbZs2aJakcdL3++uu5++6707Zt2+ywww61UisAAAAAAADVV2/v0TVmzJgkSf/+/ZfbZtq0aUkqB1177LFHZsyYkSQ599xzM27cuDVST7du3dKgQd3nik0aNcs1QybXdRkAAAAA1IFu3btlwaJ5dV0GAFTStm3bPPvss6u1bb0Nut58880kSceOHatcv2jRoooQ67+DrpoKoz4Nz+pa08bN67oEAAAAAOrIjOnTM3/hx3VdBgCsMfU26CorK0uSzJtX9S9URo8endLS0rRq1SqdO3eu8XratWu31ozoAgAAAODzqd2mmxrRBcBap23btqu9bb0Nutq2bZvZs2dnwoQJ2WWXXSqtmzFjRoYPH54k6d27d0pKSmq8nsmTJ6dFixY1/jgrs3hB8sSouq4CAAAAgLow+bXJadikrqsAgDWn7ocY1ZABAwYkSc4///y89tprFcvHjx+f/v37p7S0NEnSt2/fuigPAAAAAACAz6jejugaMWJEbr311rz99tvp2bNnttpqq8yfPz+vv/56Bg0alE6dOuWRRx6pdH8ukseeuynvzV56f7MPyt7PosULcsuffpYk2Xj9jhnYb3BdlgcAAAAAAFCh3gZd7du3z9ixYzN8+PA89dRTmTp1anr06JGrr746J554YrbYYoskEXT9jz/+/bf5x7+eqrTs+kfOTpL07rKnoAsAAAAAAFhr1NugK0m23nrrPPjgg8ssnzt3bqZOnZoGDRqkV69edVDZ2uuiU56s6xIAAAAAAABWSb0Oupbn5ZdfTnl5ebp3757mzZsvs/6uu+5KkrzyyiuV/t6pU6dsv/32tVcoAAAAAAAAy/W5DLpefPHFJMuftvDQQw+t8u/HHntsrr/++hqtDQAAAAAAgFUj6KpCeXl5bZYDAAAAAADAamhQ1wXUhZUFXQAAAAAAAKz9PpcjusaMGVPXJQAAAAAAAPAZfS5HdAEAAAAAAFB8gi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACF9LkIukpLSzNixIh07do1TZs2TYcOHXLqqaemrKwsJ5xwQkpKSnLFFVfUdZlrhWnvv5brH/lRvnv5zjnk3I1y4P+1ykkX980tj/888xaU1XV5AAAAAAAAFRrVdQE1beLEiRk0aFBmzpyZFi1apEePHpk+fXpGjRqVKVOmZNasWUmSvn371m2ha4k/jr8uv//rr7JLjwPzxW2PSsOGjfPClCdy/R//L39+4Y6M+u7fsk7jZnVdJgAAAAAAQP0OukpLS3PAAQdk5syZGTZsWM4555y0atUqSXLBBRfk9NNPT6NGjVJSUpLevXvXcbVrhy9sc0i+3v+HadFs3YplB+xycjZr0y23Pv7z/OHvv81Buw2pwwoBAAAAAACWqtdTFw4dOjTTpk3LkCFDMnLkyIqQK0lGjBiRPn36ZNGiRenUqVNat25dh5WuPbbssH2lkOtTe/U5PEkydeZLtV0SAAAAAABAlept0DVp0qSMHj06bdq0yXnnnVdlm379+iVJ+vTpU7Hsrrvuyte+9rV07NgxzZs3z1ZbbZWzzjorc+fOrZW611bvfzgtSbJ+y03quBIAAAAAAICl6m3Qddttt2XJkiU56qij0rJlyyrbNGu29F5T/x10jRw5Mg0bNswvfvGL/OEPf8gpp5ySK6+8Mvvuu2+WLFlSK7WvbRYvWZxb/vTTNGzQKHtve2RdlwMAAAAAAJCkHt+ja8yYMUmS/v37L7fNtGlLRyn9d9D1wAMPZKONNqr4+5577pmNNtooRx11VP7yl79kjz32qKGK115X/v57eeXNp/ONQb9Ih423rOtyAAAAAAAAktTjoOvNN99MknTs2LHK9YsWLcq4ceOSVA66/jvk+tT222+fJHnnnXdWu55u3bqlQYO6H0DXpFGzXDNk8iq3v/6PZ+f+cVdkv52+la/v/cMarAwAAACAmtate7csWDSvrssAgEratm2bZ599drW2rbdBV1lZWZJk3ryqT9yjR49OaWlpWrVqlc6dO69wX0888USSZOutt17tembMmLHa265JTRs3X+W2Nz56bm55/Gf50g7H59SvXVWDVQEAAABQG2ZMn575Cz+u6zIAYI2pt0FX27ZtM3v27EyYMCG77LJLpXUzZszI8OHDkyS9e/dOSUnJcvfzzjvv5Oyzz86+++6bvn37rnY97dq1W2tGdK2KGx89Nzc99uMM7HdsfnDIb1b4GgEAAABQDO023dSILgDWOm3btl3tbett0DVgwIBMmjQp559/fgYOHJju3bsnScaPH5/BgwentLQ0SVYYXs2dOzdf+cpX0qRJk1x33XWfqZ7JkyenRYsWn2kfa8LiBckTo1bc5qbHfpKbHvtxBmw3OKcddt1aEdABAAAA8NlNfm1yGjap6yoAYM2pt0HXiBEjcuutt+btt99Oz549s9VWW2X+/Pl5/fXXM2jQoHTq1CmPPPJIpftz/bd58+blgAMOyBtvvJGxY8emXbt2tfwM6sb9436VGx89Jxuvt3m26zYgY56/tdL69Vttkn7dB9ZRdQAAAAAAAP9fvQ262rdvn7Fjx2b48OF56qmnMnXq1PTo0SNXX311TjzxxGyxxRZJUmXQtXDhwhxyyCF59tln8/jjj6dHjx61XX6defXt8UmS9z54KxeMPnaZ9b277CnoAgAAAAAA1gol5eXl5XVdRG2bO3duWrdunZKSksyZMyfNmzevWLdkyZIcccQR+f3vf5+HH344e++992o/TllZWVq2bFnxmEWZuhAAAACA+qn/0Ji6EIB6pd6O6FqRl19+OeXl5enevXulkCtJvvOd7+TOO+/MGWeckebNm+dvf/tbxbotttgiG220UW2XCwAAAAAAQBUa1HUBdeHFF19MUvW0hX/4wx+SJL/85S+zyy67VPrz0EMP1WqdAAAAAAAALN/nckTXioKuqVOn1nI1AAAAAAAArA4jugAAAAAAACikz+WIrjFjxtR1CQAAAAAAAHxGn8sRXQAAAAAAABSfoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhfS6CrtLS0owYMSJdu3ZN06ZN06FDh5x66qkpKyvLCSeckJKSklxxxRV1XSYAAAAAAADV0KiuC6hpEydOzKBBgzJz5sy0aNEiPXr0yPTp0zNq1KhMmTIls2bNSpL07du3bgtdS7z93qu5+U8/yeR3JuTfH03P4sULs/F6m2fHrb6cQ/cang1bt6vrEgEAAAAAAJLU86CrtLQ0BxxwQGbOnJlhw4blnHPOSatWrZIkF1xwQU4//fQ0atQoJSUl6d27dx1Xu3Z4/8NpmfXRjOzW66vZaN32adigUd6Y+WIeeuaaPPHC7bnq+xOzfsuN67pMAAAAAACA+h10DR06NNOmTcuQIUMycuTISutGjBiRW2+9NS+88EI6d+6c1q1b11GVa5ftun0x23X74jLLt+m8R35282F5dPz1Obz/iDqoDAAAAAAAoLJ6e4+uSZMmZfTo0WnTpk3OO++8Ktv069cvSdKnT5+KZWPHjs2AAQPSrl27rLPOOmnfvn0OP/zwTJo0qVbqXlttsn7HJMncebPruBIAAAAAAICl6u2Irttuuy1LlizJUUcdlZYtW1bZplmzZkkqB12zZ8/ONttsk5NOOikbb7xxpk2blvPOOy+77LJLXnrppbRv375W6q9rCxbOz7wFc7Ng4fy8+e4r+c3DpydJdtzqy3VcGQAAAAAAwFL1NugaM2ZMkqR///7LbTNt2rQklYOuAw88MAceeGCldjvssEO23HLL3H333Tn11FNroNq1z8N//01+dd93K/7edv1OOePrN2ebLl+ow6oAAAAAAAD+v3obdL355ptJko4dO1a5ftGiRRk3blySykFXVTbccMMkSaNGq/9ydevWLQ0a1P1MkU0aNcs1QyavtN1uPQ/K5httlXkL5ub1d57P06/8Ph+WldZChQAAAADUlG7du2XBonl1XQYAVNK2bds8++yzq7VtvQ26ysrKkiTz5lV94h49enRKS0vTqlWrdO7ceZn1ixcvzpIlS/Lmm2/mhz/8Ydq2bZvDDjtsteuZMWPGam+7JjVt3HyV2m20XvtstN7SaRp363VQvrDN1zJk1A75ZOHH+freP6zJEgEAAACoITOmT8/8hR/XdRkAsMbU26Crbdu2mT17diZMmJBddtml0roZM2Zk+PDhSZLevXunpKRkme333HPPihFfXbt2zZgxY7LRRhutdj3t2rVba0Z0rY4um/bOFpttmwf++mtBFwAAAEBBtdt0UyO6AFjrtG3bdrW3rbdB14ABAzJp0qScf/75GThwYLp3754kGT9+fAYPHpzS0qXT8PXt27fK7X/729/mgw8+yBtvvJELL7ww++yzT8aNG5fNN998teqZPHlyWrRosVrbrkmLFyRPjFq9bRcsnJc5H89aswUBAAAAUGsmvzY5DZvUdRUAsObU/RCjGjJixIhsuOGGefvtt9OzZ89ss8026datW3bcccd06dIle++9d5Ll359ryy23zE477ZQjjjgijz/+eObMmZMLLrigNp9CnZj10cwql098/YlMnflStuq4cy1XBAAAAAAAULV6O6Krffv2GTt2bIYPH56nnnoqU6dOTY8ePXL11VfnxBNPzBZbbJFk+UHXf1tvvfXStWvXvP766zVddp0bdc8p+fecGenbde9ssl7HLFg0P5OnPZcnX7g9zdZplZP2v6iuSwQAAAAAAEhSj4OuJNl6663z4IMPLrN87ty5mTp1aho0aJBevXqtdD/vvfdeXn311ey00041UeZapf+2X89jz92Yx5+7KR+UvZ+SlGST9Ttmv51PymF7Ds/G66/e1I0AAAAAAABrWr0Oupbn5ZdfTnl5ebp3757mzZtXWnf00Uena9eu6du3b9Zbb71Mnjw5l1xySRo1apTvf//7dVRx7dmzz2HZs89hdV0GAAAAAADASn0ug64XX3wxSdXTFu6888658cYbc9lll2X+/Pnp0KFD+vfvnzPPPDMdO3as7VIBAAAAAABYDkHX/xgyZEiGDBlS2yUBAAAAAABQTQ3quoC6sKKgCwAAAAAAgGL4XI7oGjNmTF2XAAAAAAAAwGf0uRzRBQAAAAAAQPEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCqvdBV2lpaUaMGJGuXbumadOm6dChQ0499dSUlZXlhBNOSElJSa644oq6LnOtNX/Bxxl8XpcMHF6Sy+8dUtflAAAAAAAAVGhU1wXUpIkTJ2bQoEGZOXNmWrRokR49emT69OkZNWpUpkyZklmzZiVJ+vbtW7eFrsVueORH+bDs/bouAwAAAAAAYBn1dkRXaWlpDjjggMycOTPDhg3LjBkzMmHChMycOTPnn39+HnrooYwfPz4lJSXp3bt3XZe7Vpo8bULu+culOWbgj+u6FAAAAAAAgGXU26Br6NChmTZtWoYMGZKRI0emVatWFetGjBiRPn36ZNGiRenUqVNat25dh5WunRYvWZxL7joxO2y5b3bf5uC6LgcAAAAAAGAZ9TLomjRpUkaPHp02bdrkvPPOq7JNv379kiR9+vRZ7n4GDRqUkpKSnHvuuTVR5lrtnj9fkrff+2eGHOT+ZQAAAAAAwNqpXgZdt912W5YsWZKjjjoqLVu2rLJNs2bNkiw/6LrjjjsyceLEmipxrTZj1hu58dFzctTAH6XtBp3quhwAAAAAAIAqNarrAmrCmDFjkiT9+/dfbptp06YlqTro+uijj/K9730vI0eOzNFHH71GaurWrVsaNKj7XLFJo2a5ZsjkFba57O6T03bDLjlkjx/UUlUAAAAA1IZu3btlwaJ5dV0GAFTStm3bPPvss6u1bb0Mut58880kSceOHatcv2jRoowbNy5J1UHXWWedle7du+eoo45aY0HXjBkz1sh+PqumjZuvcP2fnrs5EyY/lotP+XMaNWxcS1UBAAAAUBtmTJ+e+Qs/rusyAGCNqZdBV1lZWZJk3ryqf50yevTolJaWplWrVuncuXOldc8++2yuvfbaPPfcc2u0pnbt2q01I7qWZ8GiT3L1Az/Ijlt9Oeu3apt3Sl9PkpR++E6SpGz+h3mn9PWs26JNWjZbrzbKBQAAAGANarfppkZ0AbDWadu27WpvWy+DrrZt22b27NmZMGFCdtlll0rrZsyYkeHDhydJevfunZKSkop1ixcvzkknnZQhQ4akZ8+ea7SmyZMnp0WLFmt0n6tj8YLkiVFVr1uwcF4+KHs/z0x6KM9MemiZ9Y9PuDmPT7g539rvwhy612k1XCkAAAAAa9rk1yanYZO6rgIA1px6GXQNGDAgkyZNyvnnn5+BAweme/fuSZLx48dn8ODBKS0tTZL07du30nZXXHFF3n333Zx77rm1XPHaoWmTFjl78J3LLP9w7vsZde+3s8OW+2bfHU9Il3a966A6AAAAAACAyupl0DVixIjceuutefvtt9OzZ89stdVWmT9/fl5//fUMGjQonTp1yiOPPFLp/lylpaU5++yzM3LkyCxatCgffPBBxbr58+fngw8+SOvWrdeK6QdrSqOGjbNH70OWWT5z1tQkSbsNt6hyPQAAAAAAQF2ol6lN+/btM3bs2Oy3335p2rRppk6dmg022CBXX311Hnroobz22mtJUinomjZtWubMmZOTTjop66+/fsWfJDn//POz/vrr56233qqT5wMAAAAAAMCySsrLy8vruojaNHfu3LRu3TolJSWZM2dOmjdvXrH82WefXaZ9//79c+yxx+a4447LzjvvnKZNm67yY5WVlaVly5YV+1/b79EFAAAAQP3Wf2jcowuAeqVeTl24Ii+//HLKy8vTvXv3ipArSVq2bJm99tqrym06deq03HUAAAAAAADUjXo5deGKvPjii0kqT1sIAAAAAABA8XzuRnRVN+j6nM3sCAAAAAAAUBhGdAEAAAAAAFBIn7sRXWPGjKnrEgAAAAAAAFgDPncjugAAAAAAAKgfBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAK6XMRdJWWlmbEiBHp2rVrmjZtmg4dOuTUU09NWVlZTjjhhJSUlOSKK66o6zIBAAAAAACohkZ1XUBNmzhxYgYNGpSZM2emRYsW6dGjR6ZPn55Ro0ZlypQpmTVrVpKkb9++dVvoWmTg8JIqlzdt0iIP/HxuLVcDAAAAAABQtXoddJWWluaAAw7IzJkzM2zYsJxzzjlp1apVkuSCCy7I6aefnkaNGqWkpCS9e/eu42rXLtt0/kK+vNO3Ki1r1LBxHVUDAAAAAACwrHoddA0dOjTTpk3LkCFDMnLkyErrRowYkVtvvTUvvPBCOnfunNatW9dRlWuntht0yYB+R9d1GQAAAAAAAMtVb+/RNWnSpIwePTpt2rTJeeedV2Wbfv36JUn69OlTsezJJ59MSUnJMn8+j1MbLly0IPM+MVUhAAAAAACwdqq3I7puu+22LFmyJEcddVRatmxZZZtmzZolqRx0fepXv/pVtttuu4q/t2jRomYKXUuNffGuPP78zVmyZHHWa7FR9ux7eI7/0s/Sotm6dV0aAAAAAABAknocdI0ZMyZJ0r9//+W2mTZtWpKqg64ePXpk5513rpni1nJbddgxe/Q+NJu26ZqP53+Uv//z4dw/7or8Y8pTuWzIX9NsnaqDQwAAAAAAgNpUb4OuN998M0nSsWPHKtcvWrQo48aNS1J10LWmdevWLQ0a1P1MkU0aNcs1QyavsM3lQ5+p9PeB2x+Tzu1653d/PCv3/OWyHPXFs2qyRAAAAABqSLfu3bJg0by6LgMAKmnbtm2effbZ1dq23gZdZWVlSZJ586o+cY8ePTqlpaVp1apVOnfuvMz6ww8/PKWlpdlwww1z4IEH5pe//GXatGmz2vXMmDFjtbddk5o2br5a2x221/Dc/NiP8/dJDwm6AAAAAApqxvTpmb/w47ouAwDWmHobdLVt2zazZ8/OhAkTsssuu1RaN2PGjAwfPjxJ0rt375SUlFSsW3fddTN8+PDsscceadmyZZ5++umcd955+dvf/pZnn302TZs2Xa162rVrt9aM6FodjRo2zoatN82HZaVruKL66+///EPO/t0BuXbYS9l8461W2v7oX3TKJut3ykWnPPmZH3vBwvn5xoVbZe9tj8o3Bv38M+8PAAAAPq+u/P3388ykh/Kb015Oo4aNV3nd2qrdppsa0QXAWqdt27arvW29DboGDBiQSZMm5fzzz8/AgQPTvXv3JMn48eMzePDglJYuDWz69u1babttt9022267bcXf99prr/Tq1SsHHnhgbrvtthx//PGrVc/kyZPTokWL1Xsya9DiBckTo6q/3YKF8/P+h9OydcfP533Lqmvx4kW5+oFh+eK2R61SyLU894y9NC2arpcv7XBctba7688XZ+68D3LonqclSe77y+X51f1Dc/y+P8+RXzxzmfYffTwrJ47smSaNmubqH/wjZ//ugPzjX0+t9HEGDzwnx+xzbm589Nzc9NiPV9q+d5c9c9EpT+aFKU/mtKuWf/+8//bYheX5yY2HZNxL9+aiU55Kr867L9PmpTf+kmFX7pnden01Pzrmror9f2u/C3PoXqdVtBs4vCQ7bb1ffvaNByuWDbtyr7w27dk88PO5SZIlS5Zk2FV75tW3x+fK7z2fjptsXemxZs95Nyde1Cstmq2Xq7//Qq5/5Ozc/eeL88Mjb8ne2x65TG3vlL6eky/uk07ttsml3xmXhg0artLz/qzmL/g4J13SJ2XzPsi1p72c9VtuXGn9m+++klMu3S5bdtghF538VBo0aJCBw0uWs7fKRp78RPpssVeGXblXjfWTnx7/QE66uHcWLJqfa097Oa2bb7BMu1sf/0V+98ez8p2DLs9Buw2p2P8VQ8dnyw7bJ8kq9YXJ0yZk6BU7p88W/fPLEx+psqYzrv1SXpjyREYN+Vu12nZrv91Kn++a8ts/nJnbx5yXYYf+Nvvu+I1K68rLy3PaVf0z6c2n86vvPZfObXvlgtuPy2PP3bDS/Q7sd2xGHHF9Hhl/fUbesfJz4Cbrd8zNZ07NzFlTM/i8ZUdMV+WmH76Rtht0ykN/uyaX3n1Sjhpwdo770k+WaffL2wbn8Qk357xvPpLtt9wnybLv4SSr3BeeffXR/PA3X8qA7Qbn9K/fuMzjXf/Hs3PL4z/L9w+5JjtsOSgnXtQrG63XIb8+9bk0btRkmfaX3PWtPPzMtfnp8Q9k5x77r9Jz/6yuemBYtY5Bx/5yi7w7+82V7ve0w36XL+1wXI33kyT5xS1H5skXbs8vT3ws23X7YqV2nyycl5Mv6ZsPy0rzm2EvZ4PWSy96V+V4nizbF6pzPklSrXNPbZn10cx886KeWa/FRrny+89nncaVf8Q0YfLjOePagenf9+v54ZG3rNZ78ehfdKqxfnL8vj+r9nvp0/3fde77WbfF0hkWPu1rZw++M3v0PiRJKp7rgbt+J9/96hVJkjdmvpTvXNovW3fcJSNPfqLSD9yS5A9//20uvvOb+freZ+Ybg35e7euApk1Wb7aE6nr/g2nVet0+LCut8WN2dfpJ6xYb5ke/OzBf3unEfP+Qa5Zps3DRgnz7sn55/4O3c+2wl7LReu1z9C86pVmTlrn2tJcq2q1KX6jucfGPf/9ttc89taG6179r03XcRac8uVrvparew0lWuS9U93xSneuAL+904kqf+5pU3Wuimv48lqTafWx1Xt/VPd4//coD1TrGzJ3/QbXODUly+F6n56G/XZ0Hnr4yX919aKX2K1q3tpr82uQ0XPZUAgCFVW+DrhEjRuTWW2/N22+/nZ49e2arrbbK/Pnz8/rrr2fQoEHp1KlTHnnkkVW6P9f++++fFi1a5Nlnn13toKsoPir7d1q32HCZ5dc/cnYWL1mUnbc+oA6qKp6n/nFn3npvUs486rZV3ua6Ea+mJJUvsO8Ze2k2Wb9TtYKuTxbOy51PXZgv7XB8WjVfP0nyld2GZNzL9+Xmx36cnbfeP1027V1pm8vv/U5mz303F540Js2btsqRXzwrg3b8ZpX7X7j4k1z1wA8y75M56dFx1yTJ7r0OzqYbdl1uTXc+NTL/mvFCxYf0zTfeOqcfcdNy2z/zz4fy5MTb07PTbkmSoQdfmRffGJsLRx+Xq37wQpo1+f+h8fwFH+fC0celdYs2OfVrV63CK7RiDRo0yGmH/S4nX9wnF44+NpcNebpSOHXp3Sdlzsezcu6x96Vpk+b5xr4/z/h//iFX3Pfd9NmifzZs3a6i7ZIlS3Lh6ONSnvKMOPyGWgu5kqRpk+YZftjvMuzKPTPq7lNyzrF3V6xbvHhRzr/9mDRs0CjDD7u+YrTpiv5NZsz6V2589Jys26JN2m+0ZZLUaD9p3rRVTjv8dxl+9d65/J5v56yjb6/U9o0ZL+bmx36cbbt+MV/Z9Tur9qIsR7f22+XIvc/KjY+dmweevioH7HJypfUPPn11nnvt0Ryzz4+r3bY2HTPw3PztlQdy1QM/SL/u+2Sj9dpXrLtn7KX5x7+eygmDzkvntr2SJPvvfFK26zagyn2Vpzy/+8OZef/DaRXv295d9lhhH3nsuRsyYfKf0qvT0vbrttxohe1fffvvuW/c5dmsTbes958gdr+dv5WxL96d28ecl916HlTpNfzLi/fm8Qk3Z7+dT1pjXzRuv+U++fJOJ+bhZ67NF3ofkl17Hvhf9Y3P7U/8Mtt3/1LFly/f/spluXD0cbnh0R/lm1/+ZaV9jX/1kTz8zLX50g7H11rIlaTax6BTDrw08z6ZW+W+5syblasfGJaGDRqle/t+SWq+nyTJkK9ekRemPJGL7zwh1/zgxTRv2qpi3W8ePiPT3n8tZx51W0XI9VlU53xSXl5ea+ee6tigddsMOejynHfrUfndH87KyQdeXLGubP5HueiOb2T9Vm3znYMuT7J678Wa7Ccbrde+Vt9Lndv2ytEDz8nv/nhW7ht3eaUvIN+d/WaueuAH6dx2mwweeE6S6l8H1Jbqvm4z/v2vGj9mV6efdG63TfbZ/rg8/My12b3Xwdlhq30rtb/x0XMydeZLGXH4DZXOX6ujusfF2j73rKrqXv+uTddxSd28l6p7PqnudUBtqm6/rOnPY0n1+1htvr679DigWseYjdK+WueGZOn5d6++R+T2J36ZA3f5dho2bLRK6wCA2lFvz77t27fP2LFjM3z48Dz11FOZOnVqevTokauvvjonnnhitthiiyRZpaDrU//7K5/66JbHf5ZJb/4tfbr2z8brbZ75n8zN3//5cCZOeSJbbb5TDtr9u3VdYiE88PSv06Vd72yx6ar3ryaN1lkjjz3m+Vszd94HGdjvmIplJSUlOe2w6/Kti3vngtHH5oqhf6+YUmHsi/fkyYm35+AvfC99ttgrSdKv+8Dl7v+iO7+Zj+d/lGP2+XHFB6sum/ZeJjz71J+euzn/mvFCtus2IMfss/RXhuu32iQD+h1dZfs3352Uy+/9djZo3S4/Grz0F/Lrtdwo3/va1Tn3hq/m2gdHZOjBv6po/5uHT8/0f0/Jj4+9r+JXf5/VZm265htfPi+/vv/UjH7i/IpRcI8+e0P++vL9OXTP09Kr89IPfU0aN82II27MqVfskkvuOrHS6IK7x16Sl6eOyykHXpoOG29Z7To+/fXip7+crq5enXfPV3c/NXePvSRjnr+14lfNtz7+80ye9lyGHHRFNm2zRUX75f2bzF/wcU69Ypc0aNAwZx09uuILo5ruJ3222CsH7TY09/7lsuy+zdeyZ59DkywN6i4YfWwaN26a0w67bo0cm4/84ll5etIDufah4dl+yy+l3QZLf9X+7uw3c+1Dw9O9/fY5cu8zq922ugYOL6n45XR1NW7UJCMOvyHfvXynXHTnCRUjzt5+79X87o9nZavNd8qhew2vaN+j0y7p0WmXKvd182M/zfsfTsuXdjg+X95p6Zdg7TbsknYbdqmy/QtTlv4yuFPbXjn1kKuTJM2atFhun5o959389g9npNk6LXPusfdW+oLrB4f+Jt+6aJtcMPrYilELH8x9P5fdc3LabtA5J+0/stqvzYqctP9Fee61R3PZ3SelV+fd07r5BlmwcH4uuP3YNFunZYYd9tuKtvtsf2zGvXRv7nxqZHbteVB6/GeUc9m8D3PJnd/MxuttnlMOvHS16jj6F53Su8teGXHE9dXarrrHoN16HVTlfpYsWZIzfzsoi5csyrBDf5vO7bZJUvP9JElaN98gp37t6pxz/Vdy9YPDKn6J/cKUJ3P/uMvzhd6HpH/fI6r1uixPdc8nNXXu+fSX95/+Sr669t72yIz9x93/OT4eXPHF5a/vPzXvffBWfvaNBytGwq7Oe7Gm+0lNvpeqcnj/0/PXl+/LdQ//MDtu9eVs1qZrysvLM/KOb2TBwnkZccQNlUZIVec6oLo+y7m9Oq9bbRyzq9tPvv2VyzLx9TG5+K5v5tphL6Vls/WSJP986++546kLs1vPgzJw+2Oq3Gd1rM61WU2ee1b33F7d49Xadh2X1Ox7qSqrcz6pznVAda3uuf1T1emXNf15LKl+H0tq9vX9X9U9xlT33JAkA7YbnEfG/y5/ffn+fKH311Z5HQBQ8+r+plE1aOutt86DDz6YOXPmZM6cOXnmmWfyrW99K2VlZZk6dWoaNGiQXr16rXQ/v//971NWVpYdd9yxFqquW3267JXmTVvnsWdvyJW//15ufPScfPTxrBy/789z0clPLjM9ztpowaJPcuvjv8g3R/bMl3/YNAedvV7Ovu6AvP7O8xVt3v9gWg4+Z8OcOLJXPllYeV7q8249KvuMaJAJr/2pYtnA4SW54PbjMuG1P+W7l++c/c9snsN+3Da/uv/UZX7JOuujmXnpjb9kx62+XK26j/5Fpwy7cq9Kj/nu7Dfzj389lYHDSyr+zJw1dYX7+fMLd2aDVm3TdbNtKy3fZP2OOeWASzJl+sTc/NjS6S8+LCvNqHtOSYeNtsw3Bv1ipTU+8Ncr88e//zY79zggRw84e6XtX3/n+Vx697eyyfodc9ZRt690RFPZvA9z7g0HZeGiT3LO4Lsr/Xp/t14HZcB2g/Pg367MhMmPJ1n6ofX3f/1VBvY7Jrv2+spK66mOg3b7bnp32TM3P/bjvDHzpbz/wbT8+v5Ts/nGW+e4L/20UtstO2yfI/b+YZ6Z9FD+8PelH9befu/VXP/H/0ufLfaq0+krjh/087TfqHuuuO+7mfXRzEyeNiG3jvl5+nbdOwfu+u1V2sdFd3wj/5rxj3zzy+dn2657r7T9muwnJ3z5vHTYaMtcfu+3M3vOu0mWBnWvv/N8Tjnw0my8/uar9BxWpmHDRjn9iBuzaPHCjBx9fMrLyys+6C5avDAjjrix4peZ1Wlb27q13y5H7P3DPPfao3nob9dk8ZLFueD2Y1JevuqjCp+Z9HBueuzcdG+/fYZ+9dcrbf/e7Lfys5sOq/gC9L9/cV6VRYsX5ic3HZLSD9/JaYf9Lp3a9qy0fuP1OuTkAy7O1Jkv5cbHzk2SjLrnlHxY9n5OO+y6NFun5Uprqo7mTVvlB4f+NrPnvpsr7h2SJLnuj2flrfcm5dsHXpY2625Wqf33DrkmrZqtnwtHH1tx/vj177+X0o/eyWmH/y4tmrZeo/WtijVxDPrtH5b2m6/sNmSVvmhe0/1k154HZsB2g/PwM9dm/KuP5OP5czJy9PFZt8VGOfXgK1e6/+qozvmkts891TH0a1emVfMNcuEdx2f+go/z9CsP5NFnr8+Xdjg+O22930q3X9l7sSprsp/U5nupYYOGGX74DVlcvjgj7zg+S5Ysyf3jrsjE18fkyC/+3zLXTEn1rgNq02d93db0Mbsqy+snLZq2zrDDrsu/P5qeK+5b+uO5BQvnLx2Z1GyDSgH4Z1Xd42Jtn3tW1Zo4BtXldVxS+++l6p5PqnsdUJvWRL9ck5/HlmdFfaw2X9/qHmNW59ywTZc90rRJi/z5H3dWax0AUPPq7YiuFXn55ZdTXl6e7t27p3nzytMkHH300enSpUu22267tGzZMk8//XQuuOCC9O3bN0ccsWZ+Tbw227XXV+r0S5vPatHihTnzN/vmlal/zRf7Dc5Xdh2Ssvkf5uFnrs33frVbLjrlz9myw/bZaL32Oe2w3+Wc67+SK+//Xr73n4veP/79uox5/tYc0f+MbNe98hQ8r78zIWNfvCtf3unEDOx3TCZOeSL3/WVUps58Keef+FjF9G+fznW/ZYfPFoyefsRNueqB76d1izY5cu+zKpav23Kj5W6zeMnivPzmuPTdouoPsfvu+I2Me+ne3P7EL7NLzwNzx5MX5qOP/52fHv/ASkPMl94Yl1///tS036h7zjjippWOovmwrDTn3rD0HifnHntvlVNi/rfy8vL88rajM+391zL04Cur/GX4dw4alRemPJGL7vhGLhvydEbe8Y20ab1ZvvOV1bjx3EqUlJTktMN/l5Mu7p0Lbj8mrZu3ybwFczPiiBvSpHHTZdofPeDsPDPpwVz1wA/Sd4v+uXD0cWnUsHFOO+x3dToadJ3GzTL88Bvy/V/vnovuPCHvffBWmjRa9ZFQdzx5YZ58YXT26nN4Dt1z2Erbr+l+sk7jZhl+xA353q92y6V3n5TBA8/NrWN+np17HJB9d1izU8l23KRHjv/Sz3LNQ8Nzz9hL06hhk0x8fUy+tf/IZe4rUZ22te3oAWfn6Zd/n2sePC1Tpk/MP9/+e07a/6JVGlU47f3J+eVtR6V18w1zzrH3VNnX/9uChfNz7o0H56OP/52fHP9ANmuz/ClzPvXr+7+Xl974Sw7vf3rFfRb+1747fiNjX7w7dzx5QRYtWpCxL96dg3b7bsWo0zVtu25fzP47n5IHnv512qy7We4de2l26XFglV/kr99y4ww9+Mr89KZD85uHz8j23ffJo89en6/sNmSVvkCsKZ/lGPTUC3fmjicvSK/Ou+fkAy5eYduk5vrJdw4alYlTxuSSO7+ZbbrskZmzp+ZHx9y9xkbr/u9jrer5pDbPPdWxfsuN892v/jo/u/mwjLrnlDz32qPZaN32OeWAS1Zp+1V5L/63Nd1Pavu91HGTpV+qX/vQiPz696fmkb9fl26bbbfcEbjVvQ6oLZ/ldaupY/Z/W1k/2a7bF3PALt/O7//6q+ze6+C88uZf89Z7k/KjwXctcz/Rz6q6x8XaPvesqs9yDKrr67ikbt5L1T2fVOc6oLZ9ln5ZE5/H/teq9LHafH2re4yp7rmhYYOG2bLDDlXe325F6wCAmlevR3Qtz4svvpik6mkLe/bsmXvvvTfHHHNMBg0alOuuuy4nnnhinnzyyTRp4k6da7v7x12RF6Y8mR8f//sMO/Q3OWDXU3LE3mfkyu8/n9Yt2uSaB0+raLtrzwNz0G7fzUPPXJM//+OuvPXeP/Or+76brTffucpfF74x88Wc8fWbc8qBl+TAXb+dHw2+MwftPjQTXx+Tp/5xR0W7N999JUmy6YZbLLOP6hjQ7+g0bdIi67dcOq3Ep39W9Mvb9z54K/M+mbvCx/7+IdemRdN1c9Zvv5w//+POHNH/jGy1+YpDudIPp+enNx2Sxo3WybnH3psWzdZdYfvFSxbnZzcdlndnv5lTv3Z1lb+G+183PHpO/jbpwey7wzeWue/Rp1o2Wy8/OPS3ee+Dt3LyJX3y7uypGXbYdSutZ3W126BzTvzyBXn9neczYfJjOXyv07Nlhx2qbNuoYeOMOOLGLFz0Sb57+U6Z9NbfctIBF6/WlINrWo+OO+eQPYbl7/98OFNnvpSTDrgom6zfcaXbTXjtT/ntH36Yzm23yQ9WYVqRmuonW2++Uw7f6/T89eX7c8a1A9N8ndb5/teWvcn0mvC1PX6QXp13z+/+eFZ+8/Dp2abzF/K1L3z/M7etTUv74g1ZsGh+Hnj6yvTqvHsO/sL3VrrdvE/m5twbDsrHn8zJWUePzsbrdVjpNpfefVImT3sugweem522Xvko1j+O/10eePrX2a7bwBy/789X2Pb7h1ybFuu0zl1/viibtumaE/7nfjRr2on7X5B2G3TJnU+NTItm6+V7X1v+yII9eh+Svbc9MvePuzzn335MNmvTLd/88vk1Wt/KrO4x6I0ZL2bkHcdnw9ab5uyj76yY1nZ5arKftGy2Xr5/yLV5/8NpFdOtfmGbg1e6/9VRnfNJbZ97qmPPPodmzz6H5bHnbsysOTPzg0N/u0p1Vee9mNRcP6nt99IhewxLj4675P5xV2TxkkUZfsQNKxyBW53rgNq0uq9bTR6zk1XvJyfud0E2bdM1F995Qu7+88X54rZH1cg0X6tzXKztc8+qWN1j0NpyHZfU/ntpdc4n1bkOqG2r0y9r6vPYf6tOH6vN17e6x5hqnxs23CKz5szMR2X/rtY6AKBmCbr+xw9/+MO8+OKL+eijj7Jw4cK88cYbufjii7PuunX/ZQYr9/iEm9Nh463SvX2/fFhWWvFn0eIF6ddtYF6a+pdKUxWeuP+F6brZtrnkrhPz0xsPScOGjXPmUbdVeWHbYaMtl7kXwRH9z0iSjHvp3oplH5a9nyRp9Z97Y9SmD+eu/LE3aL30BvUflpWmU9telW6wW5WFixbkJzd+LbPmzMzww65Px016rLSOax8cnolTnshBu303A/sNXmn7v750f259/GfZssMO+e7BK54Ca/st98l+O30rH5aV5ss7nrjC+wusCf89gm7nrfdfYdvO/3k9PywrTb/u+1Tci2RVLFq8sFKf/bCsNPMWLJ0Wc+682cusq671Wix9Hg0bNMr2W+67ktbJzFlT8/NbjkjzdVqt0tRGNd1PBg88J53a9sqHZaX5zkGXr9I0KqujQYMGGXH4DSkvL8+SJYsz/PDrK0Zrfpa2VZnzcdX/rp8s+HiZ5QsWfVKt59Gi6bpp/J/7/u241ZdXqa4LRx+XN999JSd++YL07dp/pe3v/cuoPPbcjdmlx4E5asD/rbT9q2+Pz6h7Tknb9TvlrKNuW+nUOU2bNM86/7kPzLZb7L3GblS/PI0bNknz/0z51b399ivtY0MOuiLrtdg4cz6elRGH31Ct+srmfbjMv/GS8iVZuPiTZZbPX/DxKu+3usegOR/Pzrk3fDWLFy/MjwbftUrvq5ruJ62ab5AGJUv7604rOeZ+VtU5n3yWc8+CRcv+u37yn3/X/10+5+PZ1X4e6/7n+L5uizbp0XHlv76v7nuxpvvJZ3kvVVeDBg0qrpE2bdM1m2+88hG41bkO+F81eW6v7utW08fs6vSTpk2a5/TDb8ycebOzbouN8p2DLl9pPaurusfFz3ruqalze3WPQWvbdVzy2d5Lq6O655PqXgf8r5o6tyer1y9r8vNYUv0+9llf3+qo7jGmuueG1s2XjoybPfe9aq0DAGrW53LqwhUFXRTbW+9NyicL5+WQc5c/vd+HZaUVvyxu0midnHnkbfnmRT0z9d2X88Mjb1nurzyruuDdsHW7tGy2Xmb8+1//tXTpFB/lqXyD+YWLFmTOx7MqLWu2Tss1Ouf/p9OLlJev+Ob2n34R1m2zfiv9VfYV9w3JpLf+liP6n7FKv7Yd8/ytuXvsJdmm8xdy0gEXrbT9W+/9M+ePPibrNm+THx1zd5r858v5Fdm64y556JlrsvUqfKH3Wcye+97SL3k26JyPPv53Lr37pPzq1GeXuSnxf/v0tV2VLxv/28tTx+W0q6r+MvCUS7dbZtljF6743/i/vfnupFz/yNnp1LZX3n7vn7nkzhNz3ol/XG77+Qs+zrk3fDVz583OT7/xYDZts/LRiTXdTxo3apJum/XL1JkvVfu1ra52G3bJ+q02qfj/NdX2f51y6bZ5d/abyyy/46kLc8dTF1Zadtphv8uXdjhulfa79H5hx2fRogXZfOOtc+uffpY9ex+2wn/HWx//Rca+eHf26ntEDtnzByt9jH/868+5+oFhab9R95z+9ZVPbTR77nv58Q0Hp0FJg5xz7D0rnTonSX59/6kp/fCddGnXJ3/4+28yoN8xa/SG9f/rlj/9LFOmT8wWm/bNc689mjHP35a9t/36ctu3ar5+Omy8VWbPfXeVpvb5bz+6/itVTmvz5MTb8+TE2ystGzzwnByzz7mrvO9VPQYtWbIk5916ZKb/e0pOPfiqVXoONd1PFiycnwtvPzYtmq2Xpk1a5OoHfpAdttw3rZqvv9LHWl3VOZ+s7rnniedvy8g7qp5q9X+vVzZZv2NuPnPqKu/7+dfH5IGnf50tNu2bKdMn5poHT6uYjrkq1X0v1kY/+Szvper64/jf5ZlJD1W8Xnc8eUG+vvcPl9t+da4D/ltNntur87rV9DF7dfrJp206bLxVjb7Hk+pdm33Wc09NnduTVT8GrY3XcZ/1vVRdq3M+qe51wP+qyXN7dftlTX8eW50+9llf3+qqzjGmuueG/OezdpXH0hWtAwBq1Ocy6BozZkxdl0ANKS8vT+e226zw3hGfjmz51DOTHsqSJYuTLL1Z797bHvmZaljvP79WnPPxrEpT9bzy5l+X+bKjuh9yVubTX3XPmTdrJS1XzUN/uyYPP3Nt+nXfZ5WmrJky/YVccueJabPuZjl78MqnNiqb/1HOveGr+WTBx/nJt+5fpSmwatNld5+cOR/PyrnH3pu33vtnLrnrxNzyp5/muH3X/I2zu7Trk/NPfKzSsudeezR3PHVhzvj6zVm/5Sartd/FSxbnwtHHpkFJg5x77L159Nnrc+vjP88f/v7bDNrxhCq3ueSuEzNl+sQc96WfZsetBq30MWq6n9RXZ3z9liz4rxGmSXL6tQMzYLvBGdiv8j0LOrbtucr7vW/c5XlhypM5ft+fZ9eeX8m3L90uI+/8Ri46+ckqP3SP/+cfc8MjZ6dLu94ZdujKpzZ6/4Np+elNh2adxs1y7rH3pcV/fp27PIsXL8pPbzo07384LacfcdMqTZ3z15d/n8eeuzFf3unEHPeln+abI3vmoju/kau+P3Gl9xNcHZOnTchtY36Rft33ybnH3puTL+mbX9333Wzbde+KIHNNOumAizL3f0bu/PK2o9Nl0z45bM/hlZZXN0BdVb975P8y/tU/Zt8dT8j+u5y00vY13U+S5Lo/nJm33381PzzylqzbYqOcce0++dX9Q3PG129apee0ttp+yy8tc3x/7Lkb86cJNy2zvEk1+vfH8+fkoju+kfVbbpILTno8v75vaB565prs0fvQZe4zmqzee7Gm+0lteu+Dt3PV77+fTm17ZdSQp3PGtfvkpsd+nF17fmW5o1c+63VATZ3bq6M2jtnV7SdrqzVx7qmpc3t1rI3XcbV5TZ1U/3yyJq4DaurcXt1+WRufx6rbx2r7Oqs6Vufc8NF/Pmv/7/cKK1sHANSsz2XQRf21WZtu+bDs/fTtuvcqTdX12rTnct0ffpjtug3Mui3a5K4/X5Ttug3M9lvus0zbt96btMyyf380I3PnfVDpw0qntr2SJO+UTs4Wm/7/UYNVfdmxsg85JaneL8E2Wq9DmjdtnXdKJ1dru6q88ubf8qv7vpu2G3TOmUfdttLX86OPZy2dsmbJopw9+K6VfmgpLy/PBbcfk7ff+2dOPuDiOr/R9/96fMItGffSvfnaF76fXp13T6/Ou+fP/7gztz/xy+zW66vp1n7ZX2J/Fq2ar7/MF5PvfzgtSdKz026rfa+v25/4ZV59e3y+/ZXLslmbrjl6wI/y15fvz1UP/CD9uu+zzIfZu566OGOevzW79vxKjvziWSvdf033k/pseb/Ebbdhlyq/pF4V096fnOse/mG27LBDDu9/eho2aJjB+5yb6/5wZu4bd3m+uvvQSu2nl07JebcemRZN1805x9yz0qlwFiz6JD++8eB8MPe9/OiYu9Nxk5VP+3XVAz/Ii//6cw7afWgG9Dt6pe0/Kvt3Lr3rW9lk/Y45af+L0rxpq3znoMtz3q1H5nd/OCsnH7j8HzKsjgWLPskFtx+Tpk1a5AeH/iZNmzTPaYddl2FX7pnL7jkl5x57zxp9vCTp3r7fMsuaNG6aDVq1W+1/++oY++I9Gf3EL5dOT/TVX620fW30kxf/NTb3/uWy7N7r4IofnOy307cqgptdex64ak9uLbRh63bZsHW7SstemvqXJPlM/95XPfCDvDv7zfz4uPvTuvkG+fZBo/L864/n4ru+mWt+8GKaN221TPvqvBdrup/UtovuOCHzF5RlxOE3pEnjphl22HU5+eI+uXD0cblsyNPLTM23Jq4Daurcvqpq45hd3X6ytlpT556aOLdXx9p4HVfb19TVPZ+sqeuAmji3V7df1sbnser2sbq4zqqO6p4bkmR66evZoFXbKke7rmgdAFCzPpf36KL+GtjvmMyaMzN3/7nqD6Oz57xb8f/zPpmbn99yRFo2Wz9nfP2mnPq1q9J2/c654PZjqpxT++33X824l+6rtGz0E0tv/L1rz4MqlvXusmeSZNKbf6vU9tMvO/77z8qCrqbrtFxmusMVadigYbbp/IX8861nVnmbqsz6aGZ+cuPX0qBBw5xzzD1pvZL7jS1esjg/v/mIzJz1Rr79lVHp0XHnlT7GzX/6af768v3p3/fr+doe3/9M9a5p//5oRn5133fTfqPuOX7Q//9l6w8O/U3WadI8F44+LgsXLajDClfNv6b/I7c89pP07rJnDtrtu0mWTgE4/PDr88mCj3PJnSdWaj/x9Sdy7cMj0mGjLTPiiBtXOuVGbfQTVt2SJUty4ejjsrh8cYYffkPFB/PD9hqR7u23z3UP/zDTS6dUtJ+3oCzn3vDVlM3/MGccecsqTTtz+T3fzqtvj186tdFKbuqeJI89d1PuG3d5tun8hZy8/8qnzkmSy+/9Tj4oey8/OPS3FV/U773t17Nbz4Ny718uy0tvjFul/ayqGx89J1PffTknH3BxRfDbq/PuOWj3oRn30r0Z8/xta/Tx6tqb776SC0cfm3Wbt8k5x9yz0umJaqOfzFtQlpF3HJ9WzTfI0K9dWbH8W/uPzMbrbZ7L7j5pte5dVZ+N/+cfl05ftd3gii9tWzffIKcefFXenf1mrnnwtErtq/terI1+UpseePqqTJj8WI7Y+4cVX6pv1qZrjh/0i7z69vjc8eQFldrXl+uAmj5mV7efrM1q+9xTE9bG67jafi+tzvlkbb4OqE6/rI3PY9XtY8na/fpW99yQLH2dX5v2bMVn/lVdBwDUPCO6qFe++oVT89zkx3LNQ8Pz/JQx2XaLvdO8aeu898FbeX7y42nSuGlGnvxEkuSye07JjH9PyS9O+GPFr93OPOq2fP/Xu+fC24/Nz094uNLFe+e22+SXtx2dL+90YjZr0y0TpzyRsf+4K7277Jm9+hxe0W69lhulzxZ75e//fDgnHTDyMz2frTffOX8c/9tc/8ezs/kmW6ekpEF27nHACm/2u0fvQ/PMpIfyz7f+nq0233G1HvcnNx2Sf380Pbv1+mqmznwpU2e+VGW79Vttkn7dB+bGR8/JhMmPpcPGW6Vpkxb503M3L3ffA/odnWdffTQ3PXZu1mncLH222GuF7ft1H1jro34uuevElM3/MD/7xkOVpgTZeL0OOWn/i2p8upU1YdHihblg9LFp2LBxTjv8d5X6cvf2/XJ4/9MrTWH4749m5Gc3H5Yl/6+9e4/Tuq7z//+8GA7DYVABbUBRQCDlXJiKh5IEv5KSh8xMcsvs4CqhG1/GDtu6m0dcNlsyN7bDWh6I1DSVVlMxJSwXMwyREklYEdBG8MAI4sD8/vC3fHfikCAz13zG+/124+aNz+dzXfO64IIZfMz7/dm8KUcN/Uh+veiO7T53v57D0q/XsCZ/n7BzbnnoX/Lk8ofzmQ9NbfRd+xVtKjLlY9dttYXhv97y+TyzemGG9D0qr9S9uN3fj44duuTIISfn5498L3fP/0H27LJP9t/n4B3+/h059JSsfvFP+eYtn0ubUpuMGnxSHviL+1P8b4P7HJGe3fvlwcdvzi8fn5Xxo/427x1wbKNrLvjId7Lwmbm7dQvDJ5f/Jjc/OC2HHvShHH/opxud+/S4y/PI4tktZmud3WHDxtdy8XUnZ/3r6zJ6xMfz+NJfbvfaXt0PzKA+o5r8fdKxfed8966arHxxaf7+E7OyV5d9tpzvVFmVL370e61mC8PdZd36l/KNWz6T7l175fyTpzc6d8SQk3LseyY02sLwmVULd+rP4l5V1U3+PmlOq9Y8k+/OnpJ+PYfnE2O+1ujcKUdNyq8W3rrVNlWt4euApv47e1feJy1Vc3/uaQot9eu45v6ztLOfT1ry1wE7+75s6n+PbW7YvNPvsZb867srnxuS5Pd/ejAbNtbl/cM+utVz7ugcAND0hC5albYV7XLZp2fnjl9fm/t+e31+9IuLkyTd9uiVg3ofmrEjP5kkuffRH+X+x27I6cfUNNqm8KD9D83Zx1+W786uyS0PfSMf/cDkLef67/venDv+G/mPu7+au379nXSq7JqTjpyYTx9/+VbbfIwf9be59IaP5akVv93mNhZv1dnjLsurr63JHQ9/O+s2vJSGhoZc/+Vn0rHb9kPXMcM/lu/c+cXc99j1uxy6Fi1787sD5z1xW+Y9cdt2rxvW7wMZOXBsnnjmzS2Ynn3hD5n647N2+NxjRn4iTy5/OA0NDXn9jfX55q07vpfDtHMfaNZ/+Nz9Xz/II4tn5/QPTNnm/5T50GGfadLtVnaXG+67JEtXLsgXTvl2enbru9X5v9zCcNWLS/NyXW2SZOacy3f43GeNvTj9eg1r8vcJb93y5xfnunu+loP3Pzyn/a+/t/5Hn+rBW21h+D9bpz3xzK+2/N5sy7v2OiBHDjl5yzUvrXshV8365A7nub7vM3lqxW+zsX5Dkmy1uuQv/d/T/yOVHbrkW7edl+puffPZE7b+Dtq9qt61W7cwfP2N9Zk261Pp1KEqf3fad7c636Fdxxa1tc7u8NK6F7ZsbfvzR76bnz+y9ev+H2NHfjKD+oxq8vfJ4hd/k7t+8295/7CP5gPDT9/qmpEDx7aaLQx3l2/fPim1Lz+XSz89O1067rnV+b/cwnBn/ywOP/CYJn+fNJeGhoZMm3V23qh/PTVn/HCre9WUSqWttqm699EftoqvA5r67+xdeZ+0RGvXvdCsn3uayoo//7HFfR3X3F9TP7bk/p36fDJy4NgW+3XArrwvm/rfY0l26j22794DWuyv7658bvifnRLu++316VZVnSMGn7TV8+7oHADQ9EoNDQ0N5R6itaqrq0uXLl2SJOvWrUvnztuPE81l08bkgel//ToaGzullLEjP5maM657S9dv2rwp535jeA7sNSJfOnP73x3XVH4858rMfOCKXP/lZ/7qNiQAAADA9q15ZXX+5sp+OedDV25139sdnWupRk9KKtqXewoA2H3cowuaQEWbinzuxGl5YMHMLH9+cbN//FOPvjBVHffKzQ++va0TAQAA4J3uxw9cmR577Jfxo/52p84BAM3Diq4mZEVX67GzK7oAAAAAWiIrugBobazoAgAAAAAAoJDalnsAKIJ7/9nCRwAAAAAAaGms6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAAqp1Yeu2tra1NTUpH///qmsrEzv3r1zwQUXpK6uLuecc05KpVKuueaaco8JAAAAAADATmpb7gGa0oIFCzJu3LisXr06nTt3zqBBg7Jy5cpMnz49S5cuzZo1a5IkI0aMKO+gLdArr63JzPsvz8OLbs+fX16RTh2q0qd6SD553NcztN/R5R4PAAAAAACg9Yau2trajB8/PqtXr87kyZNz8cUXp6qqKkly1VVX5aKLLkrbtm1TKpUybNiwMk/bsjy/dnn+778dk/Ub1+X4Q8/Jfj0Gpm7Dy/nTqt+n9pXnyj0eAAAAAABAklYcuiZNmpQVK1Zk4sSJmTZtWqNzNTU1uemmm/L444+nb9++6dq1a5mmbJmunPmJbNpcnxlf/H26d+1Z7nEAAAAAAAC2qVXeo2vx4sWZNWtWevTokSuuuGKb14wcOTJJMnz48K3O3XbbbTniiCPSuXPn7LHHHjnyyCOzaNGiJp25pfj9nx7KE8/8KqcfU5PuXXumftMb2bDxtXKPBQAAAAAAsJVWuaJr5syZ2bx5cyZMmJAuXbps85qOHTsm2Tp0TZ8+PZMnT87f/d3f5ZJLLsnrr7+eRx55JOvXr2/yuVuC//rDz5Mk++y5f772g/H5rz/+ZzZv3pR9ewzIJ8b8Q8aM/ESZJwQAAAAAAHhTqwxdc+bMSZKMHj16u9esWLEiSePQtXTp0kyZMiVXX311Jk6cuOX4hz70oSaatOVZ8cIfkyRX3/LZ9OoxIDUf+2He2LQxtz74L5n647NSv/mNHP++s8s8JQAAAAAAQCsNXcuXL0+SHHDAAds8X19fn3nz5iVpHLp+8IMfpF27dvnsZz+722caMGBA2rQp/06R7dt2zL9PXLLd86+9/mqSpGOHqkw794G0a9s+SXLk4JPzN1f2y3/851dy3MhPtojXAgAAAMDOGTBwQDbWvzN2LgKgOKqrq/Poo4/u0mNbZeiqq6tLku1uNzhr1qzU1tamqqoqffv23XL84Ycfzrvf/e7ccMMNufTSS/Pss89mwIAB+Yd/+Id8/OMff1szrVq16m09fnepbNdph+c7tHtzS8fR7/n4lsiVJFWd9sqoQR/Ovb/9UZ798x9zwLsObtI5AQAAANj9Vq1cmQ1vuB87AK1Hqwxd1dXVWbt2bR577LGMGjWq0blVq1ZlypQpSZJhw4alVCo1Ovfcc8/ly1/+cqZOnZrevXvn+9//fs4888zsvffeGTNmzC7P1LNnzxaxCqp92447PN9jj/2SJHtVVW91rlvXnkmSdevX7v7BAAAAAGhyPXv1sqILgBanunrrJvFWtcrQNWbMmCxevDhTp07N2LFjM3DgwCTJ/Pnzc9ZZZ6W2tjZJMmLEiEaP27x5c9atW5frr78+J598cpLk2GOPzZNPPplLLrnkbYWuJUuWpHPnzrv8+N1l08bkgenbP//u/Q/NXb/5TmpfXrHVudqX3jy2Z5d9mmo8AAAAAJrQkqeWpKL9X78OAIqi/EuMmkBNTU26d++eZ599NoMHD87QoUMzYMCAHHrooenXr18++MEPJml8f64k6datW5I0ClqlUiljxozJE0880XwvoIyOHHxyOnWoyv2P3ZD1r6/bcvzFV1Zl3qLbs9/eA7Nvj/5lnBAAAAAAAOBNrTJ07bfffpk7d25OOOGEVFZWZtmyZenWrVtmzJiR2bNn56mnnkqydegaPHjwdp9zw4YNTTpzS1HVaa987sRpqX35uUz61uG55cFv5Mdzrsykbx2e+k0bc/5J3yr3iAAAAAAAAEmSUkNDQ0O5h2hO69atS9euXVMqlfLqq6+mU6dOW87dcccdOemkk3Lrrbfm1FNPTfLmdoYjRoxIt27d8stf/nKnPlZdXV26dOmy5eMWYevC/zF34U/zk19elWWrFqbUpk0O3n9Uzhp7cYb0PbLphwQAAACgSYyeFFsXAtCqtMp7dO3IokWL0tDQkIEDBzaKXEkyfvz4HH300fnc5z6XF198Mfvvv3++973vZdGiRbn33nvLNHF5HD301Bw99NRyjwEAAAAAALBd77jQtXDhwiRbb1uYvHk/rjvuuCMXXXRRvvKVr+SVV17J8OHD8/Of/3zLfb0AAAAAAABoGYSuv7DnnntmxowZmTFjRnOOBQAAAAAAwE5qU+4BmttfC10AAAAAAAAUwztuRdecOXPKPQIAAAAAAAC7wTtuRRcAAAAAAACtg9AFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCG9I0JXbW1tampq0r9//1RWVqZ379654IILUldXl3POOSelUinXXHNNucdsEX70i3/M2Cml7f44/qJ25R4RAAAAAAAgSdK23AM0tQULFmTcuHFZvXp1OnfunEGDBmXlypWZPn16li5dmjVr1iRJRowYUd5BW4ijhpyaXt37b3X8mVW/z08e/OccPmh8GaYCAAAAAADYWqsOXbW1tRk/fnxWr16dyZMn5+KLL05VVVWS5KqrrspFF12Utm3bplQqZdiwYWWetmXo12tY+vXa+tfim7d8Pkky7tBzmnskAAAAAACAbWrVWxdOmjQpK1asyMSJEzNt2rQtkStJampqMnz48NTX16dPnz7p2rVrGSdt2dZvrMsDj/84e++xXw559/HlHgcAAAAAACBJKw5dixcvzqxZs9KjR49cccUV27xm5MiRSZLhw4dvOXbMMcekVCpt88e5557bLLO3NA89fnNe2/BKjjvkU6loU1HucQAAAAAAAJK04q0LZ86cmc2bN2fChAnp0qXLNq/p2LFjksah69prr80rr7zS6LrZs2fn0ksvzYknnth0A7dgd8//fkqlUv7PoZ8u9ygAAAAAAABbtNrQNWfOnCTJ6NGjt3vNihUrkjQOXYMGDdrqussuuyx77713jj/+nbdt37Mv/DFPPPOrvKf/senZrW+5xwEAAAAAANii1Yau5cuXJ0kOOOCAbZ6vr6/PvHnzkjQOXX/pz3/+c+6+++6cd955adt213+5BgwYkDZtyr9TZPu2HfPvE5e85evv/q/vJ0nGHfaZphoJAAAAgGYyYOCAbKxfX+4xAKCR6urqPProo7v02FYbuurq6pIk69dv+xP3rFmzUltbm6qqqvTtu/2VSjNnzkx9fX3OOuustzXPqlWr3tbjd5fKdp3e8rWbNtXn3t/+KF07dc+RQ05pwqkAAAAAaA6rVq7MhjdeK/cYALDbtNrQVV1dnbVr1+axxx7LqFGjGp1btWpVpkyZkiQZNmxYSqXSdp/n+uuvz8EHH5xDDjnkbc3Ts2fPFrOi66369ZN3Zu2653PKURekfdsOTTgVAMDO+9Ev/jFnjP5S2rerzFU//lT67zsipx594U49x7wnbs9eVdUZdMDhf/Xae+Zfl2vvuCD79hiQay9487vMbrr/8tz72x/mudolufhvfpojh5y85forbpqQ3y25P8eMOCPnnfTNnZoLAKCp9OzVy4ouAFqc6urqXX5sqw1dY8aMyeLFizN16tSMHTs2AwcOTJLMnz8/Z511Vmpra5MkI0aM2O5z/OEPf8ijjz6ayy+//G3Ps2TJknTu3PltP8/btWlj8sD0t3bt3fP//20LDz2nCScCANg119/7Tzn16AvTvl3lLj/HvCduT/99R7yl0JUkIw4cnX/61O1bfv7eAWMyesQZmfaTT2917ZfPvDE/+sU/Zt36l3Z5PgCA3W3JU0tS0b7cUwDA7tNqQ1dNTU1uuummPPvssxk8eHAOOuigbNiwIU8//XTGjRuXPn365J577tnh/bmuv/76lEqlTJgwoRknbxlqX16Z+X+8Owf1PjR9ew4t9zgAAI1889ZzkyR/d+3RaVOqSPc9euW/n1+cKTOOzZ9fejZ9qofkqxN+nHZt26d+0xu57p6vZcHTc/JG/cbst/fAXPiRGXly+a/zmyfvyGNL7s0986/LSUdOzOEHn5jLb/p4XtvwSjbWb8jwA0fn/JOmb3dl/kH7H9qcLxsAAAD4C+XfS6+J7Lfffpk7d25OOOGEVFZWZtmyZenWrVtmzJiR2bNn56mnnkqS7YauhoaG3HjjjTnmmGOy//77N+foLcIvHr0umzdvyrjDPlPuUQAAtnLhR76TJLn6vLmZ8cUF2bPzPlm6ckEuOfvOfH/K4qx99fnMXXhrkuQnv/znVLbrnGsm/VdmfHFB+lYPzX/c/fc57OAP5fBBH87px0zJjC8uyIcO+0y6dNwzl5x9Z6698LeZ8cXf5/m1y/Lg739SzpcKAAAA7ECrXdGVJAcffHDuuuuurY6vW7cuy5YtS5s2bTJkyJBtPvahhx7K8uXLc/HFFzf1mC3Smcd+JWce+5VyjwEA8JYdOeSUVLbvlOTNlVarXlyaJHl40e2p2/DylvBVv2lj3tWtzzafY3PD5nx39kVZtOxXaWhoyEvrXkif6iEZPeKMZnkNAAAAwM5p1aFrexYtWpSGhoYMHDgwnTp12uY1119/fTp27JjTTjutmacDAGBX/O97dbUpVWTT5vokb67UP/+kb+WQdx/3V5/j1oe+kZfqXsi3vvBI2rerzHfu+GI2vrGhyWYGAAAA3p5Wu3XhjixcuDDJ9rct3LBhQ2655ZacfPLJqaqqas7RAAB4izp1qErdhpf/6nVHDDk5P517dTZsfC1JsmHja1m2elGSpHNl19St/3/P8er6telWVZ327Sqz5pXVeej3NzfN8AAAAMBu8Y5c0fXXQldlZWVeeumlZpwIAICdddr7J+eifx+bDu06pfsevbZ73RnHXJTr61/PF751WEopJUk+Nvqi9KkenDEjz8o/z/pU5i26PR8+4vycetQF+fr1p+Uz0wane9deec+AMTuc4cb7Ls1dv/lOXl7353xj9RO55vaJ+bcLf5c9u+y9W18rAAAAsG2lhoaGhnIP0dw++MEP5oEHHshdd92VE044ock+Tl1dXbp06ZLkzfuCde7cuck+1lu1aWPywPRyTwEAUDz3zL8uDy+6Pf/0qdvf8mN+9It/zLr1L+W8k77ZZHMBAOyM0ZOSivblngIAdp935NaFc+bMSUNDQ5NGLgAAWpcO7Tpm6coFOe9fD3lL119x04Tc/9gN6VTZtYknAwAAgHeud+SKruZiRRcAAAAALYkVXQC0Nu/IFV0AAAAAAAAUn9AFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIbX60FVbW5uampr0798/lZWV6d27dy644ILU1dXlnHPOSalUyjXXXFPuMQEAAAAAANhJbcs9QFNasGBBxo0bl9WrV6dz584ZNGhQVq5cmenTp2fp0qVZs2ZNkmTEiBHlHbSFWf/6utz2q+l5YMHMPL92WdpVdMh+ew/Mhw77XI475JMplUrlHhEAAAAAAKD1ruiqra3N+PHjs3r16kyePDmrVq3KY489ltWrV2fq1KmZPXt25s+fn1KplGHDhpV73BZj8+bN+cr3x+WH93wt7+79vnz+xH/JhDF/n82bN2XaT87O937+pXKPCAAAAAAAkKQVh65JkyZlxYoVmThxYqZNm5aqqqot52pqajJ8+PDU19enT58+6dq1axknbVn+8N+P5IlnfpWTj5qU/3v6D3LC4Z/LqUdfmG+cNzfV3fpm9m9mlHtEAAAAAACAJK00dC1evDizZs1Kjx49csUVV2zzmpEjRyZJhg8f3uj43Llzc+yxx6ZHjx7Zc889c/jhh+enP/1pk8/cUtS9/kqSpHvXXo2Ot2vbPnt07pHK9p3LMRYAAAAAAMBWWmXomjlzZjZv3pwJEyakS5cu27ymY8eOSRqHrscffzxjx45NRUVFrrvuusyaNSu9e/fOaaedlrvuuqtZZi+3g3ofmi4d98xPfnlVHnz85ryw9r/z3y/8Id//+ZezZMVv8zfH/WO5RwQAAAAAAEiStC33AE1hzpw5SZLRo0dv95oVK1YkaRy6Zs2alVKplNtvvz2dOnVKkowZMyb9+vXLjTfemBNPPLEJp24Zqjrtla9/6o5845bP5NIbTt9yvFOHqvzD39yaI4ecXL7hAAAAAAAA/pdWGbqWL1+eJDnggAO2eb6+vj7z5s1L0jh0bdy4Me3bt9+y2itJKioqUlVVlc2bN7+tmQYMGJA2bcq/gK59247594lLdnhNxw5d0uddQzJq0Icz6IAj8ur6Nbnj4W/nipvOzD996mcZOXBsM00LAAAAwO40YOCAbKxfX+4xAKCR6urqPProo7v02FYZuurq6pIk69dv+5P2rFmzUltbm6qqqvTt23fL8bPOOivf/va3M3ny5Fx00UVp27ZtZsyYkSVLluTaa699WzOtWrXqbT1+d6ls12mH559ZtTAXXHNEzv3w1Rk/6twtx0eP+Hg++y9DcvUtn80Pv7Q0FW0qmnpUAAAAAHazVStXZsMbr5V7DADYbVpl6Kqurs7atWvz2GOPZdSoUY3OrVq1KlOmTEmSDBs2LKVSacu54cOH5/7778+pp56aq6++OknSuXPn3HzzzXn/+9//tmbq2bNni1nRtSO3zr06G+s35APDPtroeGX7Tjns4BPys3nX5Pk1y9Krx4FNOSYAAAAATaBnr15WdAHQ4lRXV+/yY1tl6BozZkwWL16cqVOnZuzYsRk4cGCSZP78+TnrrLNSW1ubJBkxYkSjxy1ZsiQf+9jH8r73vS/nnXdeKioqcuONN+aMM87IXXfdlQ9+8IO7PNOSJUvSuXPnXX787rJpY/LA9O2fr335uTeva9i09WM31b/53831TTIbAAAAAE1ryVNLUtG+3FMAwO5T/iVGTaCmpibdu3fPs88+m8GDB2fo0KEZMGBADj300PTr129LsPrf9+dKkq985Svp1KlTbrvttowbNy7HHXdcfvjDH+awww7L5MmTy/FSmt0B7xqUJPnF/OsaHV+3/qU8/OTPUtVxr/Tq0b8MkwEAAAAAADTWKkPXfvvtl7lz5+aEE05IZWVlli1blm7dumXGjBmZPXt2nnrqqSRbh66FCxdm+PDhadu28UK3Qw45JIsXL262+cvp1KMvTFWnbvn+f34pV848K3f++ju56f7L87dXvydrXlmVTx1/qftzAQAAAAAALUKpoaGhodxDNKd169ala9euKZVKefXVV9OpU6ct54455pisXLkyTz75ZKPYdcwxx+TZZ5/N0qVLd+pj1dXVpUuXLls+bhG2LkySlbVLc8N9X8/vnr4/a199Ph3adcyBvUbklKMvzNFDT22eQQEAAADY7UZPiq0LAWhVWuU9unZk0aJFaWhoyMCBAxtFriQ5//zzc/rpp+eUU07J5z//+VRUVOSmm27Kgw8+mH/9138t08TNr1ePA1Nzxg/LPQYAAAAAAMAOveNC18KFC5NsvW1hknz0ox/NnXfemalTp+aTn/xkNm3alIEDB+bGG2/MmWee2dyjAgAAAAAAsANC11848cQTc+KJJzbnSAAAAAAAAOyCNuUeoLn9tdAFAAAAAABAMbzjVnTNmTOn3CMAAAAAAACwG7zjVnQBAAAAAADQOghdAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABTSOyJ01dbWpqamJv37909lZWV69+6dCy64IHV1dTnnnHNSKpVyzTXXlHvMFmHtq8/nm7eemzMv7Z1xX2qfMy/bP9/+2QVZt/6lco8GAAAAAADQSNtyD9DUFixYkHHjxmX16tXp3LlzBg0alJUrV2b69OlZunRp1qxZkyQZMWJEeQdtAdaueyFf+NZhefGVlTnh8M+nz7uGZNnzT+SuX/9bFv7poXzz/HmpbN+p3GMCAAAAAAAkaeWhq7a2NuPHj8/q1aszefLkXHzxxamqqkqSXHXVVbnooovStm3blEqlDBs2rMzTlt/M+y/P82uX58tn3pQPvufjW44POuCIXHHTmbn1oW9kwpi/L+OEAAAAAAAA/0+r3rpw0qRJWbFiRSZOnJhp06ZtiVxJUlNTk+HDh6e+vj59+vRJ165dyzhpy/D40gfSoV3HjB5xRqPjxwz/WNq3rcw98/+jTJMBAAAAAABsrdWGrsWLF2fWrFnp0aNHrrjiim1eM3LkyCTJ8OHDGx2/7777cvjhh6eysjL77LNPzj333Lz88stNPnO5vVH/etq3rUypVGp0vE2bNunQrmNWrflTXq6rLdN0AAAAAAAAjbXa0DVz5sxs3rw5EyZMSJcuXbZ5TceOHZM0Dl0PPvhgjj/++Oy777657bbbctlll+WWW27JySefnIaGhmaZvVwOeNfgvLp+bZ5+bkGj408/tyCvrl+bJHlh7X+XYTIAAAAAAICttdp7dM2ZMydJMnr06O1es2LFiiSNQ9fXv/71DBgwIDfffHPatHmzA3bv3j0f+chHMnv27Jx44om7NM+AAQO2PF85tW/bMf8+cck2z5169IV5eNHtufSG0/O3H/5m+lYPybLnF+Xf7rgwbSvapX7TG3n9jdeaeWIAAAAAdpcBAwdkY/36co8BAI1UV1fn0Ucf3aXHttrQtXz58iTJAQccsM3z9fX1mTdvXpLGoeuRRx7J2Wef3ShKHXfccUmS22+/fZdD16pVq3bpcbtbZbtO2z03tN/R+cqEH+fan03K3//ghCRJmzYVGXfoZ3LAuwZn3hO3pVMH9zIDAAAAKKpVK1dmg29kBqAVabWhq66uLkmyfv22v0Nl1qxZqa2tTVVVVfr27bvleEVFRdq3b9/o2nbt2qVUKmXRokU7NUOnTp2ybt26HHXUUXnhhRe2uvdVObRv23GH5z8w/KM5auipeWbVwqx//dXst8+7s1eXfTJx+qGpaNM2vXr0b6ZJAQAAANjdevbqZUUXAC1OdXX1Lj+21Yau6urqrF27No899lhGjRrV6NyqVasyZcqUJMmwYcMaBaiBAwfmkUceaXT9/Pnz09DQkDVr1uzUDKVSKZ07d87vfve7XXwVu9+mjckD03d8TUWbivTfd8SWn695ZXWefu53GdbvA6lsv/0VYQAAAAC0bEueWpKK9n/9OgAoivLfNKqJjBkzJkkyderUPPXUU1uOz58/P6NHj05tbW2SZMSIEY0eN2nSpMybNy+XXnppamtrs2DBgpx33nmpqKhoEffYam6bN2/Ot382KZsbNuXMY79a7nEAAAAAAAC2aLUrumpqanLTTTfl2WefzeDBg3PQQQdlw4YNefrppzNu3Lj06dMn99xzT6P7cyXJJz7xiSxatCiXXHJJvva1r6WioiLnn39+2rdvn65dW/f9qda/vi4Tpx+aI4eckupufVO34eU8sGBmlqz4bc4+/rKM6D+63CMCAAAAAABs0WpD13777Ze5c+dmypQpefDBB7Ns2bIMGjQoM2bMyGc/+9kceOCBSbJV6CqVSrnyyivz1a9+Nc8880z23Xff7LHHHunevXu+8IUvlOOlNJu2Fe3Tr9fwPPC7m/Liq6tS2a5TBvZ+Xy7/zN1537v/T7nHAwAAAAAAaKTU0NDQUO4hmtu6devStWvXlEqlvPrqq+nUacf3nfrud7+b888/P4sXL94SyIrqrdyjCwAAAIDWafSkuEcXAK1Kq13RtSOLFi1KQ0NDBg4cuFXkevTRR3Pvvffmve99b+rr63Pfffdl+vTpmTZtWuEjFwAAAAAAQGvyjgxdCxcuTLL1toVJ0qFDh9x555254oorUl9fn6FDh2bWrFk57bTTmntMAAAAAAAAdkDo+gtDhw7Nww8/3NwjAQAAAAAAsJPalHuActhR6AIAAAAAAKAY3pEruubMmVPuEQAAAAAAAHib3pErugAAAAAAACg+oQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQio1NDQ0lHsImk9DQ7L5jXJPAQAAAEA5tGmXlErlngIAdh+hCwAAAAAAgEKydSEAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACF9P8Br9RM8hUluMsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Initiate the list of operators with the first one \n", + "operator_list = [max_operator]\n", + "# Append the second operator\n", + "operator_list.append(excitation_pool[max_index])\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.68177413 1.78560123]\n", + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -1.0765906855566985\n", + " x: [ 6.400e+00 3.193e+00]\n", + " nfev: 40\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 40 F =-1.076591E+00 MAXCV = 0.000000E+00\n", + " X = 6.400237E+00 3.192770E+00\n", + "\n", + "Found ground energy: -1.0765906855566985, exact energy: -1.0803168169635073, difference: 0.0037261314068088858\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Putting it all together\n", + "Now we automate the algorithm in a single loop." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0\n", + "Maximum gradient: 0.24763743394926327\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.074702953446552\n", + " Iterations: 5\n", + " Function evaluations: 10\n", + " Gradient evaluations: 5\n", + "Result at iter 0: -1.074702953446552\n", + "Iter: 1\n", + "Maximum gradient: 0.07359328947849739\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.076590579515175\n", + " Iterations: 6\n", + " Function evaluations: 19\n", + " Gradient evaluations: 6\n", + "Result at iter 1: -1.076590579515175\n", + "Iter: 2\n", + "Maximum gradient: 0.07078710821761426\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0783388854436093\n", + " Iterations: 7\n", + " Function evaluations: 30\n", + " Gradient evaluations: 7\n", + "Result at iter 2: -1.0783388854436093\n", + "Iter: 3\n", + "Maximum gradient: 0.0394411799822255\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.07892787356227\n", + " Iterations: 9\n", + " Function evaluations: 46\n", + " Gradient evaluations: 9\n", + "Result at iter 3: -1.07892787356227\n", + "Iter: 4\n", + "Maximum gradient: 0.03616346741301904\n", + "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 13\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0794182100398042\n", + " Iterations: 11\n", + " Function evaluations: 70\n", + " Gradient evaluations: 11\n", + "Result at iter 4: -1.0794182100398042\n", + "Iter: 5\n", + "Maximum gradient: 0.03548485527364779\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0798899562728381\n", + " Iterations: 10\n", + " Function evaluations: 72\n", + " Gradient evaluations: 10\n", + "Result at iter 5: -1.0798899562728381\n", + "Iter: 6\n", + "Maximum gradient: 0.01097376956235698\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -0.9515265642536903\n", + " Iterations: 10\n", + " Function evaluations: 87\n", + " Gradient evaluations: 10\n", + "Result at iter 6: -0.9515265642536903\n", + "Iter: 7\n", + "Maximum gradient: 0.03142079833308809\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0749480635779922\n", + " Iterations: 13\n", + " Function evaluations: 119\n", + " Gradient evaluations: 13\n", + "Result at iter 7: -1.0749480635779922\n", + "Iter: 8\n", + "Maximum gradient: 0.069293366842198\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0790663000237326\n", + " Iterations: 14\n", + " Function evaluations: 141\n", + " Gradient evaluations: 14\n", + "Result at iter 8: -1.0790663000237326\n", + "Iter: 9\n", + "Maximum gradient: 0.04079818184486173\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.080061229019495\n", + " Iterations: 23\n", + " Function evaluations: 256\n", + " Gradient evaluations: 23\n", + "Result at iter 9: -1.080061229019495\n", + "Iter: 10\n", + "Maximum gradient: 0.010995623776130652\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0773315599220445\n", + " Iterations: 12\n", + " Function evaluations: 146\n", + " Gradient evaluations: 12\n", + "Result at iter 10: -1.0773315599220445\n", + "Iter: 11\n", + "Maximum gradient: 0.06736432737713484\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0792819948910284\n", + " Iterations: 27\n", + " Function evaluations: 353\n", + " Gradient evaluations: 27\n", + "Result at iter 11: -1.0792819948910284\n", + "Iter: 12\n", + "Maximum gradient: 0.035965349163355725\n", + "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 13\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0803130079928296\n", + " Iterations: 46\n", + " Function evaluations: 649\n", + " Gradient evaluations: 46\n", + "Result at iter 12: -1.0803130079928296\n", + "Iter: 13\n", + "Maximum gradient: 0.0015269364493317172\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0803091606235888\n", + " Iterations: 49\n", + " Function evaluations: 741\n", + " Gradient evaluations: 49\n", + "Result at iter 13: -1.0803091606235888\n", + "Iter: 14\n", + "Maximum gradient: 0.003568810770530964\n", + "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -1.0803163102201847\n", + " Iterations: 44\n", + " Function evaluations: 711\n", + " Gradient evaluations: 44\n", + "Result at iter 14: -1.0803163102201847\n", + "Found ground energy: -1.0803163102201847, exact energy: -1.0803168169635073, difference: 5.067433226368934e-07\n" + ] + } + ], + "source": [ + "# Define the conditions for termination\n", + "gradient_threshold = 1e-3\n", + "max_iter = 15\n", + "terminate = False\n", + "\n", + "# Initiate the problem\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "excitation_pool = ucc.operators # TODO\n", + "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "params = None\n", + "\n", + "iter = 0\n", + "operator_list = []\n", + "while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, 'x')\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " terminate = True\n", + " \n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From e9c914dbbfc45c13296661564fbd909e786624d9 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Sun, 25 Feb 2024 22:30:16 +0300 Subject: [PATCH 07/17] show LiH converged --- .../adapt-vqe-draft-LiH_compare.ipynb | 317 +++++++++--------- 1 file changed, 150 insertions(+), 167 deletions(-) diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb index 81597a4..93a9a75 100644 --- a/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb @@ -34,17 +34,27 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 1, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", + " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ "(2, 2)\n", "6\n", + "{'nuclear_repulsion_energy': 0.998447567773585}\n", "(1, 1)\n", "5\n", + "{'nuclear_repulsion_energy': 0.998447567773585, 'ActiveSpaceTransformer': -7.800375958281276}\n", "276\n" ] } @@ -59,13 +69,14 @@ "driver = PySCFDriver(\n", " atom=\"Li 0 0 0; H 0 0 1.59\",\n", " basis=\"sto3g\",\n", - " unit=DistanceUnit.ANGSTROM,\n", + " unit=DistanceUnit.ANGSTROM, \n", ")\n", "\n", "# Full problem\n", "full_problem = driver.run()\n", "print(full_problem.num_particles)\n", "print(full_problem.num_spatial_orbitals)\n", + "print(full_problem.hamiltonian.constants)\n", "\n", "as_transformer = ActiveSpaceTransformer(\n", " num_electrons=2,\n", @@ -76,6 +87,7 @@ "as_problem = as_transformer.transform(full_problem)\n", "print(as_problem.num_particles)\n", "print(as_problem.num_spatial_orbitals)\n", + "print(as_problem.hamiltonian.constants)\n", "\n", "mapper = JordanWignerMapper()\n", "fermionic_op = as_problem.hamiltonian.second_q_op()\n", @@ -88,14 +100,15 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "-1.0803168169635073\n" + "Exact minimum eigenvalue: -1.0803168169635198\n", + "Exact electronic ground state: -7.882245207471211\n" ] } ], @@ -104,7 +117,12 @@ "\n", "exact_solver = NumPyMinimumEigensolver()\n", "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", - "print(exact_result.eigenvalue)" + "exact_eigval = exact_result.eigenvalue\n", + "print(f\"Exact minimum eigenvalue: {exact_eigval}\")\n", + "\n", + "H_constants = list(as_problem.hamiltonian.constants.values())\n", + "H_shift = sum(H_constants)\n", + "print(f\"Exact electronic ground state: {exact_eigval + H_shift}\")\n" ] }, { @@ -138,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -156,7 +174,7 @@ "
" ] }, - "execution_count": 44, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -173,14 +191,14 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Hartree-Fock energy: -1.0602464292560696 is 0.020070387707437742 above the exact ground state.\n" + "Hartree-Fock energy: -1.0602464292560696 is 0.020070387707450177 above the exact ground state.\n" ] } ], @@ -189,7 +207,7 @@ "\n", "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", "hf_energy = estimator.run(hf_circuit, qubit_op).result().values[0]\n", - "print(f\"Hartree-Fock energy: {hf_energy} is {hf_energy - exact_result.eigenvalue} above the exact ground state.\")" + "print(f\"Hartree-Fock energy: {hf_energy} is {hf_energy - exact_eigval} above the exact ground state.\")" ] }, { @@ -202,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -235,7 +253,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -274,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -320,7 +338,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -338,7 +356,7 @@ "
" ] }, - "execution_count": 48, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -368,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -379,7 +397,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -390,14 +408,14 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[5.68938058]\n" + "[1.95711264]\n" ] } ], @@ -416,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -426,16 +444,16 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -1.0747029335397233\n", - " x: [ 6.167e+00]\n", - " nfev: 23\n", + " fun: -1.0747029445589993\n", + " x: [ 3.025e+00]\n", + " nfev: 22\n", " maxcv: 0.0\n", "\n", - "Found ground energy: -1.0747029335397233, exact energy: -1.0803168169635073, difference: 0.005613883423783994\n", + "Found ground energy: -7.8766313350666906, exact energy: -7.882245207471211, difference: 0.005613872404520492\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 23 F =-1.074703E+00 MAXCV = 0.000000E+00\n", - " X = 6.166820E+00\n" + " NFVALS = 22 F =-1.074703E+00 MAXCV = 0.000000E+00\n", + " X = 3.025272E+00\n" ] } ], @@ -447,27 +465,20 @@ "\n", "\n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." + "ground_energy = getattr(res, 'fun') + H_shift\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_eigval + H_shift}, difference: {ground_energy - exact_eigval - H_shift}\")" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[6.16681964]\n" + "[3.02527201]\n" ] } ], @@ -487,18 +498,18 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00733676 0. 0. -0.00194228 0.00733676 0.\n", - " 0. -0.00194228 -0.01948449 0. 0. 0.07359726\n", - " 0. -0.04177782 0. 0. 0. 0.\n", - " -0.04177782 0. 0.07359726 0. 0. 0.00029312]\n", - "Found maximum gradient 0.07359726356645548 at index 11\n", + "[ 0.00733397 0. 0. -0.00194146 0.00733397 0.\n", + " 0. -0.00194146 -0.01948708 0. 0. 0.07359587\n", + " 0. -0.04178004 0. 0. 0. 0.\n", + " -0.04178004 0. 0.07359587 0. 0. 0.00019631]\n", + "Found maximum gradient 0.07359586585830459 at index 11\n", "Maximum gradient is below the threshold: False\n" ] } @@ -525,7 +536,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -543,7 +554,7 @@ "
" ] }, - "execution_count": 57, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -560,27 +571,27 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[4.68177413 1.78560123]\n", + "[4.59221157 2.42849133]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -1.0765906855566985\n", + " fun: -1.0765906858023189\n", " x: [ 6.400e+00 3.193e+00]\n", " nfev: 40\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", " NFVALS = 40 F =-1.076591E+00 MAXCV = 0.000000E+00\n", - " X = 6.400237E+00 3.192770E+00\n", + " X = 6.400254E+00 3.192785E+00\n", "\n", - "Found ground energy: -1.0765906855566985, exact energy: -1.0803168169635073, difference: 0.0037261314068088858\n" + "Found ground energy: -7.87851907631001, exact energy: -7.882245207471211, difference: 0.0037261311612013515\n" ] } ], @@ -593,8 +604,8 @@ "print(res)\n", "\n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + "ground_energy = getattr(res, 'fun') + H_shift\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_eigval + H_shift}, difference: {ground_energy - exact_eigval - H_shift}\")" ] }, { @@ -607,7 +618,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -620,162 +631,132 @@ " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.074702953446552\n", - " Iterations: 5\n", - " Function evaluations: 10\n", - " Gradient evaluations: 5\n", - "Result at iter 0: -1.074702953446552\n", + " Current function value: -1.0747029530371732\n", + " Iterations: 7\n", + " Function evaluations: 20\n", + " Gradient evaluations: 7\n", + "Result at iter 0: -7.876631343544864\n", "Iter: 1\n", - "Maximum gradient: 0.07359328947849739\n", + "Maximum gradient: 0.07359237164321655\n", "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.076590579515175\n", - " Iterations: 6\n", - " Function evaluations: 19\n", - " Gradient evaluations: 6\n", - "Result at iter 1: -1.076590579515175\n", + " Current function value: -1.0765906918345165\n", + " Iterations: 7\n", + " Function evaluations: 23\n", + " Gradient evaluations: 7\n", + "Result at iter 1: -7.8785190823422075\n", "Iter: 2\n", - "Maximum gradient: 0.07078710821761426\n", + "Maximum gradient: 0.07076349647954457\n", "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0783388854436093\n", + " Current function value: -1.078339311436093\n", " Iterations: 7\n", - " Function evaluations: 30\n", + " Function evaluations: 31\n", " Gradient evaluations: 7\n", - "Result at iter 2: -1.0783388854436093\n", + "Result at iter 2: -7.880267701943785\n", "Iter: 3\n", - "Maximum gradient: 0.0394411799822255\n", + "Maximum gradient: 0.03947110664487546\n", "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.07892787356227\n", - " Iterations: 9\n", - " Function evaluations: 46\n", - " Gradient evaluations: 9\n", - "Result at iter 3: -1.07892787356227\n", + " Current function value: -1.0789274736235184\n", + " Iterations: 7\n", + " Function evaluations: 38\n", + " Gradient evaluations: 7\n", + "Result at iter 3: -7.88085586413121\n", "Iter: 4\n", - "Maximum gradient: 0.03616346741301904\n", + "Maximum gradient: 0.036190296161991674\n", "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 13\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0794182100398042\n", - " Iterations: 11\n", - " Function evaluations: 70\n", - " Gradient evaluations: 11\n", - "Result at iter 4: -1.0794182100398042\n", + " Current function value: -1.079418118300944\n", + " Iterations: 17\n", + " Function evaluations: 112\n", + " Gradient evaluations: 17\n", + "Result at iter 4: -7.881346508808635\n", "Iter: 5\n", - "Maximum gradient: 0.03548485527364779\n", + "Maximum gradient: 0.03550343358388081\n", "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 18\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0798899562728381\n", - " Iterations: 10\n", - " Function evaluations: 72\n", - " Gradient evaluations: 10\n", - "Result at iter 5: -1.0798899562728381\n", + " Current function value: -1.0798898658755127\n", + " Iterations: 21\n", + " Function evaluations: 157\n", + " Gradient evaluations: 21\n", + "Result at iter 5: -7.8818182563832035\n", "Iter: 6\n", - "Maximum gradient: 0.01097376956235698\n", + "Maximum gradient: 0.010958756062794632\n", "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -0.9515265642536903\n", - " Iterations: 10\n", - " Function evaluations: 87\n", - " Gradient evaluations: 10\n", - "Result at iter 6: -0.9515265642536903\n", + " Current function value: -0.9525598305624912\n", + " Iterations: 19\n", + " Function evaluations: 157\n", + " Gradient evaluations: 19\n", + "Result at iter 6: -7.754488221070183\n", "Iter: 7\n", - "Maximum gradient: 0.03142079833308809\n", + "Maximum gradient: 0.027784171922399386\n", "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0749480635779922\n", - " Iterations: 13\n", - " Function evaluations: 119\n", - " Gradient evaluations: 13\n", - "Result at iter 7: -1.0749480635779922\n", + " Current function value: -1.0754404939598767\n", + " Iterations: 12\n", + " Function evaluations: 113\n", + " Gradient evaluations: 12\n", + "Result at iter 7: -7.877368884467568\n", "Iter: 8\n", - "Maximum gradient: 0.069293366842198\n", - "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + "Maximum gradient: 0.06939572286077894\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 20\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0790663000237326\n", - " Iterations: 14\n", - " Function evaluations: 141\n", - " Gradient evaluations: 14\n", - "Result at iter 8: -1.0790663000237326\n", + " Current function value: -1.0798917778382773\n", + " Iterations: 34\n", + " Function evaluations: 342\n", + " Gradient evaluations: 34\n", + "Result at iter 8: -7.8818201683459685\n", "Iter: 9\n", - "Maximum gradient: 0.04079818184486173\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Maximum gradient: 0.010874722715186315\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.080061229019495\n", - " Iterations: 23\n", - " Function evaluations: 256\n", - " Gradient evaluations: 23\n", - "Result at iter 9: -1.080061229019495\n", + " Current function value: -1.0772734048154884\n", + " Iterations: 24\n", + " Function evaluations: 268\n", + " Gradient evaluations: 24\n", + "Result at iter 9: -7.87920179532318\n", "Iter: 10\n", - "Maximum gradient: 0.010995623776130652\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Maximum gradient: 0.06860839917623317\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0773315599220445\n", - " Iterations: 12\n", - " Function evaluations: 146\n", - " Gradient evaluations: 12\n", - "Result at iter 10: -1.0773315599220445\n", + " Current function value: -1.0790244789965728\n", + " Iterations: 34\n", + " Function evaluations: 411\n", + " Gradient evaluations: 34\n", + "Result at iter 10: -7.880952869504264\n", "Iter: 11\n", - "Maximum gradient: 0.06736432737713484\n", - "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + "Maximum gradient: 0.04151468703828826\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 11\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0792819948910284\n", - " Iterations: 27\n", - " Function evaluations: 353\n", - " Gradient evaluations: 27\n", - "Result at iter 11: -1.0792819948910284\n", + " Current function value: -1.0803162853202792\n", + " Iterations: 36\n", + " Function evaluations: 471\n", + " Gradient evaluations: 36\n", + "Result at iter 11: -7.8822446758279705\n", "Iter: 12\n", - "Maximum gradient: 0.035965349163355725\n", - "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 13\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0803130079928296\n", - " Iterations: 46\n", - " Function evaluations: 649\n", - " Gradient evaluations: 46\n", - "Result at iter 12: -1.0803130079928296\n", - "Iter: 13\n", - "Maximum gradient: 0.0015269364493317172\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0803091606235888\n", - " Iterations: 49\n", - " Function evaluations: 741\n", - " Gradient evaluations: 49\n", - "Result at iter 13: -1.0803091606235888\n", - "Iter: 14\n", - "Maximum gradient: 0.003568810770530964\n", - "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0803163102201847\n", - " Iterations: 44\n", - " Function evaluations: 711\n", - " Gradient evaluations: 44\n", - "Result at iter 14: -1.0803163102201847\n", - "Found ground energy: -1.0803163102201847, exact energy: -1.0803168169635073, difference: 5.067433226368934e-07\n" + "Maximum gradient: 0.0005266537565274415\n", + "Found ground energy: -7.8822446758279705, exact energy: -7.882245207471211, difference: 5.316432405422233e-07\n" ] } ], @@ -807,24 +788,26 @@ " print(f\"Operator: {max_operator} at index {max_index}\")\n", " # Grow the ansatz\n", " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", " # Run VQE on the current ansatz\n", " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun') + H_shift}\")\n", " x_opt = getattr(res, 'x')\n", " params = x_opt\n", " # Terminate if maximum number of iterations reached\n", " iter += 1\n", " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration.\")\n", " terminate = True\n", " # Terminate if converged\n", " else:\n", + " print(\"Terminating: converged.\")\n", " terminate = True\n", " \n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + "ground_energy = getattr(res, 'fun') + H_shift\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_eigval + H_shift}, difference: {ground_energy - exact_eigval - H_shift}\")" ] } ], From bb53684be279c77cac37da8f3a23824bfdafd82f Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Thu, 29 Feb 2024 00:44:05 +0300 Subject: [PATCH 08/17] fix hamiltonian --- .../tutorials/adapt-vqe-draft-H2.ipynb | 839 --------------- .../adapt-vqe-draft-H2_compare.ipynb | 593 ----------- .../tutorials/adapt-vqe-draft-LiH.ipynb | 967 ------------------ ...raft-LiH_compare.ipynb => adapt-vqe.ipynb} | 662 +++++++----- 4 files changed, 406 insertions(+), 2655 deletions(-) delete mode 100644 quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb delete mode 100644 quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb delete mode 100644 quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb rename quantum_enablement/tutorials/{adapt-vqe-draft-LiH_compare.ipynb => adapt-vqe.ipynb} (67%) diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb deleted file mode 100644 index 6b45b29..0000000 --- a/quantum_enablement/tutorials/adapt-vqe-draft-H2.ipynb +++ /dev/null @@ -1,839 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit ADAPT-VQE tutorial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the molecule\n", - "We start by defining the molecule using ``pyscf``. As an example we select the $H_2$ molecule and build it by providing its geometry.\n", - "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyscf import ao2mo, gto, mcscf, scf\n", - "\n", - "distance = 0.735\n", - "a = distance / 2\n", - "mol = gto.Mole()\n", - "mol.build(\n", - " verbose=0,\n", - " atom=[\n", - " [\"H\", (0, 0, -a)],\n", - " [\"H\", (0, 0, a)],\n", - " ],\n", - " basis=\"sto-6g\",\n", - " spin=0,\n", - " charge=0,\n", - " symmetry=\"Dooh\",\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nuclear energy: 0.7199689944489797\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", - " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Electronic energy: -1.8455976628764188\n", - "Total energy: -1.125628668427439\n", - "Total energy - nuclear energy: -1.8455976628764188\n" - ] - } - ], - "source": [ - "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", - "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", - "print(f\"Total energy: {mol.energy_tot()}\")\n", - "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "range(0, 2)\n" - ] - } - ], - "source": [ - "active_space = range(mol.nelectron // 2 - 1, mol.nelectron // 2 + 1)\n", - "print(active_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate the fermionic Hamiltonian\n", - "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "mf = scf.RHF(mol)\n", - "E1 = mf.kernel()\n", - "mx = mcscf.CASCI(mf, ncas=2, nelecas=(1, 1))\n", - "mo = mx.sort_mo(active_space, base=0)\n", - "E2 = mx.kernel(mo)[:2]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "h1e, ecore = mx.get_h1eff()\n", - "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Map the fermionic Hamiltonian to a qubit operator\n", - "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", - "\n", - "import numpy as np\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "\n", - "\n", - "def cholesky(V, eps):\n", - " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", - " # see https://arxiv.org/abs/1808.02625\n", - " # see https://arxiv.org/abs/2104.08957\n", - " no = V.shape[0]\n", - " chmax, ng = 20 * no, 0\n", - " W = V.reshape(no**2, no**2)\n", - " L = np.zeros((no**2, chmax))\n", - " Dmax = np.diagonal(W).copy()\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " while vmax > eps:\n", - " L[:, ng] = W[:, nu_max]\n", - " if ng > 0:\n", - " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", - " L[:, ng] /= np.sqrt(vmax)\n", - " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", - " ng += 1\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " L = L[:, :ng].reshape((no, no, ng))\n", - " print(\n", - " \"accuracy of Cholesky decomposition \",\n", - " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", - " )\n", - " return L, ng\n", - "\n", - "\n", - "def identity(n):\n", - " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", - "\n", - "\n", - "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", - " c_list = []\n", - " if mapping == \"jordan_wigner\":\n", - " for p in range(n):\n", - " if p == 0:\n", - " l, r = \"I\" * (n - 1), \"\"\n", - " elif p == n - 1:\n", - " l, r = \"\", \"Z\" * (n - 1)\n", - " else:\n", - " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", - " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, 0.5j)])\n", - " c_list.append(cp)\n", - " else:\n", - " raise ValueError(\"Unsupported mapping.\")\n", - " d_list = [cp.adjoint() for cp in c_list]\n", - " return c_list, d_list\n", - "\n", - "\n", - "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", - " ncas, _ = h1e.shape\n", - "\n", - " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", - " Exc = []\n", - " for p in range(ncas):\n", - " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", - " for r in range(p + 1, ncas):\n", - " Excp.append(\n", - " C[p] @ D[r]\n", - " + C[ncas + p] @ D[ncas + r]\n", - " + C[r] @ D[p]\n", - " + C[ncas + r] @ D[ncas + p]\n", - " )\n", - " Exc.append(Excp)\n", - "\n", - " # low-rank decomposition of the Hamiltonian\n", - " Lop, ng = cholesky(h2e, 1e-6)\n", - " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", - "\n", - " H = ecore * identity(2 * ncas)\n", - " # one-body term\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " H += t1e[p, r] * Exc[p][r - p]\n", - " # two-body term\n", - " for g in range(ng):\n", - " Lg = 0 * identity(2 * ncas)\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " Lg += Lop[p, r, g] * Exc[p][r - p]\n", - " H += 0.5 * Lg @ Lg\n", - "\n", - " return H.chop().simplify()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "accuracy of Cholesky decomposition 6.655392125243921e-17\n", - "SparsePauliOp(['IIII', 'IIIZ', 'IZII', 'IIZI', 'ZIII', 'IZIZ', 'IIZZ', 'ZIIZ', 'IZZI', 'ZZII', 'ZIZI', 'YYYY', 'XXYY', 'YYXX', 'XXXX'],\n", - " coeffs=[-0.09820182+0.j, -0.1740751 +0.j, -0.1740751 +0.j, 0.2242933 +0.j,\n", - " 0.2242933 +0.j, 0.16891402+0.j, 0.1210099 +0.j, 0.16631441+0.j,\n", - " 0.16631441+0.j, 0.1210099 +0.j, 0.17504456+0.j, 0.04530451+0.j,\n", - " 0.04530451+0.j, 0.04530451+0.j, 0.04530451+0.j])\n" - ] - } - ], - "source": [ - "H = build_hamiltonian(ecore, h1e, h2e)\n", - "print(H)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Remark\n", - "Compare with the exact ground state energy below. There is a mismatch with this and the pyscf computed energies." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Exact ground state: -1.1459778538543897\n" - ] - } - ], - "source": [ - "from qiskit_algorithms import NumPyMinimumEigensolver\n", - "\n", - "exact_solver = NumPyMinimumEigensolver()\n", - "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", - "print(f\"Exact ground state: {exact_result.eigenvalue}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Outline of the ADAPT-VQE algorithm\n", - "https://arxiv.org/abs/1812.11173 \n", - "\n", - "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", - "\n", - "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", - "\n", - "3. Define the following conditions for termination: CONVERGED, CYCLICITY, MAXIMUM.\n", - " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", - " - CYCLICITY: Aborted due to a cyclic selection of evolution operators.\n", - " - MAXIMUM: Maximum number of iterations reached.\n", - " \n", - "4. while not TERMINATE (CONVERGED or CYCLICITY or MAXIMUM):\n", - " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", - " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", - " - Run VQE over all parameters $\\theta_i$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initial state\n", - "We initate the quantum computer to the Hartree-Fock state." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", - " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", - "\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - "\n", - " Returns:\n", - " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", - "\n", - " Raises:\n", - " ValueError: If the total number of particles is larger than the number of orbitals.\n", - " \"\"\"\n", - " # validate the input\n", - " assert num_spatial_orbitals >= 1\n", - " num_alpha, num_beta = num_particles\n", - "\n", - " if any(n > num_spatial_orbitals for n in num_particles):\n", - " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", - "\n", - " half_orbitals = num_spatial_orbitals\n", - " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", - " bitstr[:num_alpha] = True\n", - " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", - "\n", - " return bitstr.tolist()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "num_spatial_orbitals = mx.ncas\n", - "num_particles = mx.nelecas\n", - "\n", - "# Get the Hartree-Fock initial state in bitsting representation\n", - "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", - "\n", - "# Get the corresponding circuit in Jordan-Wigner transform\n", - "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", - "for i, hf_bit in enumerate(hf_bitstring):\n", - " if hf_bit:\n", - " hf_circuit.x(i)\n", - "\n", - "hf_circuit.draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operator pool\n", - "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[SparsePauliOp(['IIXY', 'IIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['XYII', 'YXII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j])]\n" - ] - } - ], - "source": [ - "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", - "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", - "\n", - "qubit_mapper = JordanWignerMapper()\n", - "\n", - "# Define the pool of operators as those generated by the UCC ansatz\n", - "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", - "excitation_pool = ucc.operators # TODO\n", - "print(excitation_pool)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Gradient of the excitation operators\n", - "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. Note that the following computation requires the operators from the pool to be anti-Hermitian, and should be replaced with an appropriate alternative method if this is not the case." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", - " \"\"\"\n", - " Computes the gradients for all available excitation operators.\n", - " Args:\n", - " ansatz: ansatz built so far.\n", - " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", - " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", - " estimator: an instance of the Qiskit Estimator primitive\n", - " params: parameters to be assigned to the ansatz, if any.\n", - " Returns:\n", - " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", - " \"\"\"\n", - " # The excitations operators are applied later as exp(i*theta*excitation).\n", - " # For this commutator, we need to explicitly pull in the imaginary phase.\n", - " if params is not None:\n", - " ansatz_opt = ansatz.assign_parameters(params)\n", - " else:\n", - " ansatz_opt = ansatz\n", - " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", - " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", - " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", - " gradients = estimator.run(ansatz_list, commutators).result().values\n", - "\n", - " return gradients" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0. -0.36243609]\n", - "Found operator SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.362436085015165 at index 2.\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "from qiskit.primitives import Estimator\n", - "\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "max_operator = excitation_pool[max_index]\n", - "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Expand the Ansatz\n", - "We found that the third operator in the pool, which is the double-excitation operator in this case, has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` for small problems." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import MatrixExponential, SuzukiTrotter, LieTrotter\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", - "ansatz.decompose().draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run VQE\n", - "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", - " return energy" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[3.22106593]\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -1.1459778429846779\n", - " x: [ 4.824e+00]\n", - " nfev: 26\n", - " maxcv: 0.0\n", - "\n", - "Found ground energy: -1.1459778429846779, exact energy: -1.1459778538543897, difference: 1.086971179731222e-08\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 26 F =-1.145978E+00 MAXCV = 0.000000E+00\n", - " X = 4.824293E+00\n" - ] - } - ], - "source": [ - "from scipy.optimize import minimize\n", - "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[4.82429327]\n" - ] - } - ], - "source": [ - "# Optimal parameters so far\n", - "x_opt = getattr(res, 'x')\n", - "print(x_opt)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another iteration of the algorithm\n", - "We now compute the gradients again to see if we need another iteration." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0. -0.00026656]\n", - "Found maximum gradient 0.00026655562367891746 at index 2\n", - "Maximum gradient is below the threshold: True\n" - ] - } - ], - "source": [ - "gradient_threshold = 1e-3\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "\n", - "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", - "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since the maximum gradient is below the threshold, we do not append another operator to the ansatz, and the algorithm terminates." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Putting it all together\n", - "Now we automate the algorithm in a single loop." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iter: 0\n", - "Maximum gradient: 0.362436085015165\n", - "Operator: SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 2\n", - "Result at iter 0: -1.1459778408064227\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 22 F =-1.145978E+00 MAXCV = 0.000000E+00\n", - " X = 4.824301E+00\n", - "\n", - "Iter: 1\n", - "Maximum gradient: 0.0002920451757324385\n", - "Terminating: converged\n", - "Found ground energy: -1.1459778408064227, exact energy: -1.1459778538543897, difference: 1.3047966929136123e-08\n" - ] - } - ], - "source": [ - "# Define the conditions for termination\n", - "gradient_threshold = 1e-3\n", - "max_iter = 10\n", - "terminate = False\n", - "\n", - "# Initiate the problem\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "excitation_pool = ucc.operators # TODO\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "params = None\n", - "\n", - "iter = 0\n", - "operator_list = []\n", - "while not terminate:\n", - " print(f\"Iter: {iter}\")\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " print(f\"Maximum gradient: {max_gradient}\")\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(np.abs(gradients))\n", - " max_operator = excitation_pool[max_index]\n", - " print(f\"Operator: {max_operator} at index {max_index}\")\n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, 'x')\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " print(\"Terminating: reached maximum iteration\")\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " print(\"Terminating: converged\")\n", - " terminate = True\n", - " \n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "quantum", - "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.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb deleted file mode 100644 index 57c1134..0000000 --- a/quantum_enablement/tutorials/adapt-vqe-draft-H2_compare.ipynb +++ /dev/null @@ -1,593 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit ADAPT-VQE tutorial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the molecule\n", - "We start by defining the molecule using ``pyscf``. As an example we select the $H_2$ molecule and build it by providing its geometry.\n", - "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate the fermionic Hamiltonian\n", - "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Map the fermionic Hamiltonian to a qubit operator\n", - "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Exact ground state: -1.857275030202378\n" - ] - } - ], - "source": [ - "from qiskit_nature.second_q.drivers import PySCFDriver\n", - "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", - "from qiskit_nature.units import DistanceUnit\n", - "from qiskit_algorithms import NumPyMinimumEigensolver\n", - "\n", - "driver = PySCFDriver(\n", - " atom=\"H 0 0 0; H 0 0 0.735\",\n", - " basis=\"sto3g\",\n", - " unit=DistanceUnit.ANGSTROM,\n", - ")\n", - "\n", - "# Electronic structure problem\n", - "problem = driver.run()\n", - "\n", - "mapper = JordanWignerMapper()\n", - "\n", - "fermionic_op = problem.hamiltonian.second_q_op()\n", - "qubit_op = mapper.map(fermionic_op)\n", - "H = qubit_op\n", - "\n", - "exact_solver = NumPyMinimumEigensolver()\n", - "exact_result = exact_solver.compute_minimum_eigenvalue(qubit_op)\n", - "print(f\"Exact ground state: {exact_result.eigenvalue}\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Outline of the ADAPT-VQE algorithm\n", - "https://arxiv.org/abs/1812.11173 \n", - "\n", - "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", - "\n", - "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", - "\n", - "3. Define the following conditions for termination: CONVERGED, CYCLICITY, MAXIMUM.\n", - " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", - " - CYCLICITY: Aborted due to a cyclic selection of evolution operators.\n", - " - MAXIMUM: Maximum number of iterations reached.\n", - " \n", - "4. while not TERMINATE (CONVERGED or CYCLICITY or MAXIMUM):\n", - " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", - " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", - " - Run VQE over all parameters $\\theta_i$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initial state\n", - "We initate the quantum computer to the Hartree-Fock state." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit_nature.second_q.circuit.library import HartreeFock\n", - "\n", - "num_spatial_orbitals = problem.num_spatial_orbitals\n", - "num_particles = problem.num_particles\n", - "\n", - "hf_circuit = HartreeFock(num_spatial_orbitals, num_particles, mapper)\n", - "hf_circuit.draw(output='mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hartree-Fock energy: -1.8369679912029837 is 0.020307038999394234 above the exact ground state.\n" - ] - } - ], - "source": [ - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "hf_energy = estimator.run(hf_circuit, qubit_op).result().values[0]\n", - "print(f\"Hartree-Fock energy: {hf_energy} is {hf_energy - exact_result.eigenvalue} above the exact ground state.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operator pool\n", - "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[SparsePauliOp(['IIXY', 'IIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['XYII', 'YXII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]), SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j])]\n" - ] - } - ], - "source": [ - "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", - "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", - "\n", - "qubit_mapper = JordanWignerMapper()\n", - "\n", - "# Define the pool of operators as those generated by the UCC ansatz\n", - "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", - "excitation_pool = ucc.operators # TODO\n", - "print(excitation_pool)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Gradient of the excitation operators\n", - "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. Note that the following computation requires the operators from the pool to be anti-Hermitian, and should be replaced with an appropriate alternative method if this is not the case." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", - " \"\"\"\n", - " Computes the gradients for all available excitation operators.\n", - " Args:\n", - " ansatz: ansatz built so far.\n", - " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", - " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", - " estimator: an instance of the Qiskit Estimator primitive\n", - " params: parameters to be assigned to the ansatz, if any.\n", - " Returns:\n", - " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", - " \"\"\"\n", - " # The excitations operators are applied later as exp(i*theta*excitation).\n", - " # For this commutator, we need to explicitly pull in the imaginary phase.\n", - " if params is not None:\n", - " ansatz_opt = ansatz.assign_parameters(params)\n", - " else:\n", - " ansatz_opt = ansatz\n", - " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", - " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", - " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", - " gradients = estimator.run(ansatz_list, commutators).result().values\n", - "\n", - " return gradients" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0. -0.3618624]\n", - "Found operator SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.36186239956846256 at index 2.\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "from qiskit.primitives import Estimator\n", - "\n", - "ansatz = hf_circuit\n", - "hamiltonian = qubit_op\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "max_operator = excitation_pool[max_index]\n", - "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Expand the Ansatz\n", - "We found that the third operator in the pool, which is the double-excitation operator in this case, has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` for small problems." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import MatrixExponential, SuzukiTrotter, LieTrotter\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", - "ansatz.decompose().draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run VQE\n", - "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", - " return energy" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[5.06246655]\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -1.8572749998063154\n", - " x: [ 6.172e+00]\n", - " nfev: 20\n", - " maxcv: 0.0\n", - "\n", - "Found ground energy: -1.8572749998063154, exact energy: -1.857275030202378, difference: 3.039606255583749e-08\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 20 F =-1.857275E+00 MAXCV = 0.000000E+00\n", - " X = 6.171553E+00\n" - ] - } - ], - "source": [ - "from scipy.optimize import minimize\n", - "\n", - "res = minimize(cost_func, x0, args=(ansatz, qubit_op, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[6.17155327]\n" - ] - } - ], - "source": [ - "# Optimal parameters so far\n", - "x_opt = getattr(res, 'x')\n", - "print(x_opt)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another iteration of the algorithm\n", - "We now compute the gradients again to see if we need another iteration." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0. -0.0004455]\n", - "Found maximum gradient 0.00044549942989826306 at index 2\n", - "Maximum gradient is below the threshold: True\n" - ] - } - ], - "source": [ - "gradient_threshold = 1e-3\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "\n", - "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", - "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since the maximum gradient is below the threshold, we do not append another operator to the ansatz, and the algorithm terminates." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Putting it all together\n", - "Now we automate the algorithm in a single loop." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iter: 0\n", - "Maximum gradient: 0.36186239956846256\n", - "Operator: SparsePauliOp(['YYXY', 'XYYY', 'XXXY', 'YXYY', 'XYXX', 'YYYX', 'YXXX', 'XXYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 2\n", - "Result at iter 0: -1.8572750106208789\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 24 F =-1.857275E+00 MAXCV = 0.000000E+00\n", - " X = 3.029715E+00\n", - "\n", - "Iter: 1\n", - "Maximum gradient: 0.0003575701706209026\n", - "Terminating: converged\n", - "Found ground energy: -1.8572750106208789, exact energy: -1.857275030202378, difference: 1.958149908887208e-08\n" - ] - } - ], - "source": [ - "# Define the conditions for termination\n", - "gradient_threshold = 1e-3\n", - "max_iter = 10\n", - "terminate = False\n", - "\n", - "# Initiate the problem\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "excitation_pool = ucc.operators # TODO\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "params = None\n", - "\n", - "iter = 0\n", - "operator_list = []\n", - "while not terminate:\n", - " print(f\"Iter: {iter}\")\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " print(f\"Maximum gradient: {max_gradient}\")\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(np.abs(gradients))\n", - " max_operator = excitation_pool[max_index]\n", - " print(f\"Operator: {max_operator} at index {max_index}\")\n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, 'x')\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " print(\"Terminating: reached maximum iteration\")\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " print(\"Terminating: converged\")\n", - " terminate = True\n", - " \n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "quantum", - "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.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb b/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb deleted file mode 100644 index 3697462..0000000 --- a/quantum_enablement/tutorials/adapt-vqe-draft-LiH.ipynb +++ /dev/null @@ -1,967 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit ADAPT-VQE tutorial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the molecule\n", - "We start by defining the molecule using ``pyscf``. As an example we select the LiH molecule and build it by providing its geometry.\n", - "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from pyscf import ao2mo, gto, mcscf, scf\n", - "\n", - "# LiH\n", - "distance = 1.56\n", - "mol = gto.Mole()\n", - "mol.build(\n", - " verbose=0,\n", - " atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n", - " basis=\"sto-6g\",\n", - " spin=0,\n", - " charge=0,\n", - " symmetry=\"Coov\", \n", - " )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nuclear energy: 2.159906983346939\n", - "Electronic energy: -9.788591664808054\n", - "Total energy: -7.628684681461115\n", - "Total energy - nuclear energy: -9.788591664808054\n" - ] - } - ], - "source": [ - "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", - "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", - "print(f\"Total energy: {mol.energy_tot()}\")\n", - "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate the fermionic Hamiltonian\n", - "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "mf = scf.RHF(mol)\n", - "E1 = mf.kernel()\n", - "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", - "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n", - "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", - "E2 = mx.kernel(mo)[:2]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "h1e, ecore = mx.get_h1eff()\n", - "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Map the fermionic Hamiltonian to a qubit operator\n", - "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", - "\n", - "import numpy as np\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "\n", - "\n", - "def cholesky(V, eps):\n", - " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", - " # see https://arxiv.org/abs/1808.02625\n", - " # see https://arxiv.org/abs/2104.08957\n", - " no = V.shape[0]\n", - " chmax, ng = 20 * no, 0\n", - " W = V.reshape(no**2, no**2)\n", - " L = np.zeros((no**2, chmax))\n", - " Dmax = np.diagonal(W).copy()\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " while vmax > eps:\n", - " L[:, ng] = W[:, nu_max]\n", - " if ng > 0:\n", - " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", - " L[:, ng] /= np.sqrt(vmax)\n", - " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", - " ng += 1\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " L = L[:, :ng].reshape((no, no, ng))\n", - " print(\n", - " \"accuracy of Cholesky decomposition \",\n", - " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", - " )\n", - " return L, ng\n", - "\n", - "\n", - "def identity(n):\n", - " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", - "\n", - "\n", - "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", - " c_list = []\n", - " if mapping == \"jordan_wigner\":\n", - " for p in range(n):\n", - " if p == 0:\n", - " l, r = \"I\" * (n - 1), \"\"\n", - " elif p == n - 1:\n", - " l, r = \"\", \"Z\" * (n - 1)\n", - " else:\n", - " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", - " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, 0.5j)])\n", - " c_list.append(cp)\n", - " else:\n", - " raise ValueError(\"Unsupported mapping.\")\n", - " d_list = [cp.adjoint() for cp in c_list]\n", - " return c_list, d_list\n", - "\n", - "\n", - "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", - " ncas, _ = h1e.shape\n", - "\n", - " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", - " Exc = []\n", - " for p in range(ncas):\n", - " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", - " for r in range(p + 1, ncas):\n", - " Excp.append(\n", - " C[p] @ D[r]\n", - " + C[ncas + p] @ D[ncas + r]\n", - " + C[r] @ D[p]\n", - " + C[ncas + r] @ D[ncas + p]\n", - " )\n", - " Exc.append(Excp)\n", - "\n", - " # low-rank decomposition of the Hamiltonian\n", - " Lop, ng = cholesky(h2e, 1e-6)\n", - " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", - "\n", - " H = ecore * identity(2 * ncas)\n", - " # one-body term\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " H += t1e[p, r] * Exc[p][r - p]\n", - " # two-body term\n", - " for g in range(ng):\n", - " Lg = 0 * identity(2 * ncas)\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " Lg += Lop[p, r, g] * Exc[p][r - p]\n", - " H += 0.5 * Lg @ Lg\n", - "\n", - " return H.chop().simplify()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "accuracy of Cholesky decomposition 2.7755575615628914e-16\n", - "The Hamiltonian consists of 276 10-qubit Pauli operators.\n" - ] - } - ], - "source": [ - "H = build_hamiltonian(ecore, h1e, h2e)\n", - "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Remark\n", - "Compare with the exact ground state energy below. There is a mismatch with this and the pyscf computed energies." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-7.646812245579224\n" - ] - } - ], - "source": [ - "from qiskit_algorithms import NumPyMinimumEigensolver\n", - "\n", - "exact_solver = NumPyMinimumEigensolver()\n", - "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", - "print(exact_result.eigenvalue)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Outline of the ADAPT-VQE algorithm\n", - "This algorithm was first introduced in https://arxiv.org/abs/1812.1117.\n", - "\n", - "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", - "\n", - "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", - "\n", - "3. Define the following conditions for termination: CONVERGED, MAXIMUM.\n", - " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", - " - MAXIMUM: Maximum number of iterations reached.\n", - " \n", - "4. while not TERMINATE (CONVERGED or MAXIMUM):\n", - " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", - " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", - " - Run VQE over all parameters $\\theta_i$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initial state\n", - "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we do with the help of the function below." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", - " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", - "\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - "\n", - " Returns:\n", - " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", - "\n", - " Raises:\n", - " ValueError: If the total number of particles is larger than the number of orbitals.\n", - " \"\"\"\n", - " # validate the input\n", - " assert num_spatial_orbitals >= 1\n", - " num_alpha, num_beta = num_particles\n", - "\n", - " if any(n > num_spatial_orbitals for n in num_particles):\n", - " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", - "\n", - " half_orbitals = num_spatial_orbitals\n", - " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", - " bitstr[:num_alpha] = True\n", - " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", - "\n", - " return bitstr.tolist()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "num_spatial_orbitals = mx.ncas\n", - "num_particles = mx.nelecas\n", - "\n", - "# Get the Hartree-Fock initial state in boolean bitstring representation\n", - "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", - "\n", - "# Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an X-gate as indicated by the boolean list\n", - "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", - "for i, hf_bit in enumerate(hf_bitstring):\n", - " if hf_bit:\n", - " hf_circuit.x(i)\n", - "\n", - "hf_circuit.draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operator pool\n", - "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The excitation pool consists of 24 operators.\n" - ] - } - ], - "source": [ - "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", - "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", - "\n", - "qubit_mapper = JordanWignerMapper()\n", - "\n", - "# Define the pool of operators as the single and double excitation operators generated by the UCC ansatz\n", - "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", - "excitation_pool = ucc.operators # TODO\n", - "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Gradient of the excitation operators\n", - "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", - " \"\"\"\n", - " Computes the gradients for all available excitation operators.\n", - " Args:\n", - " ansatz: ansatz built so far.\n", - " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", - " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", - " estimator: an instance of the Qiskit Estimator primitive\n", - " params: parameters to be assigned to the ansatz, if any.\n", - " Returns:\n", - " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", - " \"\"\"\n", - " # The excitations operators are applied later as exp(i*theta*excitation).\n", - " # For this commutator, we need to explicitly pull in the imaginary phase.\n", - " if params is not None:\n", - " ansatz_opt = ansatz.assign_parameters(params)\n", - " else:\n", - " ansatz_opt = ansatz\n", - " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", - " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", - " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", - " gradients = estimator.run(ansatz_list, commutators).result().values\n", - "\n", - " return gradients" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.11860637 0. 0. -0.50320326 0.11860637 0.\n", - " 0. -0.50320326 -0.01824441 0. 0. 0.05000378\n", - " 0. -0.05904723 0. 0. 0. 0.\n", - " -0.05904723 0. 0.05000378 0. 0. -0.24891225]\n", - "Found operator SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) with maximum gradient 0.5032032649865356 at index 3.\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "from qiskit.primitives import Estimator\n", - "\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "max_operator = excitation_pool[max_index]\n", - "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Expand the Ansatz\n", - "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import LieTrotter, MatrixExponential\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", - "ansatz.decompose().draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run VQE\n", - "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", - " return energy" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-1.8451098406948427\n" - ] - } - ], - "source": [ - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "\n", - "hf_energy = estimator.run(hf_circuit, H).result().values[0] # TODO something is wrong here\n", - "print(hf_energy)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[4.70183548]\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -2.445616758804025\n", - " x: [ 5.109e+00]\n", - " nfev: 23\n", - " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", - "\n", - "Found ground energy: -2.445616758804025, exact energy: -7.646812245579224, difference: 5.201195486775199\n", - "\n", - " NFVALS = 23 F =-2.445617E+00 MAXCV = 0.000000E+00\n", - " X = 5.109262E+00\n" - ] - } - ], - "source": [ - "from scipy.optimize import minimize\n", - "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)\n", - "\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[5.10926204]\n" - ] - } - ], - "source": [ - "# Optimal parameters so far\n", - "x_opt = getattr(res, 'x')\n", - "print(x_opt)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another iteration of the algorithm\n", - "We now compute the gradients again to see if we need another iteration." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-2.71803101e-02 0.00000000e+00 0.00000000e+00 -1.56259518e-04\n", - " 8.01303580e-02 0.00000000e+00 0.00000000e+00 -3.24241889e-01\n", - " -4.67959339e-03 0.00000000e+00 0.00000000e+00 2.65885485e-02\n", - " 0.00000000e+00 -6.34635076e-04 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 -6.34635076e-04 0.00000000e+00\n", - " -3.36275956e-02 0.00000000e+00 0.00000000e+00 1.41573354e-01]\n", - "Found maximum gradient 0.32424188915026975 at index 7\n", - "Maximum gradient is below the threshold: False\n" - ] - } - ], - "source": [ - "gradient_threshold = 1e-3\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "\n", - "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", - "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since the maximum gradient is not below the threshold, we append the operator at index 7 to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Initiate the list of operators with the first one \n", - "operator_list = [max_operator]\n", - "# Append the second operator\n", - "operator_list.append(excitation_pool[max_index])\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", - "ansatz.decompose().draw(output = 'mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.41750104 3.36633583]\n", - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -2.956190636470729\n", - " x: [ 1.899e+00 5.040e+00]\n", - " nfev: 36\n", - " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 36 F =-2.956191E+00 MAXCV = 0.000000E+00\n", - " X = 1.898789E+00 5.040352E+00\n", - "\n", - "Found ground energy: -2.956190636470729, exact energy: -7.646812245579224, difference: 4.690621609108495\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)\n", - "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Putting it all together\n", - "Now we automate the algorithm in a single loop." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iter: 0\n", - "Maximum gradient: 0.5032032649865356\n", - "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.4456165112244785\n", - " Iterations: 5\n", - " Function evaluations: 14\n", - " Gradient evaluations: 5\n", - "Result at iter 0: -2.4456165112244785\n", - "Iter: 1\n", - "Maximum gradient: 0.32407092356738126\n", - "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.956190499905813\n", - " Iterations: 6\n", - " Function evaluations: 18\n", - " Gradient evaluations: 6\n", - "Result at iter 1: -2.956190499905813\n", - "Iter: 2\n", - "Maximum gradient: 0.12976104001624783\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.9612309090295854\n", - " Iterations: 8\n", - " Function evaluations: 34\n", - " Gradient evaluations: 8\n", - "Result at iter 2: -2.9612309090295854\n", - "Iter: 3\n", - "Maximum gradient: 0.031641552187096696\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.965954068698521\n", - " Iterations: 13\n", - " Function evaluations: 67\n", - " Gradient evaluations: 13\n", - "Result at iter 3: -2.965954068698521\n", - "Iter: 4\n", - "Maximum gradient: 0.035411760167576585\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.9617004469024106\n", - " Iterations: 14\n", - " Function evaluations: 88\n", - " Gradient evaluations: 14\n", - "Result at iter 4: -2.9617004469024106\n", - "Iter: 5\n", - "Maximum gradient: 0.037296931333022955\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.970037220201674\n", - " Iterations: 13\n", - " Function evaluations: 92\n", - " Gradient evaluations: 13\n", - "Result at iter 5: -2.970037220201674\n", - "Iter: 6\n", - "Maximum gradient: 0.023284289617794322\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.97218210651401\n", - " Iterations: 20\n", - " Function evaluations: 162\n", - " Gradient evaluations: 20\n", - "Result at iter 6: -2.97218210651401\n", - "Iter: 7\n", - "Maximum gradient: 0.020475779688605242\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.975517805532193\n", - " Iterations: 21\n", - " Function evaluations: 192\n", - " Gradient evaluations: 21\n", - "Result at iter 7: -2.975517805532193\n", - "Iter: 8\n", - "Maximum gradient: 0.006992957360345902\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -2.97005663642165\n", - " Iterations: 15\n", - " Function evaluations: 152\n", - " Gradient evaluations: 15\n", - "Result at iter 8: -2.97005663642165\n", - "Iter: 9\n", - "Maximum gradient: 0.024276965466989174\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", - "Iteration limit reached (Exit mode 9)\n", - " Current function value: -2.976671400910034\n", - " Iterations: 50\n", - " Function evaluations: 557\n", - " Gradient evaluations: 50\n", - "Result at iter 9: -2.976671400910034\n", - "Terminating: reached maximum iteration.\n", - "Found ground energy: -2.976671400910034, exact energy: -7.646812245579224, difference: 4.67014084466919\n" - ] - } - ], - "source": [ - "# Define the conditions for termination\n", - "gradient_threshold = 1e-3\n", - "max_iter = 10\n", - "terminate = False\n", - "\n", - "# Initiate the problem\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "excitation_pool = ucc.operators # TODO\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "params = None\n", - "\n", - "iter = 0\n", - "operator_list = []\n", - "while not terminate:\n", - " print(f\"Iter: {iter}\")\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " print(f\"Maximum gradient: {max_gradient}\")\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(np.abs(gradients))\n", - " max_operator = excitation_pool[max_index]\n", - " print(f\"Operator: {max_operator} at index {max_index}\")\n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, 'x')\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " print(\"Terminating: reached maximum iteration.\")\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " print(\"Terminating: converged.\")\n", - " terminate = True\n", - " \n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "quantum", - "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.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb b/quantum_enablement/tutorials/adapt-vqe.ipynb similarity index 67% rename from quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb rename to quantum_enablement/tutorials/adapt-vqe.ipynb index 93a9a75..92684e9 100644 --- a/quantum_enablement/tutorials/adapt-vqe-draft-LiH_compare.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe.ipynb @@ -7,6 +7,27 @@ "## Qiskit ADAPT-VQE tutorial" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outline of the ADAPT-VQE algorithm\n", + "This algorithm was first introduced in https://arxiv.org/abs/1812.1117.\n", + "\n", + "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + "\n", + "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + "\n", + "3. Define the following conditions for termination: CONVERGED, MAXIMUM.\n", + " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", + " - MAXIMUM: Maximum number of iterations reached.\n", + " \n", + "4. while not TERMINATE (CONVERGED or MAXIMUM):\n", + " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", + " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", + " - Run VQE over all parameters $\\theta_i$" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -16,6 +37,61 @@ "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." ] }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyscf import ao2mo, gto, mcscf, scf\n", + "\n", + "# LiH\n", + "distance = 1.59\n", + "mol = gto.Mole()\n", + "mol.build(\n", + " verbose=0,\n", + " atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n", + " basis=\"sto-6g\",\n", + " spin=0,\n", + " charge=0,\n", + " symmetry=\"Coov\", \n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nuclear energy: 0.998447567773585\n", + "Electronic energy: -8.950577623117868\n", + "Total energy: -7.952130055344282\n", + "Total energy - nuclear energy: -8.950577623117868\n" + ] + } + ], + "source": [ + "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", + "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", + "print(f\"Total energy: {mol.energy_tot()}\")\n", + "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -24,6 +100,23 @@ "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "mf = scf.RHF(mol)\n", + "E1 = mf.kernel()\n", + "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", + "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n", + "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", + "E2 = mx.kernel(mo)[:2]\n", + "\n", + "h1e, ecore = mx.get_h1eff()\n", + "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -34,129 +127,204 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", + "\n", + "import numpy as np\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "\n", + "def cholesky(V, eps):\n", + " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", + " # see https://arxiv.org/abs/1808.02625\n", + " # see https://arxiv.org/abs/2104.08957\n", + " no = V.shape[0]\n", + " chmax, ng = 20 * no, 0\n", + " W = V.reshape(no**2, no**2)\n", + " L = np.zeros((no**2, chmax))\n", + " Dmax = np.diagonal(W).copy()\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " while vmax > eps:\n", + " L[:, ng] = W[:, nu_max]\n", + " if ng > 0:\n", + " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", + " L[:, ng] /= np.sqrt(vmax)\n", + " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", + " ng += 1\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " L = L[:, :ng].reshape((no, no, ng))\n", + " print(\n", + " \"accuracy of Cholesky decomposition \",\n", + " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", + " )\n", + " return L, ng\n", + "\n", + "\n", + "def identity(n):\n", + " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", + "\n", + "\n", + "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", + " c_list = []\n", + " if mapping == \"jordan_wigner\":\n", + " for p in range(n):\n", + " if p == 0:\n", + " l, r = \"I\" * (n - 1), \"\"\n", + " elif p == n - 1:\n", + " l, r = \"\", \"Z\" * (n - 1)\n", + " else:\n", + " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", + " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, -0.5j)])\n", + " c_list.append(cp)\n", + " else:\n", + " raise ValueError(\"Unsupported mapping.\")\n", + " d_list = [cp.adjoint() for cp in c_list]\n", + " return c_list, d_list\n", + "\n", + "\n", + "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", + " ncas, _ = h1e.shape\n", + "\n", + " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", + " Exc = []\n", + " for p in range(ncas):\n", + " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", + " for r in range(p + 1, ncas):\n", + " Excp.append(\n", + " C[p] @ D[r]\n", + " + C[ncas + p] @ D[ncas + r]\n", + " + C[r] @ D[p]\n", + " + C[ncas + r] @ D[ncas + p]\n", + " )\n", + " Exc.append(Excp)\n", + "\n", + " # low-rank decomposition of the Hamiltonian\n", + " Lop, ng = cholesky(h2e, 1e-6)\n", + " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", + "\n", + " H = ecore * identity(2 * ncas)\n", + " # one-body term\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " H += t1e[p, r] * Exc[p][r - p]\n", + " # two-body term\n", + " for g in range(ng):\n", + " Lg = 0 * identity(2 * ncas)\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " Lg += Lop[p, r, g] * Exc[p][r - p]\n", + " H += 0.5 * Lg @ Lg\n", + "\n", + " return H.chop().simplify()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", - " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "(2, 2)\n", - "6\n", - "{'nuclear_repulsion_energy': 0.998447567773585}\n", - "(1, 1)\n", - "5\n", - "{'nuclear_repulsion_energy': 0.998447567773585, 'ActiveSpaceTransformer': -7.800375958281276}\n", - "276\n" + "accuracy of Cholesky decomposition 1.1796119636642288e-16\n", + "The Hamiltonian consists of 276 10-qubit Pauli operators.\n" ] } ], "source": [ - "from qiskit_nature.second_q.drivers import PySCFDriver\n", - "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", - "from qiskit_nature.second_q.transformers import ActiveSpaceTransformer\n", - "from qiskit_nature.units import DistanceUnit\n", - "\n", - "\n", - "driver = PySCFDriver(\n", - " atom=\"Li 0 0 0; H 0 0 1.59\",\n", - " basis=\"sto3g\",\n", - " unit=DistanceUnit.ANGSTROM, \n", - ")\n", - "\n", - "# Full problem\n", - "full_problem = driver.run()\n", - "print(full_problem.num_particles)\n", - "print(full_problem.num_spatial_orbitals)\n", - "print(full_problem.hamiltonian.constants)\n", - "\n", - "as_transformer = ActiveSpaceTransformer(\n", - " num_electrons=2,\n", - " num_spatial_orbitals=5,\n", - " active_orbitals=[1, 2, 3, 4, 5],\n", - ")\n", - "\n", - "as_problem = as_transformer.transform(full_problem)\n", - "print(as_problem.num_particles)\n", - "print(as_problem.num_spatial_orbitals)\n", - "print(as_problem.hamiltonian.constants)\n", - "\n", - "mapper = JordanWignerMapper()\n", - "fermionic_op = as_problem.hamiltonian.second_q_op()\n", - "qubit_op = mapper.map(fermionic_op)\n", - "\n", - "H = qubit_op\n", - "\n", - "print(len(H))\n" + "H = build_hamiltonian(ecore, h1e, h2e)\n", + "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reference value\n", + "We compute the exact ground state energy of the Hamiltonian below to compare later with the algorithm." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Exact minimum eigenvalue: -1.0803168169635198\n", - "Exact electronic ground state: -7.882245207471211\n" + "Exact ground state of the Hamiltonian: -7.97217974623641\n" ] } ], "source": [ - "from qiskit_algorithms import NumPyMinimumEigensolver\n", - "\n", - "exact_solver = NumPyMinimumEigensolver()\n", - "exact_result = exact_solver.compute_minimum_eigenvalue(H)\n", - "exact_eigval = exact_result.eigenvalue\n", - "print(f\"Exact minimum eigenvalue: {exact_eigval}\")\n", + "import numpy as np\n", "\n", - "H_constants = list(as_problem.hamiltonian.constants.values())\n", - "H_shift = sum(H_constants)\n", - "print(f\"Exact electronic ground state: {exact_eigval + H_shift}\")\n" + "H_matrix = H.to_matrix()\n", + "eigvals = np.linalg.eigvals(H_matrix)\n", + "min_eigval = np.min(eigvals).real\n", + "print(f\"Exact ground state of the Hamiltonian: {min_eigval}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Outline of the ADAPT-VQE algorithm\n", - "This algorithm was first introduced in https://arxiv.org/abs/1812.1117.\n", + "### Initial state\n", + "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we do with the help of the function below." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", + " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", "\n", - "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", "\n", - "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + " Returns:\n", + " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", "\n", - "3. Define the following conditions for termination: CONVERGED, MAXIMUM.\n", - " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", - " - MAXIMUM: Maximum number of iterations reached.\n", - " \n", - "4. while not TERMINATE (CONVERGED or MAXIMUM):\n", - " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", - " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", - " - Run VQE over all parameters $\\theta_i$" + " Raises:\n", + " ValueError: If the total number of particles is larger than the number of orbitals.\n", + " \"\"\"\n", + " # validate the input\n", + " assert num_spatial_orbitals >= 1\n", + " num_alpha, num_beta = num_particles\n", + "\n", + " if any(n > num_spatial_orbitals for n in num_particles):\n", + " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", + "\n", + " half_orbitals = num_spatial_orbitals\n", + " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", + " bitstr[:num_alpha] = True\n", + " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", + "\n", + " return bitstr.tolist()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Initial state\n", - "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we do with the help of the function below." + "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -174,31 +342,39 @@ "
" ] }, - "execution_count": 3, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from qiskit_nature.second_q.circuit.library import HartreeFock\n", + "from qiskit import QuantumCircuit\n", "\n", - "num_spatial_orbitals = as_problem.num_spatial_orbitals\n", - "num_particles = as_problem.num_particles\n", + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mx.nelecas\n", "\n", - "hf_circuit = HartreeFock(num_spatial_orbitals, num_particles, mapper)\n", - "hf_circuit.draw(output='mpl')" + "# Get the Hartree-Fock initial state in boolean bitstring representation\n", + "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", + "\n", + "# Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an X-gate as indicated by the boolean list\n", + "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", + "for i, hf_bit in enumerate(hf_bitstring):\n", + " if hf_bit:\n", + " hf_circuit.x(i)\n", + "\n", + "hf_circuit.draw(output = 'mpl')" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Hartree-Fock energy: -1.0602464292560696 is 0.020070387707450177 above the exact ground state.\n" + "Hartree-Fock energy: -7.95213012467435 is 0.020049621562059805 above the exact ground state.\n" ] } ], @@ -206,8 +382,8 @@ "from qiskit.primitives import Estimator\n", "\n", "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "hf_energy = estimator.run(hf_circuit, qubit_op).result().values[0]\n", - "print(f\"Hartree-Fock energy: {hf_energy} is {hf_energy - exact_eigval} above the exact ground state.\")" + "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", + "print(f\"Hartree-Fock energy: {hf_energy}, exact_energy: {min_eigval}, difference: {hf_energy - min_eigval}\")" ] }, { @@ -220,7 +396,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -253,7 +429,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -264,7 +440,7 @@ " ansatz: ansatz built so far.\n", " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", - " estimator: an instance of the Qiskit Estimator primitive\n", + " estimator: an instance of the Qiskit Estimator primitive.\n", " params: parameters to be assigned to the ansatz, if any.\n", " Returns:\n", " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", @@ -292,22 +468,22 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 2.36926453e-08 0.00000000e+00 0.00000000e+00 1.35356602e-09\n", - " 2.36926453e-08 0.00000000e+00 0.00000000e+00 1.35356606e-09\n", - " -2.59287260e-02 0.00000000e+00 0.00000000e+00 6.89637005e-02\n", - " 0.00000000e+00 -4.69553018e-02 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 -4.69553018e-02 0.00000000e+00\n", - " 6.89637005e-02 0.00000000e+00 0.00000000e+00 -2.47637434e-01]\n", + "[ 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", + " 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", + " -2.42633656e-02 0.00000000e+00 0.00000000e+00 6.68086680e-02\n", + " 0.00000000e+00 -4.61492937e-02 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 -4.61492937e-02 0.00000000e+00\n", + " 6.68086680e-02 0.00000000e+00 0.00000000e+00 -2.50251594e-01]\n", "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.24763743394926327 at index 23.\n" + " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.2502515943160275 at index 23.\n" ] } ], @@ -338,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -356,7 +532,7 @@ "
" ] }, - "execution_count": 8, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -365,7 +541,7 @@ "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", "from qiskit.synthesis import LieTrotter, MatrixExponential\n", "\n", - "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=MatrixExponential(), parameter_prefix='theta', initial_state=hf_circuit)\n", + "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit)\n", "ansatz.decompose().draw(output = 'mpl')" ] }, @@ -386,7 +562,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -397,25 +573,14 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})" - ] - }, - { - "cell_type": "code", - "execution_count": 11, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[1.95711264]\n" + "[3.96079405]\n" ] } ], @@ -434,7 +599,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -444,16 +609,16 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -1.0747029445589993\n", - " x: [ 3.025e+00]\n", + " fun: -3.013130258132082\n", + " x: [ 1.745e+00]\n", " nfev: 22\n", " maxcv: 0.0\n", "\n", - "Found ground energy: -7.8766313350666906, exact energy: -7.882245207471211, difference: 0.005613872404520492\n", + "Found ground energy: -3.013130258132082, exact energy: -7.972497290048691, difference: 4.959367031916608\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 22 F =-1.074703E+00 MAXCV = 0.000000E+00\n", - " X = 3.025272E+00\n" + " NFVALS = 22 F =-3.013130E+00 MAXCV = 0.000000E+00\n", + " X = 1.744965E+00\n" ] } ], @@ -465,20 +630,27 @@ "\n", "\n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun') + H_shift\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_eigval + H_shift}, difference: {ground_energy - exact_eigval - H_shift}\")" + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {min_eigval}, difference: {ground_energy - min_eigval}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.02527201]\n" + "[1.74496543]\n" ] } ], @@ -498,18 +670,20 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00733397 0. 0. -0.00194146 0.00733397 0.\n", - " 0. -0.00194146 -0.01948708 0. 0. 0.07359587\n", - " 0. -0.04178004 0. 0. 0. 0.\n", - " -0.04178004 0. 0.07359587 0. 0. 0.00019631]\n", - "Found maximum gradient 0.07359586585830459 at index 11\n", + "[ 7.07949402e-03 0.00000000e+00 0.00000000e+00 -1.02440828e-01\n", + " 7.07949402e-03 0.00000000e+00 0.00000000e+00 -1.02440828e-01\n", + " 5.29059080e-03 0.00000000e+00 0.00000000e+00 -1.44652461e-02\n", + " 0.00000000e+00 3.85114011e-03 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 3.85114011e-03 0.00000000e+00\n", + " -1.44652461e-02 0.00000000e+00 0.00000000e+00 -9.02474613e-05]\n", + "Found maximum gradient 0.10244082836837858 at index 3\n", "Maximum gradient is below the threshold: False\n" ] } @@ -531,12 +705,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz." + "Since the maximum gradient is not below the threshold, we append the operator at index 7 to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -549,12 +723,12 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAAAV1CAYAAABDPR50AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADkZ0lEQVR4nOzdeXRV5d024DthkFlBVLQgoIIKCChOqFWx0KoVtc4Vcai1aotaB7Dat9W+HayKQ9HWqXWuinNVrNWKI1Wr4ix1oIIiBI3gQAQhJN8fvvIZCYREQjjhutbKWrD3s/f5ZZ89nJx7P88uqqysrAwAAAAAAAAUmOKGLgAAAAAAAADqQtAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFqWlDF0D1Kisr82nFwoYuY5m1Km6SoqKiOi9fWZlULFiOBQEAAAAANJDiZsnX+LoUqAVB10rq04qFaT/+gYYuY5nN3mVIWjep++5UsSB5aMxyLAgAAAAAoIEMOj5p0ryhq4BVg6ELAQAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEirRNBVWlqaUaNGZaONNkqLFi3SpUuXnHDCCSkrK8uRRx6ZoqKiXHzxxQ1dJgAAAAAAALXQtKELqG/PP/98dtttt5SUlKR169bp1atXpk+fnjFjxmTy5MmZNWtWkqR///4NW2g9WXjl1am46eY0OemnKd7121XmVVZWZuHIn6Vy0qQ0vXhMirp3a5gil1FFRUXuePwPGffkZSmZPSVrtF4rO/Y7IId953/Tsnnrhi4PAAAAAABYwRp1j67S0tIMHTo0JSUlOfnkkzNjxoxMnDgxJSUlOfvsszNu3Lg8/fTTKSoqSt++fRu63HpRPHxY0q1rFl52RSrfL60yr+L2O1P54kspHn7ISh9yJckld5+YS+8+Keuv0ysj9r4oO/bdP3c+Pia/vHJoKioqGro8AAAAAABgBWvUQdfxxx+fadOmZcSIERk9enTatm27aN6oUaPSr1+/lJeXp1u3bmnXrl0DVlp/ipo1S9ORJyfz5mXh+Rcuml75zrRUXH1tijbZOMX779twBS6jKSWv5G8TLsoOffbJmYfdnt23OSrH7Hl+jhl6fp6f/FAefuGmhi4RAAAAAABYwRpt0DVp0qSMHTs2HTt2zFlnnVVtmwEDBiRJ+vXrV2X6W2+9lT333DNt27ZN+/btc+ihh+aDDz6o95rrS1GPjVJ80AGpfHZiKsb9PZULF2bhOaOTyso0GXlyipo0aegSa/TQ8zemsrIy+3zzp1Wm777NUWnRrFX+OfH6hikMAAAAAABoMI32GV033nhjKioqMmzYsLRp06baNi1btkxSNej65JNPMmjQoHTo0CE33nhj5s6dm1GjRmWPPfbIhAkTUlxcmNlg8bDvp+KJp7Lwij+nePJ/U/na6yn+0Q9T1KVzQ5e2TF575+kUFxVn4/W3rjK9ebMW2WC9/nn9nacbqDIAAAAAAKChNNqga/z48UmSQYMGLbHNtGnTklQNui6//PK8++67efTRR7P++usnSTp37pztttsud911V/bee+/6K7oeFTVtmqYjT0r5cT9NxT3jUtSnd4r32buhy1pmH3w8Pe1ad0zzpqstNq/j6t/Iq1P/lQXl89OsafMGqA4AAAAAAKiNysrKfPrpp0mSVq1apaioqE7rabRB19SpU5MkXbt2rXZ+eXl5JkyYkKRq0HXPPfdkhx12WBRyJcnAgQOzwQYb5O67765T0LXlllumpKSkVstUNm+eXPbHWr/WUrVunTRrlpSXp2irLVO0HHun9ezRM0Xz59d5+eZNW+byEW8scf5n8z9Ns2pCrs+XbfF5mwWfCroAAAAAgAbXo2ePzC+f29BlwEqtoqIiM2bMSJL0798/zz33XJ3W02iDrrKysiTJ3LnVn0zGjh2b0tLStG3bNt27d180/dVXX83++++/WPvevXvn1VdfrVMtJSUleffdd2u3UIvV0qxOr1a9ysrKLDzvgqR8QbJ+l1TccFOKd9oxReutu1zWP33G9GTeZ3VevkWzVkudv1rzVpk7571q580vn/d5mxrWAQAAAACwIsyYPj3zFnza0GVAwZg5c2adl220QVenTp0ye/bsTJw4MQMHDqwyb8aMGRk5cmSSpG/fvlW6w82ePTtrrLHGYuvr0KFDXnvttTrXUluVzZvn/Tq9WvUq7rwrlS+8mOIjDkvxwG1T/pPjsvC8C9Jk9Nl17g74Zeutu97X7tG1NGu2Wy9vz3w188s/W2z4wtKP3s3qrTvqzQUAAAAArBTWXW89PbqgBl/u0bXOOuvUeT2NNugaPHhwJk2alLPPPjtDhgxJz549kyRPP/10hg8fntLS0iSfd4erb88880ytlylbWJ724x9YLq9f+e67qbjy6hRt3DPFB+yXoiZNUnzIsFRcdU0q7rwrTb6319d+jdffeD2tm9R9d1o4P3lozJLnb9xlqzz7+v157e1/Z7MNvrlo+vwF8/Lf6c9nsw12rPNrAwAAAAAsT2+8/kaauC8flqqsrCxt2rRJkjz++ON1Xs/ye0jTSmbUqFFZc801884776R3797ZbLPN0qNHj2y99dbZYIMNsssuuySp+nyuJGnfvn0+/PDDxdY3a9asdOjQYUWUvlxVVlRk4bnnJxUVaTLypBQ1aZIknwdePXuk4sqrUzl9RgNXWbOd+x2YoqKi3P7YhVWm3/vUFZm34NPssvmwhikMAAAAAABoMI026OrcuXMee+yxfPe7302LFi0yZcqUdOjQIZdddlnGjRuX119/PcniQdemm25a7bO4Xn311Wy66aYrpPblqeLW21P56qQUH3ZIitZff9H0oiZN0uSUk5KKhVl43gWprKxswCpr1n3dzbLndj/J4y/fnjOv2Sf3PvXnXHr3ybn07pPSd4OdssvmBzd0iQAAAAAAwArWaIcuTD4Pre65557Fps+ZMydTpkxJcXFx+vTpU2XeHnvskdNPPz3Tpk1L586dkyRPPfVUJk+enHPPPXeF1L28VL79diquuS5Fm26S4n33WWx+Ubeuy30Iw/p07J4XZp323XLvU5fn35PGpV3rjtl7++Ny2Hf+N8XFjTazBQAAAAAAlqCocmXvylMPnnrqqWy77bbZeOON85///KfKvI8//jibbbZZOnbsmF/96leZN29eRo0albXWWitPPPHECgtUluczulaE2bsMqddndAEAAAAAFIpBx8czuqAGX35G15w5c9K6des6rWeV7Abz0ksvJVl82MIkadeuXcaPH5911103Bx10UH74wx9mu+22yz333KPXEAAAAAAAwEqkUQ9duCRLC7qSZMMNN6x2yEMAAAAAAABWHqtkF6Wagi4AAAAAAABWfqtkj67x48c3dAkAAAAAAAB8Tatkjy4AAAAAAAAKn6ALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCA1begCqF6r4iaZvcuQhi5jmbUqbtLQJQAAAAAAAKsYQddKqqioKK2beHsAAAAAAACWxNCFAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkFaJoKu0tDSjRo3KRhttlBYtWqRLly454YQTUlZWliOPPDJFRUW5+OKLG7pMAAAAAAAAaqFpQxdQ355//vnstttuKSkpSevWrdOrV69Mnz49Y8aMyeTJkzNr1qwkSf/+/Ru2UGp04/iz8sa7E/PGtGdTMuutrNO+a64/fUpDlwUAAAAAADSQRt2jq7S0NEOHDk1JSUlOPvnkzJgxIxMnTkxJSUnOPvvsjBs3Lk8//XSKiorSt2/fhi6XGlz599Pz/Jvjs96aG6Zty/YNXQ4AAAAAANDAGnXQdfzxx2fatGkZMWJERo8enbZt2y6aN2rUqPTr1y/l5eXp1q1b2rVr14CVsiyu/dnk3P6rD3L2jx7Imu3Wa+hyAAAAAACABtZog65JkyZl7Nix6dixY84666xq2wwYMCBJ0q9fv0XTvgjGtt5666y22mopKipaIfVSs3XX3KChSwAAAAAAAFYijTbouvHGG1NRUZFhw4alTZs21bZp2bJlkqpB15tvvpnbbrstnTp1ylZbbbVCagUAAAAAAKD2Gm3QNX78+CTJoEGDlthm2rRpSaoGXTvuuGNmzJiRu+66K4MHD67fIgEAAAAAAKizpg1dQH2ZOnVqkqRr167Vzi8vL8+ECROSVA26iouXf/a35ZZbpqSkZLmvtzFp3rRlLh/xRkOXAQAAAADwtfXo2SPzy+c2dBmwUquoqFj07x122CHPPfdcndbTaIOusrKyJMncudWfTMaOHZvS0tK0bds23bt3r9daSkpK8u6779braxS6Fs1aNXQJAAAAAADLxYzp0zNvwacNXQYUjJkzZ9Z52UYbdHXq1CmzZ8/OxIkTM3DgwCrzZsyYkZEjRyZJ+vbtm6KionqvhaVr3rRlQ5cAAAAAALBcrLveenp0QQ0qKioyY8aMJMk666xT5/U02qBr8ODBmTRpUs4+++wMGTIkPXv2TJI8/fTTGT58eEpLS5Mk/fv3r/dannnmmXp/jUK3cH7y0JiGrgIAAAAA4Ot74/U30qR5Q1cBK7eysrK0adMmSfL444/XeT3L/4FUK4lRo0ZlzTXXzDvvvJPevXtns802S48ePbL11ltngw02yC677JKk6vO5AAAAAAAAKByNtkdX586d89hjj2XkyJF55JFHMmXKlPTq1SuXXXZZjjrqqGy44YZJBF2F5IFnr8t7s6cmST4sez/lC+fnr//8TZJk7fZdM2TA8IYsDwAAAAAAWMEabdCVJJtuumnuueeexabPmTMnU6ZMSXFxcfr06dMAlVEX9/37L3nxv49UmXb1P36RJOm7wU6CLgAAAAAAWMU06qBrSV555ZVUVlamZ8+eadWq1WLzb7311iTJq6++WuX/3bp1y5ZbbrniCqWK8459uKFLAAAAAAAAViKrZND10ksvJVnysIX7779/tf8/7LDDcvXVV9drbQAAAAAAACwbQVc1KisrV2Q5AAAAAAAA1EFxQxfQEGoKugAAAAAAAFj5rZI9usaPH9/QJQAAAAAAAPA1rZI9ugAAAAAAACh8gi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAK0ioRdJWWlmbUqFHZaKON0qJFi3Tp0iUnnHBCysrKcuSRR6aoqCgXX3xxQ5fJUkx7//Vc/Y9f5riLts1+Z66VPf+nbY4+v3/++uBvM3d+WUOXBwAAAAAANICmDV1AfXv++eez2267paSkJK1bt06vXr0yffr0jBkzJpMnT86sWbOSJP3792/YQlmq+56+Mnf9648Z2GvPfGvzYWnSpFlemPxQrr7vf/LoCzdnzHFPZrVmLRu6TAAAAAAAYAVq1EFXaWlphg4dmpKSkpx88sk544wz0rZt2yTJOeeck1NPPTVNmzZNUVFR+vbt28DVsjTf3Gy/fH/QaWndcvVF04YOPCbf6NgjNzz42/z933/J3tuPaMAKAQAAAACAFa1RD114/PHHZ9q0aRkxYkRGjx69KORKklGjRqVfv34pLy9Pt27d0q5duwaslJps3GXLKiHXF3bud2CSZErJyyu6JAAAAAAAoIE12qBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12/RtFtvvTX77rtvunbtmlatWmWTTTbJz3/+88yZM2eF1E3tvP/RtCRJ+zbrNHAlAAAAAADAitZog64bb7wxFRUVGTZsWNq0aVNtm5YtP3+m05eDrtGjR6dJkyb53e9+l7///e859thjc8kll2TXXXdNRUXFCqmdZbOwYmH++s9fp0lx0+yy+cENXQ4AAAAAALCCNdpndI0fPz5JMmjQoCW2mTbt895AXw667r777qy11lqL/r/TTjtlrbXWyrBhw/L4449nxx13rKeKqa1L7vppXp36RH6w2+/SZe2NG7ocAAAAAABgBWu0QdfUqVOTJF27dq12fnl5eSZMmJCkatD15ZDrC1tuuWWS5N13361TLVtuuWVKSkrqtOyqonnTlrl8xBvL3P7q+36Rv024ON/d5kf5/i6n1WNlAAAAAAC106Nnj8wvn9vQZcBK7cuj6O2www557rnn6rSeRht0lZWVJUnmzq3+ZDJ27NiUlpambdu26d69+1LX9dBDDyVJNt100zrVUlJSUueQbFXRolmrZW577f1n5q8P/ibf2eqInLDvpfVYFQAAAABA7c2YPj3zFnza0GVAwZg5c2adl220QVenTp0ye/bsTJw4MQMHDqwyb8aMGRk5cmSSpG/fvikqKlriet5999384he/yK677pr+/fvXuRaWrnnTlsvU7tr7z8x1D/wqQwYclpP2+/NS3zsAAAAAgIaw7nrr6dEFNaioqMiMGTOSJOuss06d19Nog67Bgwdn0qRJOfvsszNkyJD07NkzSfL0009n+PDhKS0tTZKlhldz5szJXnvtlebNm+fKK6+scy3PPPNMnZddVSycnzw0Zultrnvgf3PdA7/K4C2G55QDrkxxcfGKKQ4AAAAAoBbeeP2NNGne0FXAyq2srCxt2rRJkjz++ON1Xk+jDbpGjRqVG264Ie+880569+6dTTbZJPPmzcubb76Z3XbbLd26dcs//vGPKs/n+rK5c+dm6NCheeutt/LYY49l3XXXXcG/AV/2twl/zLX3n5G111g/W/QYnPHP3VBlfvu262RAzyENVB0AAAAAANAQGm3Q1blz5zz22GMZOXJkHnnkkUyZMiW9evXKZZddlqOOOiobbrhhklQbdC1YsCD77bdfnnnmmTz44IPp1avXii6fr3jtnaeTJO99+HbOGXvYYvP7brCToAsAAAAAAFYxRZWVlZUNXcSKNmfOnLRr1y5FRUX55JNP0qpVq0XzKioqctBBB+Wuu+7Kvffem1122aUBK111LMvQhQAAAAAAhWDQ8TF0IdTgy0MXzpkzJ61bt67Tehptj66leeWVV1JZWZmePXtWCbmS5Cc/+UluueWW/OxnP0urVq3y5JNPLpq34YYbZq211lrR5QIAAAAAAFCN4oYuoCG89NJLSaoftvDvf/97kuT3v/99Bg4cWOVn3LhxK7ROAAAAAAAAlmyV7NG1tKBrypQpK7gaAAAAAAAA6kKPLgAAAAAAAArSKtmja/z48Q1dAgAAAAAAAF/TKtmjCwAAAAAAgMIn6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIK0SgRdpaWlGTVqVDbaaKO0aNEiXbp0yQknnJCysrIceeSRKSoqysUXX9zQZQIAAAAAAFALTRu6gPr2/PPPZ7fddktJSUlat26dXr16Zfr06RkzZkwmT56cWbNmJUn69+/fsIWyVO+891qu/+f/5o13J+aDj6dn4cIFWXuN9bP1Jrtn/51HZs126zZ0iQAAAAAAwArWqIOu0tLSDB06NCUlJTn55JNzxhlnpG3btkmSc845J6eeemqaNm2aoqKi9O3bt4GrZWne/2haZn08I9v3+V7WWr1zmhQ3zVslL2XcU5fnoRduyqUnPp/2bdZu6DIBAAAAAIAVqFEHXccff3ymTZuWESNGZPTo0VXmjRo1KjfccENeeOGFdO/ePe3atWugKlkWW/T4Vrbo8a3Fpm/Wfcf85voDcv/TV+fAQaMaoDIAAAAAAKChNNpndE2aNCljx45Nx44dc9ZZZ1XbZsCAAUmSfv36LZr22GOPZfDgwVl33XWz2mqrpXPnzjnwwAMzadKkFVI3tbNO+65JkjlzZzdwJQAAAAAAwIrWaHt03XjjjamoqMiwYcPSpk2batu0bNkySdWga/bs2dlss81y9NFHZ+211860adNy1llnZeDAgXn55ZfTuXPnFVI/1Zu/YF7mzp+T+QvmZerMV/Pne09Nkmy9ye4NXBkAAAAAALCiNdqga/z48UmSQYMGLbHNtGnTklQNuvbcc8/sueeeVdpttdVW2XjjjXPbbbflhBNOqIdqWVb3/vvP+eOdxy36f6f23fKz71+fzTb4ZgNWBQAAAAAANIRGG3RNnTo1SdK1a9dq55eXl2fChAlJqgZd1VlzzTWTJE2b1m1zbbnllikpKanTsquK5k1b5vIRb9TYbvvee2f9tTbJ3Plz8ua7z+WJV+/KR2WlK6BCAAAAAIBl06Nnj8wvn9vQZcBKraKiYtG/d9hhhzz33HN1Wk+jDbrKysqSJHPnVn8yGTt2bEpLS9O2bdt07959sfkLFy5MRUVFpk6dmtNOOy2dOnXKAQccUKdaSkpK8u6779Zp2VVFi2atlqndWmt0zlprfD585PZ99s43N9s3I8Zslc8WfJrv73JafZYIAAAAALBMZkyfnnkLPm3oMqBgzJw5s87LNtqgq1OnTpk9e3YmTpyYgQMHVpk3Y8aMjBw5MknSt2/fFBUVLbb8TjvttKjH10YbbZTx48dnrbXWqnMtLF3zpi3rtNwG6/XNht/YPHf/60+CLgAAAABgpbDueuvp0QU1qKioyIwZM5Ik66yzTp3X02iDrsGDB2fSpEk5++yzM2TIkPTs2TNJ8vTTT2f48OEpLf18uLv+/ftXu/xf/vKXfPjhh3nrrbdy7rnn5tvf/nYmTJiQ9ddfv9a1PPPMM3X+PVYVC+cnD42p27LzF8zNJ5/OWr4FAQAAAADU0Ruvv5EmzRu6Cli5lZWVpU2bNkmSxx9/vM7rKV5eBa1sRo0alTXXXDPvvPNOevfunc022yw9evTI1ltvnQ022CC77LJLkiU/n2vjjTfONttsk4MOOigPPvhgPvnkk5xzzjkr8lfgS2Z9XP0zzp5/86FMKXk5m3TddgVXBAAAAAAANLRG26Orc+fOeeyxxzJy5Mg88sgjmTJlSnr16pXLLrssRx11VDbccMMkSw66vmyNNdbIRhttlDfffLO+y2YJxtx+bD74ZEb6b7RL1lmja+aXz8sb057Nwy/clJartc3Re5zX0CUCAAAAAAArWKMNupJk0003zT333LPY9Dlz5mTKlCkpLi5Onz59alzPe++9l9deey3bbLNNfZTJMhi0+ffzwLPX5sFnr8uHZe+nKEVZp33XfHfbo3PATiOzdvvaDykJAAAAAAAUtkYddC3JK6+8ksrKyvTs2TOtWrWqMu+QQw7JRhttlP79+2eNNdbIG2+8kQsuuCBNmzbNiSee2EAVs1O/A7JTvwMaugwAAAAAAGAlskoGXS+99FKS6oct3HbbbXPttdfmD3/4Q+bNm5cuXbpk0KBBOf3009O1a9cVXSoAAAAAAABLIOj6ihEjRmTEiBEruiQAAAAAAABqqbihC2gISwu6AAAAAAAAKAyrZI+u8ePHN3QJAAAAAAAAfE2rZI8uAAAAAAAACp+gCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgILU6IOu0tLSjBo1KhtttFFatGiRLl265IQTTkhZWVmOPPLIFBUV5eKLL27oMqmDefM/zfCzNsiQkUW56I4RDV0OAAAAAACwgjVt6ALq0/PPP5/ddtstJSUlad26dXr16pXp06dnzJgxmTx5cmbNmpUk6d+/f8MWSp1c849f5qOy9xu6DAAAAAAAoIE02h5dpaWlGTp0aEpKSnLyySdnxowZmThxYkpKSnL22Wdn3Lhxefrpp1NUVJS+ffs2dLnU0hvTJub2xy/MoUN+1dClAAAAAAAADaTRBl3HH398pk2blhEjRmT06NFp27btonmjRo1Kv379Ul5enm7duqVdu3YNWCm1tbBiYS649ahstfGu2WGzfRq6HAAAAAAAoIE0yqBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12+J69ltt91SVFSUM888sz7KpI5uf/SCvPPefzJib89WAwAAAACAVVmjDLpuvPHGVFRUZNiwYWnTpk21bVq2bJlkyUHXzTffnOeff76+SqSOZsx6K9fef0aGDfllOnXo1tDlAAAAAAAADahpQxdQH8aPH58kGTRo0BLbTJs2LUn1QdfHH3+cn/70pxk9enQOOeSQr13PlltumZKSkq+9nsasedOWuXzEGzW2+8Ntx6TTmhtkvx1PWgFVAQAAAADUXo+ePTK/fG5DlwErtYqKikX/3mGHHfLcc8/VaT2NMuiaOnVqkqRr167Vzi8vL8+ECROSVB90/fznP0/Pnj0zbNiw5RJ0lZSU5N133/3a62nMWjRrVWObfz57fSa+8UDOP/bRNG3SbAVUBQAAAABQezOmT8+8BZ82dBlQMGbOnFnnZRtl0FVWVpYkmTu3+sR87NixKS0tTdu2bdO9e/cq85555plcccUVefbZZ5dbPZ06dVpu62qsmjdtudT588s/y2V3n5StN9k97dt2yrulbyZJSj/6PEAsm/dR3i19M6u37pg2Ldeo73IBAAAAAJZo3fXW06MLalBRUZEZM2YkSdZZZ506r6dRBl2dOnXK7NmzM3HixAwcOLDKvBkzZmTkyJFJkr59+6aoqGjRvIULF+boo4/OiBEj0rt37+VWzzPPPLPc1tVYLZyfPDRmyfPnL5ibD8vez1OTxuWpSeMWm//gxOvz4MTr86Pvnpv9dz6lHisFAAAAAFi6N15/I02aN3QVsHIrKytLmzZtkiSPP/54ndfTKIOuwYMHZ9KkSTn77LMzZMiQ9OzZM0ny9NNPZ/jw4SktLU2S9O/fv8pyF198cWbOnJkzzzxzBVdMTVo0b51fDL9lsekfzXk/Y+74cbbaeNfsuvWR2WDdvg1QHQAAAAAA0BAaZdA1atSo3HDDDXnnnXfSu3fvbLLJJpk3b17efPPN7LbbbunWrVv+8Y9/VHk+V2lpaX7xi19k9OjRKS8vz4cffrho3rx58/Lhhx+mXbt2KS4uboDfiKZNmmXHvvstNr1k1pQkybprbljtfAAAAAAAoPFqlKlN586d89hjj+W73/1uWrRokSlTpqRDhw657LLLMm7cuLz++utJUiXomjZtWj755JMcffTRad++/aKfJDn77LPTvn37vP322w3y+wAAAAAAALC4osrKysqGLmJFmjNnTtq1a5eioqJ88sknadWq1aLp1T1La9CgQTnssMNy+OGHZ9ttt02LFi1WdMmrhJqe0QUAAAAAUCgGHR/P6IIafPkZXXPmzEnr1q3rtJ5GOXTh0rzyyiuprKxMz549F4VcSdKmTZvsvPPO1S7TrVu3Jc4DAAAAAACgYTTKoQuX5qWXXkpSddhCAAAAAAAACs8q16OrtkHXKjayIwAAAAAAQMHQowsAAAAAAICCtMr16Bo/fnxDlwAAAAAAAMBysMr16AIAAAAAAKBxEHQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkJo2dAFUr7KyMp9WLGzoMpZZq+ImKSoqaugyAAAAAACAVYigayX1acXCtB//QEOXscxm7zIkrZvYnQAAAAAAgBXH0IUAAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUpFUi6CotLc2oUaOy0UYbpUWLFunSpUtOOOGElJWV5cgjj0xRUVEuvvjihi6zXiy88uos+Pbuqbjv/sXmVVZWpvyUU7Pgu3um8q0pK764Whoysqjan6E/b9PQpQEAAAAAAA2gaUMXUN+ef/757LbbbikpKUnr1q3Tq1evTJ8+PWPGjMnkyZMza9asJEn//v0bttB6Ujx8WCqefCoLL7siRQO2SNFaHRfNq7j9zlS++FKKf3B4irp3a7gia2Gz7t/M7tv8qMq0pk2aNVA1AAAAAABAQ2rUQVdpaWmGDh2akpKSnHzyyTnjjDPStm3bJMk555yTU089NU2bNk1RUVH69u3bwNXWj6JmzdJ05MkpP/7ELDz/wjQ96zdJksp3pqXi6mtTtMnGKd5/3wauctl16rBBBg84pKHLAAAAAAAAVgKNeujC448/PtOmTcuIESMyevToRSFXkowaNSr9+vVLeXl5unXrlnbt2jVgpfWrqMdGKT7ogFQ+OzEV4/6eyoULs/Cc0UllZZqMPDlFTZo0dIm1sqB8fuZ+NqehywAAAAAAABpYow26Jk2alLFjx6Zjx44566yzqm0zYMCAJEm/fv0WTXv44YdTVFS02E+hD21YPOz7yQYbZOEVf07FHy9N5Wuvp/jwQ1PUpXNDl1Yrj710a/b4eavs+T9ts/+Za+fiO49L2dyPGrosAAAAAACgATTaoQtvvPHGVFRUZNiwYWnTpk21bVq2bJmkatD1hT/+8Y/ZYostFv2/devW9VPoClLUtGmajjwp5cf9NBX3jEtRn94p3mfvhi6rVjbpsnV27Lt/1uu4UT6d93H+/Z9787cJF+fFyY/kDyP+lZarVf8+AwAAAAAAjVOjDbrGjx+fJBk0aNAS20ybNi1J9UFXr169su2229ZPcQ2ldeukWbOkvDxFW22ZouLC6tB30fFPVfn/kC0PTfd1++aq+36e2x//Q4Z96+cNVBkAAAAAANAQGm3QNXXq1CRJ165dq51fXl6eCRMmJKk+6Fqettxyy5SUlNRqmcrmzZPL/rjcaqisrMzC8y5Iyhck63dJxQ03pXinHVO03rrLZf09e/RM0fz5dV6+edOWuXzEG7Ve7oCdR+b6B36Vf08aJ+gCAAAAAFYKPXr2yPzyuQ1dBqzUKioqFv17hx12yHPPPVen9TTaoKusrCxJMndu9SeTsWPHprS0NG3btk337t0Xm3/ggQemtLQ0a665Zvbcc8/8/ve/T8eOHetUS0lJSd59993aLdRitTSr06tVr+LOu1L5wospPuKwFA/cNuU/OS4Lz7sgTUafnaKioq+9/ukzpifzPqvz8i2atarTck2bNMua7dbLR2WldX5tPvfv//w9v7hqaK44+eWsv/YmNbY/5Hfdsk77bjnv2Ie/9mvPXzAvPzh3k+yy+bD8YLfffu31AQAAALDyueSuE/PUpHH58ymvpGmTZss8rxDNmD498xZ82tBlQMGYOXNmnZdttEFXp06dMnv27EycODEDBw6sMm/GjBkZOXJkkqRv375Vgp7VV189I0eOzI477pg2bdrkiSeeyFlnnZUnn3wyzzzzTFq0aFGnWmqrsnnzvF/rpZawrnffTcWVV6do454pPmC/FDVpkuJDhqXiqmtSceddafK9vb72a6y37npfu0dXXcxfMC/vfzQtm3ZtZMNMrmALF5bnsrtPzrc2H7ZMIdeS3P7YhWndYo18Z6vDa7XcrY+enzlzP8z+O52SJLnz8Yvyx78dnyN2/W0O/tbpi7X/+NNZOWp07zRv2iKXnfRifnHV0Lz430dqfJ3hQ87Iod8+M9fef2aue+BXNbbvu8FOOe/Yh/PC5IdzyqVLHgb1yx44tzL/e+1+mfDyHTnv2EfSp/sOi7V5+a3Hc/IlO2X7Pt/LLw+9NX/5++m5afxZOXn/v2TXrX9QpW1lZWVOuXRQJk19In/86bPp3qlPzrnp8Dzw7DU11jJkwGEZddDV+cfTV2f0zUfU2H6d9l1z/elTUjJrSoaftfgNANW57rS3cueEi3Lbo+fntIP/ml02P3ixNu+Wvpljzu+Xbutulgt/MiFNipss07q/rnnzP83RF/RL2dwPc8Upr6R9m7WrzJ8689Uce+EW2bjLVjnvmEdSXFycISOXLfgffcxD6bfhzjn5kp3rbd/79RF35+jz+2Z++bxcccoradeqw2Ltbnjwd7nqvp/nJ3uNyW2Pnr9sbfe+KN079anVPp2kXrfNwF575viLt02/DQfl90f9o9p2P7viO3lh8kMZM+LJ9Oi8RbVt6kOhH5+dOnTLuCcvz4W3HZ1hg3+Rw7/zv4u1+/2Nw/PgxOtz1g//kS03/nZmfVySH57XO2u0XiuXnPhcVmtW9Ro98Y0H87MrhmRQ/+/ntIP/WqeaDvldt8ycPbXG9qcccFW+s9XhtdquR+z6mxx1Xp+stUaX/OmEZ9OsafPF2l1w649y71NX5NdH3J1te+2xTLV/XZfefXKtzpWH/X7DettGddn3kuR3fz04D79wU35/1APZose3qrT7bMHcHHNB/3xUVpo/n/xKHn3xllXqWr6irGrHZ/+Ndinoa/l5xz6cioqKnHzpTnntnadzyU+fS9d1Nq3SbvYnM3PUeX3SuuUauezEF9Kied1uAKyt9z+cVqv34qOy0nq/XtVm32vXes388qo9s/s2R+XE/S5frM2C8vn58R8G5P0P38lP9r4o59x06DK1veLkl3PVff9T8NfyFaW258rGcHzW9r2o7+tVUvvP6c+8dn9O+/N3MniL4Tn1+9cu1u7q+36Rvz74m5y43+XZfZujlmndy8uqtn232ni3gj4Xf2erw/NWycv5yYUDsmnXgRl9zEOL3Uz/93//Jeff8sN8f5fTF93YfODOp2bck5fl7icuyfd2OL5K+6XNK0TrrreeHl1Qg4qKisyYMSNJss4669R5PY026Bo8eHAmTZqUs88+O0OGDEnPnj2TJE8//XSGDx+e0tLPewD179+/ynKbb755Nt9880X/33nnndOnT5/sueeeufHGG3PEETVfUL7qmWeeqfUyZQvL0378A7Ve7qsqKyqy8Nzzk4qKNBl5UoqafP4Fc/EB+6Vywr9SceXVKd5m6689hOHrb7ye1k3qvjstnJ88NGbJ8z8u+yDtWq+52PSr//GLLKwoz7abDq3za5M88uItefu9STl92I3LvMyVo15LUap+gLn9sQuzTvtutQq6PlswN7c8cm6+s9URaduqfZJkr+1HZMIrd+b6B36VbTfdIxus17fKMhfd8ZPMnjMz5x49Pq1atM3B3/p5dtv6h9Wuf8HCz3Lp3Sdl7mefpFfX7ZIkO/TZJ+utudESa7rlkdH574wXFv2xtv7am+bUg65bYvun/jMuDz9/U3p32z5Jcvw+l+Sltx7LuWMPz6UnvZCWzVsvajtv/qc5d+zhade6Y07Y99IkyaFDzsyTr96dS+8+KQN6fjtrrdF5UfvbH7swL/73kRy521np3qlPkmSPbY/OFj0GV1tLZSpz1d9Pz/sfTVtUf98Ndlxq/Q88e00mvvHP9On2efvV26y11PavvfPv3DnhonyjY4+s0Wbt/GDX3+bp//w9F995XPptOChrtvv/55OKioqcO/bwVKYyow68ZoWFXEnSonmrjDzgqpx8yU4Zc9uxOeOw2xbNW7iwPGffdGiaFDfNyAOuTvH/PbNwab/3jFn/zbX3n5HVW3dM57U2TpJ63fdatWibUw68KiMv2yUX3f7j/PyQm6q0fWvGS7n+gV9l842+lb22H5Hu6262bG23+0k+nPNerfbp+t42PTpvkYN3+XmufeDM3P3EpRk68Jgq7e954rI8+/r9OfTbv1qhIVdS+Mdnknx32x/lsZduy03jz8r2vfeusg0ff+mOPDjx+nx326MXfTHWoV2njNj7opx1w7Bc9fef55g9z1/Uvmzexznv5h+kfdtO+cneF9W5pmP3vDBzP5tTbftP5s7KZXefnCbFTdOz84Aktduua63ROT/e6w85d+zhueb+X+aHu/++SvunX/tH7n3qinxnqyNWWMiVpNbnyvrcRknt970kGfG9i/PC5Idy/i1H5vKTXkqrFm0XzfvzvT/LtPdfz+nDbkyHdp1WuWv5irIqHp+FfC1PkuLi4pxywFU55vx+OXfsYfnDiCeqfB668Laj88mns3LmYXeusJArSa3fixkf/Lfer1e12fe6r7tZvr3l4bn3qSuyQ599stUmu1Zpf+39Z2RKycsZdeA1GTJgeJ5/c/wytV1rjc6N4lq+otT2XNkYjs/avhf1fb1Kar9dt9z429l9m6Ny71NX5Jt998t2vfdc1P61d57OTQ/9Plv2/M4KD7mSVXP7FvK5OEm6d+qTQ4ackavu+3nunHBRlXBq5uypufTuk9K902YZPuSMRdM7tOuUnfsflJse+n32HPjjNPnS94lLm1eI3nj9jTRZPL8EvqSsrCxt2rRJkjz++ON1Xk9RZWVl5fIqamUybdq09O/fPx988EGaNm2aTTbZJPPmzcubb76Z3XbbLRUVFfnHP/6Ryy+/PEcdtfSLd2VlZdq2bZvDDjssf/zj8ntu1tIsr6Br4c23puLPV6b4h0ekyQH7V5lXOWVqyn9yXIo22eRrD2E4e5ch9Rp0XXLXiZk09cn022hQ1l5j/cz7bE7+/Z978/zkh7LJ+ttk9DEPLXZHK8vuxD99M5/O+ziXnfTC11pPXYYz/OLunkt+OjEbfeP/h8wzZ0/Nj87vm3U7bJCLj//3oi7rj710e/732n2zzzd/mmP3vKDG9Z93yw9z37//kkO//asMH/LLGtv/89nrc/ZNw7NFj8H53Q/vqzGYmTpzUo6/aJu0WK1NLjlhYjq0+7wH54SX78yZ13wvQwf+OMfv8//PGxffeVz+NuHi/OqwO7Ndn//fm/KNaRNz3EXbpP9Guyzq0fLOe6/l2As3T/d1+y5zT6jrH/h1rrn/l/nOVkfklAOurLH9C5MfzqmXD0mXtTfJmOOerPLHaXVmfzIzP/7DgJTN+yhjRjyZbp16J0lee+eZnHDxwGy58Xfymx/cs6j9LY+cl8vvOSXH7nlh9vnmCTXW81Vf3CH7xd1ldXHpXSfltscuqNKL4rr7f5VrHzgzI/a+OHtt/5Ma1zFv/qc54eKBmTLzlfz+qPuz+Ua71LjM8tr3/vS3n+aOx/+Q/znk5uzU7/Pz+MKF5Rlx0daZ/sHkXHHSS1m7/fq1brskS9qn63vbLFxYnuMu3jbT3n8tl530Ytbt8PmdhzNnT82PztssndfaOGNGPFGnP3SGjCxadKdvXRT68Zkk7334Tn503mZV7hb9cM77Oeq8PmnRvHUuP+nFtFytTZX1/eqaffOvV+6scpf2uWOPyP3PXJ3f/OCebLPpd2v8HZZWU3UqKipy+l92y7Ov3//5l5NbHlrjayxpu55x9d55ctI9ueDHj6fX//X8Lpv7UY46r0+Kiopz+ckvpXWLdjWu/6sO+V239N1g54w66OpaL7s8zpXLcxstydL2vX+9clfOuHqvKj0jXpj8cEZetkt22Gzf/HL4LYvarmrX8mX1xd3nX9wpXher2vFZ6NfyJLnj8TH5099OqNLL8f5nrsm5Yw/P/judkh/tcW6N66/O1/2stDzOlcvzelWdJe17ZfM+zo/O2ywVlQtzxckvp03LNZIk/3n73znhj9tl4KZDc+bhd9S67dIU2rV8WX2dz0rL41xZaMfn8novltf1akmWtl0/nfdJfnT+ZllQ/tmiESHmL5iXYy/cIrM+mZErTn45HVf/Ro2/Q3W+zmelZNXcvoV8Lk6ShRULc8LFAzO15JVcetIL+UbHjVJZWZlRlw/Oy289louOe6rK9z1J8vybD2XkZbvkl8NvzTf77rvM8wrNoOMj6IIafDnomjNnTlq3Xvr5a0mKl2dRK5POnTvnsccey3e/+920aNEiU6ZMSYcOHXLZZZdl3Lhxef3115Mk/fr1W+Z1Lo9nWa1IlW+/nYprrkvRppukeN99Fptf1K1rig8ZlsqXXk7FnXc1QIXLrt8GO6dVi3Z54JlrcsldP82195+Rjz+dlSN2/W3OO+bhgg655pd/lhse/F1+OLp3dj+tRfb+xRr5xZVD8+a7///Be+9/OC37nLFmjhrdJ58tqNrl+awbhuXbo4oz8fV/Lpo2ZGRRzrnp8Ex8/Z857qJts8fprXLArzrlj387YbE7c2Z9XJKX33o8W2+ye63qPuR33XLyJTtXec2Zs6fmxf8+kiEjixb9lMyastT1PPrCLenQttNiH3rWad81xw69IJOnP5/rH/h8yIKPykoz5vZj02WtjfOD3X5XY413/+uS3Pfvv2TbXkNzyOBf1Nj+zXefy4W3/SjrtO+anw+7qcYPwmVzP8qZ1+ydBeWf5Yzht1X5ILx9n70zeIvhuefJSzLxjQeTfP7B865//TFDBhy62B97PTpvkYN2OS3Pvn5/xj15eRZWLMw5Nx36+YfDZewJ9dSke3PdA2emZ+ctc/z3/lRj+/dmv53fXHdAWq7WJmcedkeNH4TLFy7I/163X0o/ejenHHBVlQ/CG3fZMgftclqemjQuf//3X5J8HgRcfd//pN+GOzfokANH7PbbdF6rZy6+87jM+rgkb0ybmBvG/zb9N9ole27342Vax3k3/yD/nfFifrj72cv0h/fy3PeO3P2sdFlr41x0x48z+5PPxyq+4cHf5s13n8uxe15YJbiqTdvqLG2fXpLltW2aNGmaUw+6NuULF2T02CNSWVmZysrKjL75BylfuCCjDrq2we7mK/TjM0nWXqNLjhl6fqaUvJxrHzgzSTLm9mPzUdn7OeWAK6v9suD4fS9J21Ydcu7NR2Te/E/zxKt35/5nrs53tjpimb5Er6mm6vzl759v5722H7FMX6Ivbbv+dL/L07Zl+5w79rBF184/3fXTlH78bk458Ko6hVxf1/I4Vy7PbVSdmva97XrvmcFbDM+9T12Rp1/7Rz6d90lGjz0iq7deKyfsc0mVtqvatXxFWtWOz0K/lifJ3tsfl74b7JTrH/hV3ip5Oe9/OC1/+tsJWX/tTXP4d369TL9Dffi658rlfb2qzpL2vdYt2uXkA67MBx9Pz8V3Hpfk86Htzx17eNq17JAT9rusTm2XpBCv5SvC8jhXFtrxuTzei+V5vVqSpW3XVi3a5qT9/5LZc2bm4jtGJEmuvO/nefu9Sfnxnn+oc8i1PKyK27eQz8VJ0qS4SUYeeE0WVi7M6JuPSEVFRf424eI8/+b4HPyt/1ns+54k2WyDHdOiees8+uIttZoHsCSF3f+zBptuumnuueeexabPmTMnU6ZMSXFxcfr06VPjeu66666UlZVl6623ro8y603R+uun2bi/LbVNk+8fmCbfP3AFVVR32/XZq0G/TKgv5QsX5PQ/75pXp/wr3xowPHttNyJl8z7KvU9dkZ/+cfucd+yj2bjLlllrjc455YCrcsbVe+WSv/00P/2/P8Tu+/eVGf/cDTlo0M+yRc+qw2u8+e7EPPbSrdl9m6MyZMCheX7yQ7nz8TGZUvJyzj7qgUXDu3wx5vnGXb7e/n3qQdfl0rtPTLvWHXPwLj9fNH31NmstcZmFFQvzytQJ6b9h9X/M7Lr1DzLh5Tty00O/z8Dee+bmh8/Nx59+kF8fcXeN4ebLb03In+46IZ3X6pmfHXRdjUH1R2WlOfOa7yVJzjzsjmqHyvyyysrK/P7GQzLt/ddz/D6XpFe3gYu1+cneY/LC5Idy3s0/yB9GPJHRN/8gHdt9Iz/Zq/rui4cM/kWeeOWuXH7PKZk8/fn8551/5+g9zkuXtTdeai1JMu39N/L7G4elXas1c8Zht6d5s6U/T3D+gnk589p98vGnH+R/j7g73+i45OEevvCnv/00L7/1eA4cdGp27LtftfU/NemeXHr3Sem/4aCcO/bwNG3SLKcccFWD3iiwWrOWGXngNTnxTzvkvFuOzHsfvp3mTVvklAOuXKa6bn743Dz8wtjs3O/A7L/TyTW2X9773mrNWmbkQdfkp3/cPhfednSGDzkzN4z/bbbtNTS7bnVEndt+1bLs01+1vLdN13V65Yjv/CaXjxuZ2x+7ME2bNM/zb47Pj/YYvdgzE1a0Qj8+k8/PqY+9dFtufviclJfPz2Mv3Za9tz8u/Tbcudr27dusneO+96f85voDMub2Y/Ps6/dnrdU759ihNffAWdaavuyRF27JzQ+fkz7dd8gxQ8+vsX1N27V9m7Vz/D6X5NfX7Z8/3/uzbNnz27n/mauz1/YjlulLtPrydc6Vy3sbfdWy7ns/2XtMnp88Phfc8sNstsGOKZk9Jb889Las3rrjYm1XtWv5irKqHZ+Ffi1PPr9p8pQDr8rR5/fNOTcdmnatOmbu/DkZddA1NR6b9enrnCvr63r1ZTXte1v0+FaGDvxx7vrXH7NDn33y6tR/5e33JuWXw29d7JlutWn7VYV6LV9Rvs65slCPz6/zXtTH9eqrlmW7btHjW9lj22Nz9xN/SsfVv5E7HrswA3vtuUw3M9S3VW37Fvq5OEm6rvN5MHzFuFH5010n5B//vjI9vrFFDt5l8We1Jp+HYxt32ara5/AtbR7AkjTaHl1L88orr6SysjI9evRIq1ZVx0E/5JBD8stf/jJ33nln/vnPf+bXv/51DjnkkPTv3z8HHXRQA1VMY/W3CRfnhckP51dH3JWT9/9zhm53bA7a5We55MTn0q51x1x+zymL2m7Xe8/svf1xGffU5Xn0xVvz9nv/yR/vPC6brr9ttXeZvVXyUn72/etz7J4XZM/tfpxfDr8le+9wfJ5/c3weefHmRe2mznw1SbLemht+rd9l8IBD0qJ567Rvs04GDzhk0c/S7iR678O3M/ezOUt97RP3uyKtW6yen/9l9zz64i05aNDPssn6Sw/lSj+anl9ft1+aNV0tZx52R1q3XH2p7RdWLMxvrjsgM2dPzQn7Xlbt3UZfdc39Z+TJSfdk161+sNjzhL7QpuUaOWn/v+S9D9/OMRf0y8zZU3LyAVcusZ6mTZpl1EHXZH75vNz9xCXp032H7PPNn9ZYy9zP5uTMa/bOp599kp8fMjZrr9GlxmUuvO3ovDHt2Qwfcma22bTm3nz3PX1V7n7iT9mix5Acsetvl1L/tVlQ/lmOu2ibTHr7yRw99Pw6Dzm4PPXqum322/Hk/Ps/92ZKycs5euh5Wad91xqXm/j6P/OXv5+W7p02y0kH/KXG9vW17226/jY5cOdT869X/pafXTEkrVZrlxP3Xfxh6rVt+2XLsk9/WX1tm313PCl9uu+Qq+77ef5876nZrPs3s+83T6xx/fWt0I/PL5y43xVpvVq73ProeVmv40Y58ivPAfiqnfrtn536HZAHnr02sz4pyUn7/6XG/bq2NSWfP0du9M1HZM126+UXh9yyaIi7JVnW7bpj3/2yy+YH528TLsrZNx2ab3TskR/ufnaN9dSnup4r62sbfdmy7nttWq6RE/e7Iu9/NC3jn7shu2x+cL652eKjB3xhVbqWr0ir2vFZ6NfyJFm3Q/cctfs5efPd5zLxjQdy4M6nZuMuW9VYU32r67myPq9XybLve0d995ys13GjnH/Lkbnt0fPzrc2HLXGoq9q0/UKhX8tXhLqeKwv9+KzLe1Ff16svq812PWqPc7Juhw1yyyOj07rlGvnpvjX3blxRVrXtW+jn4iTZb8eT06vrwPxtwsVZWFGekQdds9RROdZdc8PM+qQkH5d9UKt5ANVZJYOul156KUn1wxb27t07d9xxRw499NDstttuufLKK3PUUUfl4YcfTvPmBlVl+Xpw4vXpsvYm6dl5QD4qK130U75wfgb0GJKXpzxeZajCo/Y4Nxt9Y/NccOtR+fW1+6VJk2Y5fdiN1X5w6LLWxtm+z95Vph006GdJkgkv///x5z8qez9J0rZVh3r4DZfuozk1v3aHdp8/UP2jstJ069SnygNMq7OgfH7+99p9M+uTkow84Op0XadXjXVccc/IPD/5oey9/XEZMmB4je3/9fLfcsODv8nGXbbKcfssfdiSLTf+dr67zY/yUVlpdt/6qAzoOWSp7Vu3WD3Nmq6WJNl6k90X9bxbmnPHHp6pM1/NUbufk/4bDaqx/R2Pj8kDz16bgb32zLDB/1Nj+9feeTpjbj82ndp3y8+H3bjUYR+6/9979FFZaQb0/HZ236b6h0dXp3zhgirHwUdlpZk7//OhNufMnb3YvNpao/XnvQubFDfNlhvvWkPrpGTWlPz2rwel1Wptl2n4h/re94YPOSPdOvXJR2Wl+cneFy11OI3atE1qt08n9bttiouLM+rAa1JZWZmKioUZeeDVy3QcfOGTT6vfVz6b/+li0+eXf7bM600K//hMkhbNW2W1/3uY+uYb7rLowepLs/r/HTurt+6YXl1rvsO1tjV98unsnHnN97Jw4YL8cvityzRUTG2264i9L84ardfOJ5/OyqgDr1mm3/kLZXM/Wmy/qaisyIKFny02fd78T5d5vbU9V9b3Nkpqv++1bdUhxUWfHwPbbLrHUtuuatfyL5tfvvi+8tn/7Stfnf7Jp7OXeb1fWNWOz0K/lidVRzvYtoZj56vq87NSbd+L+r5e1Wbfa9G8VU498Np8Mnd2Vm+9Vn6y90XLpe0XGsO1/Mvq67NSbc+VjeH4rMt7UZ/Xq6T227VZk+Zp9X/D4vXsvOUynee/rL4+KyWr5vYt5HNx8vnfcl98v7Nex42y/tpLH5WjXavPe9vNnvNereYBVKdRD124JEsLuk477bScdtppK7okVlFvvzcpny2Ym/3OXPLwfh+VlS66a7B509Vy+sE35ofn9c6Uma/ktIP/usQ7wKv7QLFmu3XTpuUamfHBf7809fOhHipT9YHoC8rn55NPZ1WZ1nK1Nst17PcvhpmorFz6w9i/+OKmxzcG1HgX8cV3jsikt5/MQYN+tkwPLR3/3A257bELsln3b+booefV2P7t9/6Ts8cemtVbdcwvD70tzf/vS++l2bTrwIx76vJsWsMXUJ8/j+iIlJfPz/prb5ob/vmb7NT3gKzXcck93m548Hd57KXbsnP/g7LfTifVWMuL/300l919cjqv1TOnfr/moT5mz3kvv7pmnxQXFeeMw26vcdiH5P+/X8vyhduXvTJlQk65tPovD469cIvFpj1w7tL3my+bOnNSrv7HL9KtU5+8895/csEtR+Wso+5bYvt58z/Nmdd8L3Pmzs6vf3DPUt+DL9T3vtesafP0+MaATCl5ucZtW5u2td2nV8S2WXfNDdK+7TqL/l0bx164eWbOnrrY9JsfOTc3P1L1QeKnHHBVvrPV4cu03sZyfP7pbyek9KN3s8G6/fL3f/85gwccmj7dt19i++feHJ+7n/hTNlyvfyZPfz6X33PKouFzl0dNFRUVOeuGgzP9g8k5YZ9Ll2momNpu17at2qfL2ptk9pyZy7T+L/vl1XtVO2TKw8/flIefv6nKtOFDzsih3z5zmde9rOfKFbGNarvvzV8wL+fedFhat1wjLZq3zmV3n5StNt41bVu1X+Iyq8q1/Kseeu7GjL65+qFjv/r5b532XXP96VOWed2r2vHZGK7ls+e89/kXjB265+NPP8iFtx2dP57wTJo1XbYbKuvzs1Jt3ov6vl7VZd/7ok2XtTdZ6rmotm0bw7X8q+rrs1Ky7OfKxnJ81va9qO/rVV2261//+ZtMnv58Nlyvf559/f6Mf+7G7LL592tc7gv1+VlpVdy+hX4uvu/pq/LUpHGLPpvc/PA5+f4uS/mO9f++C6q29qXNA6iGoAsaUGVlZbp32mypzzr44s7VLzw1aVwqKhYm+fwBq7tsfvDXqmGN/7tr7ZNPZ1UZhuPVqf9a7A/p2n4wrckXdyF/MndWDS2XzbgnL8+9T12RAT2/vUxd8CdPfyEX3HJUOq7+jfxieM1D8ZTN+zhnXvO9fDb/0/zvj/62TMOW1MadEy7KC5MfzhG7/jbb9d4rP75wi4y+5Qc575iHq/1w9/R/7ss1//hFNli3b07ev+ahPt7/cFp+fd3+Wa1Zy5x52J01PtB24cLy/Pq6/fP+R9Ny6kHXLdOwD1/HBuv2y9lHPVBl2rOv35+bHzk3P/v+9WnfZp06rXdhxcKcO/awFBcV58zD7sj9z1ydGx78bf7+779kt62PrHaZC249KpOnP5/Dv/PrbL3JbjW+Rn3ve/WlLvt0fW+br+tn3/9r5n+pJ2ySnHrFkAzeYniGDKg6Hn7XZXjo8hcaw/H5r1fuygPPXpvdtzkqh3/n1/nh6N4575Yf5NITn6/2WUmfzvsk5938g7Rvs07OOfrB/OnO4zPuqcuzY9/9F3suZF1ruuof/5OnX7svu259ZPYYeHSN7Wu7Xb+uo4eelzlf6WXz+xsPyQbr9csBO42sMr22oeyyqu9tVNt9L0mu/Pvpeef913LawX/N6q3Xys+u+Hb++Lfj87PvX7dMv9PSFPq1/Ku23Pg7i13bHnj22vxz4nWLTW9ewzPLvmxVOz4by7X8D7cdk08+nZUzD7sjb7/3n1xw61H56z9/ncN3XXwY8urU12el2lgR16va7nv1pTFcy6tTX5+VaqMxHJ+1fS9WxPWqttv1jWkTc+P432VAz2/nzMPuyDEX9M8f7zwum2+0y6KbzmpSX5+VbN+lWxnPxe99+E4uvevEdOvUJ2NGPJGfXfHtXPfAr7Jd772W2APz4//7Luir33vVNA+gOqtk0DV+/PiGLgGSJN/o2CMflb2f/hvtskxDYL0+7dlc+ffTskWPIVm9dcfc+uh52aLHkGy58bcXa/v2e5MWm/bBxzMyZ+6HVT5gduvUJ0nybukb2XC9/x/+VveHdE0fTItSuztt1lqjS1q1aJd3S9+o1XLVeXXqk/njncelU4fuOX3YjTVuz48/nfV5F/yK8vxi+K01ftCsrKzMOTcdmnfe+0+OGXr+cn/g87T338iV956WjbtslQMHnZomxU0y/Ntn5sq/n547J1yU7+1wfJX200sn56wbDk7rFqvnjENvr3FIg/nln+VX1+6TD+e8l18eelu6rrP0IQSS5NK7T8pL/300e+9wfAYPOORr/X7Lom2r9ot9Off+R9OSJL27bV/nZ33d9NDv89o7T+fHe/0h3+i4UQ4Z/Mv865W/5dK7T8qAnt9e7I+aWx85P+OfuyHb9d4rB3/r5zWuv773vfpSl326vrfN8rCkuzzXXXODar/8XRaN4fj8uOyDXHjrj7JO+645eo/z0qpF2/xk74ty1g0H56q//zzH7Ln4DReX3n1SZs6eml8d/re0a9UhP957TJ5788Gcf+sPc/lJL6VVi7Zfq6bHXro9Yx/6/edDxXzvjzW2r+12XR56dh6w2LTmzVqkQ9t167w/1UZ9b6O67Hsv/fex3PH4H7JDn30W3Wzz3W1+tChk2a73nsv2y1Wj0K/l1Vmz3bpZs926Vaa9POXxJPla+9Cqdnw2hmv5gxP/mgkv35F9v3li+nTfIX2675BHX7wlNz30+2zf53vp0XnxHllfVV+flZbVirhe1Xbfqy+N5Vpenfr4rFQbjeH4rO17sSKuV7XdrvPLP8s5Nx2aFs1b56T9/5wWzVvllAOuzMmX7JQ/3H5szjzs9hrXkdTPZyXbt+Z1r4zn4vNuPjLz5pdl1IHXpHmzFjn5gCtzzPn9cu7Yw/OHEU9UO0zi9NI306Ftp2p7ly1tHkB1VslndMHKYsiAQzPrk5Lc9mj1f5TM/mTmon/P/WxOfvvXg9KmZfv87PvX5YR9L02n9t1zzk2HVjtm8Tvvv5YJL99ZZdrYhz5/kOl2vfdeNK3vBjslSSZNfbJK2y/+kP7yT01BV4vV2iw23OHSNCluks26fzP/efupZV6mOrM+Lsn/Xrtvioub5IxDb0+7Gp43trBiYX57/UEpmfVWfrzXmPTqum2Nr3H9P3+df73ytwzq//3su+OJX6ver6qoqMi5Yw/PwsqFGXngNYs+AB6w86j07Lxlrrz3tEwvnbyo/dz5ZTnzmu+lbN5H+dnBf12mIRMuuv3Hee2dpz8f6mOzfWps/8Cz1+XOCRdls+7fzDF71Dzsw8rqv9NfzF8f+N/03WCn7L39cUk+H9Zv5IFX57P5n+aCW46q0v75Nx/KFfeOSpe1Ns6og66tcZiEFbHv1Zfa7tP1vW1WVo3l+Lzojp/kw7L3ctL+f1n0Bfgum38/2/feO3c8/oe8/NaEKu2f/s99nw8Rs8XwRcFFu1YdcsI+l2bm7Km5/J5TvlZNU2e+mnPHHpbVW3XMGYfeXuNQMXXZroVuRWyj2u57c+eXZfTNR6Rtqw45ft9LFk3/0R6js/Ya6+cPtx1dp+dMJYV/LV+RVrXjszFcyz/4eEb+eOdx6bxWzxyx2//vjXLS/n/Oas1b5dyxh2dB+fwa19PQ6vt6Vdt9r740lmv5yqixHJ+1eS9WxPWqtts1Sa69/4xMmflKjhl6/qKbBfp03yF773B8Jrx8R8Y/d2ON66gvtu/SrYzn4rufuDQT33ggB+1y2qJg+BsdN8oRu/0ur73zdG5++JzFlllYsTCvT3tm0XdSyzoPYElWyR5dsLL43jdPyLNvPJDLx43Mc5PHZ/MNd0mrFu3y3odv57k3HkzzZi0y+piHkiR/uP3YzPhgcn535H2L7lA6fdiNOfFPO+Tcmw7Lb4+8t8oHru6dNsvvbzwku29zVL7RsUeen/xQHnvx1vTdYKfs3O/ARe3WaLNW+m24c/79n3tz9NDRX+v32XT9bXPf03/J1ff9Iuuvs2mKioqzba+hS31A6459989Tk8blP2//O5usv3WdXvd/r9svH3w8Pdv3+V6mlLycKSUvV9uufdt1MqDnkFx7/xmZ+MYD6bL2JmnRvHX++ez1S1z34AGH5JnX7s91D5yZ1Zq1TL8Nd15q+wE9h9S6h86tj56XV6f+Kz/c/ewqd2M1KW6SkQdevdgQaX+49ei8VfJS+nTfIR+XfbDEelqu1ibb99k79z7159z39JVZo83aWX/tTZda//abfS8lH/w3F976oxQXFWdg773y0FfGVv+y3t22q7fhur6u8oULcs7Yw9KkSbOccuBVVY6Pnp0H5MBBp1YZ9uiDj2fkN9cfkIqKhdlhs33zxCt3LXHdG6zbNxus17fe9736Utt9uqKyot63zcqqMRyfj7xwSx5+YWyGDjw2W/T4VpU2J+x7aV5667EqQ8HMmfthzr/1h1mz3Xr5yd5jqrTfrs9e+dbmw6oMkfbWjJdqVVP7tp1yxtV7Z+5nczKo//fzwuSHl9h+vTU3TK9uA2u9XQvdvPmf1vs2qu2+17J561xxz6hM/2By/ueQsWnfZu1F81u1aJuT9v/z1xrCsNCv5SvKqnZ8NpZr+QW3HpWyeR/lNz8YV2XIrbXX6JKj9ziv1kMYNoT6vl7VZd+rL43hWr4yaizHZ23fi/q+XtXlc/qrU5/MLY+Mztab7J5dt/5BlTY/2O13eWrSuOU2xF5t2b5LtzKei2fMeitXjBuZDdbtl0MG/6JKm+/tcHwef+m2aocwfPG/j2Te/LLs2Hf/xda9tHkASyLoggbUtEmz/PYH43LXE3/KP5+9Ltfef0aSpMPq62WTLltnyIDDkiQPPHNtHpx4fQ7YeVSVYQo3WX/rHLHrb3PFuFG59dHzs/9OJy+at9E3tsgxQ8/PVff9PPc8cWlatWiXvbYfkR/s+rvFhnsYOvDY/Ob6A/P6tGerHXpgWR2x22/zyaezcte//pg58z5MZWVlrjvtrbTssOSga+d+B+bSu0/KPydeV+eg65Upn9/RNeHlOzLh5TuW2K7vBjtlQM8hefmtz4cMeue9/+Tsm4Yvdd2DBxySV6f+K5WVlflswdxceNvSx6YefcxDtfqw+sWD1Tddf9vs96X37wvdOvVebIi0L4Y8evmtxxf9LtVZp33XbN9n70VtPpzzXs4Ze9hS67mu+1t5fdqzmV8+L0kWuyv8q0454KqVNui6/p+/zuTpz+e47/0x63bovtj8rw57NOODyfmorDRJcuP43y113cOHnJEN1utb7/tefantPp2k3rfNyqgxHJ8tVmuTi+74cTp16J6jvrv4nZTt266z2FAwf7zz+JR+9G5+84NxadNyjcWW+eoQabWtqd+GOy8asvbep67IvU9dscT2QwYcll7dBtZ6uxa6D+e8V+/bqLb73qQPnsw9T16SHfvun536HbBYmwE9h3ytIQwL+Vq+Iq1qx2djuJbf9+8r89SkcTlgp5HVhjO7b/PDWg9h2BDq+3pVl32vvjSGa/nKaNr7rxX88dlxjc61fi/q+3qV1O5z+jfW6pHRYw9Pq9Xa5sT9Fj/OVmvWcrkNsVdbs+e8Z/vWYGU7F2/adduMHntEFpR/llEHXbPYs9GKioqWOIThP5+9Lh3adsp2vfdabN1LmwewJEWVlZWVDV0EiytbWJ724x+oueFKYvYuQ9K6Sd1z04Xzk4fG1NyOZTNkZFGGDDgsow66epnaL6xYmGPO75cN1+ufnx285DuC6stN43+fGx86K9ed9lbBDm8GAAAAwNLN+rgkh/5+gxy5++8Xe97x0uYVokHHJ02aN3QVsHIrKytLmzZtkiRz5sxJ69ZL7jCxNJ7RBaRJcZP8aI/Reej5GzN15qQV/vr7fPOnaduyfW555OsNnQgAAADAyuumh36fjqt3ztCBx9ZqHsDS6NG1ktKji6+jtj26AAAAAIDlR48uqJkeXQAAAAAAAKzS6t4FB1hpPXCujpoAAAAAADR+enQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAXJM7pWUq2Km2T2LkMauoxl1qq4SUOXAAAAAAAArGIEXSupoqKitG7i7QEAAAAAAFgSQxcCAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBavRBV2lpaUaNGpWNNtooLVq0SJcuXXLCCSekrKwsRx55ZIqKinLxxRc3dJkAAAAAAADUUtOGLqA+Pf/889ltt91SUlKS1q1bp1evXpk+fXrGjBmTyZMnZ9asWUmS/v37N2yhLLOPP52VGx/8Xf71yp15/6NpabVa23Tr1CeHfft/s9kG32zo8gAAAAAAgBWo0QZdpaWlGTp0aEpKSnLyySfnjDPOSNu2bZMk55xzTk499dQ0bdo0RUVF6du3bwNXy7KYOXtqTrlk58ydPye7bn1kOnfsmbJ5H+W/M15M6cfvNnR5AAAAAADACtZog67jjz8+06ZNy4gRIzJ69Ogq80aNGpUbbrghL7zwQrp375527do1UJXUxu9vPCQLK8pz2UkvZs126zZ0OQAAAAAAQANrlM/omjRpUsaOHZuOHTvmrLPOqrbNgAEDkiT9+vVbbN4dd9yR7bbbLq1bt87qq6+e7bffPq+88kq91szSvfjfR/PyW4/ngJ1HZc1266Z84YLMm/9pQ5cFAAAAAAA0oEbZo+vGG29MRUVFhg0bljZt2lTbpmXLlkkWD7rGjBmTk08+OSeeeGJ+/etf57PPPstTTz2VuXPn1nvdLNm//3NvkmTtNdbPL64cmn+/9vdUVCzMNzr2yCGDf5nBAw5p4AoBAAAAAIAVrVEGXePHj0+SDBo0aIltpk2blqRq0DV58uSMHDkyF1xwQUaMGLFo+u67715PlbKspr33WpLkgluPynode2TUgddkwcL5ue2R83L2TcNTXrEgu251RANXCQAAAAAArEiNMuiaOnVqkqRr167Vzi8vL8+ECROSVA26rrzyyjRr1ixHHXXUcq1nyy23TElJyXJdZ2PTvGnLXD7ijSXO//SzT5IkLVdrm9HHPJRmTZsnSbbvvXcO/f0Guervp+fbAw5LcXGjHI0TAAAAACggPXr2yPxyo4TB0lRUVCz69w477JDnnnuuTutplEFXWVlZkixxuMGxY8emtLQ0bdu2Tffu3RdN/9e//pWNN944119/fX7zm9/knXfeSY8ePfLLX/4y3//+9+tcT0lJSd599906L78qaNGs1VLnr9bs86EmB23+/UUhV5K0bdU+A3vtmQeevTbvvP9auq6zab3WCQAAAABQkxnTp2fegk8bugwoGDNnzqzzso0y6OrUqVNmz56diRMnZuDAgVXmzZgxIyNHjkyS9O3bN0VFRVXmvfvuuznttNNy9tlnp0uXLvnLX/6Sgw8+OGuttVYGDx5c53pYuuZNWy51fsfVOydJ2rddfFt2aLdukmTO3NnLvzAAAAAAgFpad7319OiCGlRUVGTGjBlJknXWWafO62mUQdfgwYMzadKknH322RkyZEh69uyZJHn66aczfPjwlJaWJkn69+9fZbmKiorMmTMn1113Xfbee+8kybe+9a28+uqr+fWvf13noOuZZ56p8++yqlg4P3lozJLnb7z+1rnnyUtT+tG0xeaVfvj5tDXarF1f5QEAAAAALLM3Xn8jTZrX3A5WZWVlZWnTpk2S5PHHH6/zehrlA41GjRqVNddcM++880569+6dzTbbLD169MjWW2+dDTbYILvsskuSqs/nSpIOHTokSZVAq6ioKIMHD87LL7+84n4BFrN9773TarW2eXDi9Zn72ZxF0z/4eEYmvHJnOq/VM9/ouFEDVggAAAAAAKxojTLo6ty5cx577LF897vfTYsWLTJlypR06NAhl112WcaNG5fXX389yeJBV+/evZe4znnz5tVrzSxd21bt86M9Rqf0o3dz/EXb5tZHzs9N43+f4y/aNuUL5+cne13U0CUCAAAAAAArWFFlZWVlQxexIs2ZMyft2rVLUVFRPvnkk7Rq1WrRvLvuuit77bVXbrvttuyzzz5JPh/OsH///unQoUMefvjhBqq68atp6MIvPPbS7bn54XMyZcZLKSouzqbrD8zwIWekT/ft679IAAAAAIBlMOj4GLoQavDloQvnzJmT1q1b12k9jfIZXUvzyiuvpLKyMj179qwSciXJ0KFD881vfjM/+tGP8sEHH2T99dfPn//857zyyit54IEHGqhivuybm+2Tb262T0OXAQAAAAAArARWuaDrpZdeSrL4sIXJ58/juuuuu3Lqqafm9NNPz8cff5x+/frl3nvvXfRcLwAAAAAAAFYOgq6vWGONNXLZZZflsssuW5FlAQAAAAAAUEvFDV3AilZT0AUAAAAAAEBhWOV6dI0fP76hSwAAAAAAAGA5WOV6dAEAAAAAANA4CLoAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSKtE0FVaWppRo0Zlo402SosWLdKlS5eccMIJKSsry5FHHpmioqJcfPHFDV0mS3Ht/WdmyMiiJf7semqzhi4RAAAAAABYwZo2dAH17fnnn89uu+2WkpKStG7dOr169cr06dMzZsyYTJ48ObNmzUqS9O/fv2ELZal26LNP1ltzo8WmvzXjxdz8yLnZttfQBqgKAAAAAABoSI066CotLc3QoUNTUlKSk08+OWeccUbatm2bJDnnnHNy6qmnpmnTpikqKkrfvn0buFqWZoP1+maD9RZ/jy689egkyW5bH7miSwIAAAAAABpYox668Pjjj8+0adMyYsSIjB49elHIlSSjRo1Kv379Ul5enm7duqVdu3YNWCl1MXd+WR564aastXrnbLnxrg1dDgAAAAAAsII12qBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12/RtJ133jlFRUXV/hxzzDErpHaWzaMv3JJP532cb295eJoUN2nocgAAAAAAgBWs0Q5deOONN6aioiLDhg1LmzZtqm3TsmXLJFWDrj/96U/5+OOPq7QbN25cfvOb32SPPfaov4Kptfue/kuKioryna1/0NClAAAAAAAADaDRBl3jx49PkgwaNGiJbaZNm5akatDVq1evxdr99re/zVprrZVdd63b8HhbbrllSkpK6rTsqqJ505a5fMQby9z+nfdey8tvPZ7NN/pW1u3QvR4rAwAAAAConR49e2R++dyGLgNWahUVFYv+vcMOO+S5556r03oabdA1derUJEnXrl2rnV9eXp4JEyYkqRp0fdX777+f++67Lz/+8Y/TtGndNldJSUnefffdOi27qmjRrFWt2t/3778kSXbb5of1UQ4AAAAAQJ3NmD498xZ82tBlQMGYOXNmnZdttEFXWVlZkmTu3OpT87Fjx6a0tDRt27ZN9+5L7hF04403pry8PMOHD69zLZ06darzsquK5k1bLnPbhQvL88Cz16ZdqzWzfZ/v1WNVAAAAAAC1t+566+nRBTWoqKjIjBkzkiTrrLNOndfTaIOuTp06Zfbs2Zk4cWIGDhxYZd6MGTMycuTIJEnfvn1TVFS0xPVcd9112XTTTbPlllvWuZZnnnmmzsuuKhbOTx4as2xtn3j17syeMzPf2+GENG+6Wv0WBgDASuna+8/MQYN+lubNWuScmw7PRt/on32++dNarWPCy3emfdtO6dV12xrb/uPpq/Onu07INzr2yJ9O+Pzz/ew57+WcGw/N9FmT07zJajlunz+l7wY7JknOumFYnnvjwezc/6D8eK8La/vrAQBQ4N54/Y00ad7QVcDKraysLG3atEmSPP7443VeT/HyKmhlM3jw4CTJ2Wefnddff33R9KeffjqDBg1KaWlpkqR///5LXMd//vOfPPPMM1+rNxfL331P/9+whVsf2cCVAADQUK574FeZXz7va61jwst35j9vP7nM7ftvOGhRyJUkf7n3Z9m067a55tQ3csqBV+WsGw5O+cIFSZLTDv5r9hh4zNeqDwAAgJo12h5do0aNyg033JB33nknvXv3ziabbJJ58+blzTffzG677ZZu3brlH//4x1Kfz3XdddelqKgow4YNW4GVszSlH03P06/dl026bJ3u627W0OUAANAALrzt8wDpxD99M8VFTbLm6uvl7ZmTMvKyb+X9D99Jt0598vNhN6VZ0+YpX7ggV//jF3n+zfFZUD4/ndfqmZ/ue1lenfpEnnz1rkx844H84+mrs9f2I7Ltpnvkdzd8P5/O+zjzy+el34aD8pO9xqS4uPr7Ax954eZcc+qbSZKNu2yVNdutlxcnP5Iteg5eYdsCAABgVddoe3R17tw5jz32WL773e+mRYsWmTJlSjp06JDLLrss48aNW9TLa0lBV2VlZf76179m5513zvrrr78iS2cp7n/m6lRULMxu2/ywoUsBAKCB/HTfS5MkF/z4sVx20vNZo/XamTz9+fz6iLvzl5GTMvuTmXnspduSJDc/fG5aNGudi4//dy476fl077RZrrrvf7LNprtn21575oCdR+ayk57P7tv8MG1arpFfH3F3/vTTZ3PZSS9m5uwpeeTFm6ut4eOyD7Jw4YJ0aPf/n8e7Tvtuee/Dt+t/AwAAALBIo+3RlSSbbrpp7rnnnsWmz5kzJ1OmTElxcXH69OlT7bKPPvpopk6dmjPOOKO+y6QWDv7W6Tn4W6c3dBkAAKxktu/zvbRo3ipJssn6W2fGB5OTJP965c6UzftoUfBVvnB+1unQrdp1VFRW5Ipxp+aVKY+nsrIyH855L9069cmg/getkN8BAACA2mvUQdeSvPLKK6msrEzPnj3TqlWrattcd911admyZfbbb78VXB0AAFBbzZu1WPTv4qImWVhRnuTzkRp+stdF2XLjb9e4jtsePT8flr2Xi457Ks2btcild52U+Quqfw5Yu9Zrpklx08z6uGRRr66Zs6dk7TWMBgEAALAiNdqhC5fmpZdeSrLkYQvnzZuX/8fenYd5Vdb/H38Nm8AwKIs6KMgioLIrbrhjUJJiZm6JZmZmC2FFjGXf0lbCaCNbtM3UIHLNrcxEDakMJA2VEklMhFEnUGEE2eb3h8WviU0Q+HCGx+O6vIpz3+cz7xmn/vDpfc6NN96YU045JRUVFdtzNAAA4A1ouUtFape/vMl9R/Q5JTdP/WaWr3g1SbJ8xauZV/14kqS8eevULvv/n7Fk2eK0rahMs6bNs+iV6vz+rzds9LOP7nd67vjT649R/Puz01Pz8nPpt++xW/otAQAAsAV2yhNdmwpdzZs3z0svvbQdJwIAADbHaceMziVXD80uTVum3a57bXDfWcddkutWvZaPfuewlKUsSXLm4EvSpbJ3hgw8N1+b/N5Me/zWnHzER3LqURfnC9edlveP7512rffKgT2GbHSGC08cl69OOjfnjeuRpo2b5VPvvj5NGjfdqt8nAAAAG1dWV1dXV+ohtrfjjz8+9913X+64446ceOKJpR6HJKtXJPdNKPUUAACwfndPvyZ/ePzWfP69t77he6797eVZuuylfPgd39pmcwEAsGMaPCpp3KzUU8COrba2Nq1atUqSLF26NOXl5Vv0OTvlowunTJmSuro6kQsAAHhDdmnaInMXPJIPf/vgN7R/7MQRuXfm9WnZvPU2ngwAAGDntlOe6GLH40QXAAAAANBQONEFm+ZEFwAAAAAAADs1oQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCavChq6amJlVVVenevXuaN2+eTp065eKLL05tbW0uuOCClJWV5corryz1mAAAAAAAAGymJqUeYFt65JFHMmzYsFRXV6e8vDy9evXKggULMmHChMydOzeLFi1KkgwYMKC0g/KGLHttaW55cELue2RSnl88L00b75KOu/fM2w/7QN568HkpKysr9YgAAAAAAMB21GBPdNXU1GT48OGprq7O6NGjs3DhwsycOTPV1dUZN25c7rzzzkyfPj1lZWXp169fqcdlE9asWZNLfzwsP7v7s9mv0yG56KSvZ8SQ/8uaNasz/pfn50d3farUIwIAAAAAANtZgw1do0aNyvz58zNy5MiMHz8+FRUVa9eqqqrSv3//rFq1Kl26dEnr1q1LOClvxN/++VAee/rBnHLUqHzyjJ/kxMM/kFOP/li+8eGpqWzbNXf+6apSjwgAAAAAAGxnDTJ0zZ49O5MnT0779u0zduzY9e4ZOHBgkqR///71rk+dOjVvectb0r59++y22245/PDDc/PNN2/zmdm42tdeSZK0a71XvetNmzTLruXt07xZeSnGAgAAAAAASqhBhq5JkyZlzZo1GTFiRFq1arXePS1atEhSP3Q9+uijGTp0aBo3bpxrrrkmkydPTqdOnXLaaafljjvu2C6zs377dzo0rVrsll/ef0UeePSGvLD4n/nnC3/Lj+/6dObMfzjveevlpR4RAAAAAADYzpqUeoBtYcqUKUmSwYMHb3DP/Pnzk9QPXZMnT05ZWVluvfXWtGzZMkkyZMiQdOvWLT//+c9z0kknbcOp2ZiKlm3yhffelm/c+P586foz1l5vuUtFPveem3Jkn1NKNxwAAAAAAFASDTJ0PfPMM0mSzp07r3d91apVmTZtWpL6oWvFihVp1qzZ2tNeSdK4ceNUVFRkzZo1WzzPwQcfnOrq6i2+f2fQrEmLXD1yzkb3tNilVbrs2SeDep2cXp2PyJJli3LbH76bsRPPzuff+6sM7Dl0O00LAAAAALBhPXr2yIpVy0o9BuzQ/ru7HHXUUfnLX/6yRZ/TIENXbW1tkmTZsvX/H8nkyZNTU1OTioqKdO3ade31c889N9/97nczevToXHLJJWnSpEmuuuqqzJkzJ9/73ve2eJ7q6uo899xzW3z/zqB505YbXX964axcfOUR+eDJ38zwQR9ce33wgHfnwq/3yTdvvDA/+9TcNG7UeFuPCgAAAACwUQsXLMjyla+WegwojOeff36L722QoauysjKLFy/OzJkzM2jQoHprCxcuzJgxY5Ik/fr1S1lZ2dq1/v375957782pp56ab37zm0mS8vLy3HDDDTnmmGPe1DxsXLMmLTa6ftPUb2bFquU5tt/p9a43b9Yyhx1wYn417co8v2he9mq/77YcEwAAAABgkzrstZcTXbAJa9asycKFC5Mke+655xZ/ToMMXUOGDMns2bMzbty4DB06ND179kySTJ8+Peeee25qamqSJAMGDKh335w5c3LmmWfmkEMOyYc//OE0btw4P//5z3PWWWfljjvuyPHHH79F88yYMeNNfT87g9UrkvsmbHi95uXXT8Strlu97r2rV73+n2tWbZPZAAAAAAA2x5wn56Rxs1JPATu22tratGrVKkny4IMPbvHnNNpaA+1Iqqqq0q5duzz77LPp3bt3+vbtmx49euTQQw9Nt27d1gar/34/V5JceumladmyZW655ZYMGzYsb33rW/Ozn/0shx12WEaPHl2Kb4V/67xnryTJb6dfU+/60mUv5Q9P/CoVLdpkr/bdSzAZAAAAAABQKg0ydHXs2DFTp07NiSeemObNm2fevHlp27Ztrrrqqtx555158sknk6wbumbNmpX+/funSZP6B90OPvjgzJ49e7vNz7pOPfpjqWjZNj/+9afy1Unn5vY//iAT7/1KPvTNA7PolYV57wlf8n4uAAAAAADYyZTV1dXVlXqI7Wnp0qVp3bp1ysrKsmTJkrRs2XLt2nHHHZcFCxbkiSeeqBe7jjvuuDz77LOZO3duKUbeKWzq0YVJsqBmbq7/3Rfyl6fuzeIlz2eXpi2y714D8s6jP5aj+566fQYFAAAAANiEwaPi0YWwCf/96MKlS5emvLx8iz6nQb6ja2Mef/zx1NXVpWfPnvUiV5J85CMfyRlnnJF3vvOdueiii9K4ceNMnDgxDzzwQL797W+XaGL+Y6/2+6bqrJ+VegwAAAAAAGAHsdOFrlmzZiVZ97GFSXL66afn9ttvz7hx43Leeedl9erV6dmzZ37+85/n7LPP3t6jAgAAAAAAsBFC1/846aSTctJJJ23PkQAAAAAAANgCjUo9wPa2qdAFAAAAAABAMex0J7qmTJlS6hEAAAAAAADYCna6E10AAAAAAAA0DEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEg7ReiqqalJVVVVunfvnubNm6dTp065+OKLU1tbmwsuuCBlZWW58sorSz0mAAAAAAAAm6FJqQfY1h555JEMGzYs1dXVKS8vT69evbJgwYJMmDAhc+fOzaJFi5IkAwYMKO2gbNLiJc/nZ7+9LH+efWcWL30+bSoqc2Sfd+a8t34+rVrsVurxAAAAAACA7axBh66ampoMHz481dXVGT16dC677LJUVFQkSa644opccskladKkScrKytKvX78ST8vGLF76Qj76ncPyr1cW5MTDL0qXPftk3vOP5Y4/fj+z/vH7fOsj09K8WctSjwkAAAAAAGxHDTp0jRo1KvPnz8/IkSMzfvz4emtVVVWZOHFiHn300XTt2jWtW7cu0ZS8EZPu/UqeX/xMPn32xBx/4LvXXu/V+YiMnXh2bvr9NzJiyP+VcEIAAAAAAGB7a7Dv6Jo9e3YmT56c9u3bZ+zYsevdM3DgwCRJ//79613/3e9+l8MPPzzNmzfPHnvskQ9+8IN5+eWXt/nMbNijc+/LLk1bZPCAs+pdP67/mWnWpHnunv7TEk0GAAAAAACUSoMNXZMmTcqaNWsyYsSItGrVar17WrRokaR+6HrggQdywgknZO+9984tt9ySL3/5y7nxxhtzyimnpK6ubrvMzrpWrnotzZo0T1lZWb3rjRo1yi5NW2Thon/k5dqaEk0HAAAAAACUQoN9dOGUKVOSJIMHD97gnvnz5yepH7q+8IUvpEePHrnhhhvSqNHrHbBdu3Z517velTvvvDMnnXTSNpyaDem8Z+88++Lf89Rzj6T73gPWXn/quUeyZNniJMkLi/+ZXcvbl2hCAAAAAABge2uwoeuZZ55JknTu3Hm966tWrcq0adOS1A9dDz30UM4///y1kStJ3vrWtyZJbr311i0KXQcffHCqq6s3+76dSbMmLXL1yDkbXD/16I/lD4/fmi9df0Y+dPK30rWyT+Y9/3i+f9vH0qRx06xavTKvrXx1O04MAAAAALB+PXr2yIpVy0o9BuzQ1qxZs/a/H3XUUfnLX/6yRZ/TYENXbW1tkmTZsvX/n8nkyZNTU1OTioqKdO3ade31xo0bp1mzZvX2Nm3aNGVlZXn88ce3aJbq6uo899xzW3TvzqJ505YbXe/b7ehcOuIX+d6vRuX/fnJikqRRo8YZduj703nP3pn22C1puUvr7TEqAAAAAMBGLVywIMv9i/nwhj3//PNbfG+DDV2VlZVZvHhxZs6cmUGDBtVbW7hwYcaMGZMk6devX733PvXs2TMPPfRQvf3Tp09PXV1dFi1atMWzsHHNmrTY5J5j+5+eo/qemqcXzsqy15ak4x77pU2rPTJywqFp3KhJ9mrffTtMCgAAAACwcR322suJLtiEurq61NXVJUk6dOiwxZ/TYEPXkCFDMnv27IwbNy5Dhw5Nz549k7werc4999zU1NQkSQYMGFDvvlGjRuU973lPvvSlL+WDH/xg5s+fnw9/+MNp3LhxvccZbo4ZM2a8qe9lZ7B6RXLfhE3va9yocb13dC16pTpPPfeX9Ot2bJo32/ipMAAAAACA7WHOk3PSuNmm9wFv3paVmwKoqqpKu3bt8uyzz6Z3797p27dvevTokUMPPTTdunXL8ccfn6T++7mS5Jxzzskll1ySL37xi9l9991z8MEHZ/DgwRkwYMCbKopsfWvWrMl3fzUqa+pW5+y3fKbU4wAAAAAAANtZgz3R1bFjx0ydOjVjxozJAw88kHnz5qVXr1656qqrcuGFF2bfffdNsm7oKisry1e/+tV85jOfydNPP5299947u+66a9q1a5ePfvSjpfhWSLLstaUZOeHQHNnnnals2zW1y1/OfY9Mypz5D+f8E76cAd0Hl3pEAAAAAABgO2uwoStJDjjggNxxxx3rXF+6dGnmzZuXRo0apU+fPuu9t6KiIv369UuS/PCHP8yyZcty/vnnb9N52bAmjZul2179c99fJuZfSxamedOW6dnpkHzl/b/JIfu9rdTjAQAAAAAAJdCgQ9eGPP7446mrq0vPnj3TsmX99zrNmDEj99xzTw466KCsWrUqv/vd7zJhwoSMHz9+7Skwtr+mTZrlMyMmlXoMAAAAAABgB7JThq5Zs2YlWfexhUmyyy675Pbbb8/YsWOzatWq9O3bN5MnT85pp522vccEAAAAAABgI4Su/9G3b9/84Q9/2N4jAQAAAAAAsJkalXqAUthY6AIAAAAAAKAYdsoTXVOmTCn1CAAAAAAAALxJO+WJLgAAAAAAAIpP6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACqmsrq6urtRDQF1dsmZlqacAAAAAAHjzGjVNyspKPQXsHIQuAAAAAAAACsmjCwEAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQmpS6gHYvurqkjUrSz0FQOk0apqUlZV6CgAAAABgaxC6djJrVib3TSj1FAClM3hU0rhZqacAAAAAALYGjy4EAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkHaK0FVTU5Oqqqp07949zZs3T6dOnXLxxRentrY2F1xwQcrKynLllVeWekwAAAAAAAA2Q5NSD7CtPfLIIxk2bFiqq6tTXl6eXr16ZcGCBZkwYULmzp2bRYsWJUkGDBhQ2kF3EGvWrMktD347d/7pqlQvnpfdynfPMf3PyHlv+0JaNCsv9XgAAAAAAABrNegTXTU1NRk+fHiqq6szevToLFy4MDNnzkx1dXXGjRuXO++8M9OnT09ZWVn69etX6nF3CN+//eP5we2fyD579srIU76TY/qdnlsfnJDP/WR41qxZU+rxAAAAAAAA1mrQJ7pGjRqV+fPnZ+TIkRk/fny9taqqqkycODGPPvpounbtmtatW5doyh3HvOrH86tp38lRfU7NZefdtPZ6Zduu+e6vRuX+R3+R4w88u4QTAgAAAAAA/H8N9kTX7NmzM3ny5LRv3z5jx45d756BAwcmSfr371/v+tNPP52TTz45FRUVadOmTd7znvfkX//61zafudTue2RS6urqcurRH6t3/e2HXZjmTVvmdzOvL81gAAAAAAAA69FgQ9ekSZOyZs2ajBgxIq1atVrvnhYtWiSpH7qWLFmSwYMHZ/78+Zk0aVKuvvrqTJ06NSeddFKDf3Tf35+dnkZljbLfPofWu96safN022tAnnx2eokmAwAAAAAAWFeDfXThlClTkiSDBw/e4J758+cnqR+6rr766jz33HP5/e9/n3322SdJ0rFjxxxxxBG57bbbcsopp7zhGerq6vLqq68mSVq2bJmysrLN/Ta2q3+9siCty9unWZNd1llrv+veeeKZP2TlqhVp2qRZCaYDAAAAAACor8GGrmeeeSZJ0rlz5/Wur1q1KtOmTUtSP3TdcccdOeqoo9ZGriQZNGhQunXrlttvv32zQterr7669jRZhw4d0qhR6Q/QNWvSIlePnLPetddWvJqm64lcr9/X/PU9K18VuoBC69GzR1asWlbqMQAAAACAf6usrMyMGTO26N4GG7pqa2uTJMuWrf8fZk6ePDk1NTWpqKhI165d115/4okncvrpp6+zv3fv3nniiSe2eJ6FCxdu8b1bU/OmLTe4tkuzllm29IX1rq1Ytfz1PRu5H6AIFi5YkOUrXy31GAAAAADAVtBgQ1dlZWUWL16cmTNnZtCgQfXWFi5cmDFjxiRJ+vXrV++RgosXL85uu+22zue1bds2f//737d4nh3pRNeGtGu9V/75/BNZseq1dR5fWPPyc9m1vL3TXEDhddhrLye6AAAAAGAHUllZucX3NtjQNWTIkMyePTvjxo3L0KFD07NnzyTJ9OnTc+6556ampiZJMmDAgO0yz5w5c1JeXr5dvtbGrF6R3Ddh/Wv7dTokDz/52/z9n39O325Hr72+YuXy/GPBI+nb7ZjtNCXAtjPnyTlprNkDAAAAQINQ+iNG20hVVVXatWuXZ599Nr17907fvn3To0ePHHrooenWrVuOP/74JPXfz5Ukbdq0yUsvvbTO5y1atCht27bdHqOXzHH9z0xZWVlunvqtetfveuiHWb7y1Rx/4IjSDAYAAAAAALAeDTZ0dezYMVOnTs2JJ56Y5s2bZ968eWnbtm2uuuqq3HnnnXnyySeTrBu6DjjggPW+i+uJJ57IAQccsF1mL5WuHfrm5CM+kgcfuzmX/+zU3PXQj/KD20fnB7d/Iv26HZvjDzy71CMCAAAAAACs1WAfXZi8Hq3uuOOOda4vXbo08+bNS6NGjdKnT596ayeddFIuvfTSzJ8/Px07dkySPPTQQ5k7d26+9rWvbZe5S+lDJ38re7bpkrseujp/nn1nWpe3zylHfjTnve0LO8Q7xgAAAAAAAP6jrK6urq7UQ2xvDz30UA4//PDst99++dvf/lZv7ZVXXknfvn3Tvn37fP7zn8/y5ctTVVWV3XffPX/84x83K/bU1tamVatWSV6Pazv6O7oAdgaDR8U7ugAAAACggdgpj+jMmjUrybqPLUyS1q1bZ8qUKenQoUPOOuusvP/9788RRxyRO+64w4kmAAAAAACAHUiDfnThhmwsdCXJvvvuu95HHgIAAAAAALDj2CmPKG0qdAEAAAAAALDj2ylPdE2ZMqXUIwAAAAAAAPAm7ZQnugAAAAAAACg+oQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQtopQldNTU2qqqrSvXv3NG/ePJ06dcrFF1+c2traXHDBBSkrK8uVV15Z6jF3CJOmjM0Xrjs9547tlqFjynLOV7qUeiQAAAAAAID1alLqAba1Rx55JMOGDUt1dXXKy8vTq1evLFiwIBMmTMjcuXOzaNGiJMmAAQNKO+gO4ie/vjQVLdumx94HpXbZS6UeBwAAAAAAYIMadOiqqanJ8OHDU11dndGjR+eyyy5LRUVFkuSKK67IJZdckiZNmqSsrCz9+vUr8bQ7hms/NTcd2nVLklw4vk+WrVha4okAAAAAAADWr0E/unDUqFGZP39+Ro4cmfHjx6+NXElSVVWV/v37Z9WqVenSpUtat25dwkl3HP+JXAAAAAAAADu6Bhu6Zs+encmTJ6d9+/YZO3bsevcMHDgwSdK/f/+11/4Txg499NDssssuKSsr2y7zAgAAAAAAsHkabOiaNGlS1qxZkxEjRqRVq1br3dOiRYsk9UPXU089lZtuuimVlZU55JBDtsusAAAAAAAAbL4G+46uKVOmJEkGDx68wT3z589PUj90HXPMMVm4cGGS5PLLL8+0adO2yjw9evRIo0al74rNmrTI1SPnlHoMgJLp0bNHVqxaVuoxAAAAAIB/q6yszIwZM7bo3gYbup555pkkSefOnde7vmrVqrUR679D17aKUf+JZ6XWvGnLUo8AUFILFyzI8pWvlnoMAAAAAGAraLChq7a2NkmybNn6/639yZMnp6amJhUVFenates2n6dDhw47zIkugJ1Zh732cqILAAAAAHYglZWVW3xvgw1dlZWVWbx4cWbOnJlBgwbVW1u4cGHGjBmTJOnXr1/Kysq2+Txz5sxJeXn5Nv86m7J6RXLfhFJPAVA6c56ck8bNSj0FAAAAALA1lP6I0TYyZMiQJMm4cePy5JNPrr0+ffr0DB48ODU1NUmSAQMGlGI8AAAAAAAA3qQGe6KrqqoqEydOzLPPPpvevXtn//33z/Lly/PUU09l2LBh6dKlS+6+++567+ciuefh6/LC4tffb/ZS7YtZtXpFfv67LyVJ9mjTOUMHnlvK8QAAAAAAANZqsKGrY8eOmTp1asaMGZMHHngg8+bNS69evXLVVVflwgsvzL777pskQtf/+M2ff5y//uOBeteuufuzSZJ+3Y4VugAAAAAAgB1Ggw1dSXLAAQfkjjvuWOf60qVLM2/evDRq1Ch9+vQpwWQ7rq9/6P5SjwAAAAAAAPCGNOjQtSGPP/546urq0rNnz7Rs2XKd9RtvvDFJ8sQTT9T7c5cuXXLwwQdvv0EBAAAAAADYoJ0ydM2aNSvJhh9bePrpp6/3z+edd16uueaabTobAAAAAAAAb4zQtR51dXXbcxwAAAAAAAC2QKNSD1AKmwpdAAAAAAAA7Ph2yhNdU6ZMKfUIAAAAAAAAvEk75YkuAAAAAAAAik/oAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApppwhdNTU1qaqqSvfu3dO8efN06tQpF198cWpra3PBBRekrKwsV155ZanH3CHMf/HJXHP35/LR7xye0y7fPSf/X0Uu+saA/PzeL2fZitpSjwcAAAAAALBWk1IPsK098sgjGTZsWKqrq1NeXp5evXplwYIFmTBhQubOnZtFixYlSQYMGFDaQXcQv5n+k9z2h+9mUK+T85YDR6Rx46Z5dO59ueY3/5ffP/rLTPjon7JL0xalHhMAAAAAAKBhh66ampoMHz481dXVGT16dC677LJUVFQkSa644opccskladKkScrKytKvX78ST7tjOLrvaXn34E+nvMWua68NH/TB7N2+Rybe++X8+s8/zilHjizhhAAAAAAAAK9r0I8uHDVqVObPn5+RI0dm/PjxayNXklRVVaV///5ZtWpVunTpktatW5dw0h3Hfp0Orhe5/uO4/mcmSeZVP7a9RwIAAAAAAFivBhu6Zs+encmTJ6d9+/YZO3bsevcMHDgwSdK/f/+112688ca8613vSufOndOyZcvsv//++cxnPpOlS5dul7l3VC++PD9J0qbVniWeBAAAAAAA4HUNNnRNmjQpa9asyYgRI9KqVav17mnR4vV3Tf136Bo/fnwaN26cr3zlK/n1r3+dD33oQ/n+97+fE044IWvWrNkus+9oVq9ZnZ//7otp3KhJjj/w7FKPAwAAAAAAkKQBv6NrypQpSZLBgwdvcM/8+a+fUvrv0HX77bdn9913X/vnY489NrvvvntGjBiRBx98MMccc8w2mnjH9f3bPpYnnvlj3jfsK+m0x36lHgcAAAAAACBJAw5dzzzzTJKkc+fO611ftWpVpk2blqR+6PrvyPUfBx98cJLkueee2+J5evTokUaNSn+ArlmTFrl65Jw3vP+a33w2v5p2ZU487AN59/Gf3oaTAWwfPXr2yIpVy0o9BgAAAADwb5WVlZkxY8YW3dtgQ1dtbW2SZNmy9f/DzMmTJ6empiYVFRXp2rXrRj/rvvvuS5IccMABWzzPwoULt/jeral505ZveO+1v708P7/3S3nbIefn4nf9YBtOBbD9LFywIMtXvlrqMQAAAACAraDBhq7KysosXrw4M2fOzKBBg+qtLVy4MGPGjEmS9OvXL2VlZRv8nOeeey6f/exnc8IJJ2TAgAFbPE+HDh12mBNdb8S1v708193z+QwdeF4+cdqPNvozAiiSDnvt5UQXAAAAAOxAKisrt/jeBhu6hgwZktmzZ2fcuHEZOnRoevbsmSSZPn16zj333NTU1CTJRuPV0qVL8453vCPNmjXLT37ykzc1z5w5c1JeXv6mPmNrWL0iuW/Cxvdcd88Xct09n8+Qg87NJ8/4yQ4R6AC2ljlPzknjZqWeAgAAAADYGhps6KqqqsrEiRPz7LPPpnfv3tl///2zfPnyPPXUUxk2bFi6dOmSu+++u977uf7bsmXLMnz48Dz99NOZOnVqOnTosJ2/g9L41bTv5trfXpY9dtsnB/UYkil/mVhvvU3FnhnYc2iJpgMAAAAAAPj/Gmzo6tixY6ZOnZoxY8bkgQceyLx589KrV69cddVVufDCC7PvvvsmyXpD18qVK3PaaadlxowZuffee9OrV6/tPX7J/P3Z6UmSF176Z66YfN466/26HSt0AQAAAAAAO4Syurq6ulIPsb0tXbo0rVu3TllZWZYsWZKWLVuuXVuzZk3OOuus3Hbbbbnrrrty/PHHb/HXqa2tTatWrdZ+zaI8uhCgIRs8Kh5dCAAAAAANRIM90bUxjz/+eOrq6tKzZ896kStJPvKRj+SGG27Ipz71qbRs2TJ/+tOf1q7tu+++2X333bf3uAAAAAAAAKxHo1IPUAqzZs1Ksv7HFv76179Oknz1q1/NoEGD6v115513btc5AQAAAAAA2LCd8kTXxkLXvHnztvM0AAAAAAAAbAknugAAAAAAACiknfJE15QpU0o9AgAAAAAAAG/STnmiCwAAAAAAgOITugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBC2ilCV01NTaqqqtK9e/c0b948nTp1ysUXX5za2tpccMEFKSsry5VXXlnqMQEAAAAAANgMTUo9wLb2yCOPZNiwYamurk55eXl69eqVBQsWZMKECZk7d24WLVqUJBkwYEBpB91BPPvC33P9776QOc/NzL9eWZDVq1dmj932yaH7vz2nHzcm7Vp3KPWIAAAAAAAASRp46Kqpqcnw4cNTXV2d0aNH57LLLktFRUWS5Iorrsgll1ySJk2apKysLP369SvxtDuGF1+en0WvLMyRfd6Z3XftmMaNmuTp6lm586Grc9+jv8gPPv5I2rTao9RjAgAAAAAANOzQNWrUqMyfPz8jR47M+PHj661VVVVl4sSJefTRR9O1a9e0bt26RFPuWA7q8ZYc1OMt61zv2/WYfOn6M/Lb6dfkzMFVJZgMAAAAAACgvgb7jq7Zs2dn8uTJad++fcaOHbvePQMHDkyS9O/ff+21qVOnZsiQIenQoUN22WWXdOzYMWeeeWZmz569XebeUe3ZpnOSZOmyxSWeBAAAAAAA4HUN9kTXpEmTsmbNmowYMSKtWrVa754WLVokqR+6Fi9enL59++aiiy7KHnvskfnz52fs2LEZNGhQHnvssXTs2HG7zF9qK1Yuz7IVS7Ni5fI88/wT+dFdlyRJDt3/7SWeDAAAAAAA4HUNNnRNmTIlSTJ48OAN7pk/f36S+qHr5JNPzsknn1xv3yGHHJL99tsvN910Uy6++OJtMO2O564//yjfvfWja/9c2aZLPvXu69O329ElnAoAAAAAAOD/a7Ch65lnnkmSdO7ceb3rq1atyrRp05LUD13r065duyRJkyZb/uPq0aNHGjUq/ZMimzVpkatHztnkviN7n5J9dt8/y1YszVPP/SV/fOK2vFxbsx0mBNi2evTskRWrlpV6DAAAAADg3yorKzNjxowturfBhq7a2tokybJl6/+HmZMnT05NTU0qKirStWvXddZXr16dNWvW5JlnnsmnP/3pVFZW5owzztjieRYuXLjF925NzZu2fEP7dt+tY3bf7fXHNB7Z55Qc3fddGTnhkLy28tW8+/hPb8sRAbaphQsWZPnKV0s9BgAAAACwFTTY0FVZWZnFixdn5syZGTRoUL21hQsXZsyYMUmSfv36paysbJ37jz322LUnvrp3754pU6Zk99133+J5OnTosMOc6NoS3fbql333PjC3/+F7QhdQaB322suJLgAAAADYgVRWVm7xvQ02dA0ZMiSzZ8/OuHHjMnTo0PTs2TNJMn369Jx77rmpqXn9MXwDBgxY7/0//vGP89JLL+Xpp5/O1772tbz1rW/NtGnTss8++2zRPHPmzEl5efkW3bs1rV6R3Ddhy+5dsXJZlry6aOsOBLCdzXlyTho3K/UUAAAAAMDWUPojRttIVVVV2rVrl2effTa9e/dO375906NHjxx66KHp1q1bjj/++CQbfj/Xfvvtl8MOOyxnnXVW7r333ixZsiRXXHHF9vwWSmLRK9Xrvf7IU/dlXvVj2b/z4dt5IgAAAAAAgPVrsCe6OnbsmKlTp2bMmDF54IEHMm/evPTq1StXXXVVLrzwwuy7775JNhy6/ttuu+2W7t2756mnntrWY5fchJs/lH8tWZgB3Y/Pnrt1zopVyzNn/sO5/9FfpMUuFbnopK+XekQAAAAAAIAkDTh0JckBBxyQO+64Y53rS5cuzbx589KoUaP06dNnk5/zwgsv5O9//3sOO+ywbTHmDmXwge/OPQ9fm3sfvi4v1b6YspRlzzadc+LhF+WMY8dkjzZb9uhGAAAAAACAra1Bh64Nefzxx1NXV5eePXumZcuW9dbOOeecdO/ePQMGDMhuu+2WOXPm5Jvf/GaaNGmSj3/84yWaePs5tv8ZObb/GaUeAwAAAAAAYJN2ytA1a9asJOt/bOHhhx+ea6+9Nt/+9rezfPnydOrUKYMHD86ll16azp07b+9RAQAAAAAA2ACh63+MHDkyI0eO3N4jAQAAAAAAsJkalXqAUthY6AIAAAAAAKAYdsoTXVOmTCn1CAAAAAAAALxJO+WJLgAAAAAAAIpP6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkBp86KqpqUlVVVW6d++e5s2bp1OnTrn44otTW1ubCy64IGVlZbnyyitLPeYOa/mKV3Pu2G4ZOqYs37llZKnHAQAAAAAAWKtJqQfYlh555JEMGzYs1dXVKS8vT69evbJgwYJMmDAhc+fOzaJFi5IkAwYMKO2gO7Cf3f25vFz7YqnHAAAAAAAAWEeDPdFVU1OT4cOHp7q6OqNHj87ChQszc+bMVFdXZ9y4cbnzzjszffr0lJWVpV+/fqUed4c0Z/7M3Pzgt/KeoZ8v9SgAAAAAAADraLCha9SoUZk/f35GjhyZ8ePHp6KiYu1aVVVV+vfvn1WrVqVLly5p3bp1CSfdMa1eszrfvPHCHLLfCTmq76mlHgcAAAAAAGAdDTJ0zZ49O5MnT0779u0zduzY9e4ZOHBgkqR///4b/Jxhw4alrKwsl19++bYYc4d28++/mWdf+FtGnuL9ZQAAAAAAwI6pQYauSZMmZc2aNRkxYkRatWq13j0tWrRIsuHQ9ctf/jKPPPLIthpxh7Zw0dO59reXZcTQz6WybZdSjwMAAAAAALBeTUo9wLYwZcqUJMngwYM3uGf+/PlJ1h+6XnnllXzsYx/L+PHjc84552yVmXr06JFGjUrfFZs1aZGrR87Z6J5v3/TBVLbrltOO+cR2mgpg++nRs0dWrFpW6jEAAAAAgH+rrKzMjBkztujeBhm6nnnmmSRJ586d17u+atWqTJs2Lcn6Q9dnPvOZ9OzZMyNGjNhqoWvhwoVb5XPerOZNW250/XcPX5+Zc+7JNz70+zRp3HQ7TQWw/SxcsCDLV75a6jEAAAAAgK2gQYau2traJMmyZev/N/YnT56cmpqaVFRUpGvXrvXWZsyYkR/+8Id5+OGHt+pMHTp02GFOdG3IilWv5arbP5FD93972lRU5rmap5IkNS8/lySpXf5ynqt5KruWt0+rFrttj3EBtroOe+3lRBcAAAAA7EAqKyu3+N4GGboqKyuzePHizJw5M4MGDaq3tnDhwowZMyZJ0q9fv5SVla1dW716dS666KKMHDkyvXv33qozzZkzJ+Xl5Vv1M7fE6hXJfRPWv7Zi5bK8VPtiHpp9Zx6afec66/fOvD73zrw+Hzjxazn9uE9u40kBto05T85J42alngIAAAAA2BoaZOgaMmRIZs+enXHjxmXo0KHp2bNnkmT69Ok599xzU1NTkyQZMGBAvfuuvPLKPP/887n88su388Q7hubNyvPZc29Y5/rLS1/MhFs+nEP2OyEnHHpBunXoV4LpAAAAAAAA6muQoauqqioTJ07Ms88+m969e2f//ffP8uXL89RTT2XYsGHp0qVL7r777nrv56qpqclnP/vZjB8/PqtWrcpLL720dm358uV56aWX0rp16x3i8YPbSpPGTXNMv9PWuV69aF6SpEO7fde7DgAAAAAAUAoNstp07NgxU6dOzYknnpjmzZtn3rx5adu2ba666qrceeedefLJJ5OkXuiaP39+lixZkosuuiht2rRZ+1eSjBs3Lm3atMk///nPknw/AAAAAAAArKusrq6urtRDbE9Lly5N69atU1ZWliVLlqRly5Zrr8+YMWOd/YMHD855552X9773vTn88MPTvHnzN/y1amtr06pVq7Wfv6O/owtgZzB4VLyjCwAAAAAaiAb56MKNefzxx1NXV5eePXuujVxJ0qpVqxx33HHrvadLly4bXAMAAAAAAKA0GuSjCzdm1qxZSeo/thAAAAAAAIDi2elOdG1u6NrJnuwIAAAAAABQGE50AQAAAAAAUEg73YmuKVOmlHoEAAAAAAAAtoKd7kQXAAAAAAAADYPQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABTSThG6ampqUlVVle7du6d58+bp1KlTLr744tTW1uaCCy5IWVlZrrzyylKPCQAAAAAAwGZoUuoBtrVHHnkkw4YNS3V1dcrLy9OrV68sWLAgEyZMyNy5c7No0aIkyYABA0o76A5k6Jiy9V5v3qw8t3956XaeBgAAAAAAYP0adOiqqanJ8OHDU11dndGjR+eyyy5LRUVFkuSKK67IJZdckiZNmqSsrCz9+vUr8bQ7lr5dj87bD/tAvWtNGjct0TQAAAAAAADratCha9SoUZk/f35GjhyZ8ePH11urqqrKxIkT8+ijj6Zr165p3bp1iabcMVW27ZYhA88p9RgAAAAAAAAb1GDf0TV79uxMnjw57du3z9ixY9e7Z+DAgUmS/v37r712//33p6ysbJ2/dsZHG65ctSLLXvOoQgAAAAAAYMfUYE90TZo0KWvWrMmIESPSqlWr9e5p0aJFkvqh6z+++93v5qCDDlr75/Ly8m0z6A5q6qwbc+9frs+aNauzW/nuOXbAmTn/bV9KeYtdSz0aAAAAAABAkgYcuqZMmZIkGTx48Ab3zJ8/P8n6Q1evXr1y+OGHb5vhdnD7dzo0x/Q7PXu1755Xl7+SP//trvxq2pX569wH8u2Rf0iLXdYfDgEAAAAAALanBhu6nnnmmSRJ586d17u+atWqTJs2Lcn6Q9fW1qNHjzRqVPonRTZr0iJXj5yz0T3fGfVQvT8PPfg96dqhX376m8/k5ge/nRFv+cy2HBFgm+rRs0dWrFpW6jEAAAAAgH+rrKzMjBkztujeBhu6amtrkyTLlq3/H2ZOnjw5NTU1qaioSNeuXddZP/PMM1NTU5N27drl5JNPzle/+tW0b99+i+dZuHDhFt+7NTVv2nKL7jvjuDG5/p7P58+z7xS6gEJbuGBBlq98tdRjAAAAAABbQYMNXZWVlVm8eHFmzpyZQYMG1VtbuHBhxowZkyTp169fysrK1q7tuuuuGTNmTI455pi0atUqf/zjHzN27Nj86U9/yowZM9K8efMtmqdDhw47zImuLdGkcdO0a71XXq6t2coTbR9//tuv89mfDs8PRz+WffbYf5P7z/lKl+zZpku+/qH73/TXXrFyed73tf1z/IEj8r5hX37TnwcNWV1dXT787YHp1qF/xpz50ze8tjk67LWXE10AAAAAsAOprKzc4nsbbOgaMmRIZs+enXHjxmXo0KHp2bNnkmT69Ok599xzU1PzerAZMGBAvfsOPPDAHHjggWv/fNxxx6VPnz45+eSTM2nSpJx//vlbNM+cOXNSXl6+Zd/MVrR6RXLfhM2/b8XK5Xnx5fk5oHPx3lu2evWqXHX76LzlwBFvKHJtyM1Tv5Xy5rvlbYe8d7Puu/H338jSZS/l9GM/We/60DFlOeyAE/Ol992x9tro7x+XJ+fPyO1fXrr22rW/vTzX3fP5XDlqevbrdHCS5NG59+eTPxicD5z4tZx+3Cc3+JmLXqnO+7/eO7uV757vf/wv2aVp/dA5c869+dQPh2bwgHfn02f/PNWL5uXcseuecFyf6z79dCrbdsk5X+mS5xc/s8n9nzzjp3nbIe/NFb94b+55+Geb3D904Hk5/4Qv5cKv98nuu3XK9y5+OE2bNFtn3zdv/EDueuiH+eL5t+fwXie9odm3hv/8rE4+4iP56DuvXHv9nK90SYtmrfLDTz629tp/vucbL38xu5a/fjL07unXZPwvz89nz70hx/Q7bb2f+ccnbs/nfnpy3n7Yhfn4aVevM8PKVSvy4W8PzIsvPZsfjn4sP/3N/73hn23VWdesnWFT9mzTOddfOm+Lfj/u/NPV+dZNF2XEkM/mvW/7wjr7vjrp3Nw78/qMff/dOXi/t6asrCznDr08n//ZO/POoy5O970HrN27sbXNMefJOWm87q8SAAAAAFBADTZ0VVVVZeLEiXn22WfTu3fv7L///lm+fHmeeuqpDBs2LF26dMndd9/9ht7PddJJJ6W8vDwzZszY4tBVFK/U/iuty9utc/2auz+b1WtW5fADhpdgqjfngb/ekH++MDuXjpj0hu/5SdXfU5ayetdunvqt7Nmmy2aFrtdWLssND3wtbzvk/FS0bPOG79ta2rauzMhTvpOxE0fkp7/+TD548jfWrtUufyVf/+X70qaiMh855TtJkl1b7Z5Lzrpug5/392f/nFunfSd7t++R3VrtkST50MnfyrLXlq53/5Jli3LV7aPTuFGT9Ow4MEly0uEX5aAeQ9a7vy51+emvL82LL89Pn65HZffdOubD7/h2vjb5vfnZbz+X97/9q/X2T//73bnroR/mbYecv10j1/YyqNfwvPXg9+auh36Yo/qcmkP2P6He+rW/vSzzqh9L1Zk/y+67ddysn22S9Ot2zEb/ft/z8M8yc87v0qfL6/u35PfjxMM/kKmzbsovpozNkb1PSY+OB63d/+CsW3LvzOtz4uEX5eD93rr2+hG9T86ebbpk4pQv53Pn3lDva2xsDQAAAADY+TTY0NWxY8dMnTo1Y8aMyQMPPJB58+alV69eueqqq3LhhRdm3333TZI3FLr+478fcdhQ/fzeL2X2M39K/+6Ds8du+2T5a0vz57/dlUfm3pf99zkspxz10VKPuNlu/+P30q1Dv+y71xv/e92syS5b5WtP+cvELF32UoYOfM9W+bwtcfyBZ2fqX2/KLQ9+O0f1PXVt5Pjery7OCy/9M1963x1p3bJtkqRFs/IMGXjOej9n8ZLn8+NffyotdmmVy8+7Jc2bvf6+tyP7nLLe/WvWrMmlPx6W1WtWZfTpP07XDn2TJL26DEqvLoPWe8/193wxL748P2875Py8/bD3J0neevB5mfbYLbnhgfE5ovcp6fXvU4W1y17ON294f/bYbZ986ORvbdHP5pyvdEm/bsel6qxrtuj+7eHD7/h2HnlqSr5x4/vzw9GPpVWL3ZIkf/vnn/PLB76WI3ufkqEHv/77tbk/2w7tuqVDu27r3f/o3Pvz6Nz706WyTy4+7aokW/b7kSSfOP1H+cDX++aKyeetPZn30tIX8+2bP5jKtl1z0Unj1/m8txx0Tn5x39gseqU6bVtXvuE1AAAAAGDnUvqXRm1DBxxwQO64444sWbIkS5YsyUMPPZQPfOADqa2tzbx589KoUaP06dNnk59z2223pba2Noceeuh2mLq0+nc7Li2bt849M36W79/2sVz728vyyquLcv4JX87XP3j/Oo++25QVq17LxHu/kveP7523f7p5TvnsbvnsT4bnqef+snbPiy/Nz6mXtcuF4/vktZX135szduKIvLWqUWY++bu114aOKcsVv3hvZj75u3z0O4fnpEtb5ozPV+a7v7p4nZNFi16pzmNPP5hD93/7Zs19zle6ZPT3j6v3NZ9f/Ez++o8HMnRM2dq/qhfN2+jn/P7RG9K2ojLd9z5wo/u2tVHv+n4qWrbN1355fpaveDV/fOL2/HbGNXnbIefnsANO3OT9q1avzBeuOy01Lz+XT57x03Sp7L3Je37860/n4Sd/m3ccOXJtiNmYh2bflevuuTw9Ox6cUe/8Xr21j512dSpatMnXJp+39nfke7d9LDWvPJdPnvnTlDdvvcnPL6ry5q0z+oyf5F+vLMiVt74emlesXJ6vTX5vWrdouzZCbczGfrbr88Lif+ZL152xNlq1aLbxx65u6vdjj9065YPDv5F51Y/l2nsuT5JMuPlDebn2xXzyjJ+kxS6t1vnMQ/YfllWrV2ba47du1hoAAAAAsHNpsCe6Nubxxx9PXV1devbsmZYtW9ZbO+ecc9KtW7ccdNBBadWqVf74xz/miiuuyIABA3LWWWeVaOLt54g+78gRfd6xVT5r1eqVufRHJ+SJeX/IWwaem3ccMTK1y1/OXQ/9MB/77pH5+od+n/06HZzdd+uYT57x01x2zTvy/V99LB/79z+4/82ff5Ipf5mYswZ/Kgf1rP84tqeem5mps27M2w+7MEMHviePzL0vtz44IfOqH8u4C+9Jo0avN9y//uOBJMl+nd5cpLzkrOvyg9s/ntbl7XP28Z9Ze33XVrtv8J7Va1bn8WemZcC+x7+pr701tGm1Rz76zu/lS9efkQk3fygPP/nb7L5rx3xo+Dff0P3f+9XH8tjTD+bMwZesfZ/Uxjzw6A355f1XpE/Xo/LB4d/Y5P75L87JVyeNSOuW7XLZeTenWdPm68w/6tTv54vXnZ4f3fWpHNzzrfntjGvyjiNH5sDupf/5bmsH9XhLhg/6cG77w3dzVJ9T88Qzf8g/X5idz517Y9r8+xGBG7Kpn+3/WrFyeS6/9tS88uq/8oXzb8/e7btvcr438vtxwqHvy9RZN+WX91+RVatWZOqsm3LKkR9N/32PW+/+HnsflKZNdslf596f4YM++IbXAAAAAICdy04ZumbNmpVk/Y8t7N27dyZOnJhvfetbWbZsWTp27JgLL7wwl112WZo1a7a9Ry20X027Mo/OvT9fef9vcsh+b1t7ffgRH86FX++Tq+/4ZL7+ofuTvP7enVOO/GhunfadHNRzaLpU9sl3b/1oDtjn8Lz3bV9c57Ofrp6Vy8+7Ze1j804+4sP57q8uzq0PTsgDf/1lBg94PUo+8/wTSZK92u37pr6XIQPPyTV3/1/atNpzg49u+18vvPTPLHtt6Zv+2lvLsf1Pz9RZZ+Seh69Nkox9/90pb7HrJu/7zfSf5vY/fi8H9Ria80/48ib3P71wVsb/8vy0a71XPnvODWnSuOlG9y97bWku/9kpefW1JRl34T3ZY7dO6913TL/TcvyBZ+dX076Te2den73b98j73z5uk/M0FBeeeEVmPHl3vnHDBald/nLecuCIHN3vXRu9543+bP/bt266KHPmP5zz3vqFHHbApk9Cbs7vx8dP+2E+8PU+ufH3X89e7bvngv9559p/a9qkWXbftWPmPf/4Zq0BAAAAADuXBv3owg3ZWOj69Kc/nVmzZuWVV17JypUr8/TTT+cb3/hGdt1100GA+u6deX067bF/enYcmJdra9b+tWr1igzsMTSPzXuw3qMKLzzpa+m+94H55o0X5ovXnpbGjZvm0hGT0rjxuj220+77rfNuqLMGfypJMu2xW9Zee7n2xSRJxb/fQbU9vby0dF97Q3Yt3/3f/9k+vTqv/11O/+3vz07PhJs/lMo2XfKZEZPSuFHjje5f8uriXP6zd2b16pX53Lk3vqH3J31t8nvzzPNP5MK3X5EB3QdvdO/IU67MbuV7ZMmri1J15s/qvQdqU2qXvVzv9/Dl2pqsqVuTlatfW+f68hWvvuHP3V6aN2uZS868NkuWLc6u5bvnI6d8Z5P3bM7PNklueXBC7nn42gzqdXJGDPm/Te7f3N+P5s1aZpd//z07cN/jN/n3r3XLdnlp6QubvQYAAAAA7Dyc6GKb+ecLs/PaymU57fINP97v5dqatadMmjXZJZeePSnv/3rvzHv+8Xz67J+nsm2X9d63zx4HrHOtXesOadVityz81z/+62pZkqQudfX2rly1IkteXVTvWotdWq33XUFbqqzs31+7rm4TO7ePvzw1Jbf/8XvZd68BmbvgkVx9xyfXPiZyfRYvfSGf/9mpaVTWKJedd3Nal7fb6OevWbMmYyeenQX/mpuLT/1BenXZdEibeO9XMnXWTTluwFk57dhPbHJ/Rcs26bTH/lm89Pk39Pn/7XPXvGPtoyz/2/2P/CL3P/KLetfOHXpZ3vPWyzfr87eH/3zPnfbYPxUt22x07+b+bP/6j9/nqttHp+PuPXPJu69b+/u7IZv7+5Ek3/vVxal5+bl069A/v/7zjzJk4HvSp+uRG9xfl7qUZf1zbGwNAAAAANh57JSha8qUKaUeYadQV1eXrpV9N/qOpt3K60ewh2bfmTVrVidJnnruLzn+wLPf1Ay7/fsdWkteXVTvsW1PPPOHfPIH9U+4bO248Z/TU0uWLdrEzm3v1eVL8vVfvi9tWu2ZKy66N9+7dVTufOjqHNPv9HXef5Ykq1evyhevOz0vvjw/l5x1XbrvfeAmv8ZP7/6/TP/7b3LCoRfkpEEXbXL/9L/9Jj+7+7Pp1qFfRp/+4y36vjbHRcO/nqWvLq537auTzkm3vfrnjGPH1LveoV23bT7PtrS5P9sXX5qfL153enZp2iKXn3drypu33uj+Lfn9+MPjt+Weh6/N2w+7MO992xfz/vG98/Ub3pcffPyR7NK0xXrvWfLqog2+B29jawAAAADAzmOnDF1sH3u375GXa1/MgO7Hp1GjTT8l88n5D+cnv/50DuoxNLuWt8+Nv/96DuoxNAfv99Z19v7zhdnrXPvXKwuzdNlL9SJFl8o+SZLnauZk373+/wm+bh36Z9yF99S7f1NxY3NPj+y+W6e0bN46z9XM2az7toUf3P6JPL/4mXz+vb9K65Zt8+FTJuQvT92bb9z4/lz9iVlp2bxinf2z/vH7nHLUqDf0TrKps27O5Pu+mv06HZKPvvO7m9y/oGZuxk48O+XNd81l77l5sx5BuKV6dhy4zrVmTZunbUWH9ca+otrcn+2KVa/l89eempeWvpDPveemdN5z3dOS/2tzfz9eqf1XvnXjB7Jnm8656KSvp2XzinzklO9k7MSz89NffyYfPHndGL5i1Wt58aVnc2TfUzdrDQAAAADYueyU7+hi+xg68D1ZtKQ6N/1+/Se6Fi95fu1/X/ba0nz552elVYs2+dS7r8vF7/pBKtt0zRW/eE8Wr+c9PM+++PdMe+zWetcm3zcuSXJE71PWXuvX7dgkyexn/lRvb0XLNjmo55B6f20qdDXfpdU6jzvcmMaNGqdv16Pzt38+9Ibv2Ram/+03rz8m7qBzc0Tvk5MkrVu2zcWn/iDPL34mV9/xyXr773n4utw67Tvp2/XofPCkr2/y8595/ol8bfJ52bVl+1z2npvTrMkuG92/bEVtLv/ZO1O7/OV86uyfZ6/2+275N0c9W/Kz/c7NH87fn52eswZ/Kke/gXC0ub8fSfKdWz6Sl2pfyCdO//HaqHr8ge/Okb1PyS0PfjuPPT1tnXueeu4vWbl6xdr/Db/RNQAAAABg5+JEF9vMO4++OA/PuSdX3zkmf5k7JQfue3xaNm+dF176Z/4y5940a9o84z94X5Lk2zd/KAv/NTdfueA3aVOxZ5Lk0hGT8vHvHZWv/eK8fPmCu+q9M6hrZd98ddI5efthF2bv9j3yyNz7MvWvN6Zft2NzXP8z1+7brdXu6b/vcfnz3+7KRcPHv6nv54B9Ds9vpv841/zms9lnzwNSVtYoh/canhbNyjd4zzH9Ts9Ds+/M3/755+y/z6Fv6utviaXLXso3bnx/2rXeKx85ZUK9tSP6vCNvOXBEvUcYPr1wVr514wfSqKxRBvV+R+77n3dX/bfeXY5Im4rKXHbNKVn22tIMHvDuPDr3/g3u36vdvunVZVC+feNFebp6Vvp0PSqv1P4rv3v4+vXub7FLqxzZ55Qt+bZ3Wpv7s73roR/lN9N/kt1a7ZF99jhgg/uT5Mi+70z1v/6xWb8fHdp1ywOP3pD7H52c4YM+lIN6vKXenovf9YPMenrqeh9h+Oe/3ZUmjZvmyP8K129kDQAAAADYuQhdbDNNGjfNl993Z2774/fyu4evy7W/vSxJ0nbXvbJ/p0MzdOB5SZJ7Zlybe2denzOOq6r3mML99zk055/w5fzwzqrc+Ptv5PRjR69d6773Qfng8G/kp7/5TO744w/SsnnrvOPIkXnfCV9Z5zGJwwd9KF+6/sw8Of/h9T6+7o06f9iXs+TVRbntD9/N0uUvpa6uLtd9+um0aLvh0HVc/zPzg9s/kd/NvK4koeu7t45KzcvP5UvvuzOtWuy2zvr/PsLwyfkPZ8Wq5Umyzkmv//XJM36a/vset/bRjHc99MPc9dAPN7h/6MDz0qvLoDw278EkyWNPP5jHnn5wg/v3bNNZ6NpMm/uz/c+el5a+kCsmn7fRz76u69Ob/fvRfJdW+c4tH05l26658MQr1tnTpmLPDT7C8N6Z12dQ73ekbevKde7b2BoAAAAAsHMpq6urqyv1EA1VbW1tWrVqlSRZunRpyss3HES2l9UrkvsmbHrfjmzomLIMHXheqs665g3tX71mdT74jf7Zd68B+dTZGz6xsq38YspXM+m+sbnu00+ndcu22/3rQ9H84bFf5fPXnprvXvxwuu894A2vvVGDRyWNm735OQEAAACA0vOOLhq8xo0a5wMnjc99j0zKM8/P3u5f/9SjP5aKFm1ywwNv7tGJsDOoq6vLtfdcniED37NOyNrYGgAAAACwc/LoQnYKh+x/Qu6+YnVJvnazps1z/aXzSvK1oWjKysryg4//ZbPXAAAAAICdkxNdAAAAAAAAFJITXRTOPV/zWjkAAAAAAMCJLgAAAAAAAApK6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJAafOiqqalJVVVVunfvnubNm6dTp065+OKLU1tbmwsuuCBlZWW58sorSz0mAAAAAAAAm6lJqQfYlh555JEMGzYs1dXVKS8vT69evbJgwYJMmDAhc+fOzaJFi5IkAwYMKO2gO6BXXl2USfd+JX94/Na8+PL8tNylIl0q++S8t34hfbsdXerxAAAAAAAAGm7oqqmpyfDhw1NdXZ3Ro0fnsssuS0VFRZLkiiuuyCWXXJImTZqkrKws/fr1K/G0O5bnFz+TT37/uCxbsTQnHHpBOrbvmdrlL+cfC/+amleeK/V4AAAAAAAASRpw6Bo1alTmz5+fkSNHZvz48fXWqqqqMnHixDz66KPp2rVrWrduXaIpd0xfnXROVq9Zlas+8de0a92h1OMAAAAAAACsV4N8R9fs2bMzefLktG/fPmPHjl3vnoEDByZJ+vfvv87aLbfckiOOOCLl5eXZddddc+SRR+bxxx/fpjPvKP76j9/nsacfzBnHVaVd6w5ZtXpllq94tdRjAQAAAAAArKNBnuiaNGlS1qxZkxEjRqRVq1br3dOiRYsk64auCRMmZPTo0fn4xz+eL37xi3nttdfy0EMPZdmyZdt87h3Bn/92V5Jkj932yWd/Mjx//vuvs2bN6uzdvkfOGfK5DBl4ToknBAAAAAAAeF2DDF1TpkxJkgwePHiDe+bPn5+kfuiaO3duxowZk29+85sZOXLk2utvf/vbt9GkO575L/w9SfLNGy/MXu17pOrMn2Xl6hW56YGvZ9wvzs2qNStzwiHnl3hKAAAAAACABhq6nnnmmSRJ586d17u+atWqTJs2LUn90PWTn/wkTZs2zYUXXrjVZ+rRo0caNSr9kyKbNWmRq0fO2eD6q68tSZK02KUi4z94X5o2aZYkObL3KXnPV7vlp7++NG8deN4O8b0AbIkePXtkxaqd45QuAAAAABRBZWVlZsyYsUX3NsjQVVtbmyQbfNzg5MmTU1NTk4qKinTt2nXt9T/84Q/Zb7/9cv311+dLX/pSnn322fTo0SOf+9zn8u53v/tNzbRw4cI3df/W0rxpy42u79L09Uc6Dj7w3WsjV5JUtGyTQb1Ozj0PX5tnX/x7Ou95wDadE2BbWbhgQZav9O5BAAAAAGgIGmToqqyszOLFizNz5swMGjSo3trChQszZsyYJEm/fv1SVlZWb+25557Lpz/96YwbNy6dOnXKj3/845x99tnZfffdM2TIkC2eqUOHDjvEKahmTVpsdL39rh2TJG0qKtdZa9u6Q5Jk6bLFW38wgO2kw157OdEFAAAAADuQysp1m8Qb1SBD15AhQzJ79uyMGzcuQ4cOTc+ePZMk06dPz7nnnpuampokyYABA+rdt2bNmixdujTXXXddTjnllCTJW97yljzxxBP54he/+KZC15w5c1JeXr7F928tq1ck903Y8Pp++xyaO/70g9S8PH+dtZqXXr+2W6s9ttV4ANvcnCfnpHGzTe8DAAAAAHZ8pT9itA1UVVWlXbt2efbZZ9O7d+/07ds3PXr0yKGHHppu3brl+OOPT1L//VxJ0rZt2ySpF7TKysoyZMiQPPbYY9vvGyihI3ufkpa7VOTemddn2WtL117/1ysLM+3xW9Nx957Zu333Ek4IAAAAAADwugYZujp27JipU6fmxBNPTPPmzTNv3ry0bds2V111Ve688848+eSTSdYNXb17997gZy5fvnybzryjqGjZJh84aXxqXn4uo75zeG584Bv5xZSvZtR3Ds+q1SvykXd8p9QjAgAAAAAAJEnK6urq6ko9xPa0dOnStG7dOmVlZVmyZElatmy5du22227LO97xjtx000059dRTk7z+OMMBAwakbdu2uf/++zfra9XW1qZVq1Zrv24RHl34H1Nn3Zxf3n9F5i2clbJGjXLAPoNy7tDL0qfrkdt+SIBtaPCoeHQhAAAAADQQDfIdXRvz+OOPp66uLj179qwXuZJk+PDhOfroo/OBD3wg//rXv7LPPvvkRz/6UR5//PHcc889JZq4NI7ue2qO7ntqqccAAAAAAADYoJ0udM2aNSvJuo8tTF5/H9dtt92WSy65JJdeemleeeWV9O/fP3fdddfa93oBAAAAAACwYxC6/sduu+2Wq666KlddddX2HAsAAAAAAIDN1KjUA2xvmwpdAAAAAAAAFMNOd6JrypQppR4BAAAAAACArWCnO9EFAAAAAABAwyB0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAD8v/buPkyrgsD7+O9mhmGYYbCEakQJVCBFhCnNl9IWEl1ZsdTMXFk3W2tzlcAnHrC1euxFJVw2jcyNetrVDIjUpJR9tBRXCVsXUgyJVmSFJAZtFlSYQByY5w+72J3lJUVm7jnj53NdXF6c+5yb3/AnX885AAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAU0hsidDU1NWXKlCkZNGhQqqur079//0ycODHNzc25+OKLUyqVcuONN5Z7Zqfw3Z98IadOLu3x1+lXdC/3RAAAAAAAgCRJZbkHtLelS5dmzJgxWb9+fWprazN06NCsW7cuM2bMyKpVq7Jhw4YkSUNDQ3mHdhInDTsn/foM2uX4042/zA8e/LucMPTMMqwCAAAAAADYVZcOXU1NTTnzzDOzfv36TJo0KVdddVXq6uqSJNddd12uuOKKVFZWplQqZfjw4WVe2zkc1m94Duu369/FDbd/Mkky5riLO3oSAAAAAADAbnXpRxdOmDAha9euzfjx4zN9+vSdkStJpkyZkhEjRqSlpSUDBw5M7969y7i0c9uyrTkPPP79vOWAQ3LsO04v9xwAAAAAAIAkXTh0rVixInPnzk3fvn0zderU3Z5zzDHHJElGjBix89jIkSNTKpV2++uSSy7pkO2dzUOP35bfb30xpx17USq6VZR7DgAAAAAAQJIu/OjCOXPmZMeOHRk3blx69eq123N69uyZpG3ouummm/Liiy+2OW/+/Pm5+uqrM3bs2PYb3Inds/g7KZVK+dPj/qrcUwAAAAAAAHbqsqFrwYIFSZJRo0bt8Zy1a9cmaRu6hg4dust511xzTd7ylrfk9NPfeI/te+a5f88TT/8s7xx0Sg468NByzwEAAAAAANipy4auNWvWJEkGDBiw289bWlqyaNGiJG1D1//0u9/9Lvfcc08uvfTSVFbu+1/X4MGD061b+Z8UWVXZM98av/JVn3/Pv30nSTLm+I+31ySADjV4yOBsa9lS7hkAAAAAwB/U19dnyZIl+3Rtlw1dzc3NSZItW3b/j5lz585NU1NT6urqcuihe75Tac6cOWlpacmFF174uvY0Nja+ruv3l+ruNa/63O3bW/LTX3w3vWv65L3Dzm7HVQAdp3Hdumx9+fflngEAAAAA7AddNnTV19dn48aNefTRR3PiiSe2+ayxsTGTJ09OkgwfPjylUmmP33PrrbfmyCOPzLHHHvu69hx00EGd5o6uV+vnv7orGzc/m7NPmpiqyh7tuIoi+u5PvpDzR30mVd2rc933L8qggxtyzsmXv6bvWPTEvLy5rj5DB5zwR8+9d/HNuenHE3Nw38G5aeIrZX/2/dfmp7+4Jb9tWpmr/vKHee+ws3aeP3X2uDy28v6MbDg/l37whte0i67toH793NEFAAAAAJ1IfX39Pl/bZUPX6NGjs2LFikybNi2nnnpqhgwZkiRZvHhxLrzwwjQ1NSVJGhoa9vgdv/71r7NkyZJce+21r3vPypUrU1tb+7q/5/Xavi15YMarO/eexX94bOFxF7fjIorq1p9+MeecfHmqulfv83csemJeBh3c8KpCV5I0HD4qX7xo3s7fv2vw6IxqOD/Tf/BXu5z7txfMynd/8oVs3vL8Pu+ja1r55MpUVJV7BQAAAACwP3TZ0DVlypTMnj07zzzzTI466qgcccQR2bp1a5566qmMGTMmAwcOzL333rvX93PdeuutKZVKGTduXAcu7xyaXliXxf9+T47of1wOPejocs+hk7nhjkuSJP/rppPTrVSRPgf0y2+eXZHJM0/J755/JgPrh+Wz476f7pVVadn+cm6+9/NZ+tSCvNyyLYe8ZUgu/9DM/GrNz/Ovv/pxHl3509y7+OZ88L3jc8KRY3Pt7D/P77e+mG0tWzPi8FG57IMz9ng35BFvP64jf2wAAAAAADqZ8j9Lr50ccsghWbhwYc4444xUV1dn9erVOfDAAzNz5szMnz8/Tz75ZJLsMXS1trZm1qxZGTlyZN7+9rd35PRO4SdLbs6OHdsz5viPl3sKndDlH/pmkuT6Sxdm5qeX5k21b82qdUvz5Y/dle9MXpGNm57NwmV3JEl+8C9/l+rutblxwr9l5qeX5tD6o/NP93wuxx/5Zzlh6Ady3sjJmfnppfmz4z+eXj3flC9/7K7cdPkvMvPTv8yzG1fnwV/+oJw/KgAAAAAAnViXvaMrSY488sjcfffduxzfvHlzVq9enW7dumXYsGG7vfahhx7KmjVrctVVV7X3zE7pglOuzAWnXFnuGRTIe4edneqqmiSv3GnV+J+rkiQPL5+X5q0v7AxfLdu35W0HDtztd+xo3ZFvz78iy1f/LK2trXl+83MZWD8soxrO75CfAQAAAACAYunSoWtPli9fntbW1gwZMiQ1NTW7PefWW29Nz549c+6553bwOiim//6urm6limzf0ZLklbsjL/vg13PsO077o99xx0NfzfPNz+Xrn3okVd2r880ffzrbXt7abpsBAAAAACi2Lvvowr1ZtmxZkj0/tnDr1q25/fbbc9ZZZ6Wurq4jp0Fh1PSoS/PWF/7oee8ZdlZ+uPD6bN32+yTJ1m2/z+r1y5MktdW907zlv75j05aNObCuPlXdq7PhxfV56Je3tc94AAAAAAC6hDfkHV1/LHRVV1fn+eef78BFUDznvm9SrvjWqenRvSZ9Dui3x/POH3lFbm15KZ/6+vEppZQk+cioKzKw/qiMPubC/N3ci7Jo+bx84D2X5ZyTJuZLt56bj08/Kn1698s7B4/e64ZZ912du//1m3lh8+/y1fVP5MZ54/MPlz+WN/V6y379WQEAAAAA6JxKra2treUe0dHe//7354EHHsjdd9+dM844o93+nObm5vTq1SvJK+8Fq62tbbc/69Xavi15YEa5V8Brd+/im/Pw8nn54kXzXvU13/3JF7J5y/O59IM3tNsuimfUhKSiqtwrAAAAAID94Q356MIFCxaktbW1XSMXsH/16N4zq9YtzaVfO/ZVnT919rjc/+j3UlPdu52XAQAAAABQLm/IO7o6iju6ADofd3QBAAAAQNfxhryjCwAAAAAAgOITugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACikLh+6mpqaMmXKlAwaNCjV1dXp379/Jk6cmObm5lx88cUplUq58cYbyz0TAAAAAACA16iy3APa09KlSzNmzJisX78+tbW1GTp0aNatW5cZM2Zk1apV2bBhQ5KkoaGhvEM7mS0vbc6dP5uRB5bOybMbV6d7RY8c8pYh+bPj/zqnHfvRlEqlck8EAAAAAADound0NTU15cwzz8z69eszadKkNDY25tFHH8369eszbdq0zJ8/P4sXL06pVMrw4cPLPbfT2LFjR678zpjccu/n847+784nx/59xo3+XHbs2J7pP/hY/u8/f6bcEwEAAAAAAJJ04dA1YcKErF27NuPHj8/06dNTV1e387MpU6ZkxIgRaWlpycCBA9O7d+8yLu1cfv2bR/LE0z/LWSdNyP8+7x9zxgl/nXNOvjxfvXRh6g88NPP/dWa5JwIAAAAAACTpoqFrxYoVmTt3bvr27ZupU6fu9pxjjjkmSTJixIg2xxcuXJhTTjklffv2zZve9KaccMIJ+eEPf9jumzuL5pdeTJL06d2vzfHulVU5oLZvqqtqyzELAAAAAABgF10ydM2ZMyc7duzIuHHj0qtXr92e07NnzyRtQ9fjjz+eU089NRUVFbn55pszd+7c9O/fP+eee27uvvvuDtlebkf0Py69er4pP/iX6/Lg47fluY2/yW+e+3W+889/m5Vrf5G/PO0L5Z4IAAAAAACQJKks94D2sGDBgiTJqFGj9njO2rVrk7QNXXPnzk2pVMq8efNSU1OTJBk9enQOO+ywzJo1K2PHjm3H1Z1DXc2b86WLfpyv3v7xXP2983Yer+lRl//zl3fkvcPOKt84AAAAAACA/6ZLhq41a9YkSQYMGLDbz1taWrJo0aIkbUPXtm3bUlVVtfNurySpqKhIXV1dduzY8bo2DR48ON26lf8GuqrKnvnW+JV7Padnj14Z+LZhOXHoBzJ0wHuyacuG/Pjhb2Tq7AvyxYt+lGOGnNpBawH2v8FDBmdby5ZyzwAAAAAA/qC+vj5LlizZp2u7ZOhqbm5OkmzZsvt/yJw7d26amppSV1eXQw89dOfxCy+8MN/4xjcyadKkXHHFFamsrMzMmTOzcuXK3HTTTa9rU2Nj4+u6fn+p7l6z18+fblyWiTe+J5d84PqceeIlO4+PavjzfOLvh+X62z+RWz6zKhXdKtp7KkC7aFy3Lltf/n25ZwAAAAAA+0GXDF319fXZuHFjHn300Zx44oltPmtsbMzkyZOTJMOHD0+pVNr52YgRI3L//ffnnHPOyfXXX58kqa2tzW233Zb3ve99r2vTQQcd1Gnu6NqbOxZen20tW/Mnwz/c5nh1VU2OP/KM/GjRjXl2w+r063t4e84EaDcH9evnji4AAAAA6ETq6+v3+douGbpGjx6dFStWZNq0aTn11FMzZMiQJMnixYtz4YUXpqmpKUnS0NDQ5rqVK1fmIx/5SN797nfn0ksvTUVFRWbNmpXzzz8/d999d97//vfv86aVK1emtrZ2n6/fX7ZvSx6YsefPm1747SvntW7f9drtLa/8d0dLu2wD6Agrn1yZiqpyrwAAAAAA9ofy32LUDqZMmZI+ffrkmWeeyVFHHZWjjz46gwcPznHHHZfDDjtsZ7D67+/nSpIrr7wyNTU1ufPOOzNmzJicdtppueWWW3L88cdn0qRJ5fhROtyAtw1Nkvxk8c1tjm/e8nwe/tWPUtfzzenXd1AZlgEAAAAAALTVJUPXIYcckoULF+aMM85IdXV1Vq9enQMPPDAzZ87M/Pnz8+STTybZNXQtW7YsI0aMSGVl2xvdjj322KxYsaLD9pfTOSdfnrqaA/Od//eZfGXOhbnr59/M7Puvzd9c/85seLExF51+tfdzAQAAAAAAnUKptbW1tdwjOtLmzZvTu3fvlEqlbNq0KTU1NTs/GzlyZNatW5df/epXbWLXyJEj88wzz2TVqlWv6c9qbm5Or169dv65RXh0YZKsa1qV7933pTz21P3ZuOnZ9OjeM4f3a8jZJ1+ek48+p2OGArSTURPi0YUAAAAA0EV0yXd07c3y5cvT2tqaIUOGtIlcSXLZZZflvPPOy9lnn51PfvKTqaioyOzZs/Pggw/ma1/7WpkWd7x+fQ/PlPNvKfcMAAAAAACAvXrDha5ly5Yl2fWxhUny4Q9/OHfddVemTZuWj370o9m+fXuGDBmSWbNm5YILLujoqQAAAAAAAOyF0PU/jB07NmPHju3ISQAAAAAAAOyDbuUe0NH+WOgCAAAAAACgGN5wd3QtWLCg3BMAAAAAAADYD95wd3QBAAAAAADQNQhdAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABTSGyJ0NTU1ZcqUKRk0aFCqq6vTv3//TJw4Mc3Nzbn44otTKpVy4403lntmp7Bx07O54Y5LcsHV/TPmM1W54Jq35xs/mpjNW54v9zQAAAAAAIA2Kss9oL0tXbo0Y8aMyfr161NbW5uhQ4dm3bp1mTFjRlatWpUNGzYkSRoaGso7tBPYuPm5fOrrx+c/X1yXM074ZAa+bVhWP/tE7v75P2TZfzyUGy5blOqqmnLPBAAAAAAASNLFQ1dTU1POPPPMrF+/PpMmTcpVV12Vurq6JMl1112XK664IpWVlSmVShk+fHiZ15bfnPuvzbMb1+RvL5id97/zz3ceHzrgPZk6+4Lc8dBXM27058q4EAAAAAAA4L906UcXTpgwIWvXrs348eMzffr0nZErSaZMmZIRI0akpaUlAwcOTO/evcu4tHN4fNUD6dG9Z0Y1nN/m+MgRH0lVZXXuXfxPZVoGAAAAAACwqy4bulasWJG5c+emb9++mTp16m7POeaYY5IkI0aMaHP8vvvuywknnJDq6uq89a1vzSWXXJIXXnih3TeX28stL6WqsjqlUqnN8W7duqVH955p3PAfeaG5qUzrAAAAAAAA2uqyoWvOnDnZsWNHxo0bl169eu32nJ49eyZpG7oefPDBnH766Tn44INz55135pprrsntt9+es846K62trR2yvVwGvO2obNqyMU/9dmmb40/9dmk2bdmYJHlu42/KsAwAAAAAAGBXXfYdXQsWLEiSjBo1ao/nrF27Nknb0PWlL30pgwcPzm233ZZu3V7pgH369MmHPvShzJ8/P2PHjt2nPYMHD975feVUVdkz3xq/crefnXPy5Xl4+bxc/b3z8jcfuCGH1g/L6meX5x9+fHkqK7qnZfvLeenl33fwYoD9a/CQwdnWsqXcMwAAAACAP6ivr8+SJUv26douG7rWrFmTJBkwYMBuP29pacmiRYuStA1djzzySD72sY+1iVKnnXZakmTevHn7HLoaGxv36br9rbp7zR4/O/qwk3PluO/nph9NyOf+8YwkSbduFRlz3Mcz4G1HZdETd6amh3eZAcXWuG5dtor2AAAAANAldNnQ1dzcnCTZsmX3/9f+3Llz09TUlLq6uhx66KE7j1dUVKSqqqrNud27d0+pVMry5ctf04aampps3rw5J510Up577rld3n1VDlWVPff6+Z+M+HBOOvqcPN24LFte2pRD3vqOvLnXWzN+xnGp6FaZfn0HddBSgPZxUL9+7ugCAAAAgE6kvr5+n6/tsqGrvr4+GzduzKOPPpoTTzyxzWeNjY2ZPHlykmT48OFtAtSQIUPyyCOPtDl/8eLFaW1tzYYNG17ThlKplNra2jz22GP7+FPsf9u3JQ/M2Ps5Fd0qMujghp2/3/Di+jz128cy/LA/SXXVnu8IAyiClU+uTEXVHz8PAAAAAOj8yv/SqHYyevToJMm0adPy5JNP7jy+ePHijBo1Kk1NTUmShoaGNtdNmDAhixYtytVXX52mpqYsXbo0l156aSoqKjrFO7Y62o4dO/KNH03IjtbtueCUz5Z7DgAAAAAAwE5d9o6uKVOmZPbs2XnmmWdy1FFH5YgjjsjWrVvz1FNPZcyYMRk4cGDuvffeNu/nSpK/+Iu/yPLly/PlL385n//851NRUZHLLrssVVVV6d27a7+fastLmzN+xnF577CzU3/goWne+kIeWDonK9f+Ih87/Zo0DBpV7okAAAAAAAA7ddnQdcghh2ThwoWZPHlyHnzwwaxevTpDhw7NzJkz84lPfCKHH354kuwSukqlUr7yla/ks5/9bJ5++ukcfPDBOeCAA9KnT5986lOfKseP0mEqK6pyWL8ReeCx2fnPTY2p7l6TIf3fnWs/fk/e/Y4/Lfc8AAAAAACANkqtra2t5R7R0TZv3pzevXunVCpl06ZNqanZ+3unvv3tb+eyyy7LihUrdgayono17+gC6MpGTYh3dAEAAABAF9Fl7+jam+XLl6e1tTVDhgzZJXItWbIkP/3pT/Oud70rLS0tue+++zJjxoxMnz698JELAAAAAACgK3lDhq5ly5Yl2fWxhUnSo0eP3HXXXZk6dWpaWlpy9NFHZ+7cuTn33HM7eiYAAAAAAAB7IXT9D0cffXQefvjhjp4EAAAAAADAa9St3APKYW+hCwAAAAAAgGJ4Q97RtWDBgnJPAAAAAAAA4HV6Q97RBQAAAAAAQPEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUUqm1tbW13CPoOK2tyY6Xy70CoHy6dU9KpXKvAAAAAAD2B6ELAAAAAACAQvLoQgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAArp/wPU+npU7/X5wgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, - "execution_count": 15, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -571,27 +745,27 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[4.59221157 2.42849133]\n", + "[4.2960303 2.69863461]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -1.0765906858023189\n", - " x: [ 6.400e+00 3.193e+00]\n", - " nfev: 40\n", + " fun: -3.017671843360538\n", + " x: [ 4.822e+00 3.053e+00]\n", + " nfev: 38\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 40 F =-1.076591E+00 MAXCV = 0.000000E+00\n", - " X = 6.400254E+00 3.192785E+00\n", + " NFVALS = 38 F =-3.017672E+00 MAXCV = 0.000000E+00\n", + " X = 4.822121E+00 3.053208E+00\n", "\n", - "Found ground energy: -7.87851907631001, exact energy: -7.882245207471211, difference: 0.0037261311612013515\n" + "Found ground energy: -3.017671843360538, exact energy: -7.972497290048691, difference: 4.954825446688153\n" ] } ], @@ -604,8 +778,8 @@ "print(res)\n", "\n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun') + H_shift\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_eigval + H_shift}, difference: {ground_energy - exact_eigval - H_shift}\")" + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" ] }, { @@ -618,7 +792,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -626,144 +800,120 @@ "output_type": "stream", "text": [ "Iter: 0\n", - "Maximum gradient: 0.24763743394926327\n", + "Maximum gradient: 0.2496163591110339\n", "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0747029530371732\n", - " Iterations: 7\n", - " Function evaluations: 20\n", - " Gradient evaluations: 7\n", - "Result at iter 0: -7.876631343544864\n", + " Current function value: -3.0131302594375997\n", + " Iterations: 3\n", + " Function evaluations: 7\n", + " Gradient evaluations: 3\n", + "Result at iter 0: -3.0131302594375997\n", "Iter: 1\n", - "Maximum gradient: 0.07359237164321655\n", - "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 20\n", + "Maximum gradient: 0.10244138083491211\n", + "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0765906918345165\n", - " Iterations: 7\n", - " Function evaluations: 23\n", - " Gradient evaluations: 7\n", - "Result at iter 1: -7.8785190823422075\n", + " Current function value: -3.017671847064684\n", + " Iterations: 8\n", + " Function evaluations: 26\n", + " Gradient evaluations: 8\n", + "Result at iter 1: -3.017671847064684\n", "Iter: 2\n", - "Maximum gradient: 0.07076349647954457\n", - "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Maximum gradient: 0.05905724077183245\n", + "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.078339311436093\n", - " Iterations: 7\n", - " Function evaluations: 31\n", - " Gradient evaluations: 7\n", - "Result at iter 2: -7.880267701943785\n", + " Current function value: -3.019514279322607\n", + " Iterations: 8\n", + " Function evaluations: 37\n", + " Gradient evaluations: 8\n", + "Result at iter 2: -3.019514279322607\n", "Iter: 3\n", - "Maximum gradient: 0.03947110664487546\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Maximum gradient: 0.013853880090120743\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0789274736235184\n", - " Iterations: 7\n", - " Function evaluations: 38\n", - " Gradient evaluations: 7\n", - "Result at iter 3: -7.88085586413121\n", + " Current function value: -3.0277777096442287\n", + " Iterations: 23\n", + " Function evaluations: 121\n", + " Gradient evaluations: 23\n", + "Result at iter 3: -3.0277777096442287\n", "Iter: 4\n", - "Maximum gradient: 0.036190296161991674\n", - "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + "Maximum gradient: 0.07811936381248823\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 13\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.079418118300944\n", - " Iterations: 17\n", - " Function evaluations: 112\n", - " Gradient evaluations: 17\n", - "Result at iter 4: -7.881346508808635\n", + " Current function value: -3.0204748733330344\n", + " Iterations: 10\n", + " Function evaluations: 60\n", + " Gradient evaluations: 10\n", + "Result at iter 4: -3.0204748733330344\n", "Iter: 5\n", - "Maximum gradient: 0.03550343358388081\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0798898658755127\n", - " Iterations: 21\n", - " Function evaluations: 157\n", - " Gradient evaluations: 21\n", - "Result at iter 5: -7.8818182563832035\n", - "Iter: 6\n", - "Maximum gradient: 0.010958756062794632\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Maximum gradient: 0.014568885631272867\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -0.9525598305624912\n", + " Current function value: -3.028806372184411\n", " Iterations: 19\n", - " Function evaluations: 157\n", + " Function evaluations: 136\n", " Gradient evaluations: 19\n", - "Result at iter 6: -7.754488221070183\n", - "Iter: 7\n", - "Maximum gradient: 0.027784171922399386\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Result at iter 5: -3.028806372184411\n", + "Iter: 6\n", + "Maximum gradient: 0.07884802902698873\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0754404939598767\n", - " Iterations: 12\n", - " Function evaluations: 113\n", - " Gradient evaluations: 12\n", - "Result at iter 7: -7.877368884467568\n", - "Iter: 8\n", - "Maximum gradient: 0.06939572286077894\n", + " Current function value: -3.0320150552720655\n", + " Iterations: 17\n", + " Function evaluations: 144\n", + " Gradient evaluations: 17\n", + "Result at iter 6: -3.0320150552720655\n", + "Iter: 7\n", + "Maximum gradient: 0.011936842881169323\n", "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0798917778382773\n", - " Iterations: 34\n", - " Function evaluations: 342\n", - " Gradient evaluations: 34\n", - "Result at iter 8: -7.8818201683459685\n", - "Iter: 9\n", - "Maximum gradient: 0.010874722715186315\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0772734048154884\n", - " Iterations: 24\n", - " Function evaluations: 268\n", - " Gradient evaluations: 24\n", - "Result at iter 9: -7.87920179532318\n", - "Iter: 10\n", - "Maximum gradient: 0.06860839917623317\n", + " Current function value: -3.0320037673838245\n", + " Iterations: 17\n", + " Function evaluations: 155\n", + " Gradient evaluations: 17\n", + "Result at iter 7: -3.0320037673838245\n", + "Iter: 8\n", + "Maximum gradient: 0.011955602856887966\n", "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0790244789965728\n", - " Iterations: 34\n", - " Function evaluations: 411\n", - " Gradient evaluations: 34\n", - "Result at iter 10: -7.880952869504264\n", - "Iter: 11\n", - "Maximum gradient: 0.04151468703828826\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " Current function value: -3.0414411695455468\n", + " Iterations: 25\n", + " Function evaluations: 254\n", + " Gradient evaluations: 25\n", + "Result at iter 8: -3.0414411695455468\n", + "Iter: 9\n", + "Maximum gradient: 0.006024521513410661\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -1.0803162853202792\n", - " Iterations: 36\n", - " Function evaluations: 471\n", - " Gradient evaluations: 36\n", - "Result at iter 11: -7.8822446758279705\n", - "Iter: 12\n", - "Maximum gradient: 0.0005266537565274415\n", - "Found ground energy: -7.8822446758279705, exact energy: -7.882245207471211, difference: 5.316432405422233e-07\n" + " Current function value: -3.0424112394114586\n", + " Iterations: 32\n", + " Function evaluations: 356\n", + " Gradient evaluations: 32\n", + "Result at iter 9: -3.0424112394114586\n", + "Terminating: reached maximum iteration.\n", + "Found ground energy: -3.0424112394114586, exact energy: -7.972497290048691, difference: 4.930086050637232\n" ] } ], "source": [ "# Define the conditions for termination\n", "gradient_threshold = 1e-3\n", - "max_iter = 15\n", + "max_iter = 10\n", "terminate = False\n", "\n", "# Initiate the problem\n", @@ -788,11 +938,11 @@ " print(f\"Operator: {max_operator} at index {max_index}\")\n", " # Grow the ansatz\n", " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", " # Run VQE on the current ansatz\n", " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun') + H_shift}\")\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", " x_opt = getattr(res, 'x')\n", " params = x_opt\n", " # Terminate if maximum number of iterations reached\n", @@ -806,8 +956,8 @@ " terminate = True\n", " \n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun') + H_shift\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_eigval + H_shift}, difference: {ground_energy - exact_eigval - H_shift}\")" + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" ] } ], From 0232f37df677f73aa620404817e1b07274bf6e1a Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Thu, 29 Feb 2024 01:22:47 +0300 Subject: [PATCH 09/17] display result --- quantum_enablement/tutorials/adapt-vqe.ipynb | 272 +++++++++++-------- 1 file changed, 162 insertions(+), 110 deletions(-) diff --git a/quantum_enablement/tutorials/adapt-vqe.ipynb b/quantum_enablement/tutorials/adapt-vqe.ipynb index 92684e9..f055f14 100644 --- a/quantum_enablement/tutorials/adapt-vqe.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe.ipynb @@ -367,14 +367,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Hartree-Fock energy: -7.95213012467435 is 0.020049621562059805 above the exact ground state.\n" + "Hartree-Fock energy: -7.95213012467435, exact_energy: -7.97217974623641, difference: 0.020049621562059805\n" ] } ], @@ -599,7 +599,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -609,16 +609,16 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -3.013130258132082\n", - " x: [ 1.745e+00]\n", - " nfev: 22\n", + " fun: -7.966906279134248\n", + " x: [ 3.024e+00]\n", + " nfev: 21\n", " maxcv: 0.0\n", "\n", - "Found ground energy: -3.013130258132082, exact energy: -7.972497290048691, difference: 4.959367031916608\n", + "Found ground energy: -7.966906279134248, exact energy: -7.97217974623641, difference: 0.005273467102162144\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 22 F =-3.013130E+00 MAXCV = 0.000000E+00\n", - " X = 1.744965E+00\n" + " NFVALS = 21 F =-7.966906E+00 MAXCV = 0.000000E+00\n", + " X = 3.023971E+00\n" ] } ], @@ -643,14 +643,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[1.74496543]\n" + "[3.02397061]\n" ] } ], @@ -670,20 +670,18 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 7.07949402e-03 0.00000000e+00 0.00000000e+00 -1.02440828e-01\n", - " 7.07949402e-03 0.00000000e+00 0.00000000e+00 -1.02440828e-01\n", - " 5.29059080e-03 0.00000000e+00 0.00000000e+00 -1.44652461e-02\n", - " 0.00000000e+00 3.85114011e-03 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 3.85114011e-03 0.00000000e+00\n", - " -1.44652461e-02 0.00000000e+00 0.00000000e+00 -9.02474613e-05]\n", - "Found maximum gradient 0.10244082836837858 at index 3\n", + "[ 0.00708742 0. 0. -0.00171104 0.00708742 0.\n", + " 0. -0.00171104 -0.01804318 0. 0. 0.07148648\n", + " 0. -0.04084344 0. 0. 0. 0.\n", + " -0.04084344 0. 0.07148648 0. 0. 0.00016328]\n", + "Found maximum gradient 0.07148648034965663 at index 11\n", "Maximum gradient is below the threshold: False\n" ] } @@ -705,12 +703,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Since the maximum gradient is not below the threshold, we append the operator at index 7 to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." + "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -723,12 +721,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 20, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -745,27 +743,27 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[4.2960303 2.69863461]\n", + "[5.58505312 4.10947516]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -3.017671843360538\n", - " x: [ 4.822e+00 3.053e+00]\n", - " nfev: 38\n", + " fun: -7.9686841753704645\n", + " x: [ 6.401e+00 3.191e+00]\n", + " nfev: 40\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 38 F =-3.017672E+00 MAXCV = 0.000000E+00\n", - " X = 4.822121E+00 3.053208E+00\n", + " NFVALS = 40 F =-7.968684E+00 MAXCV = 0.000000E+00\n", + " X = 6.401450E+00 3.191243E+00\n", "\n", - "Found ground energy: -3.017671843360538, exact energy: -7.972497290048691, difference: 4.954825446688153\n" + "Found ground energy: -7.9686841753704645, exact energy: -7.972179746236373, difference: 0.0034955708659083484\n" ] } ], @@ -792,7 +790,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -800,120 +798,174 @@ "output_type": "stream", "text": [ "Iter: 0\n", - "Maximum gradient: 0.2496163591110339\n", + "Maximum gradient: 0.2502515943160275\n", "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.0131302594375997\n", - " Iterations: 3\n", - " Function evaluations: 7\n", - " Gradient evaluations: 3\n", - "Result at iter 0: -3.0131302594375997\n", + " Current function value: -7.966906285249934\n", + " Iterations: 5\n", + " Function evaluations: 10\n", + " Gradient evaluations: 5\n", + "Result at iter 0: -7.966906285249934\n", "Iter: 1\n", - "Maximum gradient: 0.10244138083491211\n", - "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", + "Maximum gradient: 0.0714843962547343\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.017671847064684\n", - " Iterations: 8\n", - " Function evaluations: 26\n", - " Gradient evaluations: 8\n", - "Result at iter 1: -3.017671847064684\n", + " Current function value: -7.968684174341684\n", + " Iterations: 4\n", + " Function evaluations: 13\n", + " Gradient evaluations: 4\n", + "Result at iter 1: -7.968684174341684\n", "Iter: 2\n", - "Maximum gradient: 0.05905724077183245\n", - "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", + "Maximum gradient: 0.06886799369717088\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.019514279322607\n", - " Iterations: 8\n", - " Function evaluations: 37\n", - " Gradient evaluations: 8\n", - "Result at iter 2: -3.019514279322607\n", + " Current function value: -7.970336994989368\n", + " Iterations: 13\n", + " Function evaluations: 55\n", + " Gradient evaluations: 13\n", + "Result at iter 2: -7.970336994989368\n", "Iter: 3\n", - "Maximum gradient: 0.013853880090120743\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Maximum gradient: 0.037948738688156215\n", + "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 13\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.0277777096442287\n", - " Iterations: 23\n", - " Function evaluations: 121\n", - " Gradient evaluations: 23\n", - "Result at iter 3: -3.0277777096442287\n", + " Current function value: -7.970872532722423\n", + " Iterations: 5\n", + " Function evaluations: 27\n", + " Gradient evaluations: 5\n", + "Result at iter 3: -7.970872532722423\n", "Iter: 4\n", - "Maximum gradient: 0.07811936381248823\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + "Maximum gradient: 0.03701667743466218\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.0204748733330344\n", - " Iterations: 10\n", - " Function evaluations: 60\n", - " Gradient evaluations: 10\n", - "Result at iter 4: -3.0204748733330344\n", + " Current function value: -7.971383218763356\n", + " Iterations: 15\n", + " Function evaluations: 93\n", + " Gradient evaluations: 15\n", + "Result at iter 4: -7.971383218763356\n", "Iter: 5\n", - "Maximum gradient: 0.014568885631272867\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Maximum gradient: 0.03223049060005989\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.028806372184411\n", - " Iterations: 19\n", - " Function evaluations: 136\n", - " Gradient evaluations: 19\n", - "Result at iter 5: -3.028806372184411\n", + " Current function value: -7.971773194204802\n", + " Iterations: 10\n", + " Function evaluations: 73\n", + " Gradient evaluations: 10\n", + "Result at iter 5: -7.971773194204802\n", "Iter: 6\n", - "Maximum gradient: 0.07884802902698873\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", + "Maximum gradient: 0.010744753345870463\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.0320150552720655\n", - " Iterations: 17\n", - " Function evaluations: 144\n", - " Gradient evaluations: 17\n", - "Result at iter 6: -3.0320150552720655\n", + " Current function value: -7.971978670550741\n", + " Iterations: 18\n", + " Function evaluations: 153\n", + " Gradient evaluations: 18\n", + "Result at iter 6: -7.971978670550741\n", "Iter: 7\n", - "Maximum gradient: 0.011936842881169323\n", - "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Maximum gradient: 0.009602411091095806\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.0320037673838245\n", + " Current function value: -7.575750014713241\n", " Iterations: 17\n", - " Function evaluations: 155\n", + " Function evaluations: 159\n", " Gradient evaluations: 17\n", - "Result at iter 7: -3.0320037673838245\n", + "Result at iter 7: -7.575750014713241\n", "Iter: 8\n", - "Maximum gradient: 0.011955602856887966\n", + "Maximum gradient: 0.003893189579611439\n", + "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.968780427510825\n", + " Iterations: 16\n", + " Function evaluations: 162\n", + " Gradient evaluations: 16\n", + "Result at iter 8: -7.968780427510825\n", + "Iter: 9\n", + "Maximum gradient: 0.06249414533040526\n", "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.0414411695455468\n", - " Iterations: 25\n", - " Function evaluations: 254\n", - " Gradient evaluations: 25\n", - "Result at iter 8: -3.0414411695455468\n", - "Iter: 9\n", - "Maximum gradient: 0.006024521513410661\n", + " Current function value: -7.971483126872179\n", + " Iterations: 39\n", + " Function evaluations: 437\n", + " Gradient evaluations: 39\n", + "Result at iter 9: -7.971483126872179\n", + "Iter: 10\n", + "Maximum gradient: 0.034851301316264974\n", "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -3.0424112394114586\n", - " Iterations: 32\n", - " Function evaluations: 356\n", - " Gradient evaluations: 32\n", - "Result at iter 9: -3.0424112394114586\n", + " Current function value: -7.97217795139302\n", + " Iterations: 35\n", + " Function evaluations: 425\n", + " Gradient evaluations: 35\n", + "Result at iter 10: -7.97217795139302\n", + "Iter: 11\n", + "Maximum gradient: 0.001827710883478376\n", + "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", + "Iteration limit reached (Exit mode 9)\n", + " Current function value: -7.972134549102386\n", + " Iterations: 50\n", + " Function evaluations: 656\n", + " Gradient evaluations: 50\n", + "Result at iter 11: -7.972134549102386\n", + "Iter: 12\n", + "Maximum gradient: 0.008545102111382121\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.952930630064943\n", + " Iterations: 9\n", + " Function evaluations: 129\n", + " Gradient evaluations: 9\n", + "Result at iter 12: -7.952930630064943\n", + "Iter: 13\n", + "Maximum gradient: 0.2482768757536423\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.971931257810572\n", + " Iterations: 41\n", + " Function evaluations: 621\n", + " Gradient evaluations: 41\n", + "Result at iter 13: -7.971931257810572\n", + "Iter: 14\n", + "Maximum gradient: 0.00962225362695998\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.972130045637424\n", + " Iterations: 47\n", + " Function evaluations: 754\n", + " Gradient evaluations: 47\n", + "Result at iter 14: -7.972130045637424\n", "Terminating: reached maximum iteration.\n", - "Found ground energy: -3.0424112394114586, exact energy: -7.972497290048691, difference: 4.930086050637232\n" + "Found ground energy: -7.972130045637424, exact energy: -7.97217974623641, difference: 4.970059898656842e-05\n" ] } ], "source": [ "# Define the conditions for termination\n", "gradient_threshold = 1e-3\n", - "max_iter = 10\n", + "max_iter = 15\n", "terminate = False\n", "\n", "# Initiate the problem\n", @@ -957,7 +1009,7 @@ " \n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + "print(f\"Found ground energy: {ground_energy}, exact energy: {min_eigval}, difference: {ground_energy - min_eigval}\")" ] } ], From 7fc27ea5461c0c1fbf14f6813c1b352daf42ca13 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Thu, 29 Feb 2024 21:52:56 +0300 Subject: [PATCH 10/17] create single and double excitation operators manually --- quantum_enablement/tutorials/adapt-vqe.ipynb | 380 ++++++++++--------- 1 file changed, 206 insertions(+), 174 deletions(-) diff --git a/quantum_enablement/tutorials/adapt-vqe.ipynb b/quantum_enablement/tutorials/adapt-vqe.ipynb index f055f14..08bd871 100644 --- a/quantum_enablement/tutorials/adapt-vqe.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe.ipynb @@ -45,7 +45,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -225,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -252,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -282,21 +282,18 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", - "\n", " Args:\n", " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", " electrons in the first and second number, respectively.\n", - "\n", " Returns:\n", " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", - "\n", " Raises:\n", " ValueError: If the total number of particles is larger than the number of orbitals.\n", " \"\"\"\n", @@ -324,7 +321,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -342,7 +339,7 @@ "
" ] }, - "execution_count": 17, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -367,7 +364,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -396,7 +393,90 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Single excitation operators under the Jordan-Wigner transform (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian)\n", + "\n", + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mx.nelecas\n", + "\n", + "C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "\n", + "num_alpha, num_beta = num_particles\n", + "half_orbitals = num_spatial_orbitals\n", + "indices_alpha = list(range(num_alpha))\n", + "indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + "\n", + "single_excitation_operators = []\n", + "\n", + "for p in indices_alpha:\n", + " for n in range(p + 1, half_orbitals):\n", + " if n not in indices_alpha:\n", + " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)\n", + "\n", + "for p in indices_beta:\n", + " for n in range(p + 1, 2 * half_orbitals):\n", + " if n not in indices_beta:\n", + " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Double excitation operators under the Jordan-Wigner transform (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian)\n", + "\n", + "C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "\n", + "num_alpha, num_beta = num_particles\n", + "half_orbitals = num_spatial_orbitals\n", + "indices_alpha = list(range(num_alpha))\n", + "indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + "\n", + "double_excitation_operators = []\n", + "\n", + "# Both excitations from alpha\n", + "if len(indices_alpha) > 1:\n", + " # from these indices\n", + " for p in indices_alpha:\n", + " for n in range(p + 1, num_alpha):\n", + " # to these indices\n", + " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", + " for b in range(a + 1, half_orbitals):\n", + " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", + "\n", + "# Both excitations from beta\n", + "if len(indices_beta) > 1:\n", + " # from these indices\n", + " for p in indices_beta:\n", + " for n in range(p + 1, half_orbitals + num_beta):\n", + " # to these indices\n", + " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", + " for b in range(a + 1, 2 * half_orbitals):\n", + " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", + "\n", + "# One excitation from alpha, one from beta\n", + "# from these indices\n", + "for p in indices_alpha:\n", + " for n in indices_beta:\n", + " # to these indices\n", + " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", + " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", + " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -408,14 +488,7 @@ } ], "source": [ - "from qiskit_nature.second_q.circuit.library.ansatzes import UCC\n", - "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", - "\n", - "qubit_mapper = JordanWignerMapper()\n", - "\n", - "# Define the pool of operators as the single and double excitation operators generated by the UCC ansatz\n", - "ucc = UCC(num_spatial_orbitals, num_particles, 'sd', qubit_mapper)\n", - "excitation_pool = ucc.operators # TODO\n", + "excitation_pool = single_excitation_operators + double_excitation_operators\n", "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" ] }, @@ -429,7 +502,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -468,7 +541,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -514,7 +587,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -532,14 +605,14 @@ "
" ] }, - "execution_count": 22, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import LieTrotter, MatrixExponential\n", + "from qiskit.synthesis import LieTrotter\n", "\n", "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit)\n", "ansatz.decompose().draw(output = 'mpl')" @@ -562,7 +635,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -573,14 +646,14 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.96079405]\n" + "[3.96645199]\n" ] } ], @@ -599,7 +672,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -609,16 +682,16 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.966906279134248\n", + " fun: -7.966906278898801\n", " x: [ 3.024e+00]\n", - " nfev: 21\n", + " nfev: 22\n", " maxcv: 0.0\n", - "\n", - "Found ground energy: -7.966906279134248, exact energy: -7.97217974623641, difference: 0.005273467102162144\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 21 F =-7.966906E+00 MAXCV = 0.000000E+00\n", - " X = 3.023971E+00\n" + " NFVALS = 22 F =-7.966906E+00 MAXCV = 0.000000E+00\n", + " X = 3.023969E+00\n", + "\n", + "Found ground energy: -7.966906278898801, exact energy: -7.97217974623641, difference: 0.005273467337609361\n" ] } ], @@ -643,14 +716,14 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.02397061]\n" + "[3.02396918]\n" ] } ], @@ -670,18 +743,18 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00708742 0. 0. -0.00171104 0.00708742 0.\n", - " 0. -0.00171104 -0.01804318 0. 0. 0.07148648\n", - " 0. -0.04084344 0. 0. 0. 0.\n", - " -0.04084344 0. 0.07148648 0. 0. 0.00016328]\n", - "Found maximum gradient 0.07148648034965663 at index 11\n", + "[ 0.00708751 0. 0. -0.00171107 0.00708751 0.\n", + " 0. -0.00171107 -0.0180431 0. 0. 0.07148652\n", + " 0. -0.04084337 0. 0. 0. 0.\n", + " -0.04084337 0. 0.07148652 0. 0. 0.00016635]\n", + "Found maximum gradient 0.07148652482967087 at index 11\n", "Maximum gradient is below the threshold: False\n" ] } @@ -703,12 +776,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz. Note that this was the second operator with the maximum gradient in the previous step." + "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -726,7 +799,7 @@ "
" ] }, - "execution_count": 31, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -743,27 +816,27 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[5.58505312 4.10947516]\n", + "[3.3397298 2.86894403]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.9686841753704645\n", - " x: [ 6.401e+00 3.191e+00]\n", - " nfev: 40\n", + " fun: -7.9686841760049925\n", + " x: [ 3.260e+00 3.191e+00]\n", + " nfev: 31\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 40 F =-7.968684E+00 MAXCV = 0.000000E+00\n", - " X = 6.401450E+00 3.191243E+00\n", + " NFVALS = 31 F =-7.968684E+00 MAXCV = 0.000000E+00\n", + " X = 3.259967E+00 3.191270E+00\n", "\n", - "Found ground energy: -7.9686841753704645, exact energy: -7.972179746236373, difference: 0.0034955708659083484\n" + "Found ground energy: -7.9686841760049925, exact energy: -7.97217974623641, difference: 0.003495570231417666\n" ] } ], @@ -777,7 +850,7 @@ "\n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {exact_result.eigenvalue}, difference: {ground_energy - exact_result.eigenvalue}\")" + "print(f\"Found ground energy: {ground_energy}, exact energy: {min_eigval}, difference: {ground_energy - min_eigval}\")" ] }, { @@ -790,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -803,175 +876,134 @@ " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.966906285249934\n", - " Iterations: 5\n", - " Function evaluations: 10\n", - " Gradient evaluations: 5\n", - "Result at iter 0: -7.966906285249934\n", + " Current function value: -7.966906285252653\n", + " Iterations: 6\n", + " Function evaluations: 14\n", + " Gradient evaluations: 6\n", + "Result at iter 0: -7.966906285252653\n", "Iter: 1\n", - "Maximum gradient: 0.0714843962547343\n", + "Maximum gradient: 0.07148439188181017\n", "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.968684174341684\n", - " Iterations: 4\n", - " Function evaluations: 13\n", - " Gradient evaluations: 4\n", - "Result at iter 1: -7.968684174341684\n", + " Current function value: -7.968684170219699\n", + " Iterations: 6\n", + " Function evaluations: 18\n", + " Gradient evaluations: 6\n", + "Result at iter 1: -7.968684170219699\n", "Iter: 2\n", - "Maximum gradient: 0.06886799369717088\n", + "Maximum gradient: 0.06886672061476416\n", "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970336994989368\n", - " Iterations: 13\n", - " Function evaluations: 55\n", - " Gradient evaluations: 13\n", - "Result at iter 2: -7.970336994989368\n", + " Current function value: -7.970337004852715\n", + " Iterations: 6\n", + " Function evaluations: 24\n", + " Gradient evaluations: 6\n", + "Result at iter 2: -7.970337004852715\n", "Iter: 3\n", - "Maximum gradient: 0.037948738688156215\n", + "Maximum gradient: 0.03793394213567434\n", "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 13\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970872532722423\n", - " Iterations: 5\n", - " Function evaluations: 27\n", - " Gradient evaluations: 5\n", - "Result at iter 3: -7.970872532722423\n", + " Current function value: -7.970872587753581\n", + " Iterations: 8\n", + " Function evaluations: 45\n", + " Gradient evaluations: 8\n", + "Result at iter 3: -7.970872587753581\n", "Iter: 4\n", - "Maximum gradient: 0.03701667743466218\n", + "Maximum gradient: 0.037038123475672986\n", "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 18\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971383218763356\n", - " Iterations: 15\n", - " Function evaluations: 93\n", - " Gradient evaluations: 15\n", - "Result at iter 4: -7.971383218763356\n", + " Current function value: -7.971382963416607\n", + " Iterations: 21\n", + " Function evaluations: 132\n", + " Gradient evaluations: 21\n", + "Result at iter 4: -7.971382963416607\n", "Iter: 5\n", - "Maximum gradient: 0.03223049060005989\n", + "Maximum gradient: 0.03229833589401405\n", "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971773194204802\n", - " Iterations: 10\n", - " Function evaluations: 73\n", - " Gradient evaluations: 10\n", - "Result at iter 5: -7.971773194204802\n", + " Current function value: -7.971773233908281\n", + " Iterations: 20\n", + " Function evaluations: 151\n", + " Gradient evaluations: 20\n", + "Result at iter 5: -7.971773233908281\n", "Iter: 6\n", - "Maximum gradient: 0.010744753345870463\n", + "Maximum gradient: 0.01078583265147669\n", "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971978670550741\n", - " Iterations: 18\n", - " Function evaluations: 153\n", - " Gradient evaluations: 18\n", - "Result at iter 6: -7.971978670550741\n", + " Current function value: -7.9719789847206\n", + " Iterations: 21\n", + " Function evaluations: 177\n", + " Gradient evaluations: 21\n", + "Result at iter 6: -7.9719789847206\n", "Iter: 7\n", - "Maximum gradient: 0.009602411091095806\n", + "Maximum gradient: 0.009758560644558783\n", "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.575750014713241\n", - " Iterations: 17\n", - " Function evaluations: 159\n", - " Gradient evaluations: 17\n", - "Result at iter 7: -7.575750014713241\n", + " Current function value: -7.972146459034053\n", + " Iterations: 15\n", + " Function evaluations: 140\n", + " Gradient evaluations: 15\n", + "Result at iter 7: -7.972146459034053\n", "Iter: 8\n", - "Maximum gradient: 0.003893189579611439\n", - "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", + "Maximum gradient: 0.007087554378849258\n", + "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.968780427510825\n", - " Iterations: 16\n", - " Function evaluations: 162\n", - " Gradient evaluations: 16\n", - "Result at iter 8: -7.968780427510825\n", + " Current function value: -7.969773091701047\n", + " Iterations: 32\n", + " Function evaluations: 321\n", + " Gradient evaluations: 32\n", + "Result at iter 8: -7.969773091701047\n", "Iter: 9\n", - "Maximum gradient: 0.06249414533040526\n", - "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 20\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971483126872179\n", - " Iterations: 39\n", - " Function evaluations: 437\n", - " Gradient evaluations: 39\n", - "Result at iter 9: -7.971483126872179\n", - "Iter: 10\n", - "Maximum gradient: 0.034851301316264974\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + "Maximum gradient: 0.06970259970154505\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.97217795139302\n", - " Iterations: 35\n", - " Function evaluations: 425\n", - " Gradient evaluations: 35\n", - "Result at iter 10: -7.97217795139302\n", - "Iter: 11\n", - "Maximum gradient: 0.001827710883478376\n", - "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", "Iteration limit reached (Exit mode 9)\n", - " Current function value: -7.972134549102386\n", + " Current function value: -7.972003744865285\n", " Iterations: 50\n", - " Function evaluations: 656\n", + " Function evaluations: 554\n", " Gradient evaluations: 50\n", - "Result at iter 11: -7.972134549102386\n", - "Iter: 12\n", - "Maximum gradient: 0.008545102111382121\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.952930630064943\n", - " Iterations: 9\n", - " Function evaluations: 129\n", - " Gradient evaluations: 9\n", - "Result at iter 12: -7.952930630064943\n", - "Iter: 13\n", - "Maximum gradient: 0.2482768757536423\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971931257810572\n", - " Iterations: 41\n", - " Function evaluations: 621\n", - " Gradient evaluations: 41\n", - "Result at iter 13: -7.971931257810572\n", - "Iter: 14\n", - "Maximum gradient: 0.00962225362695998\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Result at iter 9: -7.972003744865285\n", + "Iter: 10\n", + "Maximum gradient: 0.010146956387318147\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972130045637424\n", - " Iterations: 47\n", - " Function evaluations: 754\n", - " Gradient evaluations: 47\n", - "Result at iter 14: -7.972130045637424\n", - "Terminating: reached maximum iteration.\n", - "Found ground energy: -7.972130045637424, exact energy: -7.97217974623641, difference: 4.970059898656842e-05\n" + " Current function value: -7.972177628337713\n", + " Iterations: 36\n", + " Function evaluations: 437\n", + " Gradient evaluations: 36\n", + "Result at iter 10: -7.972177628337713\n", + "Iter: 11\n", + "Maximum gradient: 0.0014615495206443262\n", + "Terminating: converged.\n", + "Found ground energy: -7.972177628337713, exact energy: -7.97217974623641, difference: 2.1178986973069414e-06\n" ] } ], "source": [ "# Define the conditions for termination\n", - "gradient_threshold = 1e-3\n", + "gradient_threshold = 5e-3\n", "max_iter = 15\n", "terminate = False\n", "\n", "# Initiate the problem\n", "ansatz = hf_circuit\n", "hamiltonian = H\n", - "excitation_pool = ucc.operators # TODO\n", + "excitation_pool = single_excitation_operators + double_excitation_operators\n", "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", "params = None\n", "\n", From 53af16ff90bb505df14f04f42c1717f4b986bf77 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Fri, 1 Mar 2024 02:16:58 +0300 Subject: [PATCH 11/17] add functions for hf, single exc, double exc --- quantum_enablement/tutorials/adapt-vqe.ipynb | 180 +++++++++++-------- 1 file changed, 109 insertions(+), 71 deletions(-) diff --git a/quantum_enablement/tutorials/adapt-vqe.ipynb b/quantum_enablement/tutorials/adapt-vqe.ipynb index 08bd871..25fdee8 100644 --- a/quantum_enablement/tutorials/adapt-vqe.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe.ipynb @@ -282,10 +282,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "\n", "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", " Args:\n", @@ -309,7 +312,29 @@ " bitstr[:num_alpha] = True\n", " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", "\n", - " return bitstr.tolist()" + " return bitstr.tolist()\n", + "\n", + "\n", + "def hartree_fock_circuit(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> QuantumCircuit:\n", + " \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing \n", + " the Hartree-Fock state for the specified system.\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " The quantum circuit preparing the Hartree-Fock state under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " # Get the Hartree-Fock initial state in boolean bitstring representation\n", + " hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", + "\n", + " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an X-gate as indicated by the boolean list\n", + " hf_circuit = QuantumCircuit(len(hf_bitstring))\n", + " for i, hf_bit in enumerate(hf_bitstring):\n", + " if hf_bit:\n", + " hf_circuit.x(i)\n", + " \n", + " return hf_circuit\n" ] }, { @@ -321,7 +346,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -339,26 +364,16 @@ "
" ] }, - "execution_count": 9, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from qiskit import QuantumCircuit\n", - "\n", "num_spatial_orbitals = mx.ncas\n", "num_particles = mx.nelecas\n", "\n", - "# Get the Hartree-Fock initial state in boolean bitstring representation\n", - "hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", - "\n", - "# Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an X-gate as indicated by the boolean list\n", - "hf_circuit = QuantumCircuit(len(hf_bitstring))\n", - "for i, hf_bit in enumerate(hf_bitstring):\n", - " if hf_bit:\n", - " hf_circuit.x(i)\n", - "\n", + "hf_circuit = hartree_fock_circuit(num_spatial_orbitals, num_particles)\n", "hf_circuit.draw(output = 'mpl')" ] }, @@ -393,90 +408,107 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ - "# Single excitation operators under the Jordan-Wigner transform (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian)\n", - "\n", - "num_spatial_orbitals = mx.ncas\n", - "num_particles = mx.nelecas\n", - "\n", - "C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "def single_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", + " \"\"\"Compute single excitation operators under the Jordan-Wigner transform \n", + " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " A list of single excitation operators under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", "\n", - "num_alpha, num_beta = num_particles\n", - "half_orbitals = num_spatial_orbitals\n", - "indices_alpha = list(range(num_alpha))\n", - "indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + " num_alpha, num_beta = num_particles\n", + " half_orbitals = num_spatial_orbitals\n", + " indices_alpha = list(range(num_alpha))\n", + " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", "\n", - "single_excitation_operators = []\n", + " single_excitation_operators = []\n", "\n", - "for p in indices_alpha:\n", - " for n in range(p + 1, half_orbitals):\n", - " if n not in indices_alpha:\n", - " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", - " single_excitation_operators.append(exc)\n", + " for p in indices_alpha:\n", + " for n in range(p + 1, half_orbitals):\n", + " if n not in indices_alpha:\n", + " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)\n", "\n", - "for p in indices_beta:\n", - " for n in range(p + 1, 2 * half_orbitals):\n", - " if n not in indices_beta:\n", - " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", - " single_excitation_operators.append(exc)" + " for p in indices_beta:\n", + " for n in range(p + 1, 2 * half_orbitals):\n", + " if n not in indices_beta:\n", + " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)\n", + " \n", + " return single_excitation_operators" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ - "# Double excitation operators under the Jordan-Wigner transform (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian)\n", + "def double_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", + " \"\"\"Compute double excitation operators under the Jordan-Wigner transform \n", + " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " A list of single excitation operators under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "\n", + " num_alpha, num_beta = num_particles\n", + " half_orbitals = num_spatial_orbitals\n", + " indices_alpha = list(range(num_alpha))\n", + " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", "\n", - "C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + " double_excitation_operators = []\n", "\n", - "num_alpha, num_beta = num_particles\n", - "half_orbitals = num_spatial_orbitals\n", - "indices_alpha = list(range(num_alpha))\n", - "indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + " # Both excitations from alpha\n", + " if len(indices_alpha) > 1:\n", + " # from these indices\n", + " for p in indices_alpha:\n", + " for n in range(p + 1, num_alpha):\n", + " # to these indices\n", + " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", + " for b in range(a + 1, half_orbitals):\n", + " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", "\n", - "double_excitation_operators = []\n", + " # Both excitations from beta\n", + " if len(indices_beta) > 1:\n", + " # from these indices\n", + " for p in indices_beta:\n", + " for n in range(p + 1, half_orbitals + num_beta):\n", + " # to these indices\n", + " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", + " for b in range(a + 1, 2 * half_orbitals):\n", + " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", "\n", - "# Both excitations from alpha\n", - "if len(indices_alpha) > 1:\n", + " # One excitation from alpha, one from beta\n", " # from these indices\n", " for p in indices_alpha:\n", - " for n in range(p + 1, num_alpha):\n", + " for n in indices_beta:\n", " # to these indices\n", " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", - " for b in range(a + 1, half_orbitals):\n", - " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", - " double_excitation_operators.append(exc)\n", - "\n", - "# Both excitations from beta\n", - "if len(indices_beta) > 1:\n", - " # from these indices\n", - " for p in indices_beta:\n", - " for n in range(p + 1, half_orbitals + num_beta):\n", - " # to these indices\n", - " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", - " for b in range(a + 1, 2 * half_orbitals):\n", + " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", " double_excitation_operators.append(exc)\n", - "\n", - "# One excitation from alpha, one from beta\n", - "# from these indices\n", - "for p in indices_alpha:\n", - " for n in indices_beta:\n", - " # to these indices\n", - " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", - " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", - " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", - " double_excitation_operators.append(exc)\n" + " \n", + " return double_excitation_operators\n" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -488,6 +520,12 @@ } ], "source": [ + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mx.nelecas\n", + "\n", + "single_excitation_operators = single_excitation(num_spatial_orbitals, num_particles)\n", + "double_excitation_operators = double_excitation(num_spatial_orbitals, num_particles)\n", + "\n", "excitation_pool = single_excitation_operators + double_excitation_operators\n", "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" ] From fcc82ce9dbb0195a7e5d059c1337e71469e7e4c3 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Thu, 7 Mar 2024 11:44:24 -0800 Subject: [PATCH 12/17] add qiskit patterns --- .../tutorials/adapt-vqe-patterns.ipynb | 1134 +++++++++++++++++ quantum_enablement/tutorials/adapt-vqe.ipynb | 73 +- 2 files changed, 1165 insertions(+), 42 deletions(-) create mode 100644 quantum_enablement/tutorials/adapt-vqe-patterns.ipynb diff --git a/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb b/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb new file mode 100644 index 0000000..de8e17d --- /dev/null +++ b/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb @@ -0,0 +1,1134 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit ADAPT-VQE tutorial\n", + "\n", + "ADAPT-VQE is a variation of the original VQE algorithm, which grows the ansatz at each iteration by selecting operators from an operator pool. This typically results in shorter depth circuits than fixed-depth ansatze designed for VQE. This algorithm was first introduced in https://arxiv.org/abs/1812.1117. For a ground state estimation problem from the quantum chemistry domain, steps are outlined as follows.\n", + "\n", + "1. We find the fermionic Hamiltonian by defining the molecular geometry, and map it onto qubit representation using a mapper such as the Jordan-Wigner transform. \n", + "2. The quantum computer is typically initiated in the Hartree-Fock state under the same transformation as an estimate to the ground state energy.\n", + "3. We define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian.\n", + "4. Until the algorithm terminates:\n", + " - we compute the gradient of each operator from the pool and select the operator with the maximum gradient,\n", + " - grow the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$,\n", + " - run VQE over all parameters $\\theta_i$,\n", + " - and terminate the algorithm if the gradient of all operators from the pool are smaller than some threshold (convergence) or if we reach the maximum number of allowed iterations.\n", + "\n", + "We note the following variants of the ADAPT-VQE algorithm:\n", + "- A hardware-efficient variant called qubit-ADAPT-VQE, which reduces the circuit depth by constructing the pool directly with individual Pauli operators: https://arxiv.org/abs/1911.10205.\n", + "- A utility scale ADAPT-VQE experiment for the Schwinger model using up to 100 qubits of IBM Quantum devices: https://arxiv.org/abs/2308.04481.\n", + "\n", + "In the following, we define the problem and implement the algorithm using Qiskit Patterns formalism in 4 steps:\n", + "1. Map classical inputs to a quantum problem\n", + "2. Optimize problem for quantum execution\n", + "3. Execute using Qiskit Primitives\n", + "4. Post-process and return result in classical format\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the molecule\n", + "We start by defining the molecule using ``pyscf``. As an example we select LiH and build it by providing its geometry.\n", + "Code to generate additional molecules can be found in ``Example_Molecules.ipynb`` at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyscf import ao2mo, gto, mcscf, scf\n", + "\n", + "# LiH\n", + "distance = 1.59\n", + "mol = gto.Mole()\n", + "mol.build(\n", + " verbose=0,\n", + " atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n", + " basis=\"sto-6g\",\n", + " spin=0,\n", + " charge=0,\n", + " symmetry=\"Coov\", \n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nuclear energy: 0.998447567773585\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", + " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Electronic energy: -8.950577623117868\n", + "Total energy: -7.952130055344282\n", + "Total energy - nuclear energy: -8.950577623117868\n" + ] + } + ], + "source": [ + "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", + "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", + "print(f\"Total energy: {mol.energy_tot()}\")\n", + "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the fermionic Hamiltonian\n", + "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "mf = scf.RHF(mol)\n", + "E1 = mf.kernel()\n", + "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", + "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n", + "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", + "E2 = mx.kernel(mo)[:2]\n", + "\n", + "h1e, ecore = mx.get_h1eff()\n", + "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 1: Map classical inputs to a quantum problem\n", + "We will map the Hamiltonian operator, the initial state and the operator pool of the ansatz to a quantum problem using the Jordan-Wigner transform. We also define functions to compute gradients and the cost of these operators." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map the fermionic Hamiltonian to a qubit operator\n", + "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", + "\n", + "import numpy as np\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "\n", + "def cholesky(V, eps):\n", + " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", + " # see https://arxiv.org/abs/1808.02625\n", + " # see https://arxiv.org/abs/2104.08957\n", + " no = V.shape[0]\n", + " chmax, ng = 20 * no, 0\n", + " W = V.reshape(no**2, no**2)\n", + " L = np.zeros((no**2, chmax))\n", + " Dmax = np.diagonal(W).copy()\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " while vmax > eps:\n", + " L[:, ng] = W[:, nu_max]\n", + " if ng > 0:\n", + " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", + " L[:, ng] /= np.sqrt(vmax)\n", + " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", + " ng += 1\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " L = L[:, :ng].reshape((no, no, ng))\n", + " print(\n", + " \"accuracy of Cholesky decomposition \",\n", + " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", + " )\n", + " return L, ng\n", + "\n", + "\n", + "def identity(n):\n", + " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", + "\n", + "\n", + "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", + " c_list = []\n", + " if mapping == \"jordan_wigner\":\n", + " for p in range(n):\n", + " if p == 0:\n", + " l, r = \"I\" * (n - 1), \"\"\n", + " elif p == n - 1:\n", + " l, r = \"\", \"Z\" * (n - 1)\n", + " else:\n", + " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", + " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, -0.5j)])\n", + " c_list.append(cp)\n", + " else:\n", + " raise ValueError(\"Unsupported mapping.\")\n", + " d_list = [cp.adjoint() for cp in c_list]\n", + " return c_list, d_list\n", + "\n", + "\n", + "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", + " ncas, _ = h1e.shape\n", + "\n", + " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", + " Exc = []\n", + " for p in range(ncas):\n", + " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", + " for r in range(p + 1, ncas):\n", + " Excp.append(\n", + " C[p] @ D[r]\n", + " + C[ncas + p] @ D[ncas + r]\n", + " + C[r] @ D[p]\n", + " + C[ncas + r] @ D[ncas + p]\n", + " )\n", + " Exc.append(Excp)\n", + "\n", + " # low-rank decomposition of the Hamiltonian\n", + " Lop, ng = cholesky(h2e, 1e-6)\n", + " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", + "\n", + " H = ecore * identity(2 * ncas)\n", + " # one-body term\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " H += t1e[p, r] * Exc[p][r - p]\n", + " # two-body term\n", + " for g in range(ng):\n", + " Lg = 0 * identity(2 * ncas)\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " Lg += Lop[p, r, g] * Exc[p][r - p]\n", + " H += 0.5 * Lg @ Lg\n", + "\n", + " return H.chop().simplify()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy of Cholesky decomposition 1.1796119636642288e-16\n", + "The Hamiltonian consists of 276 10-qubit Pauli operators.\n" + ] + } + ], + "source": [ + "H = build_hamiltonian(ecore, h1e, h2e)\n", + "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial state\n", + "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we implement using the functions below." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "\n", + "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", + " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", + " Raises:\n", + " ValueError: If the total number of particles is larger than the number of orbitals.\n", + " \"\"\"\n", + " # validate the input\n", + " assert num_spatial_orbitals >= 1\n", + " num_alpha, num_beta = num_particles\n", + "\n", + " if any(n > num_spatial_orbitals for n in num_particles):\n", + " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", + "\n", + " half_orbitals = num_spatial_orbitals\n", + " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", + " bitstr[:num_alpha] = True\n", + " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", + "\n", + " return bitstr.tolist()\n", + "\n", + "\n", + "def hartree_fock_circuit(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> QuantumCircuit:\n", + " \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing \n", + " the Hartree-Fock state for the specified system.\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " The quantum circuit preparing the Hartree-Fock state under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " # Get the Hartree-Fock initial state in boolean bitstring representation\n", + " hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", + "\n", + " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an \n", + " # X-gate as indicated by the boolean list\n", + " hf_circuit = QuantumCircuit(len(hf_bitstring))\n", + " for i, hf_bit in enumerate(hf_bitstring):\n", + " if hf_bit:\n", + " hf_circuit.x(i)\n", + " \n", + " return hf_circuit\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mx.nelecas\n", + "\n", + "hf_circuit = hartree_fock_circuit(num_spatial_orbitals, num_particles)\n", + "hf_circuit.draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator pool\n", + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we multiply them with the complex phase 1j so that they appear Hermitian." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def single_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", + " \"\"\"Compute single excitation operators under the Jordan-Wigner transform \n", + " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " A list of single excitation operators under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "\n", + " num_alpha, num_beta = num_particles\n", + " half_orbitals = num_spatial_orbitals\n", + " indices_alpha = list(range(num_alpha))\n", + " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + "\n", + " single_excitation_operators = []\n", + "\n", + " for p in indices_alpha:\n", + " for r in range(p + 1, half_orbitals):\n", + " if r not in indices_alpha:\n", + " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)\n", + "\n", + " for p in indices_beta:\n", + " for r in range(p + 1, 2 * half_orbitals):\n", + " if r not in indices_beta:\n", + " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)\n", + " \n", + " return single_excitation_operators" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def double_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", + " \"\"\"Compute double excitation operators under the Jordan-Wigner transform \n", + " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " A list of single excitation operators under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "\n", + " num_alpha, num_beta = num_particles\n", + " half_orbitals = num_spatial_orbitals\n", + " indices_alpha = list(range(num_alpha))\n", + " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + "\n", + " double_excitation_operators = []\n", + "\n", + " # Both excitations from alpha\n", + " if len(indices_alpha) > 1:\n", + " # from these indices\n", + " for p in indices_alpha:\n", + " for r in range(p + 1, num_alpha):\n", + " # to these indices\n", + " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", + " for b in range(a + 1, half_orbitals):\n", + " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", + "\n", + " # Both excitations from beta\n", + " if len(indices_beta) > 1:\n", + " # from these indices\n", + " for p in indices_beta:\n", + " for r in range(p + 1, half_orbitals + num_beta):\n", + " # to these indices\n", + " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", + " for b in range(a + 1, 2 * half_orbitals):\n", + " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", + "\n", + " # One excitation from alpha, one from beta\n", + " # from these indices\n", + " for p in indices_alpha:\n", + " for r in indices_beta:\n", + " # to these indices\n", + " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", + " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", + " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", + " \n", + " return double_excitation_operators\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The excitation pool consists of 24 operators.\n" + ] + } + ], + "source": [ + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mx.nelecas\n", + "\n", + "single_excitation_operators = single_excitation(num_spatial_orbitals, num_particles)\n", + "double_excitation_operators = double_excitation(num_spatial_orbitals, num_particles)\n", + "\n", + "excitation_pool = single_excitation_operators + double_excitation_operators\n", + "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient of the excitation operators\n", + "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", + " \"\"\"\n", + " Computes the gradients for all available excitation operators.\n", + " Args:\n", + " ansatz: ansatz built so far.\n", + " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", + " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", + " estimator: an instance of the Qiskit Estimator primitive.\n", + " params: parameters to be assigned to the ansatz, if any.\n", + " Returns:\n", + " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", + " \"\"\"\n", + " # The excitations operators are applied later as exp(i*theta*excitation).\n", + " # For this commutator, we need to explicitly pull in the imaginary phase.\n", + " if params is not None:\n", + " ansatz_opt = ansatz.assign_parameters(params)\n", + " else:\n", + " ansatz_opt = ansatz\n", + " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", + " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", + " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", + " gradients = estimator.run(ansatz_list, commutators).result().values\n", + "\n", + " return gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cost function\n", + "We define the cost function as the expectation value of the Hamiltonian operator given an ansatz with its parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 2: Optimize problem for quantum execution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by selecting a backend for execution." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# To run on hardware:\n", + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", + "backend = service.least_busy(operational=True, simulator=False)\n", + "# backend = service.get_backend('ibmq_kolkata')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we optimize the circuit for running on a real backend by specifying the optimization_level and adding dynamical decoupling. The code below generates a mass manager using preset pass managers from qiskit.transpiler." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.transpiler import PassManager\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "from qiskit.transpiler.passes import ALAPScheduleAnalysis, PadDynamicalDecoupling, ConstrainedReschedule\n", + "from qiskit.circuit.library import XGate\n", + "\n", + "target = backend.target\n", + "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", + "pm.scheduling = PassManager(\n", + " [\n", + " ALAPScheduleAnalysis(target=target), \n", + " ConstrainedReschedule(target.acquire_alignment, target.pulse_alignment),\n", + " PadDynamicalDecoupling(target=target, dd_sequence=[XGate(), XGate()], pulse_alignment=target.pulse_alignment)\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we use the pass manager on the initial state. We can similarly apply device layout characteristics to the Hamiltonian to get a more physical representation." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "hf_circuit_ibm = pm.run(hf_circuit)\n", + "H_ibm = H.apply_layout(hf_circuit_ibm.layout) \n", + "excitation_pool_ibm = [exc.apply_layout(hf_circuit_ibm.layout) for exc in excitation_pool]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 3: Execute using Qiskit Primitives\n", + "Before we execute on the selected hardware, it is a good idea to use a simulator for cursory debugging, and sometimes for estimates of error. For those reasons, we briefly show how to run ADAPT-VQE on a simulator. But it is critical to note that no classical computer, simulator or GPU can accurately simulate the full functionality of a highly-entangled 127-qubit quantum computer. In the present era of quantum utility, simulators will have limited use." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that for each choice of parameters in the variational circuit, an expectation value must be calculated (since that is the value to be minimized). We do this with the Qiskit Primitive, Estimator." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hartree-Fock energy: -7.95213012467435\n" + ] + } + ], + "source": [ + "# To run on simulator\n", + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator()\n", + "\n", + "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", + "print(f\"Hartree-Fock energy: {hf_energy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", + " 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", + " -2.42633656e-02 0.00000000e+00 0.00000000e+00 6.68086680e-02\n", + " 0.00000000e+00 -4.61492937e-02 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 -4.61492937e-02 0.00000000e+00\n", + " 6.68086680e-02 0.00000000e+00 0.00000000e+00 -2.50251594e-01]\n", + "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.2502515943160275 at index 23.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "max_operator = excitation_pool[max_index]\n", + "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expand the Ansatz\n", + "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit)\n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run VQE\n", + "We are now ready to run a full VQE on the ansatz that we have so far. We use the cost function and the Estimator primitive as defined above and randomly initiate the parameters to be optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.83402244]\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -7.966906270570856\n", + " x: [ 3.024e+00]\n", + " nfev: 22\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 22 F =-7.966906E+00 MAXCV = 0.000000E+00\n", + " X = 3.024164E+00\n", + "\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Post-process, return result in classical format\n", + "We now interpret the results and decide if we need another iteration of the algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found ground energy: -7.966906270570856\n", + "[3.02416384]\n" + ] + } + ], + "source": [ + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}\")\n", + "\n", + "# Optimal parameters so far\n", + "x_opt = getattr(res, 'x')\n", + "print(x_opt)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.00707599 0. 0. -0.00170799 0.00707599 0.\n", + " 0. -0.00170799 -0.01805376 0. 0. 0.07148046\n", + " 0. -0.04085305 0. 0. 0. 0.\n", + " -0.04085305 0. 0.07148046 0. 0. -0.00025192]\n", + "Found maximum gradient 0.07148046043169676 at index 20\n", + "Maximum gradient is below the threshold: False\n" + ] + } + ], + "source": [ + "gradient_threshold = 1e-3\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "\n", + "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", + "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Initiate the list of operators with the first one \n", + "operator_list = [max_operator]\n", + "# Append the second operator\n", + "operator_list.append(excitation_pool[max_index])\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + "ansatz.decompose().draw(output = 'mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.51330317 3.48868114]\n", + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -7.968684172213385\n", + " x: [ 3.260e+00 3.191e+00]\n", + " nfev: 37\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 37 F =-7.968684E+00 MAXCV = 0.000000E+00\n", + " X = 3.259915E+00 3.191406E+00\n", + "\n", + "Found ground energy: -7.968684172213385\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)\n", + "\n", + "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "print(res)\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Putting it all together\n", + "Now we automate the algorithm in a single loop." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Estimator\n", + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter\n", + "from scipy.optimize import minimize\n", + "\n", + "\n", + "# Define the conditions for termination\n", + "gradient_threshold = 5e-3\n", + "max_iter = 15\n", + "terminate = False\n", + "\n", + "# Initiate the problem\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "excitation_pool = single_excitation_operators + double_excitation_operators\n", + "estimator = Estimator()\n", + "params = None\n", + "\n", + "iter = 0\n", + "operator_list = []\n", + "while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, 'x')\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration.\")\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " print(\"Terminating: converged.\")\n", + " terminate = True\n", + " \n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# To continue running on real hardware use\n", + "from qiskit_ibm_runtime import Estimator, Session, Options\n", + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter\n", + "from scipy.optimize import minimize\n", + "\n", + "\n", + "hf_circuit_ibm = pm.run(hf_circuit)\n", + "H_ibm = H.apply_layout(hf_circuit_ibm.layout) \n", + "\n", + "# Define the conditions for termination\n", + "gradient_threshold = 5e-3\n", + "max_iter = 15\n", + "terminate = False\n", + "\n", + "with Session(backend=backend):\n", + " session_options = Options()\n", + " session_options.execution.shots = 2000\n", + " session_options.resilience_level = 1\n", + "\n", + " # Initiate the problem\n", + " ansatz = hf_circuit_ibm\n", + " hamiltonian = H_ibm\n", + " excitation_pool = single_excitation_operators + double_excitation_operators\n", + " estimator = Estimator(session=Session(service, backend=backend), options=session_options)\n", + " params = None\n", + "\n", + " iter = 0\n", + " operator_list = []\n", + " while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " excitation_pool_ibm = [exc.apply_layout(ansatz.layout) for exc in excitation_pool]\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool_ibm, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + " ansatz = pm.run(ansatz)\n", + " hamiltonian = H.apply_layout(ansatz.layout) \n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(cost_func, x0, args=(ansatz, hamiltonian, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, 'x')\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration.\")\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " print(\"Terminating: converged.\")\n", + " terminate = True\n", + " \n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, 'fun')\n", + "print(f\"Found ground energy: {ground_energy}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/quantum_enablement/tutorials/adapt-vqe.ipynb b/quantum_enablement/tutorials/adapt-vqe.ipynb index 25fdee8..9724f8e 100644 --- a/quantum_enablement/tutorials/adapt-vqe.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe.ipynb @@ -4,28 +4,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Qiskit ADAPT-VQE tutorial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Outline of the ADAPT-VQE algorithm\n", - "This algorithm was first introduced in https://arxiv.org/abs/1812.1117.\n", + "## Qiskit ADAPT-VQE tutorial\n", "\n", - "1. Initiate the quantum computer in the Hartree-Fock state. In Jordan-Wigner transformation, this has a bitstring representation implemented with $X$-gates.\n", + "ADAPT-VQE is a variation of the original VQE algorithm, which grows the ansatz at each iteration by selecting operators from an operator pool. This typically results in shorter depth circuits than fixed-depth ansatze designed for VQE. This algorithm was first introduced in https://arxiv.org/abs/1812.1117. For a ground state estimation problem from the quantum chemistry domain, steps are outlined as follows.\n", "\n", - "2. Define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian. \n", + "1. We find the fermionic Hamiltonian by defining the molecular geometry, and map it onto qubit representation using a mapper such as the Jordan-Wigner transform. \n", + "2. The quantum computer is typically initiated in the Hartree-Fock state under the same transformation as an estimate to the ground state energy.\n", + "3. We define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian.\n", + "4. Until the algorithm terminates:\n", + " - we compute the gradient of each operator from the pool and select the operator with the maximum gradient,\n", + " - grow the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$,\n", + " - run VQE over all parameters $\\theta_i$,\n", + " - and terminate the algorithm if the gradient of all operators from the pool are smaller than some threshold (convergence) or if we reach the maximum number of allowed iterations.\n", "\n", - "3. Define the following conditions for termination: CONVERGED, MAXIMUM.\n", - " - CONVERGED: Gradient of all operators from the pool are smaller than some threshold.\n", - " - MAXIMUM: Maximum number of iterations reached.\n", - " \n", - "4. while not TERMINATE (CONVERGED or MAXIMUM):\n", - " - Compute the gradient of each operator from the pool and select the operator with the maximum gradient\n", - " - Append the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$\n", - " - Run VQE over all parameters $\\theta_i$" + "We note the following variants of the ADAPT-VQE algorithm:\n", + "- A hardware-efficient variant called qubit-ADAPT-VQE, which reduces the circuit depth by constructing the pool directly with individual Pauli operators: https://arxiv.org/abs/1911.10205.\n", + "- A utility scale ADAPT-VQE experiment for the Schwinger model using up to 100 qubits of IBM Quantum devices: https://arxiv.org/abs/2308.04481.\n", + "\n" ] }, { @@ -33,7 +28,7 @@ "metadata": {}, "source": [ "### Define the molecule\n", - "We start by defining the molecule using ``pyscf``. As an example we select the LiH molecule and build it by providing its geometry.\n", + "We start by defining the molecule using ``pyscf``. As an example we select LiH and build it by providing its geometry.\n", "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." ] }, @@ -277,7 +272,7 @@ "metadata": {}, "source": [ "### Initial state\n", - "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we do with the help of the function below." + "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we implement using the functions below." ] }, { @@ -328,7 +323,8 @@ " # Get the Hartree-Fock initial state in boolean bitstring representation\n", " hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", "\n", - " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an X-gate as indicated by the boolean list\n", + " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an \n", + " # X-gate as indicated by the boolean list\n", " hf_circuit = QuantumCircuit(len(hf_bitstring))\n", " for i, hf_bit in enumerate(hf_bitstring):\n", " if hf_bit:\n", @@ -432,15 +428,15 @@ " single_excitation_operators = []\n", "\n", " for p in indices_alpha:\n", - " for n in range(p + 1, half_orbitals):\n", - " if n not in indices_alpha:\n", - " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", + " for r in range(p + 1, half_orbitals):\n", + " if r not in indices_alpha:\n", + " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", " single_excitation_operators.append(exc)\n", "\n", " for p in indices_beta:\n", - " for n in range(p + 1, 2 * half_orbitals):\n", - " if n not in indices_beta:\n", - " exc = 1j * (C[p] @ D[n] - C[n] @ D[p]).simplify()\n", + " for r in range(p + 1, 2 * half_orbitals):\n", + " if r not in indices_beta:\n", + " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", " single_excitation_operators.append(exc)\n", " \n", " return single_excitation_operators" @@ -475,32 +471,32 @@ " if len(indices_alpha) > 1:\n", " # from these indices\n", " for p in indices_alpha:\n", - " for n in range(p + 1, num_alpha):\n", + " for r in range(p + 1, num_alpha):\n", " # to these indices\n", " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", " for b in range(a + 1, half_orbitals):\n", - " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", " double_excitation_operators.append(exc)\n", "\n", " # Both excitations from beta\n", " if len(indices_beta) > 1:\n", " # from these indices\n", " for p in indices_beta:\n", - " for n in range(p + 1, half_orbitals + num_beta):\n", + " for r in range(p + 1, half_orbitals + num_beta):\n", " # to these indices\n", " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", " for b in range(a + 1, 2 * half_orbitals):\n", - " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", " double_excitation_operators.append(exc)\n", "\n", " # One excitation from alpha, one from beta\n", " # from these indices\n", " for p in indices_alpha:\n", - " for n in indices_beta:\n", + " for r in indices_beta:\n", " # to these indices\n", " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", - " exc = 1j * (C[p] @ C[n] @ D[a] @ D[b] - C[b] @ C[a] @ D[n] @ D[p]).simplify()\n", + " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", " double_excitation_operators.append(exc)\n", " \n", " return double_excitation_operators\n" @@ -745,13 +741,6 @@ "print(f\"Found ground energy: {ground_energy}, exact energy: {min_eigval}, difference: {ground_energy - min_eigval}\")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "NOTE: The ground state energy went below the exact value computed by ``pyscf``. This numerical error is due to the approximation error in the simulation of the EvolvedOperatorAnsatz evolution (LieTrotter in this case)." - ] - }, { "cell_type": "code", "execution_count": 22, @@ -1060,7 +1049,7 @@ " print(f\"Operator: {max_operator} at index {max_index}\")\n", " # Grow the ansatz\n", " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) # TODO\n", + " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", " # Run VQE on the current ansatz\n", " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", From f8922d473b656d813ebc614443f4cdf78dff56c2 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Tue, 12 Mar 2024 13:52:59 -0700 Subject: [PATCH 13/17] add hardware --- .../tutorials/adapt-vqe-patterns.ipynb | 327 +++++++++++++----- 1 file changed, 250 insertions(+), 77 deletions(-) diff --git a/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb b/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb index de8e17d..393f3e0 100644 --- a/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb @@ -46,7 +46,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -72,28 +72,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Nuclear energy: 0.998447567773585\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/pyscf/dft/libxc.py:771: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, corresponding to the original definition by Stephens et al. (issue 1480) and the same as the B3LYP functional in Gaussian. To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n", - " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Nuclear energy: 0.998447567773585\n", "Electronic energy: -8.950577623117868\n", "Total energy: -7.952130055344282\n", "Total energy - nuclear energy: -8.950577623117868\n" @@ -117,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -150,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -248,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -275,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -340,7 +326,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -358,7 +344,7 @@ "
" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -381,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -421,7 +407,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -481,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -513,7 +499,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -553,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -578,16 +564,25 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibm_cleveland\n" + ] + } + ], "source": [ "# To run on hardware:\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", + "#service = QiskitRuntimeService(channel=\"ibm_quantum\", instance=\"ibm-q/open/main\")\n", "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", "backend = service.least_busy(operational=True, simulator=False)\n", - "# backend = service.get_backend('ibmq_kolkata')" + "print(backend.name)" ] }, { @@ -599,7 +594,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -628,7 +623,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -654,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -684,7 +679,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -728,17 +723,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, { "data": { "image/png": "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", @@ -746,7 +733,7 @@ "
" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -776,14 +763,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.83402244]\n" + "[3.36448432]\n" ] } ], @@ -802,7 +789,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -812,14 +799,14 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.966906270570856\n", + " fun: -7.966906275781369\n", " x: [ 3.024e+00]\n", - " nfev: 22\n", + " nfev: 24\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 22 F =-7.966906E+00 MAXCV = 0.000000E+00\n", - " X = 3.024164E+00\n", + " NFVALS = 24 F =-7.966906E+00 MAXCV = 0.000000E+00\n", + " X = 3.023952E+00\n", "\n" ] } @@ -841,15 +828,15 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Found ground energy: -7.966906270570856\n", - "[3.02416384]\n" + "Found ground energy: -7.966906275781369\n", + "[3.02395229]\n" ] } ], @@ -865,18 +852,18 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00707599 0. 0. -0.00170799 0.00707599 0.\n", - " 0. -0.00170799 -0.01805376 0. 0. 0.07148046\n", - " 0. -0.04085305 0. 0. 0. 0.\n", - " -0.04085305 0. 0.07148046 0. 0. -0.00025192]\n", - "Found maximum gradient 0.07148046043169676 at index 20\n", + "[ 0.00708851 0. 0. -0.00171134 0.00708851 0.\n", + " 0. -0.00171134 -0.01804218 0. 0. 0.07148705\n", + " 0. -0.04084253 0. 0. 0. 0.\n", + " -0.04084253 0. 0.07148705 0. 0. 0.00020266]\n", + "Found maximum gradient 0.07148705093020453 at index 11\n", "Maximum gradient is below the threshold: False\n" ] } @@ -903,17 +890,17 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAAAV1CAYAAABDPR50AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD9AklEQVR4nOzdeXRV5d024DthkFlBVLQgoIIKCChOqFWx0KoVtc4Vcai1aotaB7Dat9W+HayKQ9HWqXWuinNVrNWKI1Wr4ix1oIIiBI3gQAQhJN8fvvIZCYREQjjhutbKWrD3s/f5ZZ89nJx7P88uqqysrAwAAAAAAAAUmOKGLgAAAAAAAADqQtAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFSdAFAAAAAABAQRJ0AQAAAAAAUJAEXQAAAAAAABQkQRcAAAAAAAAFqWlDF0D1Kisr82nFwoYuY5m1Km6SoqKiOi9fWZlULFiOBQEAAAAANJDiZsnX+LoUqAVB10rq04qFaT/+gYYuY5nN3mVIWjep++5UsSB5aMxyLAgAAAAAoIEMOj5p0ryhq4BVg6ELAQAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEiCLgAAAAAAAAqSoAsAAAAAAICCJOgCAAAAAACgIAm6AAAAAAAAKEirRNBVWlqaUaNGZaONNkqLFi3SpUuXnHDCCSkrK8uRRx6ZoqKiXHzxxQ1dJgAAAAAAALXQtKELqG/PP/98dtttt5SUlKR169bp1atXpk+fnjFjxmTy5MmZNWtWkqR///4NW2g9WXjl1am46eY0OemnKd7121XmVVZWZuHIn6Vy0qQ0vXhMirp3a5gil1FFRUXuePwPGffkZSmZPSVrtF4rO/Y7IId953/Tsnnrhi4PAAAAAABYwRp1j67S0tIMHTo0JSUlOfnkkzNjxoxMnDgxJSUlOfvsszNu3Lg8/fTTKSoqSt++fRu63HpRPHxY0q1rFl52RSrfL60yr+L2O1P54kspHn7ISh9yJckld5+YS+8+Keuv0ysj9r4oO/bdP3c+Pia/vHJoKioqGro8AAAAAABgBWvUQdfxxx+fadOmZcSIERk9enTatm27aN6oUaPSr1+/lJeXp1u3bmnXrl0DVlp/ipo1S9ORJyfz5mXh+Rcuml75zrRUXH1tijbZOMX779twBS6jKSWv5G8TLsoOffbJmYfdnt23OSrH7Hl+jhl6fp6f/FAefuGmhi4RAAAAAABYwRpt0DVp0qSMHTs2HTt2zFlnnVVtmwEDBiRJ+vXrV2X6W2+9lT333DNt27ZN+/btc+ihh+aDDz6o95rrS1GPjVJ80AGpfHZiKsb9PZULF2bhOaOTyso0GXlyipo0aegSa/TQ8zemsrIy+3zzp1Wm777NUWnRrFX+OfH6hikMAAAAAABoMI32GV033nhjKioqMmzYsLRp06baNi1btkxSNej65JNPMmjQoHTo0CE33nhj5s6dm1GjRmWPPfbIhAkTUlxcmNlg8bDvp+KJp7Lwij+nePJ/U/na6yn+0Q9T1KVzQ5e2TF575+kUFxVn4/W3rjK9ebMW2WC9/nn9nacbqDIAAAAAAKChNNqga/z48UmSQYMGLbHNtGnTklQNui6//PK8++67efTRR7P++usnSTp37pztttsud911V/bee+/6K7oeFTVtmqYjT0r5cT9NxT3jUtSnd4r32buhy1pmH3w8Pe1ad0zzpqstNq/j6t/Iq1P/lQXl89OsafMGqA4AAAAAAKiNysrKfPrpp0mSVq1apaioqE7rabRB19SpU5MkXbt2rXZ+eXl5JkyYkKRq0HXPPfdkhx12WBRyJcnAgQOzwQYb5O67765T0LXlllumpKSkVstUNm+eXPbHWr/WUrVunTRrlpSXp2irLVO0HHun9ezRM0Xz59d5+eZNW+byEW8scf5n8z9Ns2pCrs+XbfF5mwWfCroAAAAAgAbXo2ePzC+f29BlwEqtoqIiM2bMSJL0798/zz33XJ3W02iDrrKysiTJ3LnVn0zGjh2b0tLStG3bNt27d180/dVXX83++++/WPvevXvn1VdfrVMtJSUleffdd2u3UIvV0qxOr1a9ysrKLDzvgqR8QbJ+l1TccFOKd9oxReutu1zWP33G9GTeZ3VevkWzVkudv1rzVpk7571q580vn/d5mxrWAQAAAACwIsyYPj3zFnza0GVAwZg5c2adl220QVenTp0ye/bsTJw4MQMHDqwyb8aMGRk5cmSSpG/fvlW6w82ePTtrrLHGYuvr0KFDXnvttTrXUluVzZvn/Tq9WvUq7rwrlS+8mOIjDkvxwG1T/pPjsvC8C9Jk9Nl17g74Zeutu97X7tG1NGu2Wy9vz3w188s/W2z4wtKP3s3qrTvqzQUAAAAArBTWXW89PbqgBl/u0bXOOuvUeT2NNugaPHhwJk2alLPPPjtDhgxJz549kyRPP/10hg8fntLS0iSfd4erb88880ytlylbWJ724x9YLq9f+e67qbjy6hRt3DPFB+yXoiZNUnzIsFRcdU0q7rwrTb6319d+jdffeD2tm9R9d1o4P3lozJLnb9xlqzz7+v157e1/Z7MNvrlo+vwF8/Lf6c9nsw12rPNrAwAAAAAsT2+8/kaauC8flqqsrCxt2rRJkjz++ON1Xs/ye0jTSmbUqFFZc801884776R3797ZbLPN0qNHj2y99dbZYIMNsssuuySp+nyuJGnfvn0+/PDDxdY3a9asdOjQYUWUvlxVVlRk4bnnJxUVaTLypBQ1aZIknwdePXuk4sqrUzl9RgNXWbOd+x2YoqKi3P7YhVWm3/vUFZm34NPssvmwhikMAAAAAABoMI026OrcuXMee+yxfPe7302LFi0yZcqUdOjQIZdddlnGjRuX119/PcniQdemm25a7bO4Xn311Wy66aYrpPblqeLW21P56qQUH3ZIitZff9H0oiZN0uSUk5KKhVl43gWprKxswCpr1n3dzbLndj/J4y/fnjOv2Sf3PvXnXHr3ybn07pPSd4OdssvmBzd0iQAAAAAAwArWaIcuTD4Pre65557Fps+ZMydTpkxJcXFx+vTpU2XeHnvskdNPPz3Tpk1L586dkyRPPfVUJk+enHPPPXeF1L28VL79diquuS5Fm26S4n33WWx+Ubeuy30Iw/p07J4XZp323XLvU5fn35PGpV3rjtl7++Ny2Hf+N8XFjTazBQAAAAAAlqCocmXvylMPnnrqqWy77bbZeOON85///KfKvI8//jibbbZZOnbsmF/96leZN29eRo0albXWWitPPPHECgtUluczulaE2bsMqddndAEAAAAAFIpBx8czuqAGX35G15w5c9K6des6rWeV7Abz0ksvJVl82MIkadeuXcaPH5911103Bx10UH74wx9mu+22yz333KPXEAAAAAAAwEqkUQ9duCRLC7qSZMMNN6x2yEMAAAAAAABWHqtkF6Wagi4AAAAAAABWfqtkj67x48c3dAkAAAAAAAB8Tatkjy4AAAAAAAAKn6ALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCA1begCqF6r4iaZvcuQhi5jmbUqbtLQJQAAAAAAAKsYQddKqqioKK2beHsAAAAAAACWxNCFAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkFaJoKu0tDSjRo3KRhttlBYtWqRLly454YQTUlZWliOPPDJFRUW5+OKLG7pMAAAAAAAAaqFpQxdQ355//vnstttuKSkpSevWrdOrV69Mnz49Y8aMyeTJkzNr1qwkSf/+/Ru2UGp04/iz8sa7E/PGtGdTMuutrNO+a64/fUpDlwUAAAAAADSQRt2jq7S0NEOHDk1JSUlOPvnkzJgxIxMnTkxJSUnOPvvsjBs3Lk8//XSKiorSt2/fhi6XGlz599Pz/Jvjs96aG6Zty/YNXQ4AAAAAANDAGnXQdfzxx2fatGkZMWJERo8enbZt2y6aN2rUqPTr1y/l5eXp1q1b2rVr14CVsiyu/dnk3P6rD3L2jx7Imu3Wa+hyAAAAAACABtZog65JkyZl7Nix6dixY84666xq2wwYMCBJ0q9fv0XTvgjGtt5666y22mopKipaIfVSs3XX3KChSwAAAAAAAFYijTbouvHGG1NRUZFhw4alTZs21bZp2bJlkqpB15tvvpnbbrstnTp1ylZbbbVCagUAAAAAAKD2Gm3QNX78+CTJoEGDlthm2rRpSaoGXTvuuGNmzJiRu+66K4MHD67fIgEAAAAAAKizpg1dQH2ZOnVqkqRr167Vzi8vL8+ECROSVA26iouXf/a35ZZbpqSkZLmvtzFp3rRlLh/xRkOXAQAAAADwtfXo2SPzy+c2dBmwUquoqFj07x122CHPPfdcndbTaIOusrKyJMncudWfTMaOHZvS0tK0bds23bt3r9daSkpK8u6779braxS6Fs1aNXQJAAAAAADLxYzp0zNvwacNXQYUjJkzZ9Z52UYbdHXq1CmzZ8/OxIkTM3DgwCrzZsyYkZEjRyZJ+vbtm6KionqvhaVr3rRlQ5cAAAAAALBcrLveenp0QQ0qKioyY8aMJMk666xT5/U02qBr8ODBmTRpUs4+++wMGTIkPXv2TJI8/fTTGT58eEpLS5Mk/fv3r/dannnmmXp/jUK3cH7y0JiGrgIAAAAA4Ot74/U30qR5Q1cBK7eysrK0adMmSfL444/XeT3L/4FUK4lRo0ZlzTXXzDvvvJPevXtns802S48ePbL11ltngw02yC677JKk6vO5AAAAAAAAKByNtkdX586d89hjj2XkyJF55JFHMmXKlPTq1SuXXXZZjjrqqGy44YZJBF2F5IFnr8t7s6cmST4sez/lC+fnr//8TZJk7fZdM2TA8IYsDwAAAAAAWMEabdCVJJtuumnuueeexabPmTMnU6ZMSXFxcfr06dMAlVEX9/37L3nxv49UmXb1P36RJOm7wU6CLgAAAAAAWMU06qBrSV555ZVUVlamZ8+eadWq1WLzb7311iTJq6++WuX/3bp1y5ZbbrniCqWK8459uKFLAAAAAAAAViKrZND10ksvJVnysIX7779/tf8/7LDDcvXVV9drbQAAAAAAACwbQVc1KisrV2Q5AAAAAAAA1EFxQxfQEGoKugAAAAAAAFj5rZI9usaPH9/QJQAAAAAAAPA1rZI9ugAAAAAAACh8gi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAK0ioRdJWWlmbUqFHZaKON0qJFi3Tp0iUnnHBCysrKcuSRR6aoqCgXX3xxQ5fJUkx7//Vc/Y9f5riLts1+Z66VPf+nbY4+v3/++uBvM3d+WUOXBwAAAAAANICmDV1AfXv++eez2267paSkJK1bt06vXr0yffr0jBkzJpMnT86sWbOSJP3792/YQlmq+56+Mnf9648Z2GvPfGvzYWnSpFlemPxQrr7vf/LoCzdnzHFPZrVmLRu6TAAAAAAAYAVq1EFXaWlphg4dmpKSkpx88sk544wz0rZt2yTJOeeck1NPPTVNmzZNUVFR+vbt28DVsjTf3Gy/fH/QaWndcvVF04YOPCbf6NgjNzz42/z933/J3tuPaMAKAQAAAACAFa1RD114/PHHZ9q0aRkxYkRGjx69KORKklGjRqVfv34pLy9Pt27d0q5duwaslJps3GXLKiHXF3bud2CSZErJyyu6JAAAAAAAoIE12qBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12/RtFtvvTX77rtvunbtmlatWmWTTTbJz3/+88yZM2eF1E3tvP/RtCRJ+zbrNHAlAAAAAADAitZog64bb7wxFRUVGTZsWNq0aVNtm5YtP3+m05eDrtGjR6dJkyb53e9+l7///e859thjc8kll2TXXXdNRUXFCqmdZbOwYmH++s9fp0lx0+yy+cENXQ4AAAAAALCCNdpndI0fPz5JMmjQoCW2mTbt895AXw667r777qy11lqL/r/TTjtlrbXWyrBhw/L4449nxx13rKeKqa1L7vppXp36RH6w2+/SZe2NG7ocAAAAAABgBWu0QdfUqVOTJF27dq12fnl5eSZMmJCkatD15ZDrC1tuuWWS5N13361TLVtuuWVKSkrqtOyqonnTlrl8xBvL3P7q+36Rv024ON/d5kf5/i6n1WNlAAAAAAC106Nnj8wvn9vQZcBK7cuj6O2www557rnn6rSeRht0lZWVJUnmzq3+ZDJ27NiUlpambdu26d69+1LX9dBDDyVJNt100zrVUlJSUueQbFXRolmrZW577f1n5q8P/ibf2eqInLDvpfVYFQAAAABA7c2YPj3zFnza0GVAwZg5c2adl220QVenTp0ye/bsTJw4MQMHDqwyb8aMGRk5cmSSpG/fvikqKlriet5999384he/yK677pr+/fvXuRaWrnnTlsvU7tr7z8x1D/wqQwYclpP2+/NS3zsAAAAAgIaw7nrr6dEFNaioqMiMGTOSJOuss06d19Nog67Bgwdn0qRJOfvsszNkyJD07NkzSfL0009n+PDhKS0tTZKlhldz5szJXnvtlebNm+fKK6+scy3PPPNMnZddVSycnzw0Zultrnvgf3PdA7/K4C2G55QDrkxxcfGKKQ4AAAAAoBbeeP2NNGne0FXAyq2srCxt2rRJkjz++ON1Xk+jDbpGjRqVG264Ie+880569+6dTTbZJPPmzcubb76Z3XbbLd26dcs//vGPKs/n+rK5c+dm6NCheeutt/LYY49l3XXXXcG/AV/2twl/zLX3n5G111g/W/QYnPHP3VBlfvu262RAzyENVB0AAAAAANAQGm3Q1blz5zz22GMZOXJkHnnkkUyZMiW9evXKZZddlqOOOiobbrhhklQbdC1YsCD77bdfnnnmmTz44IPp1avXii6fr3jtnaeTJO99+HbOGXvYYvP7brCToAsAAAAAAFYxRZWVlZUNXcSKNmfOnLRr1y5FRUX55JNP0qpVq0XzKioqctBBB+Wuu+7Kvffem1122aUBK111LMvQhQAAAAAAhWDQ8TF0IdTgy0MXzpkzJ61bt67Tehptj66leeWVV1JZWZmePXtWCbmS5Cc/+UluueWW/OxnP0urVq3y5JNPLpq34YYbZq211lrR5QIAAAAAAFCN4oYuoCG89NJLSaoftvDvf/97kuT3v/99Bg4cWOVn3LhxK7ROAAAAAAAAlmyV7NG1tKBrypQpK7gaAAAAAAAA6kKPLgAAAAAAAArSKtmja/z48Q1dAgAAAAAAAF/TKtmjCwAAAAAAgMIn6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIK0SgRdpaWlGTVqVDbaaKO0aNEiXbp0yQknnJCysrIceeSRKSoqysUXX9zQZQIAAAAAAFALTRu6gPr2/PPPZ7fddktJSUlat26dXr16Zfr06RkzZkwmT56cWbNmJUn69+/fsIWyVO+891qu/+f/5o13J+aDj6dn4cIFWXuN9bP1Jrtn/51HZs126zZ0iQAAAAAAwArWqIOu0tLSDB06NCUlJTn55JNzxhlnpG3btkmSc845J6eeemqaNm2aoqKi9O3bt4GrZWne/2haZn08I9v3+V7WWr1zmhQ3zVslL2XcU5fnoRduyqUnPp/2bdZu6DIBAAAAAIAVqFEHXccff3ymTZuWESNGZPTo0VXmjRo1KjfccENeeOGFdO/ePe3atWugKlkWW/T4Vrbo8a3Fpm/Wfcf85voDcv/TV+fAQaMaoDIAAAAAAKChNNpndE2aNCljx45Nx44dc9ZZZ1XbZsCAAUmSfv36LZr22GOPZfDgwVl33XWz2mqrpXPnzjnwwAMzadKkFVI3tbNO+65JkjlzZzdwJQAAAAAAwIrWaHt03XjjjamoqMiwYcPSpk2batu0bNkySdWga/bs2dlss81y9NFHZ+211860adNy1llnZeDAgXn55ZfTuXPnFVI/1Zu/YF7mzp+T+QvmZerMV/Pne09Nkmy9ye4NXBkAAAAAALCiNdqga/z48UmSQYMGLbHNtGnTklQNuvbcc8/sueeeVdpttdVW2XjjjXPbbbflhBNOqIdqWVb3/vvP+eOdxy36f6f23fKz71+fzTb4ZgNWBQAAAAAANIRGG3RNnTo1SdK1a9dq55eXl2fChAlJqgZd1VlzzTWTJE2b1m1zbbnllikpKanTsquK5k1b5vIRb9TYbvvee2f9tTbJ3Plz8ua7z+WJV+/KR2WlK6BCAAAAAIBl06Nnj8wvn9vQZcBKraKiYtG/d9hhhzz33HN1Wk+jDbrKysqSJHPnVn8yGTt2bEpLS9O2bdt07959sfkLFy5MRUVFpk6dmtNOOy2dOnXKAQccUKdaSkpK8u6779Zp2VVFi2atlqndWmt0zlprfD585PZ99s43N9s3I8Zslc8WfJrv73JafZYIAAAAALBMZkyfnnkLPm3oMqBgzJw5s87LNtqgq1OnTpk9e3YmTpyYgQMHVpk3Y8aMjBw5MknSt2/fFBUVLbb8TjvttKjH10YbbZTx48dnrbXWqnMtLF3zpi3rtNwG6/XNht/YPHf/60+CLgAAAABgpbDueuvp0QU1qKioyIwZM5Ik66yzTp3X02iDrsGDB2fSpEk5++yzM2TIkPTs2TNJ8vTTT2f48OEpLf18uLv+/ftXu/xf/vKXfPjhh3nrrbdy7rnn5tvf/nYmTJiQ9ddfv9a1PPPMM3X+PVYVC+cnD42p27LzF8zNJ5/OWr4FAQAAAADU0Ruvv5EmzRu6Cli5lZWVpU2bNkmSxx9/vM7rKV5eBa1sRo0alTXXXDPvvPNOevfunc022yw9evTI1ltvnQ022CC77LJLkiU/n2vjjTfONttsk4MOOigPPvhgPvnkk5xzzjkr8lfgS2Z9XP0zzp5/86FMKXk5m3TddgVXBAAAAAAANLRG26Orc+fOeeyxxzJy5Mg88sgjmTJlSnr16pXLLrssRx11VDbccMMkSw66vmyNNdbIRhttlDfffLO+y2YJxtx+bD74ZEb6b7RL1lmja+aXz8sb057Nwy/clJartc3Re5zX0CUCAAAAAAArWKMNupJk0003zT333LPY9Dlz5mTKlCkpLi5Onz59alzPe++9l9deey3bbLNNfZTJMhi0+ffzwLPX5sFnr8uHZe+nKEVZp33XfHfbo3PATiOzdvvaDykJAAAAAAAUtkYddC3JK6+8ksrKyvTs2TOtWrWqMu+QQw7JRhttlP79+2eNNdbIG2+8kQsuuCBNmzbNiSee2EAVs1O/A7JTvwMaugwAAAAAAGAlskoGXS+99FKS6oct3HbbbXPttdfmD3/4Q+bNm5cuXbpk0KBBOf3009O1a9cVXSoAAAAAAABLIOj6ihEjRmTEiBEruiQAAAAAAABqqbihC2gISwu6AAAAAAAAKAyrZI+u8ePHN3QJAAAAAAAAfE2rZI8uAAAAAAAACp+gCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgILU6IOu0tLSjBo1KhtttFFatGiRLl265IQTTkhZWVmOPPLIFBUV5eKLL27oMqmDefM/zfCzNsiQkUW56I4RDV0OAAAAAACwgjVt6ALq0/PPP5/ddtstJSUlad26dXr16pXp06dnzJgxmTx5cmbNmpUk6d+/f8MWSp1c849f5qOy9xu6DAAAAAAAoIE02h5dpaWlGTp0aEpKSnLyySdnxowZmThxYkpKSnL22Wdn3Lhxefrpp1NUVJS+ffs2dLnU0hvTJub2xy/MoUN+1dClAAAAAAAADaTRBl3HH398pk2blhEjRmT06NFp27btonmjRo1Kv379Ul5enm7duqVdu3YNWCm1tbBiYS649ahstfGu2WGzfRq6HAAAAAAAoIE0yqBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12+J69ltt91SVFSUM888sz7KpI5uf/SCvPPefzJib89WAwAAAACAVVmjDLpuvPHGVFRUZNiwYWnTpk21bVq2bJlkyUHXzTffnOeff76+SqSOZsx6K9fef0aGDfllOnXo1tDlAAAAAAAADahpQxdQH8aPH58kGTRo0BLbTJs2LUn1QdfHH3+cn/70pxk9enQOOeSQr13PlltumZKSkq+9nsasedOWuXzEGzW2+8Ntx6TTmhtkvx1PWgFVAQAAAADUXo+ePTK/fG5DlwErtYqKikX/3mGHHfLcc8/VaT2NMuiaOnVqkqRr167Vzi8vL8+ECROSVB90/fznP0/Pnj0zbNiw5RJ0lZSU5N133/3a62nMWjRrVWObfz57fSa+8UDOP/bRNG3SbAVUBQAAAABQezOmT8+8BZ82dBlQMGbOnFnnZRtl0FVWVpYkmTu3+sR87NixKS0tTdu2bdO9e/cq85555plcccUVefbZZ5dbPZ06dVpu62qsmjdtudT588s/y2V3n5StN9k97dt2yrulbyZJSj/6PEAsm/dR3i19M6u37pg2Ldeo73IBAAAAAJZo3fXW06MLalBRUZEZM2YkSdZZZ506r6dRBl2dOnXK7NmzM3HixAwcOLDKvBkzZmTkyJFJkr59+6aoqGjRvIULF+boo4/OiBEj0rt37+VWzzPPPLPc1tVYLZyfPDRmyfPnL5ibD8vez1OTxuWpSeMWm//gxOvz4MTr86Pvnpv9dz6lHisFAAAAAFi6N15/I02aN3QVsHIrKytLmzZtkiSPP/54ndfTKIOuwYMHZ9KkSTn77LMzZMiQ9OzZM0ny9NNPZ/jw4SktLU2S9O/fv8pyF198cWbOnJkzzzxzBVdMTVo0b51fDL9lsekfzXk/Y+74cbbaeNfsuvWR2WDdvg1QHQAAAAAA0BAaZdA1atSo3HDDDXnnnXfSu3fvbLLJJpk3b17efPPN7LbbbunWrVv+8Y9/VHk+V2lpaX7xi19k9OjRKS8vz4cffrho3rx58/Lhhx+mXbt2KS4uboDfiKZNmmXHvvstNr1k1pQkybprbljtfAAAAAAAoPFqlKlN586d89hjj+W73/1uWrRokSlTpqRDhw657LLLMm7cuLz++utJUiXomjZtWj755JMcffTRad++/aKfJDn77LPTvn37vP322w3y+wAAAAAAALC4osrKysqGLmJFmjNnTtq1a5eioqJ88sknadWq1aLp1T1La9CgQTnssMNy+OGHZ9ttt02LFi1WdMmrhJqe0QUAAAAAUCgGHR/P6IIafPkZXXPmzEnr1q3rtJ5GOXTh0rzyyiuprKxMz549F4VcSdKmTZvsvPPO1S7TrVu3Jc4DAAAAAACgYTTKoQuX5qWXXkpSddhCAAAAAAAACs8q16OrtkHXKjayIwAAAAAAQMHQowsAAAAAAICCtMr16Bo/fnxDlwAAAAAAAMBysMr16AIAAAAAAKBxEHQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkJo2dAFUr7KyMp9WLGzoMpZZq+ImKSoqaugyAAAAAACAVYigayX1acXCtB//QEOXscxm7zIkrZvYnQAAAAAAgBXH0IUAAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUpFUi6CotLc2oUaOy0UYbpUWLFunSpUtOOOGElJWV5cgjj0xRUVEuvvjihi6zXiy88uos+Pbuqbjv/sXmVVZWpvyUU7Pgu3um8q0pK764Whoysqjan6E/b9PQpQEAAAAAAA2gaUMXUN+ef/757LbbbikpKUnr1q3Tq1evTJ8+PWPGjMnkyZMza9asJEn//v0bttB6Ujx8WCqefCoLL7siRQO2SNFaHRfNq7j9zlS++FKKf3B4irp3a7gia2Gz7t/M7tv8qMq0pk2aNVA1AAAAAABAQ2rUQVdpaWmGDh2akpKSnHzyyTnjjDPStm3bJMk555yTU089NU2bNk1RUVH69u3bwNXWj6JmzdJ05MkpP/7ELDz/wjQ96zdJksp3pqXi6mtTtMnGKd5/3wauctl16rBBBg84pKHLAAAAAAAAVgKNeujC448/PtOmTcuIESMyevToRSFXkowaNSr9+vVLeXl5unXrlnbt2jVgpfWrqMdGKT7ogFQ+OzEV4/6eyoULs/Cc0UllZZqMPDlFTZo0dIm1sqB8fuZ+NqehywAAAAAAABpYow26Jk2alLFjx6Zjx44566yzqm0zYMCAJEm/fv0WTXv44YdTVFS02E+hD21YPOz7yQYbZOEVf07FHy9N5Wuvp/jwQ1PUpXNDl1Yrj710a/b4eavs+T9ts/+Za+fiO49L2dyPGrosAAAAAACgATTaoQtvvPHGVFRUZNiwYWnTpk21bVq2bJmkatD1hT/+8Y/ZYostFv2/devW9VPoClLUtGmajjwp5cf9NBX3jEtRn94p3mfvhi6rVjbpsnV27Lt/1uu4UT6d93H+/Z9787cJF+fFyY/kDyP+lZarVf8+AwAAAAAAjVOjDbrGjx+fJBk0aNAS20ybNi1J9UFXr169su2229ZPcQ2ldeukWbOkvDxFW22ZouLC6tB30fFPVfn/kC0PTfd1++aq+36e2x//Q4Z96+cNVBkAAAAAANAQGm3QNXXq1CRJ165dq51fXl6eCRMmJKk+6Fqettxyy5SUlNRqmcrmzZPL/rjcaqisrMzC8y5Iyhck63dJxQ03pXinHVO03rrLZf09e/RM0fz5dV6+edOWuXzEG7Ve7oCdR+b6B36Vf08aJ+gCAAAAAFYKPXr2yPzyuQ1dBqzUKioqFv17hx12yHPPPVen9TTaoKusrCxJMndu9SeTsWPHprS0NG3btk337t0Xm3/ggQemtLQ0a665Zvbcc8/8/ve/T8eOHetUS0lJSd59993aLdRitTSr06tVr+LOu1L5wospPuKwFA/cNuU/OS4Lz7sgTUafnaKioq+9/ukzpifzPqvz8i2atarTck2bNMua7dbLR2WldX5tPvfv//w9v7hqaK44+eWsv/YmNbY/5Hfdsk77bjnv2Ie/9mvPXzAvPzh3k+yy+bD8YLfffu31AQAAALDyueSuE/PUpHH58ymvpGmTZss8rxDNmD498xZ82tBlQMGYOXNmnZdttEFXp06dMnv27EycODEDBw6sMm/GjBkZOXJkkqRv375Vgp7VV189I0eOzI477pg2bdrkiSeeyFlnnZUnn3wyzzzzTFq0aFGnWmqrsnnzvF/rpZawrnffTcWVV6do454pPmC/FDVpkuJDhqXiqmtSceddafK9vb72a6y37npfu0dXXcxfMC/vfzQtm3ZtZMNMrmALF5bnsrtPzrc2H7ZMIdeS3P7YhWndYo18Z6vDa7XcrY+enzlzP8z+O52SJLnz8Yvyx78dnyN2/W0O/tbpi7X/+NNZOWp07zRv2iKXnfRifnHV0Lz430dqfJ3hQ87Iod8+M9fef2aue+BXNbbvu8FOOe/Yh/PC5IdzyqVLHgb1yx44tzL/e+1+mfDyHTnv2EfSp/sOi7V5+a3Hc/IlO2X7Pt/LLw+9NX/5++m5afxZOXn/v2TXrX9QpW1lZWVOuXRQJk19In/86bPp3qlPzrnp8Dzw7DU11jJkwGEZddDV+cfTV2f0zUfU2H6d9l1z/elTUjJrSoaftfgNANW57rS3cueEi3Lbo+fntIP/ml02P3ixNu+Wvpljzu+Xbutulgt/MiFNipss07q/rnnzP83RF/RL2dwPc8Upr6R9m7WrzJ8689Uce+EW2bjLVjnvmEdSXFycISOXLfgffcxD6bfhzjn5kp3rbd/79RF35+jz+2Z++bxcccoradeqw2Ltbnjwd7nqvp/nJ3uNyW2Pnr9sbfe+KN079anVPp2kXrfNwF575viLt02/DQfl90f9o9p2P7viO3lh8kMZM+LJ9Oi8RbVt6kOhH5+dOnTLuCcvz4W3HZ1hg3+Rw7/zv4u1+/2Nw/PgxOtz1g//kS03/nZmfVySH57XO2u0XiuXnPhcVmtW9Ro98Y0H87MrhmRQ/+/ntIP/WqeaDvldt8ycPbXG9qcccFW+s9XhtdquR+z6mxx1Xp+stUaX/OmEZ9OsafPF2l1w649y71NX5NdH3J1te+2xTLV/XZfefXKtzpWH/X7DettGddn3kuR3fz04D79wU35/1APZose3qrT7bMHcHHNB/3xUVpo/n/xKHn3xllXqWr6irGrHZ/+Ndinoa/l5xz6cioqKnHzpTnntnadzyU+fS9d1Nq3SbvYnM3PUeX3SuuUauezEF9Kied1uAKyt9z+cVqv34qOy0nq/XtVm32vXes388qo9s/s2R+XE/S5frM2C8vn58R8G5P0P38lP9r4o59x06DK1veLkl3PVff9T8NfyFaW258rGcHzW9r2o7+tVUvvP6c+8dn9O+/N3MniL4Tn1+9cu1u7q+36Rvz74m5y43+XZfZujlmndy8uqtn232ni3gj4Xf2erw/NWycv5yYUDsmnXgRl9zEOL3Uz/93//Jeff8sN8f5fTF93YfODOp2bck5fl7icuyfd2OL5K+6XNK0TrrreeHl1Qg4qKisyYMSNJss4669R5PY026Bo8eHAmTZqUs88+O0OGDEnPnj2TJE8//XSGDx+e0tLPewD179+/ynKbb755Nt9880X/33nnndOnT5/sueeeufHGG3PEETVfUL7qmWeeqfUyZQvL0378A7Ve7qsqKyqy8Nzzk4qKNBl5UoqafP4Fc/EB+6Vywr9SceXVKd5m6689hOHrb7ye1k3qvjstnJ88NGbJ8z8u+yDtWq+52PSr//GLLKwoz7abDq3za5M88uItefu9STl92I3LvMyVo15LUap+gLn9sQuzTvtutQq6PlswN7c8cm6+s9URaduqfZJkr+1HZMIrd+b6B36VbTfdIxus17fKMhfd8ZPMnjMz5x49Pq1atM3B3/p5dtv6h9Wuf8HCz3Lp3Sdl7mefpFfX7ZIkO/TZJ+utudESa7rlkdH574wXFv2xtv7am+bUg65bYvun/jMuDz9/U3p32z5Jcvw+l+Sltx7LuWMPz6UnvZCWzVsvajtv/qc5d+zhade6Y07Y99IkyaFDzsyTr96dS+8+KQN6fjtrrdF5UfvbH7swL/73kRy521np3qlPkmSPbY/OFj0GV1tLZSpz1d9Pz/sfTVtUf98Ndlxq/Q88e00mvvHP9On2efvV26y11PavvfPv3DnhonyjY4+s0Wbt/GDX3+bp//w9F995XPptOChrtvv/55OKioqcO/bwVKYyow68ZoWFXEnSonmrjDzgqpx8yU4Zc9uxOeOw2xbNW7iwPGffdGiaFDfNyAOuTvH/PbNwab/3jFn/zbX3n5HVW3dM57U2TpJ63fdatWibUw68KiMv2yUX3f7j/PyQm6q0fWvGS7n+gV9l842+lb22H5Hu6262bG23+0k+nPNerfbp+t42PTpvkYN3+XmufeDM3P3EpRk68Jgq7e954rI8+/r9OfTbv1qhIVdS+Mdnknx32x/lsZduy03jz8r2vfeusg0ff+mOPDjx+nx326MXfTHWoV2njNj7opx1w7Bc9fef55g9z1/Uvmzexznv5h+kfdtO+cneF9W5pmP3vDBzP5tTbftP5s7KZXefnCbFTdOz84Aktduua63ROT/e6w85d+zhueb+X+aHu/++SvunX/tH7n3qinxnqyNWWMiVpNbnyvrcRknt970kGfG9i/PC5Idy/i1H5vKTXkqrFm0XzfvzvT/LtPdfz+nDbkyHdp1WuWv5irIqHp+FfC1PkuLi4pxywFU55vx+OXfsYfnDiCeqfB668Laj88mns3LmYXeusJArSa3fixkf/Lfer1e12fe6r7tZvr3l4bn3qSuyQ599stUmu1Zpf+39Z2RKycsZdeA1GTJgeJ5/c/wytV1rjc6N4lq+otT2XNkYjs/avhf1fb1Kar9dt9z429l9m6Ny71NX5Jt998t2vfdc1P61d57OTQ/9Plv2/M4KD7mSVXP7FvK5OEm6d+qTQ4ackavu+3nunHBRlXBq5uypufTuk9K902YZPuSMRdM7tOuUnfsflJse+n32HPjjNPnS94lLm1eI3nj9jTRZPL8EvqSsrCxt2rRJkjz++ON1Xk9RZWVl5fIqamUybdq09O/fPx988EGaNm2aTTbZJPPmzcubb76Z3XbbLRUVFfnHP/6Ryy+/PEcdtfSLd2VlZdq2bZvDDjssf/zj8ntu1tIsr6Br4c23puLPV6b4h0ekyQH7V5lXOWVqyn9yXIo22eRrD2E4e5ch9Rp0XXLXiZk09cn022hQ1l5j/cz7bE7+/Z978/zkh7LJ+ttk9DEPLXZHK8vuxD99M5/O+ziXnfTC11pPXYYz/OLunkt+OjEbfeP/h8wzZ0/Nj87vm3U7bJCLj//3oi7rj710e/732n2zzzd/mmP3vKDG9Z93yw9z37//kkO//asMH/LLGtv/89nrc/ZNw7NFj8H53Q/vqzGYmTpzUo6/aJu0WK1NLjlhYjq0+7wH54SX78yZ13wvQwf+OMfv8//PGxffeVz+NuHi/OqwO7Ndn//fm/KNaRNz3EXbpP9Guyzq0fLOe6/l2As3T/d1+y5zT6jrH/h1rrn/l/nOVkfklAOurLH9C5MfzqmXD0mXtTfJmOOerPLHaXVmfzIzP/7DgJTN+yhjRjyZbp16J0lee+eZnHDxwGy58Xfymx/cs6j9LY+cl8vvOSXH7nlh9vnmCTXW81Vf3CH7xd1ldXHpXSfltscuqNKL4rr7f5VrHzgzI/a+OHtt/5Ma1zFv/qc54eKBmTLzlfz+qPuz+Ua71LjM8tr3/vS3n+aOx/+Q/znk5uzU7/Pz+MKF5Rlx0daZ/sHkXHHSS1m7/fq1brskS9qn63vbLFxYnuMu3jbT3n8tl530Ytbt8PmdhzNnT82PztssndfaOGNGPFGnP3SGjCxadKdvXRT68Zkk7334Tn503mZV7hb9cM77Oeq8PmnRvHUuP+nFtFytTZX1/eqaffOvV+6scpf2uWOPyP3PXJ3f/OCebLPpd2v8HZZWU3UqKipy+l92y7Ov3//5l5NbHlrjayxpu55x9d55ctI9ueDHj6fX//X8Lpv7UY46r0+Kiopz+ckvpXWLdjWu/6sO+V239N1g54w66OpaL7s8zpXLcxstydL2vX+9clfOuHqvKj0jXpj8cEZetkt22Gzf/HL4LYvarmrX8mX1xd3nX9wpXher2vFZ6NfyJLnj8TH5099OqNLL8f5nrsm5Yw/P/judkh/tcW6N66/O1/2stDzOlcvzelWdJe17ZfM+zo/O2ywVlQtzxckvp03LNZIk/3n73znhj9tl4KZDc+bhd9S67dIU2rV8WX2dz0rL41xZaMfn8novltf1akmWtl0/nfdJfnT+ZllQ/tmiESHmL5iXYy/cIrM+mZErTn45HVf/Ro2/Q3W+zmelZNXcvoV8Lk6ShRULc8LFAzO15JVcetIL+UbHjVJZWZlRlw/Oy289louOe6rK9z1J8vybD2XkZbvkl8NvzTf77rvM8wrNoOMj6IIafDnomjNnTlq3Xvr5a0mKl2dRK5POnTvnsccey3e/+920aNEiU6ZMSYcOHXLZZZdl3Lhxef3115Mk/fr1W+Z1Lo9nWa1IlW+/nYprrkvRppukeN99Fptf1K1rig8ZlsqXXk7FnXc1QIXLrt8GO6dVi3Z54JlrcsldP82195+Rjz+dlSN2/W3OO+bhgg655pd/lhse/F1+OLp3dj+tRfb+xRr5xZVD8+a7///Be+9/OC37nLFmjhrdJ58tqNrl+awbhuXbo4oz8fV/Lpo2ZGRRzrnp8Ex8/Z857qJts8fprXLArzrlj387YbE7c2Z9XJKX33o8W2+ye63qPuR33XLyJTtXec2Zs6fmxf8+kiEjixb9lMyastT1PPrCLenQttNiH3rWad81xw69IJOnP5/rH/h8yIKPykoz5vZj02WtjfOD3X5XY413/+uS3Pfvv2TbXkNzyOBf1Nj+zXefy4W3/SjrtO+anw+7qcYPwmVzP8qZ1+ydBeWf5Yzht1X5ILx9n70zeIvhuefJSzLxjQeTfP7B865//TFDBhy62B97PTpvkYN2OS3Pvn5/xj15eRZWLMw5Nx36+YfDZewJ9dSke3PdA2emZ+ctc/z3/lRj+/dmv53fXHdAWq7WJmcedkeNH4TLFy7I/163X0o/ejenHHBVlQ/CG3fZMgftclqemjQuf//3X5J8HgRcfd//pN+GOzfokANH7PbbdF6rZy6+87jM+rgkb0ybmBvG/zb9N9ole27342Vax3k3/yD/nfFifrj72cv0h/fy3PeO3P2sdFlr41x0x48z+5PPxyq+4cHf5s13n8uxe15YJbiqTdvqLG2fXpLltW2aNGmaUw+6NuULF2T02CNSWVmZysrKjL75BylfuCCjDrq2we7mK/TjM0nWXqNLjhl6fqaUvJxrHzgzSTLm9mPzUdn7OeWAK6v9suD4fS9J21Ydcu7NR2Te/E/zxKt35/5nrs53tjpimb5Er6mm6vzl759v5722H7FMX6Ivbbv+dL/L07Zl+5w79rBF184/3fXTlH78bk458Ko6hVxf1/I4Vy7PbVSdmva97XrvmcFbDM+9T12Rp1/7Rz6d90lGjz0iq7deKyfsc0mVtqvatXxFWtWOz0K/lifJ3tsfl74b7JTrH/hV3ip5Oe9/OC1/+tsJWX/tTXP4d369TL9Dffi658rlfb2qzpL2vdYt2uXkA67MBx9Pz8V3Hpfk86Htzx17eNq17JAT9rusTm2XpBCv5SvC8jhXFtrxuTzei+V5vVqSpW3XVi3a5qT9/5LZc2bm4jtGJEmuvO/nefu9Sfnxnn+oc8i1PKyK27eQz8VJ0qS4SUYeeE0WVi7M6JuPSEVFRf424eI8/+b4HPyt/1ns+54k2WyDHdOiees8+uIttZoHsCSF3f+zBptuumnuueeexabPmTMnU6ZMSXFxcfr06VPjeu66666UlZVl6623ro8y603R+uun2bi/LbVNk+8fmCbfP3AFVVR32/XZq0G/TKgv5QsX5PQ/75pXp/wr3xowPHttNyJl8z7KvU9dkZ/+cfucd+yj2bjLlllrjc455YCrcsbVe+WSv/00P/2/P8Tu+/eVGf/cDTlo0M+yRc+qw2u8+e7EPPbSrdl9m6MyZMCheX7yQ7nz8TGZUvJyzj7qgUXDu3wx5vnGXb7e/n3qQdfl0rtPTLvWHXPwLj9fNH31NmstcZmFFQvzytQJ6b9h9X/M7Lr1DzLh5Tty00O/z8Dee+bmh8/Nx59+kF8fcXeN4ebLb03In+46IZ3X6pmfHXRdjUH1R2WlOfOa7yVJzjzsjmqHyvyyysrK/P7GQzLt/ddz/D6XpFe3gYu1+cneY/LC5Idy3s0/yB9GPJHRN/8gHdt9Iz/Zq/rui4cM/kWeeOWuXH7PKZk8/fn8551/5+g9zkuXtTdeai1JMu39N/L7G4elXas1c8Zht6d5s6U/T3D+gnk589p98vGnH+R/j7g73+i45OEevvCnv/00L7/1eA4cdGp27LtftfU/NemeXHr3Sem/4aCcO/bwNG3SLKcccFWD3iiwWrOWGXngNTnxTzvkvFuOzHsfvp3mTVvklAOuXKa6bn743Dz8wtjs3O/A7L/TyTW2X9773mrNWmbkQdfkp3/cPhfednSGDzkzN4z/bbbtNTS7bnVEndt+1bLs01+1vLdN13V65Yjv/CaXjxuZ2x+7ME2bNM/zb47Pj/YYvdgzE1a0Qj8+k8/PqY+9dFtufviclJfPz2Mv3Za9tz8u/Tbcudr27dusneO+96f85voDMub2Y/Ps6/dnrdU759ihNffAWdaavuyRF27JzQ+fkz7dd8gxQ8+vsX1N27V9m7Vz/D6X5NfX7Z8/3/uzbNnz27n/mauz1/YjlulLtPrydc6Vy3sbfdWy7ns/2XtMnp88Phfc8sNstsGOKZk9Jb889Las3rrjYm1XtWv5irKqHZ+Ffi1PPr9p8pQDr8rR5/fNOTcdmnatOmbu/DkZddA1NR6b9enrnCvr63r1ZTXte1v0+FaGDvxx7vrXH7NDn33y6tR/5e33JuWXw29d7JlutWn7VYV6LV9Rvs65slCPz6/zXtTH9eqrlmW7btHjW9lj22Nz9xN/SsfVv5E7HrswA3vtuUw3M9S3VW37Fvq5OEm6rvN5MHzFuFH5010n5B//vjI9vrFFDt5l8We1Jp+HYxt32ara5/AtbR7AkjTaHl1L88orr6SysjI9evRIq1ZVx0E/5JBD8stf/jJ33nln/vnPf+bXv/51DjnkkPTv3z8HHXRQA1VMY/W3CRfnhckP51dH3JWT9/9zhm53bA7a5We55MTn0q51x1x+zymL2m7Xe8/svf1xGffU5Xn0xVvz9nv/yR/vPC6brr9ttXeZvVXyUn72/etz7J4XZM/tfpxfDr8le+9wfJ5/c3weefHmRe2mznw1SbLemht+rd9l8IBD0qJ567Rvs04GDzhk0c/S7iR678O3M/ezOUt97RP3uyKtW6yen/9l9zz64i05aNDPssn6Sw/lSj+anl9ft1+aNV0tZx52R1q3XH2p7RdWLMxvrjsgM2dPzQn7Xlbt3UZfdc39Z+TJSfdk161+sNjzhL7QpuUaOWn/v+S9D9/OMRf0y8zZU3LyAVcusZ6mTZpl1EHXZH75vNz9xCXp032H7PPNn9ZYy9zP5uTMa/bOp599kp8fMjZrr9GlxmUuvO3ovDHt2Qwfcma22bTm3nz3PX1V7n7iT9mix5Acsetvl1L/tVlQ/lmOu2ibTHr7yRw99Pw6Dzm4PPXqum322/Hk/Ps/92ZKycs5euh5Wad91xqXm/j6P/OXv5+W7p02y0kH/KXG9vW17226/jY5cOdT869X/pafXTEkrVZrlxP3Xfxh6rVt+2XLsk9/WX1tm313PCl9uu+Qq+77ef5876nZrPs3s+83T6xx/fWt0I/PL5y43xVpvVq73ProeVmv40Y58ivPAfiqnfrtn536HZAHnr02sz4pyUn7/6XG/bq2NSWfP0du9M1HZM126+UXh9yyaIi7JVnW7bpj3/2yy+YH528TLsrZNx2ab3TskR/ufnaN9dSnup4r62sbfdmy7nttWq6RE/e7Iu9/NC3jn7shu2x+cL652eKjB3xhVbqWr0ir2vFZ6NfyJFm3Q/cctfs5efPd5zLxjQdy4M6nZuMuW9VYU32r67myPq9XybLve0d995ys13GjnH/Lkbnt0fPzrc2HLXGoq9q0/UKhX8tXhLqeKwv9+KzLe1Ff16svq812PWqPc7Juhw1yyyOj07rlGvnpvjX3blxRVrXtW+jn4iTZb8eT06vrwPxtwsVZWFGekQdds9RROdZdc8PM+qQkH5d9UKt5ANVZJYOul156KUn1wxb27t07d9xxRw499NDstttuufLKK3PUUUfl4YcfTvPmBlVl+Xpw4vXpsvYm6dl5QD4qK130U75wfgb0GJKXpzxeZajCo/Y4Nxt9Y/NccOtR+fW1+6VJk2Y5fdiN1X5w6LLWxtm+z95Vph006GdJkgkv///x5z8qez9J0rZVh3r4DZfuozk1v3aHdp8/UP2jstJ069SnygNMq7OgfH7+99p9M+uTkow84Op0XadXjXVccc/IPD/5oey9/XEZMmB4je3/9fLfcsODv8nGXbbKcfssfdiSLTf+dr67zY/yUVlpdt/6qAzoOWSp7Vu3WD3Nmq6WJNl6k90X9bxbmnPHHp6pM1/NUbufk/4bDaqx/R2Pj8kDz16bgb32zLDB/1Nj+9feeTpjbj82ndp3y8+H3bjUYR+6/9979FFZaQb0/HZ236b6h0dXp3zhgirHwUdlpZk7//OhNufMnb3YvNpao/XnvQubFDfNlhvvWkPrpGTWlPz2rwel1Wptl2n4h/re94YPOSPdOvXJR2Wl+cneFy11OI3atE1qt08n9bttiouLM+rAa1JZWZmKioUZeeDVy3QcfOGTT6vfVz6b/+li0+eXf7bM600K//hMkhbNW2W1/3uY+uYb7rLowepLs/r/HTurt+6YXl1rvsO1tjV98unsnHnN97Jw4YL8cvityzRUTG2264i9L84ardfOJ5/OyqgDr1mm3/kLZXM/Wmy/qaisyIKFny02fd78T5d5vbU9V9b3Nkpqv++1bdUhxUWfHwPbbLrHUtuuatfyL5tfvvi+8tn/7Stfnf7Jp7OXeb1fWNWOz0K/lidVRzvYtoZj56vq87NSbd+L+r5e1Wbfa9G8VU498Np8Mnd2Vm+9Vn6y90XLpe0XGsO1/Mvq67NSbc+VjeH4rMt7UZ/Xq6T227VZk+Zp9X/D4vXsvOUynee/rL4+KyWr5vYt5HNx8vnfcl98v7Nex42y/tpLH5WjXavPe9vNnvNereYBVKdRD124JEsLuk477bScdtppK7okVlFvvzcpny2Ym/3OXPLwfh+VlS66a7B509Vy+sE35ofn9c6Uma/ktIP/usQ7wKv7QLFmu3XTpuUamfHBf7809fOhHipT9YHoC8rn55NPZ1WZ1nK1Nst17PcvhpmorFz6w9i/+OKmxzcG1HgX8cV3jsikt5/MQYN+tkwPLR3/3A257bELsln3b+booefV2P7t9/6Ts8cemtVbdcwvD70tzf/vS++l2bTrwIx76vJsWsMXUJ8/j+iIlJfPz/prb5ob/vmb7NT3gKzXcck93m548Hd57KXbsnP/g7LfTifVWMuL/300l919cjqv1TOnfr/moT5mz3kvv7pmnxQXFeeMw26vcdiH5P+/X8vyhduXvTJlQk65tPovD469cIvFpj1w7tL3my+bOnNSrv7HL9KtU5+8895/csEtR+Wso+5bYvt58z/Nmdd8L3Pmzs6vf3DPUt+DL9T3vtesafP0+MaATCl5ucZtW5u2td2nV8S2WXfNDdK+7TqL/l0bx164eWbOnrrY9JsfOTc3P1L1QeKnHHBVvrPV4cu03sZyfP7pbyek9KN3s8G6/fL3f/85gwccmj7dt19i++feHJ+7n/hTNlyvfyZPfz6X33PKouFzl0dNFRUVOeuGgzP9g8k5YZ9Ll2momNpu17at2qfL2ptk9pyZy7T+L/vl1XtVO2TKw8/flIefv6nKtOFDzsih3z5zmde9rOfKFbGNarvvzV8wL+fedFhat1wjLZq3zmV3n5StNt41bVu1X+Iyq8q1/Kseeu7GjL65+qFjv/r5b532XXP96VOWed2r2vHZGK7ls+e89/kXjB265+NPP8iFtx2dP57wTJo1XbYbKuvzs1Jt3ov6vl7VZd/7ok2XtTdZ6rmotm0bw7X8q+rrs1Ky7OfKxnJ81va9qO/rVV2261//+ZtMnv58Nlyvf559/f6Mf+7G7LL592tc7gv1+VlpVdy+hX4uvu/pq/LUpHGLPpvc/PA5+f4uS/mO9f++C6q29qXNA6iGoAsaUGVlZbp32mypzzr44s7VLzw1aVwqKhYm+fwBq7tsfvDXqmGN/7tr7ZNPZ1UZhuPVqf9a7A/p2n4wrckXdyF/MndWDS2XzbgnL8+9T12RAT2/vUxd8CdPfyEX3HJUOq7+jfxieM1D8ZTN+zhnXvO9fDb/0/zvj/62TMOW1MadEy7KC5MfzhG7/jbb9d4rP75wi4y+5Qc575iHq/1w9/R/7ss1//hFNli3b07ev+ahPt7/cFp+fd3+Wa1Zy5x52J01PtB24cLy/Pq6/fP+R9Ny6kHXLdOwD1/HBuv2y9lHPVBl2rOv35+bHzk3P/v+9WnfZp06rXdhxcKcO/awFBcV58zD7sj9z1ydGx78bf7+779kt62PrHaZC249KpOnP5/Dv/PrbL3JbjW+Rn3ve/WlLvt0fW+br+tn3/9r5n+pJ2ySnHrFkAzeYniGDKg6Hn7XZXjo8hcaw/H5r1fuygPPXpvdtzkqh3/n1/nh6N4575Yf5NITn6/2WUmfzvsk5938g7Rvs07OOfrB/OnO4zPuqcuzY9/9F3suZF1ruuof/5OnX7svu259ZPYYeHSN7Wu7Xb+uo4eelzlf6WXz+xsPyQbr9csBO42sMr22oeyyqu9tVNt9L0mu/Pvpeef913LawX/N6q3Xys+u+Hb++Lfj87PvX7dMv9PSFPq1/Ku23Pg7i13bHnj22vxz4nWLTW9ewzPLvmxVOz4by7X8D7cdk08+nZUzD7sjb7/3n1xw61H56z9/ncN3XXwY8urU12el2lgR16va7nv1pTFcy6tTX5+VaqMxHJ+1fS9WxPWqttv1jWkTc+P432VAz2/nzMPuyDEX9M8f7zwum2+0y6KbzmpSX5+VbN+lWxnPxe99+E4uvevEdOvUJ2NGPJGfXfHtXPfAr7Jd772W2APz4//7Luir33vVNA+gOqtk0DV+/PiGLgGSJN/o2CMflb2f/hvtskxDYL0+7dlc+ffTskWPIVm9dcfc+uh52aLHkGy58bcXa/v2e5MWm/bBxzMyZ+6HVT5gduvUJ0nybukb2XC9/x/+VveHdE0fTItSuztt1lqjS1q1aJd3S9+o1XLVeXXqk/njncelU4fuOX3YjTVuz48/nfV5F/yK8vxi+K01ftCsrKzMOTcdmnfe+0+OGXr+cn/g87T338iV956WjbtslQMHnZomxU0y/Ntn5sq/n547J1yU7+1wfJX200sn56wbDk7rFqvnjENvr3FIg/nln+VX1+6TD+e8l18eelu6rrP0IQSS5NK7T8pL/300e+9wfAYPOORr/X7Lom2r9ot9Off+R9OSJL27bV/nZ33d9NDv89o7T+fHe/0h3+i4UQ4Z/Mv865W/5dK7T8qAnt9e7I+aWx85P+OfuyHb9d4rB3/r5zWuv773vfpSl326vrfN8rCkuzzXXXODar/8XRaN4fj8uOyDXHjrj7JO+645eo/z0qpF2/xk74ty1g0H56q//zzH7Ln4DReX3n1SZs6eml8d/re0a9UhP957TJ5788Gcf+sPc/lJL6VVi7Zfq6bHXro9Yx/6/edDxXzvjzW2r+12XR56dh6w2LTmzVqkQ9t167w/1UZ9b6O67Hsv/fex3PH4H7JDn30W3Wzz3W1+tChk2a73nsv2y1Wj0K/l1Vmz3bpZs926Vaa9POXxJPla+9Cqdnw2hmv5gxP/mgkv35F9v3li+nTfIX2675BHX7wlNz30+2zf53vp0XnxHllfVV+flZbVirhe1Xbfqy+N5Vpenfr4rFQbjeH4rO17sSKuV7XdrvPLP8s5Nx2aFs1b56T9/5wWzVvllAOuzMmX7JQ/3H5szjzs9hrXkdTPZyXbt+Z1r4zn4vNuPjLz5pdl1IHXpHmzFjn5gCtzzPn9cu7Yw/OHEU9UO0zi9NI306Ftp2p7ly1tHkB1VslndMHKYsiAQzPrk5Lc9mj1f5TM/mTmon/P/WxOfvvXg9KmZfv87PvX5YR9L02n9t1zzk2HVjtm8Tvvv5YJL99ZZdrYhz5/kOl2vfdeNK3vBjslSSZNfbJK2y/+kP7yT01BV4vV2iw23OHSNCluks26fzP/efupZV6mOrM+Lsn/Xrtvioub5IxDb0+7Gp43trBiYX57/UEpmfVWfrzXmPTqum2Nr3H9P3+df73ytwzq//3su+OJX6ver6qoqMi5Yw/PwsqFGXngNYs+AB6w86j07Lxlrrz3tEwvnbyo/dz5ZTnzmu+lbN5H+dnBf12mIRMuuv3Hee2dpz8f6mOzfWps/8Cz1+XOCRdls+7fzDF71Dzsw8rqv9NfzF8f+N/03WCn7L39cUk+H9Zv5IFX57P5n+aCW46q0v75Nx/KFfeOSpe1Ns6og66tcZiEFbHv1Zfa7tP1vW1WVo3l+Lzojp/kw7L3ctL+f1n0Bfgum38/2/feO3c8/oe8/NaEKu2f/s99nw8Rs8XwRcFFu1YdcsI+l2bm7Km5/J5TvlZNU2e+mnPHHpbVW3XMGYfeXuNQMXXZroVuRWyj2u57c+eXZfTNR6Rtqw45ft9LFk3/0R6js/Ya6+cPtx1dp+dMJYV/LV+RVrXjszFcyz/4eEb+eOdx6bxWzxyx2//vjXLS/n/Oas1b5dyxh2dB+fwa19PQ6vt6Vdt9r740lmv5yqixHJ+1eS9WxPWqtts1Sa69/4xMmflKjhl6/qKbBfp03yF773B8Jrx8R8Y/d2ON66gvtu/SrYzn4rufuDQT33ggB+1y2qJg+BsdN8oRu/0ur73zdG5++JzFlllYsTCvT3tm0XdSyzoPYElWyR5dsLL43jdPyLNvPJDLx43Mc5PHZ/MNd0mrFu3y3odv57k3HkzzZi0y+piHkiR/uP3YzPhgcn535H2L7lA6fdiNOfFPO+Tcmw7Lb4+8t8oHru6dNsvvbzwku29zVL7RsUeen/xQHnvx1vTdYKfs3O/ARe3WaLNW+m24c/79n3tz9NDRX+v32XT9bXPf03/J1ff9Iuuvs2mKioqzba+hS31A6459989Tk8blP2//O5usv3WdXvd/r9svH3w8Pdv3+V6mlLycKSUvV9uufdt1MqDnkFx7/xmZ+MYD6bL2JmnRvHX++ez1S1z34AGH5JnX7s91D5yZ1Zq1TL8Nd15q+wE9h9S6h86tj56XV6f+Kz/c/ewqd2M1KW6SkQdevdgQaX+49ei8VfJS+nTfIR+XfbDEelqu1ibb99k79z7159z39JVZo83aWX/tTZda//abfS8lH/w3F976oxQXFWdg773y0FfGVv+y3t22q7fhur6u8oULcs7Yw9KkSbOccuBVVY6Pnp0H5MBBp1YZ9uiDj2fkN9cfkIqKhdlhs33zxCt3LXHdG6zbNxus17fe9736Utt9uqKyot63zcqqMRyfj7xwSx5+YWyGDjw2W/T4VpU2J+x7aV5667EqQ8HMmfthzr/1h1mz3Xr5yd5jqrTfrs9e+dbmw6oMkfbWjJdqVVP7tp1yxtV7Z+5nczKo//fzwuSHl9h+vTU3TK9uA2u9XQvdvPmf1vs2qu2+17J561xxz6hM/2By/ueQsWnfZu1F81u1aJuT9v/z1xrCsNCv5SvKqnZ8NpZr+QW3HpWyeR/lNz8YV2XIrbXX6JKj9ziv1kMYNoT6vl7VZd+rL43hWr4yaizHZ23fi/q+XtXlc/qrU5/MLY+Mztab7J5dt/5BlTY/2O13eWrSuOU2xF5t2b5LtzKei2fMeitXjBuZDdbtl0MG/6JKm+/tcHwef+m2aocwfPG/j2Te/LLs2Hf/xda9tHkASyLoggbUtEmz/PYH43LXE3/KP5+9Ltfef0aSpMPq62WTLltnyIDDkiQPPHNtHpx4fQ7YeVSVYQo3WX/rHLHrb3PFuFG59dHzs/9OJy+at9E3tsgxQ8/PVff9PPc8cWlatWiXvbYfkR/s+rvFhnsYOvDY/Ob6A/P6tGerHXpgWR2x22/zyaezcte//pg58z5MZWVlrjvtrbTssOSga+d+B+bSu0/KPydeV+eg65Upn9/RNeHlOzLh5TuW2K7vBjtlQM8hefmtz4cMeue9/+Tsm4Yvdd2DBxySV6f+K5WVlflswdxceNvSx6YefcxDtfqw+sWD1Tddf9vs96X37wvdOvVebIi0L4Y8evmtxxf9LtVZp33XbN9n70VtPpzzXs4Ze9hS67mu+1t5fdqzmV8+L0kWuyv8q0454KqVNui6/p+/zuTpz+e47/0x63bovtj8rw57NOODyfmorDRJcuP43y113cOHnJEN1utb7/tefantPp2k3rfNyqgxHJ8tVmuTi+74cTp16J6jvrv4nZTt266z2FAwf7zz+JR+9G5+84NxadNyjcWW+eoQabWtqd+GOy8asvbep67IvU9dscT2QwYcll7dBtZ6uxa6D+e8V+/bqLb73qQPnsw9T16SHfvun536HbBYmwE9h3ytIQwL+Vq+Iq1qx2djuJbf9+8r89SkcTlgp5HVhjO7b/PDWg9h2BDq+3pVl32vvjSGa/nKaNr7rxX88dlxjc61fi/q+3qV1O5z+jfW6pHRYw9Pq9Xa5sT9Fj/OVmvWcrkNsVdbs+e8Z/vWYGU7F2/adduMHntEFpR/llEHXbPYs9GKioqWOIThP5+9Lh3adsp2vfdabN1LmwewJEWVlZWVDV0EiytbWJ724x+oueFKYvYuQ9K6Sd1z04Xzk4fG1NyOZTNkZFGGDDgsow66epnaL6xYmGPO75cN1+ufnx285DuC6stN43+fGx86K9ed9lbBDm8GAAAAwNLN+rgkh/5+gxy5++8Xe97x0uYVokHHJ02aN3QVsHIrKytLmzZtkiRz5sxJ69ZL7jCxNJ7RBaRJcZP8aI/Reej5GzN15qQV/vr7fPOnaduyfW555OsNnQgAAADAyuumh36fjqt3ztCBx9ZqHsDS6NG1ktKji6+jtj26AAAAAIDlR48uqJkeXQAAAAAAAKzS6t4FB1hpPXCujpoAAAAAADR+enQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAXJM7pWUq2Km2T2LkMauoxl1qq4SUOXAAAAAAAArGIEXSupoqKitG7i7QEAAAAAAFgSQxcCAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBavRBV2lpaUaNGpWNNtooLVq0SJcuXXLCCSekrKwsRx55ZIqKinLxxRc3dJkAAAAAAADUUtOGLqA+Pf/889ltt91SUlKS1q1bp1evXpk+fXrGjBmTyZMnZ9asWUmS/v37N2yhLLOPP52VGx/8Xf71yp15/6NpabVa23Tr1CeHfft/s9kG32zo8gAAAAAAgBWo0QZdpaWlGTp0aEpKSnLyySfnjDPOSNu2bZMk55xzTk499dQ0bdo0RUVF6du3bwNXy7KYOXtqTrlk58ydPye7bn1kOnfsmbJ5H+W/M15M6cfvNnR5AAAAAADACtZog67jjz8+06ZNy4gRIzJ69Ogq80aNGpUbbrghL7zwQrp375527do1UJXUxu9vPCQLK8pz2UkvZs126zZ0OQAAAAAAQANrlM/omjRpUsaOHZuOHTvmrLPOqrbNgAEDkiT9+vVbbN4dd9yR7bbbLq1bt87qq6+e7bffPq+88kq91szSvfjfR/PyW4/ngJ1HZc1266Z84YLMm/9pQ5cFAAAAAAA0oEbZo+vGG29MRUVFhg0bljZt2lTbpmXLlkkWD7rGjBmTk08+OSeeeGJ+/etf57PPPstTTz2VuXPn1nvdLNm//3NvkmTtNdbPL64cmn+/9vdUVCzMNzr2yCGDf5nBAw5p4AoBAAAAAIAVrVEGXePHj0+SDBo0aIltpk2blqRq0DV58uSMHDkyF1xwQUaMGLFo+u67715PlbKspr33WpLkgluPynode2TUgddkwcL5ue2R83L2TcNTXrEgu251RANXCQAAAAAArEiNMuiaOnVqkqRr167Vzi8vL8+ECROSVA26rrzyyjRr1ixHHXXUcq1nyy23TElJyXJdZ2PTvGnLXD7ijSXO//SzT5IkLVdrm9HHPJRmTZsnSbbvvXcO/f0Guervp+fbAw5LcXGjHI0TAAAAACggPXr2yPxyo4TB0lRUVCz69w477JDnnnuuTutplEFXWVlZkixxuMGxY8emtLQ0bdu2Tffu3RdN/9e//pWNN944119/fX7zm9/knXfeSY8ePfLLX/4y3//+9+tcT0lJSd599906L78qaNGs1VLnr9bs86EmB23+/UUhV5K0bdU+A3vtmQeevTbvvP9auq6zab3WCQAAAABQkxnTp2fegk8bugwoGDNnzqzzso0y6OrUqVNmz56diRMnZuDAgVXmzZgxIyNHjkyS9O3bN0VFRVXmvfvuuznttNNy9tlnp0uXLvnLX/6Sgw8+OGuttVYGDx5c53pYuuZNWy51fsfVOydJ2rddfFt2aLdukmTO3NnLvzAAAAAAgFpad7319OiCGlRUVGTGjBlJknXWWafO62mUQdfgwYMzadKknH322RkyZEh69uyZJHn66aczfPjwlJaWJkn69+9fZbmKiorMmTMn1113Xfbee+8kybe+9a28+uqr+fWvf13noOuZZ56p8++yqlg4P3lozJLnb7z+1rnnyUtT+tG0xeaVfvj5tDXarF1f5QEAAAAALLM3Xn8jTZrX3A5WZWVlZWnTpk2S5PHHH6/zehrlA41GjRqVNddcM++880569+6dzTbbLD169MjWW2+dDTbYILvsskuSqs/nSpIOHTokSZVAq6ioKIMHD87LL7+84n4BFrN9773TarW2eXDi9Zn72ZxF0z/4eEYmvHJnOq/VM9/ouFEDVggAAAAAAKxojTLo6ty5cx577LF897vfTYsWLTJlypR06NAhl112WcaNG5fXX389yeJBV+/evZe4znnz5tVrzSxd21bt86M9Rqf0o3dz/EXb5tZHzs9N43+f4y/aNuUL5+cne13U0CUCAAAAAAArWFFlZWVlQxexIs2ZMyft2rVLUVFRPvnkk7Rq1WrRvLvuuit77bVXbrvttuyzzz5JPh/OsH///unQoUMefvjhBqq68atp6MIvPPbS7bn54XMyZcZLKSouzqbrD8zwIWekT/ft679IAAAAAIBlMOj4GLoQavDloQvnzJmT1q1b12k9jfIZXUvzyiuvpLKyMj179qwSciXJ0KFD881vfjM/+tGP8sEHH2T99dfPn//857zyyit54IEHGqhivuybm+2Tb262T0OXAQAAAAAArARWuaDrpZdeSrL4sIXJ58/juuuuu3Lqqafm9NNPz8cff5x+/frl3nvvXfRcLwAAAAAAAFYOgq6vWGONNXLZZZflsssuW5FlAQAAAAAAUEvFDV3AilZT0AUAAAAAAEBhWOV6dI0fP76hSwAAAAAAAGA5WOV6dAEAAAAAANA4CLoAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSIIuAAAAAAAACpKgCwAAAAAAgIIk6AIAAAAAAKAgCboAAAAAAAAoSKtE0FVaWppRo0Zlo402SosWLdKlS5eccMIJKSsry5FHHpmioqJcfPHFDV0mS3Ht/WdmyMiiJf7semqzhi4RAAAAAABYwZo2dAH17fnnn89uu+2WkpKStG7dOr169cr06dMzZsyYTJ48ObNmzUqS9O/fv2ELZal26LNP1ltzo8WmvzXjxdz8yLnZttfQBqgKAAAAAABoSI066CotLc3QoUNTUlKSk08+OWeccUbatm2bJDnnnHNy6qmnpmnTpikqKkrfvn0buFqWZoP1+maD9RZ/jy689egkyW5bH7miSwIAAAAAABpYox668Pjjj8+0adMyYsSIjB49elHIlSSjRo1Kv379Ul5enm7duqVdu3YNWCl1MXd+WR564aastXrnbLnxrg1dDgAAAAAAsII12qBr0qRJGTt2bDp27Jizzjqr2jYDBgxIkvTr12/RtJ133jlFRUXV/hxzzDErpHaWzaMv3JJP532cb295eJoUN2nocgAAAAAAgBWs0Q5deOONN6aioiLDhg1LmzZtqm3TsmXLJFWDrj/96U/5+OOPq7QbN25cfvOb32SPPfaov4Kptfue/kuKioryna1/0NClAAAAAAAADaDRBl3jx49PkgwaNGiJbaZNm5akatDVq1evxdr99re/zVprrZVdd63b8HhbbrllSkpK6rTsqqJ505a5fMQby9z+nfdey8tvPZ7NN/pW1u3QvR4rAwAAAAConR49e2R++dyGLgNWahUVFYv+vcMOO+S5556r03oabdA1derUJEnXrl2rnV9eXp4JEyYkqRp0fdX777+f++67Lz/+8Y/TtGndNldJSUnefffdOi27qmjRrFWt2t/3778kSXbb5of1UQ4AAAAAQJ3NmD498xZ82tBlQMGYOXNmnZdttEFXWVlZkmTu3OpT87Fjx6a0tDRt27ZN9+5L7hF04403pry8PMOHD69zLZ06darzsquK5k1bLnPbhQvL88Cz16ZdqzWzfZ/v1WNVAAAAAAC1t+566+nRBTWoqKjIjBkzkiTrrLNOndfTaIOuTp06Zfbs2Zk4cWIGDhxYZd6MGTMycuTIJEnfvn1TVFS0xPVcd9112XTTTbPlllvWuZZnnnmmzsuuKhbOTx4as2xtn3j17syeMzPf2+GENG+6Wv0WBgDASuna+8/MQYN+lubNWuScmw7PRt/on32++dNarWPCy3emfdtO6dV12xrb/uPpq/Onu07INzr2yJ9O+Pzz/ew57+WcGw/N9FmT07zJajlunz+l7wY7JknOumFYnnvjwezc/6D8eK8La/vrAQBQ4N54/Y00ad7QVcDKraysLG3atEmSPP7443VeT/HyKmhlM3jw4CTJ2Wefnddff33R9KeffjqDBg1KaWlpkqR///5LXMd//vOfPPPMM1+rNxfL331P/9+whVsf2cCVAADQUK574FeZXz7va61jwst35j9vP7nM7ftvOGhRyJUkf7n3Z9m067a55tQ3csqBV+WsGw5O+cIFSZLTDv5r9hh4zNeqDwAAgJo12h5do0aNyg033JB33nknvXv3ziabbJJ58+blzTffzG677ZZu3brlH//4x1Kfz3XdddelqKgow4YNW4GVszSlH03P06/dl026bJ3u627W0OUAANAALrzt8wDpxD99M8VFTbLm6uvl7ZmTMvKyb+X9D99Jt0598vNhN6VZ0+YpX7ggV//jF3n+zfFZUD4/ndfqmZ/ue1lenfpEnnz1rkx844H84+mrs9f2I7Ltpnvkdzd8P5/O+zjzy+el34aD8pO9xqS4uPr7Ax954eZcc+qbSZKNu2yVNdutlxcnP5Iteg5eYdsCAABgVddoe3R17tw5jz32WL773e+mRYsWmTJlSjp06JDLLrss48aNW9TLa0lBV2VlZf76179m5513zvrrr78iS2cp7n/m6lRULMxu2/ywoUsBAKCB/HTfS5MkF/z4sVx20vNZo/XamTz9+fz6iLvzl5GTMvuTmXnspduSJDc/fG5aNGudi4//dy476fl077RZrrrvf7LNprtn21575oCdR+ayk57P7tv8MG1arpFfH3F3/vTTZ3PZSS9m5uwpeeTFm6ut4eOyD7Jw4YJ0aPf/n8e7Tvtuee/Dt+t/AwAAALBIo+3RlSSbbrpp7rnnnsWmz5kzJ1OmTElxcXH69OlT7bKPPvpopk6dmjPOOKO+y6QWDv7W6Tn4W6c3dBkAAKxktu/zvbRo3ipJssn6W2fGB5OTJP965c6UzftoUfBVvnB+1unQrdp1VFRW5Ipxp+aVKY+nsrIyH855L9069cmg/getkN8BAACA2mvUQdeSvPLKK6msrEzPnj3TqlWrattcd911admyZfbbb78VXB0AAFBbzZu1WPTv4qImWVhRnuTzkRp+stdF2XLjb9e4jtsePT8flr2Xi457Ks2btcild52U+Quqfw5Yu9Zrpklx08z6uGRRr66Zs6dk7TWMBgEAALAiNdqhC5fmpZdeSrLkYQvnzZuX/8fenYdpVdb/A38Pm+xuqKAQi4AKCCjumoqJiVtmbom4ZOYSYomg6a+0lVTc0HIrU1MU973URI3IDEXMhRRJVATUCVQYQbb5/UHO15FhGQSGM75e1zWXcs59znxm5jn3Oc/zPvd97rzzzhx88MFp1qzZmiwNAABYAY3XaZayuR8ut90u3Q7O3aMvzdx5HydJ5s77OJOnv5wkadKwecrm/N8+Zs2ZmQ2atUyD+g0z46Pp+eu/7ljmvr/a/bA8+I/F0yi++vbYlH74TrpvvsfK/kgAAACshC/liK7lBV0NGzbMBx98sAYrAgAAquPQ3QflrGv7ZJ36jbPhupsutd2Re56VPy74JKddsWNKUpIkOaL3WWnXsmv27tU/F408LmNevjcH7fL9HLLb6fnZHw/Nd4d1zYbNN802nfZeZg0n7n9Bfn1r/xx7QafUr9sgZ3/75tSrW3+V/pwAAAAsW0l5eXl5TRexpu2111554okn8uCDD2b//fev6XJIsnBe8sTwmq4CAACq9sjYG/L3l+/NT4+7d4W3uenR8zN7zgc59RuXrba6AABYO/UemNRtUNNVwNqtrKwsTZs2TZLMnj07TZo0Wan9fCmnLhw1alTKy8uFXAAAwApZp36jTJo6Pqdevt0KtR86ol8eH3dzGjdsvporAwAA+HL7Uo7oYu1jRBcAAAAAUFsY0QXLZ0QXAAAAAAAAX2qCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKKRaH3SVlpZmyJAh6dixYxo2bJg2bdrk9NNPT1lZWU444YSUlJTkyiuvrOkyAQAAAAAAqKZ6NV3A6jR+/Pj07ds306dPT5MmTdKlS5dMnTo1w4cPz6RJkzJjxowkSc+ePWu2UFbInE9m556/Dc8T42/NuzMnp37dddJ6o87Zb8fvZZ/tjk1JSUlNlwgAAAAAAKxBtXZEV2lpaQ488MBMnz49gwYNyrRp0zJu3LhMnz49F1xwQR566KGMHTs2JSUl6d69e02Xy3IsWrQo5/y+b2585MfZos32OemAi9Nv7/+XRYsWZtjtx+d3D59d0yUCAAAAAABrWK0NugYOHJgpU6ZkwIABGTZsWJo1a1axbsiQIenRo0cWLFiQdu3apXnz5jVYKSvi3289k5fe+FsO3m1gzjz8+uy/0/dyyFd/kEtOHZ2WG7TPQ/+4pqZLBAAAAAAA1rBaGXRNmDAhI0eOTIsWLTJ06NAq2/Tq1StJ0qNHj0rLR48ena997Wtp0aJF1ltvvey00065++67V3vNLFvZJx8lSTZsvmml5fXrNci6TVqkYYMmNVEWAAAAAABQg2pl0HXrrbdm0aJF6devX5o2bVplm0aNGiWpHHS98MIL6dOnT+rWrZsbbrghI0eOTJs2bXLooYfmwQcfXCO1U7Ut2+yQpo3Wy+1PXpinXrgj7818K2+99+/8/uEfZeKU53LMPufXdIkAAAAAAMAaVq+mC1gdRo0alSTp3bv3UttMmTIlSeWga+TIkSkpKcm9996bxo0bJ0n23nvvdOjQIbfccksOOOCA1Vg1y9Ks8fr52XH355I7v5tf3Hx4xfLG6zTLT465K7t2O7jmigMAAAAAAGpErQy63nzzzSRJ27Ztq1y/YMGCjBkzJknloGvevHlp0KBBxWivJKlbt26aNWuWRYsWrXQ92223XaZPn77S238ZNKjXKNcOmLjMNo3WaZp2m3TLzl0OSpe2u2TWnBm5/++/ydARR+Wnx92XXp37rKFqAQAAAACWrlPnTpm3YE5NlwFrtc/mLrvttluef/75ldpPrQy6ysrKkiRz5lTdkYwcOTKlpaVp1qxZ2rdvX7G8f//++c1vfpNBgwblrLPOSr169XLNNddk4sSJ+e1vf7vS9UyfPj3vvPPOSm//ZdCwfuNlrn9j2os5/cpdcvJBl+bAnU+uWN6757dz4sXdcumdJ+bGsyelbp26q7tUAAAAAIBlmjZ1aubO/7imy4DCePfdd1d621oZdLVs2TIzZ87MuHHjsvPOO1daN23atAwePDhJ0r1795SUlFSs69GjRx5//PEccsghufTSS5MkTZo0yR133JHdd9/9C9XDsjWo12iZ6+8afWnmLZibPbofVml5wwaNs+NW++e+MVfm3RmTs2mLzVdnmQAAAAAAy9Vq002N6ILlWLRoUaZNm5Yk2WSTTVZ6P7Uy6Np7770zYcKEXHDBBenTp086d+6cJBk7dmz69++f0tLSJEnPnj0rbTdx4sQcccQR2X777XPqqaembt26ueWWW3LkkUfmwQcfzF577bVS9Tz77LNf6Of5Mlg4L3li+NLXl364eETcwvKFS267cMHi/y5asFpqAwAAAACojomvTUzdBjVdBazdysrK0rRp0yTJ3/72t5XeT51VVdDaZMiQIdlwww3z9ttvp2vXrtl6663TqVOn7LDDDunQoUNFYPXZ53MlyTnnnJPGjRvnnnvuSd++fbPPPvvkxhtvzI477phBgwbVxI/C/7TdpEuS5NGxN1RaPnvOB/n7K/elWaP1s2mLjjVQGQAAAAAAUFNqZdDVunXrjB49Ovvvv38aNmyYyZMnZ4MNNsg111yThx56KK+99lqSJYOuF198MT169Ei9epUHum233XaZMGHCGqufJR3y1R+kWeMN8vs/nZ1f39o/Dzx9dUY8/quccuk2mfHRtBy37y88nwsAAAAAAL5kSsrLy8truog1afbs2WnevHlKSkoya9asNG7cuGLdnnvumalTp+aVV16pFHbtueeeefvttzNp0qSaKPlLYXlTFybJ1NJJufkvP8vzrz+embPezTr1G2XzTXvmm1/9Qb669SFrplAAAAAAgOXoPTCmLoTl+OzUhbNnz06TJk1Waj+18hldy/Lyyy+nvLw8nTt3rhRyJcn3v//9HH744fnmN7+Zk046KXXr1s2IESPy1FNP5fLLL6+hivnUpi02z5Ajb6zpMgAAAAAAgLXEly7oevHFF5MsOW1hkhx22GF54IEHcsEFF+TYY4/NwoUL07lz59xyyy056qij1nSpAAAAAAAALIOg63MOOOCAHHDAAWuyJAAAAAAAAFZCnZouYE1bXtAFAAAAAABAMXzpRnSNGjWqpksAAAAAAABgFfjSjegCAAAAAACgdhB0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKKQvRdBVWlqaIUOGpGPHjmnYsGHatGmT008/PWVlZTnhhBNSUlKSK6+8sqbLBAAAAAAAoBrq1XQBq9v48ePTt2/fTJ8+PU2aNEmXLl0yderUDB8+PJMmTcqMGTOSJD179qzZQlmumbPezY2Pnpd/TngoM2e/m/Wbtcyu3b6ZY/f5aZo2Wq+mywMAAAAAANawWh10lZaW5sADD8z06dMzaNCgnHfeeWnWrFmS5MILL8xZZ52VevXqpaSkJN27d6/halmWmbPfy2lX7Jj/fjQ1++90Utpt0i2T330pDz59VV78z19z2ffHpGGDxjVdJgAAAAAAsAbV6qBr4MCBmTJlSgYMGJBhw4ZVWjdkyJCMGDEiL7zwQtq3b5/mzZvXUJWsiFsf/1XenflmfnTUiOy1zbcrlndpu0uGjjgqd/31kvTb+//VYIUAAAAAAMCaVmuf0TVhwoSMHDkyLVq0yNChQ6ts06tXryRJjx49Ki3/y1/+kp122ikNGzbMxhtvnJNPPjkffvjhaq+ZpXth0hNZp36j9O55ZKXle/Y4Ig3qNcwjY/9QQ5UBAAAAAAA1pdYGXbfeemsWLVqUfv36pWnTplW2adSoUZLKQddTTz2VfffdN5tttlnuueee/PKXv8ydd96Zgw8+OOXl5WukdpY0f8EnaVCvYUpKSiotr1OnTtap3yjTZvwnH5aV1lB1AAAAAABATai1UxeOGjUqSdK7d++ltpkyZUqSykHXz372s3Tq1Cl33HFH6tRZnANuuOGG+da3vpWHHnooBxxwwGqsmqVpu0nXvP3+q3n9nfHpuFnPiuWvvzM+s+bMTJK8N/OtrNukRQ1VCAAAAAAArGm1Nuh68803kyRt27atcv2CBQsyZsyYJJWDrmeeeSbHH398RciVJPvss0+S5N57712poGu77bbL9OnTq73dl0mDeo1y7YCJS11/yFd/kL+/fG9+cfPhOeWgy9K+ZbdMfvflXHX/D1Kvbv0sWDg/n8z/eA1WDAAAAABQtU6dO2Xegjk1XQas1RYtWlTx/7vttluef/75ldpPrQ26ysrKkiRz5lTdmYwcOTKlpaVp1qxZ2rdvX7G8bt26adCgQaW29evXT0lJSV5++eWVqmX69Ol55513VmrbL4uG9Rsvc/3WHb6ac/rdlt/eNzD/7/r9kyR16tRN3x2+m7abdM2Yl+5J43War4lSAQAAAACWadrUqZnrxnxYYe++++5Kb1trg66WLVtm5syZGTduXHbeeedK66ZNm5bBgwcnSbp3717puU+dO3fOM888U6n92LFjU15enhkzZqx0LSxbg3qNlttmjx6HZbetD8kb017MnE9mpfXGW2T9phtnwPAdUrdOvWzaouMaqBQAAAAAYNlabbqpEV2wHOXl5SkvL0+StGrVaqX3U2uDrr333jsTJkzIBRdckD59+qRz585JFodW/fv3T2lpaZKkZ8+elbYbOHBgjjnmmPziF7/IySefnClTpuTUU09N3bp1K01nWB3PPvvsF/pZvgwWzkueGL78dnXr1K30jK4ZH03P6+88n+4d9kjDBsseFQYAAAAAsCZMfG1i6jZYfjvgi1u55KYAhgwZkg033DBvv/12unbtmq233jqdOnXKDjvskA4dOmSvvfZKUvn5XEly9NFH56yzzsrPf/7zbLTRRtluu+3Su3fv9OzZ8wsliqx6ixYtym/uG5hF5Qtz1NfOrelyAAAAAACANazWjuhq3bp1Ro8encGDB+epp57K5MmT06VLl1xzzTU58cQTs/nmmydZMugqKSnJr3/965x77rl54403stlmm2XdddfNhhtumNNOO60mfhSSzPlkdgYM3yG7dvtmWm7QPmVzP8wT42/NxCnP5fh9f5meHXvXdIkAAAAAAMAaVmuDriTZaqut8uCDDy6xfPbs2Zk8eXLq1KmTbt26Vblts2bN0r179yTJddddlzlz5uT4449frfWydPXqNkiHTXvkiedH5L+zpqVh/cbp3Gb7/Oq7f872W3y9pssDAAAAAABqQK0Oupbm5ZdfTnl5eTp37pzGjSs/1+nZZ5/NY489lm233TYLFizIX/7ylwwfPjzDhg2rGAXGmle/XoOc2+/Wmi4DAAAAAABYi3wpg64XX3wxyZLTFibJOuuskwceeCBDhw7NggULsvXWW2fkyJE59NBD13SZAAAAAAAALIOg63O23nrr/P3vf1/TJQEAAAAAAFBNdWq6gJqwrKALAAAAAACAYvhSjugaNWpUTZcAAAAAAADAF/SlHNEFAAAAAABA8Qm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhVRSXl5eXtNFQHl5smh+TVcBAAAAAPDF1amflJTUdBXw5SDoAgAAAAAAoJBMXQgAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACikejVdAGtWeXmyaH5NVwEAAABATahTPykpqekqAGDVEXR9ySyanzwxvKarAAAAAKAm9B6Y1G1Q01UAwKpj6kIAAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJC+FEFXaWlphgwZko4dO6Zhw4Zp06ZNTj/99JSVleWEE05ISUlJrrzyypouEwAAAAAAgGqoV9MFrG7jx49P3759M3369DRp0iRdunTJ1KlTM3z48EyaNCkzZsxIkvTs2bNmC11LLFq0KPf87fI89I9rMn3m5KzXZKPs3uPwHPv1n6VRgyY1XR4AAAAAAECFWj2iq7S0NAceeGCmT5+eQYMGZdq0aRk3blymT5+eCy64IA899FDGjh2bkpKSdO/evabLXStc9cAPc/UDZ+Qrm3TJgIOvyO7dD8u9fxuen1x/YBYtWlTT5QEAAAAAAFSo1SO6Bg4cmClTpmTAgAEZNmxYpXVDhgzJiBEj8sILL6R9+/Zp3rx5DVW59pg8/eXcN+aK7NbtkJx37F0Vy1tu0D6/uW9gnnzhtuy1zVE1WCEAAAAAAMD/qbUjuiZMmJCRI0emRYsWGTp0aJVtevXqlSTp0aNHpeVvvPFGDjrooDRr1izrr79+jjnmmPz3v/9d7TXXtCfG35ry8vIc8tUfVFq+344npmH9xvnLuJtrpjAAAAAAAIAq1Nqg69Zbb82iRYvSr1+/NG3atMo2jRo1SlI56Jo1a1Z69+6dKVOm5NZbb821116b0aNH54ADDqj1U/e9+vbY1Cmpky2+skOl5Q3qN0yHTXvmtbfH1lBlAAAAAAAAS6q1UxeOGjUqSdK7d++ltpkyZUqSykHXtddem3feeSd//etf85WvfCVJ0rp16+yyyy65//77c/DBB69wDeXl5fn444+TJI0bN05JSUl1f4w16r8fTU3zJi3SoN46S6xrse5meeXNv2f+gnmpX69BDVQHAAAAAABQWa0Nut58880kSdu2batcv2DBgowZMyZJ5aDrwQcfzG677VYRciXJzjvvnA4dOuSBBx6oVtD18ccfV4wma9WqVerUqfkBdA3qNcq1AyZWue6TeR+nfhUh1+LtGi5uM/9jQRcAAABAQXXq3CnzFsyp6TIAoJKWLVvm2WefXalta23QVVZWliSZM6fqE/fIkSNTWlqaZs2apX379hXLX3nllRx22GFLtO/atWteeeWVla5n2rRpK73tqtSwfuOlrlunQePMmf1elevmLZi7uM0ytgcAAABg7TZt6tTMnf9xTZcBAKtMrQ26WrZsmZkzZ2bcuHHZeeedK62bNm1aBg8enCTp3r17pSkFZ86cmfXWW2+J/W2wwQZ59dVXV7qetWlE19Js2HzTvPXuK5m34JMlpi8s/fCdrNukhdFcAAAAAAXWatNNjegCYK3TsmXLld621gZde++9dyZMmJALLrggffr0SefOnZMkY8eOTf/+/VNaWpok6dmz5xqpZ+LEiWnSpMka+V7LsnBe8sTwqtdt0Wb7PPfao3n1rX9m6w5frVg+b/7c/Gfq+GzdYfc1VCUAAAAAq8PE1yamrvuYAahFan6I0WoyZMiQbLjhhnn77bfTtWvXbL311unUqVN22GGHdOjQIXvttVeSys/nSpL1118/H3zwwRL7mzFjRjbYYIM1UXqN2bPHESkpKcndoy+rtPzhZ67L3PkfZ69t+tVMYQAAAAAAAFWotUFX69atM3r06Oy///5p2LBhJk+enA022CDXXHNNHnroobz22mtJlgy6ttpqqyqfxfXKK69kq622WiO115T2rbbOQbt8P3976e6cf+MhefiZ3+XqBwbl6gfOSPcOe2SvbY6q6RIBAAAAAAAq1NqpC5PFodWDDz64xPLZs2dn8uTJqVOnTrp161Zp3QEHHJBzzjknU6ZMSevWrZMkzzzzTCZNmpSLLrpojdRdk0456LJssn67PPzMtfnnhIfSvEmLHLzraTn26z9bK54xBgAAAAAA8KmS8vLy8pouYk175plnstNOO2WLLbbIv//970rrPvroo2y99dZp0aJFfvrTn2bu3LkZMmRINtpoozz99NPVCnvKysrStGnTJIvDtbX9GV0AAAAA1G69B8YzugCoVb6UQ3RefPHFJEtOW5gkzZs3z6hRo9KqVasceeSR+e53v5tddtklDz74oBFNAAAAAAAAa5FaPXXh0iwr6EqSzTffvMopDwEAAAAAAFh7fCmHKC0v6AIAAAAAAGDt96Uc0TVq1KiaLgEAAAAAAIAv6Es5ogsAAAAAAIDiE3QBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhfSlCLpKS0szZMiQdOzYMQ0bNkybNm1y+umnp6ysLCeccEJKSkpy5ZVX1nSZa4VbRw3Nz/54WPoP7ZA+g0ty9K/a1XRJAAAAAAAAVapX0wWsbuPHj0/fvn0zffr0NGnSJF26dMnUqVMzfPjwTJo0KTNmzEiS9OzZs2YLXUtc/6dz0qzxBum02bYpm/NBTZcDAAAAAACwVLU66CotLc2BBx6Y6dOnZ9CgQTnvvPPSrFmzJMmFF16Ys846K/Xq1UtJSUm6d+9ew9WuHW46e1JabdghSXLisG6ZM292DVcEAAAAAABQtVo9deHAgQMzZcqUDBgwIMOGDasIuZJkyJAh6dGjRxYsWJB27dqlefPmNVjp2uPTkAsAAAAAAGBtV2uDrgkTJmTkyJFp0aJFhg4dWmWbXr16JUl69OhRsezTYGyHHXbIOuusk5KSkjVSLwAAAAAAANVTa4OuW2+9NYsWLUq/fv3StGnTKts0atQoSeWg6/XXX89dd92Vli1bZvvtt18jtQIAAAAAAFB9tfYZXaNGjUqS9O7de6ltpkyZkqRy0LX77rtn2rRpSZLzzz8/Y8aMWSX1dOrUKXXq1Hyu2KBeo1w7YGJNlwEAAABADejUuVPmLZhT02UAQCUtW7bMs88+u1Lb1tqg680330yStG3btsr1CxYsqAixPht0ra4w6tPwrKY1rN+4pksAAAAAoIZMmzo1c+d/XNNlAMAqU2uDrrKysiTJnDlV36EycuTIlJaWplmzZmnfvv1qr6dVq1ZrzYguAAAAAL6cWm26qRFdAKx1WrZsudLb1tqgq2XLlpk5c2bGjRuXnXfeudK6adOmZfDgwUmS7t27p6SkZLXXM3HixDRp0mS1f5/lWTgveWJ4TVcBAAAAQE2Y+NrE1G1Q01UAwKpT80OMVpO99947SXLBBRfktddeq1g+duzY9O7dO6WlpUmSnj171kR5AAAAAAAAfEG1dkTXkCFDMmLEiLz99tvp2rVrttxyy8ydOzevv/56+vbtm3bt2uWRRx6p9Hwuksee+2Pem7n4+WYflL2fBQvn5Za//CJJsvH6bdOnV/+aLA8AAAAAAKBCrQ26WrdundGjR2fw4MF56qmnMnny5HTp0iXXXHNNTjzxxGy++eZJIuj6nD//8/f513+eqrTshkd+nCTp3mEPQRcAAAAAALDWqLVBV5JstdVWefDBB5dYPnv27EyePDl16tRJt27daqCytdfFpzxZ0yUAAAAAAACskFoddC3Nyy+/nPLy8nTu3DmNGzdeYv2dd96ZJHnllVcq/btdu3bZbrvt1lyhAAAAAAAALNWXMuh68cUXkyx92sLDDjusyn8fe+yxueGGG1ZrbQAAAAAAAKwYQVcVysvL12Q5AAAAAAAArIQ6NV1ATVhe0AUAAAAAAMDa70s5omvUqFE1XQIAAAAAAABf0JdyRBcAAAAAAADFJ+gCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSF+KoKu0tDRDhgxJx44d07Bhw7Rp0yann356ysrKcsIJJ6SkpCRXXnllTZe5Vpjy/mu54ZGf5LQrdsqh52+Ug/5fs5x0Sc/c8vgvM2deWU2XBwAAAAAAUKFeTRewuo0fPz59+/bN9OnT06RJk3Tp0iVTp07N8OHDM2nSpMyYMSNJ0rNnz5otdC3x57HX5/6//yY7dzkoX9umX+rWrZ8XJj2RG/78//LXF27P8NP+kXXqN6rpMgEAAAAAAGp30FVaWpoDDzww06dPz6BBg3LeeeelWbNmSZILL7wwZ511VurVq5eSkpJ07969hqtdO3x160Pz7d4/SpNG61YsO3Dnk7NZi04Z8fgv86d//j4H7zqgBisEAAAAAABYrFZPXThw4MBMmTIlAwYMyLBhwypCriQZMmRIevTokQULFqRdu3Zp3rx5DVa69tiizXaVQq5P7dnjiCTJ5OkvremSAAAAAAAAqlRrg64JEyZk5MiRadGiRYYOHVplm169eiVJevToUbHszjvvzLe+9a20bds2jRs3zpZbbplzzz03s2fPXiN1r63e/3BKkmT9ppvUcCUAAAAAAACL1dqg69Zbb82iRYvSr1+/NG3atMo2jRotftbUZ4OuYcOGpW7duvnVr36VP/3pTznllFNy1VVXZd99982iRYvWSO1rm4WLFuaWv/w8devUy17bHFXT5QAAAAAAACSpxc/oGjVqVJKkd+/eS20zZcriUUqfDboeeOCBbLTRRhX/3mOPPbLRRhulX79++dvf/pbdd999NVW89rrq/h/klTefznf6/iptNt6ipssBAAAAAABIUouDrjfffDNJ0rZt2yrXL1iwIGPGjElSOej6bMj1qe222y5J8s4776x0PZ06dUqdOjU/gK5BvUa5dsDEFW5/w59/nPvGXJn9d/xevr3Xj1ZjZQAAAACsbp06d8q8BXNqugwAqKRly5Z59tlnV2rbWht0lZWVJUnmzKn6xD1y5MiUlpamWbNmad++/TL39cQTTyRJttpqq5WuZ9q0aSu97arUsH7jFW5706Pn55bHf5Gvb398Tv/W1auxKgAAAADWhGlTp2bu/I9rugwAWGVqbdDVsmXLzJw5M+PGjcvOO+9cad20adMyePDgJEn37t1TUlKy1P288847+fGPf5x99903PXv2XOl6WrVqtdaM6FoRNz16fv742E/Tp9exOePQ3y3zdwQAAABAMbTadFMjugBY67Rs2XKlt621Qdfee++dCRMm5IILLkifPn3SuXPnJMnYsWPTv3//lJaWJskyw6vZs2fnG9/4Rho0aJDrr7/+C9UzceLENGnS5AvtY1VYOC95Yviy2/zxsZ/lj4/9NHtv2z9nHn79WhHQAQAAAPDFTXxtYuo2qOkqAGDVqbVB15AhQzJixIi8/fbb6dq1a7bccsvMnTs3r7/+evr27Zt27drlkUceqfR8rs+aM2dODjzwwLzxxhsZPXp0WrVqtYZ/gppx35jf5KZHz8vG630l23baO6OeH1Fp/frNNkmvzn1qqDoAAAAAAID/U2uDrtatW2f06NEZPHhwnnrqqUyePDldunTJNddckxNPPDGbb755klQZdM2fPz+HHnponn322Tz++OPp0qXLmi6/xrz69tgkyXsfvJULRx67xPruHfYQdAEAAAAAAGuFkvLy8vKaLmJNmz17dpo3b56SkpLMmjUrjRs3rli3aNGiHHnkkbn//vvz8MMPZ6+99lrp71NWVpamTZtWfM+iTF0IAAAAQO3Ue2BMXQhArVJrR3Qty8svv5zy8vJ07ty5UsiVJN///vdzxx135Oyzz07jxo3zj3/8o2Ld5ptvno022mhNlwsAAAAAAEAV6tR0ATXhxRdfTFL1tIV/+tOfkiS//vWvs/POO1f6euihh9ZonQAAAAAAACzdl3JE17KCrsmTJ6/hagAAAAAAAFgZRnQBAAAAAABQSF/KEV2jRo2q6RIAAAAAAAD4gr6UI7oAAAAAAAAoPkEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQvpSBF2lpaUZMmRIOnbsmIYNG6ZNmzY5/fTTU1ZWlhNOOCElJSW58sora7pMAAAAAAAAqqFeTRewuo0fPz59+/bN9OnT06RJk3Tp0iVTp07N8OHDM2nSpMyYMSNJ0rNnz5otdC3x9nuv5ua//CwT3xmX/340NQsXzs/G630lO2y5Xw7bc3A2bN6qpksEAAAAAABIUsuDrtLS0hx44IGZPn16Bg0alPPOOy/NmjVLklx44YU566yzUq9evZSUlKR79+41XO3a4f0Pp2TGR9Oya7dvZqN1W6dunXp5Y/qLeeiZa/PEC7fl6h+Oz/pNN67pMgEAAAAAAGp30DVw4MBMmTIlAwYMyLBhwyqtGzJkSEaMGJEXXngh7du3T/PmzWuoyrXLtp2+lm07fW2J5Vu33z2/uPnwPDr2hhzRe0gNVAYAAAAAAFBZrX1G14QJEzJy5Mi0aNEiQ4cOrbJNr169kiQ9evSoWDZ69OjsvffeadWqVdZZZ520bt06RxxxRCZMmLBG6l5bbbJ+2yTJ7Dkza7gSAAAAAACAxWrtiK5bb701ixYtSr9+/dK0adMq2zRq1ChJ5aBr5syZ2XrrrXPSSSdl4403zpQpUzJ06NDsvPPOeemll9K6des1Un9Nmzd/bubMm5158+fmzXdfye8ePitJssOW+9VwZQAAAAAAAIvV2qBr1KhRSZLevXsvtc2UKVOSVA66DjrooBx00EGV2m2//fbZYostctddd+X0009fDdWufR7+5+/ym3tPq/h3y/Xb5exv35ytO3y1BqsCAAAAAAD4P7U26HrzzTeTJG3btq1y/YIFCzJmzJgklYOuqmy44YZJknr1Vv7X1alTp9SpU/MzRTao1yjXDpi43Ha7dj04X9loy8yZNzuvv/N8nn7l/nxYVroGKgQAAABgdenUuVPmLZhT02UAQCUtW7bMs88+u1Lb1tqgq6ysLEkyZ07VJ+6RI0emtLQ0zZo1S/v27ZdYv3DhwixatChvvvlmfvSjH6Vly5Y5/PDDV7qeadOmrfS2q1LD+o1XqN1G67XORustnqZx124H56tbfysDhm+fT+Z/nG/v9aPVWSIAAAAAq8m0qVMzd/7HNV0GAKwytTboatmyZWbOnJlx48Zl5513rrRu2rRpGTx4cJKke/fuKSkpWWL7PfbYo2LEV8eOHTNq1KhstNFGK11Pq1at1poRXSujw6bds/lm2+SBv/9W0AUAAABQUK023dSILgDWOi1btlzpbWtt0LX33ntnwoQJueCCC9KnT5907tw5STJ27Nj0798/paWLp+Hr2bNnldv//ve/zwcffJA33ngjF110UfbZZ5+MGTMmX/nKV1aqnokTJ6ZJkyYrte2qtHBe8sTwldt23vw5mfXxjFVbEAAAAABrzMTXJqZug5quAgBWnZofYrSaDBkyJBtuuGHefvvtdO3aNVtvvXU6deqUHXbYIR06dMhee+2VZOnP59piiy2y44475sgjj8zjjz+eWbNm5cILL1yTP0KNmPHR9CqXj3/9iUye/lK2bLvTGq4IAAAAAACgarV2RFfr1q0zevToDB48OE899VQmT56cLl265JprrsmJJ56YzTffPMnSg67PWm+99dKxY8e8/vrrq7vsGjf87lPy31nT0rPjXtlkvbaZt2BuJk55Lk++cFsardMsJx1wcU2XCAAAAAAAkKQWB11JstVWW+XBBx9cYvns2bMzefLk1KlTJ926dVvuft577728+uqr2XHHHVdHmWuV3tt8O489d1Mef+6P+aDs/ZSkJJus3zb773RSDt9jcDZef+WmbgQAAAAAAFjVanXQtTQvv/xyysvL07lz5zRu3LjSuqOPPjodO3ZMz549s95662XixIm59NJLU69evfzwhz+soYrXnD16HJ49ehxe02UAAAAAAAAs15cy6HrxxReTVD1t4U477ZSbbropl19+eebOnZs2bdqkd+/eOeecc9K2bds1XSoAAAAAAABLIej6nAEDBmTAgAFruiQAAAAAAACqqU5NF1ATlhV0AQAAAAAAUAxfyhFdo0aNqukSAAAAAAAA+IK+lCO6AAAAAAAAKD5BFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBItT7oKi0tzZAhQ9KxY8c0bNgwbdq0yemnn56ysrKccMIJKSkpyZVXXlnTZa615s77OP2HdkifwSW54p4BNV0OAAAAAABAhXo1XcDqNH78+PTt2zfTp09PkyZN0qVLl0ydOjXDhw/PpEmTMmPGjCRJz549a7bQtdiNj/wkH5a9X9NlAAAAAAAALKHWjugqLS3NgQcemOnTp2fQoEGZNm1axo0bl+nTp+eCCy7IQw89lLFjx6akpCTdu3ev6XLXShOnjMvdf7ssx/T5aU2XAgAAAAAAsIRaG3QNHDgwU6ZMyYABAzJs2LA0a9asYt2QIUPSo0ePLFiwIO3atUvz5s1rsNK108JFC3PpnSdm+y32zW5bH1LT5QAAAAAAACyhVgZdEyZMyMiRI9OiRYsMHTq0yja9evVKkvTo0WOp++nbt29KSkpy/vnnr44y12p3//XSvP3evzPgYM8vAwAAAAAA1k61Mui69dZbs2jRovTr1y9Nmzatsk2jRo2SLD3ouv322zN+/PjVVeJabdqMN3LTo+elX5+fpOUG7Wq6HAAAAAAAgCrVq+kCVodRo0YlSXr37r3UNlOmTElSddD10Ucf5Qc/+EGGDRuWo48+epXU1KlTp9SpU/O5YoN6jXLtgInLbHP5XSen5YYdcujuZ6yhqgAAAABYEzp17pR5C+bUdBkAUEnLli3z7LPPrtS2tTLoevPNN5Mkbdu2rXL9ggULMmbMmCRVB13nnntuOnfunH79+q2yoGvatGmrZD9fVMP6jZe5/i/P3ZxxEx/LJaf8NfXq1l9DVQEAAACwJkybOjVz539c02UAwCpTK4OusrKyJMmcOVXfnTJy5MiUlpamWbNmad++faV1zz77bK677ro899xzq7SmVq1arTUjupZm3oJPcs0DZ2SHLffL+s1a5p3S15MkpR++kyQpm/th3il9Pes2aZGmjdZbE+UCAAAAsAq12nRTI7oAWOu0bNlypbetlUFXy5YtM3PmzIwbNy4777xzpXXTpk3L4MGDkyTdu3dPSUlJxbqFCxfmpJNOyoABA9K1a9dVWtPEiRPTpEmTVbrPlbFwXvLE8KrXzZs/Jx+UvZ9nJjyUZyY8tMT6x8fdnMfH3Zzv7X9RDtvzzNVcKQAAAACr2sTXJqZug5quAgBWnVoZdO29996ZMGFCLrjggvTp0yedO3dOkowdOzb9+/dPaWlpkqRnz56Vtrvyyivz7rvv5vzzz1/DFa8dGjZokh/3v2OJ5R/Ofj/D7zk122+xb/bd4YR0aNW9BqoDAAAAAACorFYGXUOGDMmIESPy9ttvp2vXrtlyyy0zd+7cvP766+nbt2/atWuXRx55pNLzuUpLS/PjH/84w4YNy4IFC/LBBx9UrJs7d24++OCDNG/efK2YfnB1qVe3fnbvfugSy6fPmJwkabXh5lWuBwAAAAAAqAm1MrVp3bp1Ro8enf333z8NGzbM5MmTs8EGG+Saa67JQw89lNdeey1JKgVdU6ZMyaxZs3LSSSdl/fXXr/hKkgsuuCDrr79+3nrrrRr5eQAAAAAAAFhSSXl5eXlNF7EmzZ49O82bN09JSUlmzZqVxo0bVyx/9tlnl2jfu3fvHHvssTnuuOOy0047pWHDhiv8vcrKytK0adOK/a/tz+gCAAAAoHbrPTCe0QVArVIrpy5clpdffjnl5eXp3LlzRciVJE2bNs2ee+5Z5Tbt2rVb6joAAAAAAABqRq2cunBZXnzxxSSVpy0EAAAAAACgeL50I7qqG3R9yWZ2BAAAAAAAKAwjugAAAAAAACikL92IrlGjRtV0CQAAAAAAAKwCX7oRXQAAAAAAANQOgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACF9KUIukpLSzNkyJB07NgxDRs2TJs2bXL66aenrKwsJ5xwQkpKSnLllVfWdJkAAAAAAABUQ72aLmB1Gz9+fPr27Zvp06enSZMm6dKlS6ZOnZrhw4dn0qRJmTFjRpKkZ8+eNVvoWqTP4JIqlzds0CQP/HL2Gq4GAAAAAACgarU66CotLc2BBx6Y6dOnZ9CgQTnvvPPSrFmzJMmFF16Ys846K/Xq1UtJSUm6d+9ew9WuXbZu/9Xst+P3Ki2rV7d+DVUDAAAAAACwpFoddA0cODBTpkzJgAEDMmzYsErrhgwZkhEjRuSFF15I+/bt07x58xqqcu3UcoMO2bvX0TVdBgAAAAAAwFLV2md0TZgwISNHjkyLFi0ydOjQKtv06tUrSdKjR4+KZU8++WRKSkqW+PoyTm04f8G8zPnEVIUAAAAAAMDaqdaO6Lr11luzaNGi9OvXL02bNq2yTaNGjZJUDro+9Zvf/Cbbbrttxb+bNGmyegpdS41+8c48/vzNWbRoYdZrslH26HlEjv/6L9Kk0bo1XRoAAAAAAECSWhx0jRo1KknSu3fvpbaZMmVKkqqDri5dumSnnXZaPcWt5bZss0N2735YNm3RMR/P/Sj//PfDuW/MlfnXpKdy+YC/p9E6VQeHAAAAAAAAa1KtDbrefPPNJEnbtm2rXL9gwYKMGTMmSdVB16rWqVOn1KlT8zNFNqjXKNcOmLjMNlcMfKbSv/tsd0zat+qeP/z53Nz9t8vT72vnrs4SAQAAAFhNOnXulHkL5tR0GQBQScuWLfPss8+u1La1NugqKytLksyZU/WJe+TIkSktLU2zZs3Svn37JdYfccQRKS0tzYYbbpiDDjoov/71r9OiRYuVrmfatGkrve2q1LB+45Xa7vA9B+fmx36af054SNAFAAAAUFDTpk7N3Pkf13QZALDK1Nqgq2XLlpk5c2bGjRuXnXfeudK6adOmZfDgwUmS7t27p6SkpGLduuuum8GDB2f33XdP06ZN8/TTT2fo0KH5xz/+kWeffTYNGzZcqXpatWq11ozoWhn16tbPhs03zYdlpau4otrrn//+U378hwNz3aCX8pWNt1xu+6N/1S6brN8uF5/y5Bf+3vPmz813Ltoye23TL9/p+8svvD8AAAD4srrq/h/mmQkP5Xdnvpx6deuv8Lq1VatNNzWiC4C1TsuWLVd621obdO29996ZMGFCLrjggvTp0yedO3dOkowdOzb9+/dPaeniwKZnz56Vtttmm22yzTbbVPx7zz33TLdu3XLQQQfl1ltvzfHHH79S9UycODFNmjRZuR9mFVo4L3liePW3mzd/bt7/cEq2avvlfG5ZdS1cuCDXPDAoX9um3wqFXEtz9+jL0qThevn69sdVa7s7/3pJZs/5IIftcWal5X0Gl2THrfbPL77zYMWyQVftmdemPJsHfjm7YtlNj56fPz7201w5cGy2aLNdfnbToRnz0j25+JSn0q39bkt8v5fe+FsGXbVHdu32zSRZ4bY/OebO/P5P5+S2UUMz6LDfZ98dvlOpbXl5ec68uncmvPl0fvOD59K+ZbdceNtxeey5G5f7O+jT69gMOfKGPDL2hgy7ffnH7Sbrt83N50zO9BmT03/okqM8q/LHH72Re8dckbv+ekl+dNQt2Wubo5Zo807p6zn5kh5p12rrXPb9Malbp+4K7XtV+PR3def572fdJotHpH76+/hx/zuye/dDk6TiZz5ol+/ntG9emSR5Y/pL+f5lvbJV250z7OQnKt0QkCR/+ufvc8kd38239zonR/Y+Oydd0j3zFszNdWe+nOaNN1iilhGP/yp/+PO5+f43hueuv16yYm0PviLtW3bLmVcv/VmLn/XYReVJFr/OV8Swk59Ij833zKCr9sy//vPUctv373Nedu5yUAZeuVN6bN47vz7xkSrbnX3d1/PCpCcyfMA/0qn1titUy6rwwqQnc+bVvfO9/S/KYXv+37G/Isf9okWLMujqPfLq22Nz1Q+eT9tNtqq075mz3s2JF3dLk0br5ZofvpCGDRrnoX9cm8vuOin99v5xjvv6z5ao59e39s/j427O0O8+ku222CczPpqe717cNes12ShX/fD5rFO/8o0X4yY+nrOv65PePb+dHx11S7WPxZYbtMvRv2qXd2e+udz2Zx7+h3x9++Oq1Z8cv+8vcuLF3bLRem3y29OfS/16DZZod+md38vDz1yXnx//QHbqcsAK1b4qVHUMJ4tvoGjUoGmuO/OlimWf7ReaNlo/P7hyl0ye/lKuPuOFbNai4xL7HvX8iAwd0S+H7j4oJx04LL+65ag8+cJt+fWJj2XbTl+r1PaT+XNy8qU982FZaX436OX89V935Df3Dczx+/4yR33tnCX2/dHHM3LisK5pUK9hrjnjX/nxHw5c4WPxmH3OrzhXLU/3Dnvk4lOerDhGVsRjF5VX69z3k2PuXKH9riorcu5Oqu4Xnn310fzod1/P3tv2z1nfvmmJfd/w5x/nlsd/kR8eem2236JvtV73PTvulZMu7ZGyOR/kujNfzvpNN67U9s13X8kpl22bLdpsn4tPfip16tRZrX32yrxOVqY/XJNW9tz+9CsP5Cd/OCj77XhifnjotUvsd/6CeTn18l55/4O38/2Dr8iFtx2zytteN+il/OHP/2+tuo5ruUG7ap/P1qSVPbd/PHfWil+bHXxFDtr51NV+HbC6++xPfy8r4tP+pDr94X47nrhC+15VVvbc/mm/UJ3z9QbNW67Wc8OHZaWr/Tiu7jVgdd7rfHrj6BF7npWH/nFNHnj6qnxzt4GV2i9r3dpq4msTU3fJPx0AFFatDbqGDBmSESNG5O23307Xrl2z5ZZbZu7cuXn99dfTt2/ftGvXLo888sgKPZ/rgAMOSJMmTfLss8+udNBVFB+V/TfNm2y4xPIbHvlxFi5akJ22OrAGqiqep/51R956b0LO6XfrCm9z/ZBXU5LKF9h3j74sm6zfrlpB1yfz5+SOpy7K17c/Ps0ar7/C2y3LwEOuyotvjM5FI4/L1We8kEYN/i+0nTvv41w08rg0b9Iip3/r6pSXl69w2yQ5ps/5+ccrD+TqB85Ir877ZKP1Wle0v3v0ZfnXf57KCX2Hpn3LbkmSA3Y6Kdt22rvKOstTnj/86Zy8/+GUig8lu3fYPWcd+cel/myPPXdjxk38S7q1W9x+3aYbLbP9q2//M/eOuSKbteiU9ZpunO/s+8uM/fefcuW9p6XH5r2zYfNWFW0XLVqUi0Yel/KUZ8gRN67RkOuLat+yW47uc17+8Odzc++YKyq9YXt35pu5+oEz0r7l1unf57zUr9cgZx7xhwy+Zq9ccfepOffo2yrt641pL+bmx36abTp+Ld/YdUDat9p6xdru8v18MPu9Zf49nvn3Q3ly/G3p2m7XimXLaj9txn9y06PnZd0mLdJ6oy2SJEd97dz03eG7Vbafv/CTXP3AGZnzyax0abtLOrXeNkftdW5ueuz8PPD01Tlw55MrtX/w6Wvy3GuP5ph9frpGQ64vqk6dOjnz8D/k5Et65KKRx+byAU9Xer1edtdJmfXxjJx/7L0VH+ruv9P3MvrFu3LbqKHZtevBlX7ev714Tx4fd3P23+mkig8FN2jeMgMOviJDR/TLH/50bk4+6JKK9mVzP8rFt38n6zdrme8ffEWS6h+LSXLKQZdlziezq2w/a86MXPPAoNStUy+dW/dKUr3+ZKP1WufUb1yei0Yelxsf/Um+u9+vK7Uf++ojefiZ6/L17Y9foyHXF1G3Tt0MPvLGnHLpNrnwtmNz6amjK40+/+9H03Llvael7SZdcvy+v0iSDPjmlXlh0hO55I4Tcu0ZL6Zxw2YV7X/38NmZ8v5rOaffrdmgect8Y9cBGfPyvbn5sZ9mp60OSIdNu1f6/lfc8/3MnP1uLjppVBo3bFatYzFJdut2SDbdcMlw7lN3PDUs/5n2QsX54Csbb1Wt/qQ6574i2W6LfbLfjifm4Weuy1e7H5pduh5Use7Vt8fmtid+ne06f73iQ93qvu4HH/6HDLpqjwy/65Scd+xdFW0XLlyQC247JnXr1Mvgw2+oeK2tzj47qf7rZGX6wyLYucuB2We74/LwM9dlt26HZPst9620/qZHz8vk6S9lyBE3pk+v/hn/+qhV3naj9VqvdddxSfXPZ0XQuGGzFb822+X7KSkpWe3XAau7z06q359Utz8skuqcr5PVe26Y9t//rPbjuLrXgNV5r/OpDZq3zJ49j8xtT/w6B+18aurWrbdC6wCANaPWnn1bt26d0aNHZ/DgwXnqqacyefLkdOnSJddcc01OPPHEbL755kmyQkHXpz5/l09tdMvjv8iEN/+RHh17Z+P1vpK5n8zOP//9cMZPeiJbfmXHHLzbaTVdYiE88PRv06FV92y+6Yq/vhrUW2eVfO9Rz4/I7DkfpE+vY1bJ/pJkvaYb5Qffuibn3/jNXPfgkAw85DcV63738FmZ+t9J+emx91bcQVidtvXrNciQI27MaVfsmIvvOKFilMzb772aP/z53Gz5lR1z2J6DK/bRpd3O6dKu8nSkn7r5sZ/n/Q+n5OvbH5/9dlz8IVirDTuk1YYdqmz/wqTFd4u2a9ktpx96TZKkUYMm2bvX0VW2nznr3fz+T2en0TpNc/6x91S80R9y5E05/cqdc+mdJ1a6s/au0Zfm5cljcspBl6XNxlss4zdctU/vYv70TsU17YjeZ+XvL9+b6x/+UXbYcr9s1qJjysvLM+z272Te/DkZcuSNFXdw9th8zxy868Dc87fLs9vW38oePQ5LsviDzQtHHpv69RvmzMOvT0lJSbXart9sk6X+Pd58d0KuuOfUbNC8VX7S//9GUyyt/dx5H+f0K3dOnTp1c+7RIytCyV6d+yz1d3DxHd/Nx3M/yjH7/LTig5qjvnZunp7wQK57aHC22+LrabXB4jtO3535Zq57aHA6t94uR+215OiVFdFncEnFKIQ1bbMWHfOd/Ybmt/ednpFPXFAxAufRZ2/M31++L4ftcWa6td+10jZnHPa7fO/irXPhyGMr7uj9YPb7ufzuk9Nyg/Y56YBhldrvtc1RGf2vu/73tz+k4sOs3953et774K384jsPVtx1vjLH4q7dDq6y/aJFi3LO7/tm4aIFGXTY79O+1dZJqt+f7LPdsRnz0j2546lh2aXrwenyv1HOZXM+zKV3fDcbr/eVnHLQZcv6NS/V0b9ql+4d9syQI29Yqe1X1lc23jIn7Dc0V93/w9z514tz+Gf628vuOikfz/0oQ7/7SBrUXzx1c/PGG+T0b12T8274Rq55cFDFCI4XJj2Z+8Zcka92PzS9ex6ZJP/74PT6fO+S7rlw5LG5cuA/K6bzGf3i3Xly/G055Ks/SI/N90xS/WOxw6bdlwjPPvWX527Of6a9kG077Z1j9lk8gqC6/Ul1z33V8enIhk9HIaxpJx1wcZ577dFcftdJ6dZ+tzRvvEHmzZ+bC287No3WaZpBh/++om11X/fd2u+Wb+52eu4afWlGPT+iYrTziMd/mYlTnsuAg6/Mpi02r2i/uvvs6r5OkpXrD1dUTZ7bT/3G5Rn/+qhccud3c92gl9K00XpJkn+/9c/c/tRF2bXrwemz3TGrte3aeB2XVP98Vh01dW6vzvVWsvqvA1Z3n51Uvz9JqtcfVldNnduT6p2vP7W6zg1r4jiu7jVgUr33Op/ae9v+eWTsH/L3l+/LV7t/a4XXAQCrX80/NGo12mqrrfLggw9m1qxZmTVrVp555pl873vfS1lZWSZPnpw6deqkW7duy93P/fffn7Kysuywww5roOqa1aPDnmncsHkee/bGXHX/D3LTo+flo49n5Ph9f5mLT35yiamm1kbzFnySEY//Kt8d1jX7/ahhDv7xevnx9Qfm9Xeer2jz/gdTcsh5G+bEYd3yyfzK81IPHdEv+wypk3Gv/aViWZ/BJbnwtuMy7rW/5LQrdsoB5zTO4T9tmd/cd/oSd47N+Gh6Xnrjb9lhy/2qVffRv2qXQVftWel7vjvzzfzrP0+lz+CSiq/pMyYvcz9/feGObNCsZTputs0y21XXrt0Ozt7b9s+D/7gq4yY+nmTxG5P7//6b9Ol1THbp9o2VapsknVpvmyP3+lGee+3RPPSPa7Nw0cJceNsxKS9f8ZFQz0x4OH987Px0br1dBn7zt8tt/97Mt/KLPx5e8Sbps3fqV2XBwvn52R8PTemH7+TMw/+Qdi27Vqzbos12OXKvH+WZCQ/lT/9c/Abw7fdezQ1//n/psfmehZm+4vPq1qmbwUfcmIXlCzPs9uOzaNGi3Dfmyox/fVSO+tr/W+I1dsJ+Q9Nmoy1yxT2nZuasd5Ms/mDz9XeezykHXZaN1//KSrWtStmcD3P+jQdn/oJPcl7/uyruRl2Wi2//Tv4z7V/57n4XZJuOey23/QN/vyp//ufvs1OXA3P03j/+v99L3Xo568ibsmDh/AwbeXzKy8sr3hQvWDg/Q468qbB3cR6862np3mGP3PzYT/PG9Jfy/gdT8tv7Ts9XNt4qx33950u033i9Njn5wEsyefpLuemx85Mkw+8+JR+WvZ8zD78+jdZpusQ2A791VZo13iAX3X585s77OE+/8kAeffaGfH3747PjVvsvt8ZlHYtL8/s/Le5fvrHrgIoPW5dlWf3JDw69Ns0arZ+LRh5bcf747f0/SOlH7+TMI/6QJg2bL3f/a5tv7nZ6unfYIzc88uO8+e4rSRZ/sPmPVx7It/c6p2IavE/t0vWg7L1t/zz8zHUZ++oj+XjurAwbeXzWbbJRTj/kqkptN1m/bU458NJMmjo+Nz+2eGqrD8tKM/zuU9Jmoy3ynb6/Wm59SzsWl+b1d57PZXd9L5us3zbn9rttueeQZfUn1T2fFUXjhs1yxmG/z8zZ7+bKewYkSa7/87l5670JOfWgy9Ni3c0qta/u6/74vr9M640658p7T8uMj6Zn4pRxGTHql+nZca8ctMupK1Tjquqzl2Z5r5Pq9odF0KRh8ww6/Pr896OpufLexTevzZs/d/HoxEYbVHzIvDrbLk1NXsclK3c+K4LqXm+tieuAz1uVffbSLKs/qW5/WCTVOV8nq//c8Hmr+jiuyrKuAav7XidJtu6wexo2aJK//uuOaq0DAFa/Yn4S9wW9/PLLKS8vT+fOndO4ceUpR44++uh06NAh2267bZo2bZqnn346F154YXr27JkjjzxyKXusPXbp9o3CfmiTLL74Ped3++aVyX/P13r1zzd2GZCyuR/m4Weuyw9+s2suPuWv2aLNdtlovdY58/A/5LwbvpGr7vtBfvC/N+B//uf1GfX8iBzZ++xs27nytCqvvzMuo1+8M/vteGL69Dom4yc9kXv/NjyTp7+UC058rGIKnk+fG7FFmy8WjJ515B9z9QM/TPMmLXLUXudWLF+36UZL3WbhooV5+c0x6bn58j8QWhnfP3h4Xpj0RC6+/Tu5fMDTGXb7d9Ki+Wb5/jeWfPBbddomydF7/zhPv3x/rn3wzEyaOj7/fvufOemAi1doJNSU9yfm17f2S/PGG+a8Y++uGHmwNPPmz835Nx2Sjz7+b352/ANVPpfm83573w/y0ht/yxG9z6p4/sXn639mwoO5+oEz0nPz3rlo5HGpV7d+zjz8D4UeDdp2k8UfbFz30JD89v7T88g/r0+nzbatcsTSOvUbZfCRN+YHv9k1l911Uvr3OT8jRv0yO3U5MPtuf/xKt/288vLy/PrWozPl/dcy8JCrlnpn+Gfd/uRFefKFkdmzxxE5bI9By23/0htj8tv7T0/rjTrn7CP/uMTfsO0mXXL813+Rax8anLtHX5Z6dRtk/Ouj8r0Dhi3xXIsiKSkpyZlH/CEnXdI9F952TJo3bpE582ZnyJE3LvW42neH72T0i3fl9icvzIIF8zL6xbty8K6nVYzS+bz1m26c07752/zi5sMz/O5T8txrj2ajdVvnlAMvXaEal3csft5TL9yR25+8MN3a75aTD7xkue2X15+s33TjDDzkqvz8j4fldw+fne0675NHn70h39h1wAp9GL82+uzf/YLbjsl5x9yVq+7/QTpttm367f3/qtzm+wcPz/hJo3LpHd/N1h12z/SZk/OTY+6qcnTTvjt8J2Neuie3PfHr7Nz1oNz+5EX56OP/5ufHP7DcG2iWdyx+3odlpTn/xsXPizz/2HuqnI75s1akP6nu+awotu30tRyw0yl54OnfpsW6m+We0Zdl5y4HVRkGV/d1v079Rhl8xI354W93y8V3nJD3PngrDepVHj2yLKu6z/68FXmdrEx/WATbdvpaDtz51Nz/999kt26H5JU3/5633puQn/S/c4lnqq2utp+3NlzHJdU/nxVBda+31sR1wGetjj7781akP6lOf1g01TlfJ6v33PBZq+s4/qwVuQasznudZHE4tkWb7at8VuSy1gEAq1+tHtG1NC+++GKSqqct7Nq1a+65554cc8wx6du3b66//vqceOKJefLJJ9OggSd1ru3uG3NlXpj0ZH56/P0ZdNjvcuAup+TIvc7OVT98Ps2btMi1D/7fQ5x36XpQDt71tDz0zLX567/uzFvv/Tu/ufe0bPWVnaq8Y/GN6S/m7G/fnFMOujQH7XJqftL/jhy828CMf31UnvrX7RXtPr0bftMNN19iH9Wxd6+j07BBk6zfdPG0HZ9+LetOt/c+eCtzPpn9hb/30jRttF7OOOz3ee+Dt3LypT3y7szJGXT49WnSaN0v1DZJ6tWtnyFH3ph5C+bmgaevSrf2u+WQr/5guTXN+WR2zr/x4Hz8yayce/TIbLxem+Vuc9ldJ2XilOfSv8/52XGr5Y+8+/PYP+SBp3+bbTv1yfH7/nIZ9d+U+Qs+yWlX7JgJb/0jJx14SY1MObiqHbr7oHRpu3PuG3NlFi5akMFH3rjUEUtbfWXHHLHnWfn7y/fl7Ov6pPE6zfPDby35cPrqtv2sGx89L/+Y8GD23f47SzwjqyrjXvtLfv+nH6V9y61zxgpMP1P64dT8/I+Hpn69dXL+sfcs9TX7rd3PSLf2u+UPfz43v3v4rGzd/qv51ld/uNz9r+1abdA+J+53YV5/5/mMm/hYjtjzrGzRZvtlbvPDQ69Lk3Wa586/XpxNW3TMCZ97VsPn7dHjsOzR4/A89txNmTFres447PdL/T1/1ooci5/1xrQXM+z247Nh803z46PvqJg2b2lWtD/Zvfuh2Wubo3LfmCtywW3HZLMWnfLd/S5Ybj1rs1YbtM/JB16SiVOey/cv3y6fzJ+TwUfeuNTfWdNG6+WHh16X9z+cUjE93Ve3PmSp+//hodelScN1c+7v98tf/3VHjux9drb8yrJvCFnRY/FTCxctzC/+eHjenflmTv/WNSs0snlF+pPqns+K5MQDLkyrDTrkjqeGpUmj9fKDby195E11X/dd2u6UQ3cflH/+++FMnv5STjrw4myyftvl1rS6+uxPVed1sjL9YRGcuP+F2bRFx1xyxwm566+X5Gvb9FvqNFurq+2n1pbruE9V93xWBNW93loT1wHJ6uuzP6s6/Ul1+sMiqe75Olm954ZPrc7jOKneNWB13uskSasNN8+MWdPzUdl/q7UOAFi9BF2f86Mf/SgvvvhiPvroo8yfPz9vvPFGLrnkkqy7bvE/zPgyeHzczWmz8Zbp3LpXPiwrrfhasHBeenXqk5cm/63SVIUnHnBROm62TS6988T8/KZDU7du/ZzT79YqL2zbbLTFEnN/H9n77CTJmJfuqVj2Ydn7SZJm/3vOzJr04ezV/72322Kf7L/j9/JhWWn22+HEZT4rozptk6RJw3VT/3/PKtthy/0qRskty0Ujj8ub776SE/e7MD079l5u+3v+NjyPPXdTdu5y0FJHKnzWq2+PzfC7T0nL9dvl3H63LnM6lfYtu6V/n/PyYVlpenXep+L5EitiwcL5lV6zH5aVZs68xdNizp4zc4l1a1KdOnUqXlObtuiYr2y87BFL/fucl3Ytu+XDstJ8/+ArljmlTHXaJsnfX7ovIx7/RbZos31OO2T5UxtNnzE5v7zlyDRep9kKTYkyf8G8/Oymb2XGrOkZfPgNabtJl6W2rVOnToYccWPKy8uzaNHCDD7ihhV6zX5q1sdV/10/mffxEsvnLfhkhfe7Knx25OhOWx2w3PYNGzTOOv97RsI2m+9V6bknS/0eTTb6339bpEvb5d+RXZ1jMVn8+z3/xm9m4cL5+Un/O1doaqPq9CcDDr4y6zXZOLM+npEhR9y4Qj/zp8rmfLjE33hR+aLMX/jJEsvnzvt4hff7Re2344np1XmffFhWmv59zkv7lsue3rlZ4w1Sp2Txa37H5bxONmjeMt8/+Ip8WFaadv/rK5elOsfip657cHDGT3oiB+96Wvr06r/c9tXpT6p7PvuseQuW/Lt+8r+/6+eXz/p45grvd1WoX7dBGv9vaqnOrbdb7nFS3df9ev87zuvWqZfttth3ufWszj77U9V9nVS3P/ystfXc3rBB45x1xE2ZNWdm1m2yUb5/8BVrvO2n1qbruE9/huqezz5rbT23V/d6a01cB6zOPjupfn9S3f7w89bWc3tSvfN1svrPDav7OK7uNWB13+s0b7x45OHM2e9Vax0AsHp9KacuXFbQRbG99d6EfDJ/Tg49f+nT+31YVlpxt2iDeuvknKNuzXcv7prJ776cHx11y1JH4FR1wbth81Zp2mi9TPvvfz6zdPF0OeWp/ID5+QvmZdbHMyota7RO01U65/+nU/WUl6/eh9tv1XbnPPTMtdlqBT6cXtG2i59xdHwWLJiXr2y8VUb85RfZo/vhlR5Y/3kjHv9VRr94V/bseWQO3eOM5dbyr//8Ndc8MCitN+qcs769/KmNZs5+Lz+98ZDUKamT8469e7nTqSSp+MB+RT64/6yXJ4/JmVdX/QHPKZdtu8Syxy5avX/jz/rz2D/kmQkPZfNNe2bS1PG5/ckL8+29frTU9vXrNUinzXpl8vSXlvt7qE7bt977dy4YeUzWbdwiPznmrjT4Xyi6NHPnfZzzb/xmZs+ZmZ9/58FlvpY+deW9AzLhrX/kyN5nr9BDpFtt2CHrN9uk4v+r45TLtsm7M99cYvntT12U25+6qNKyMw//Q76+/XHV2v/Kmjn7vcUfJmzQPh99/N9cdtdJ+c3pzy7xMO7P+u19p6f0w3fSoVWP/Omfv8vevY5Z4oH1n/X866PywNO/rXhNXfvgmRVTyC6tpuoci4sWLcrQEUdl6n8n5fRDrl6hqY2q2580a7x+2my8ZWbOfneF9v9ZP7nhG1VOa/Pk+Nvy5PjbKi3r3+e8HLPP+dXa/xfRpe3Oee61R5d7PM6bPzcX3XZsmjRaLw0bNMk1D5yR7bfYN80ar7/MfSdJp816LXd0XXWPxVHPj8hdoy/N1u2/mpMOvHi57avbnyTVO/d91hPP35pht1c9Jevnr1c2Wb9tbj5ncrX2/0Xc8pdfZNLU8dl805557rVHM+r5W7PXNt9eavvqvO7ffHdCbnjkx2nXslvefu/fufSOEzP0xD8vtf2a6LOr+zpZmf7ws9bmc/unf782G2+5zON2dbZdG6/jqns++7y19dxeneutNXEdsLr77JXpT6rbH37e2npuX5nz9eo8N6zu43hlrgGr+14n/3uvXWXty1oHAKxWX8qga9SoUTVdAqtJeXl52rfcepnPYfn07uJPPTPhoSxatDDJ4och77XNUV+ohvX+dwfkrI9nVJp+5ZU3/77Ehx2r+k3OpyMkZs2ZsZyWa597x1yRFyY9meP3/WV26fqNnHrZthl2x3dy8clPVvlGYey//5wbH/lxOrTqnkGHLX9qo/c/mJKf//GwrFO/Uc4/9t7lPhx54cIF+fkfD8v7H07JWUf+cYWmU/kiOrTqkQtOfKzSsudeezS3P3VRzv72zVm/6Sar9fsvzXsfvJ2r7/9h2rXsluEDns7Z1+2TPz720+zS9RsrdOf8qlI296Ocf+M388m8j/Oz7923QlMbXXrniZk0dXyO+/rPs8OWfZfb/qF/XJuHn7kuvTrvs0JTonxRZ3/7lsz7zAjTJDnruj7Ze9v+6dOr8nMQ2q7Aw7ZXlcvvOjmzPp6R84+9J2+99+9ceueJueUvP89x+y45pWuS/P3l+/PYczdlvx1PzHFf/3m+O6xrLr7jO7n6h+OrfP7Sx3Nn5eLbv5P1m26SC096PL+9d2Aeeuba7N79sCWejZis3LH4h0f+X8a++ufsu8MJOWDnk5bbvrr9yRd10oEXZ/bnRu78+taj02HTHjl8j8GVllc3QF1Trv/TOXn7/Vfzo6NuybpNNsrZ1+2T39w3MGd/+49feN/VPRYnTX0hl95xYlqsu1l+3H/5U1SuTH/yRWy3xdeX6N8fe+6m/GXcH5dY3mA5zyxblSZOGZdbR/0qvTrvk/OPvScnX9ozv7n3tGzTca+KAH9lLVy0MBeNPDZ1Surk/GPvyaPP3pARj/8yf/rn79N3hxOq3GZ199nVfZ0k1e8PP29tPbevDdbG67jqns+qsrae26tjdV8HrIk+u7r9yaroD9fWc3t1z9er89ywJo7j6l4Drsx7nY/+9177858rLG8dALB6fSmDLmqvzVp0yodl76dnx71WaAqx16Y8l+v/9KNs26lP1m3SInf+9eJs26lPtttinyXavvXehCWW/fejaZk954NKb1ba/W+qp3dKJ2bzTf9v1GBVH3Ys701OSap3J9hG67VJ44bN807pxGptV9OmvD8x1z/8o2zRZvsc0fus1K1TN/33OT/X/+mc3Dvminxzt4GV2k8tnZShI45Kk4br5rxj7l7u9BjzFnySn950SD6Y/V5+csxdabvJsqejSJKrHzgjL/7nrzl4t4HZu9fRX+jnWxHNGq+/xIf87384JUnStd2uNfasr4tvPyFz55VlyBGLH0I+6PDrc/IlPXLRyONy+YCnlzt1yKpQXl6eC287Jm+/9++cfOAlK/Rw8zufuiSjnh+RXbp+I0d97dzltn/lzX/kN/eelpYbtM85/W6t1hSEK2tpdzq32rBDlYHPmvD4uFsy5qV78q2v/jDd2u+Wbu13y1//dUdue+LX2bXbN9OpdeURCB+V/TeX3fm9bLJ+25x0wMVp3LBZvn/wFRk64qj84U/n5uSDlrzp4OoHzsi7M9/MT4+7L80bb5BTDx6e519/PJfc+d1ce8aLadyw2RLtq3Msjn7x7ox84teLpzb65m+W2766/cmq0Ll1ryWWNajfMBs0a1Vjf/vqePE/o3PP3y7Pbt0Oqbg5ZP8dv1cRWO7S9aCV3nd1j8WPPp6xeHqiRQvy4/53LvdDuJXpT76oDZu3yobNW1Va9tLkvyVJjf295y34JBfedkwaNmiSMw77XRo2aJwzD78+g67aI5fffUrOP/buL7T/2574dV59e2xO/cbl2axFxxy990/y95fvy9UPnJFenfdZ4oPq1d1nV/d1klS/P6zK2npur2lr43XcypzPqrI2nturY3VfB6yJPru6/cmq6g/XxnN7dc/Xq/PcsCaO4+peAyYr915naunr2aBZyypHly1rHQCwen0pn9FF7dWn1zGZMWt67vpr1W9GZ856t+L/53wyO7+85cg0bbR+zv72H3P6t65Oy/Xb58LbjqlyTu233381Y166t9KykU8sftDuLl0PrljWvcMeSZIJb/6jUttPP+z47Nfygq6G6zRdYrrDZalbp262bv/V/PutZ1Z4m5q2aNGiXDTyuCwsX5jBR9xY8Wbi8D2HpHPr7XL9wz/K1NJJFe3nzCvL+Td+M2VzP8zZR92yQlORXHH3qXn17bGLpzZazsOXk+Sx5/6Ye8dcka3bfzUnH7D86VRqqweevjrjJj6WI/f6UcUHG5u16Jjj+/4qr749Nrc/eeEaqePmv/w8f3/5vvTu+e18a/cfLrf9+NefyHUPD0mbjbbIkCNvWu7UITM+mp6f3fSt1KlTN+cdc3ea18Dz9dYG//1oWn5z72lpvVHnHN/3/0ZHnHHY77JOg8a5aORxmb9gXqVtrrjn+/mg7L2ccdjvKwKqvbb5dnbtenDu+dvleemNMZXaj/33nxdPabRt/4oPV5o33iCnH3J13p35Zq598MxK7at7LL757iu5aOSxWbdxi5x3zN3LndpoZfqTL7s588oy7Pbj06zxBhn4rasqln/vgGHZeL2v5PK7Tlrp50xV91hcuGhhfnnzkZk+442c+o3h6dJ2p+V+j+r2J7XVTY+el8nvvpyTD7ykInTq1n63HLzbwIx56Z6Mev7Wld73f6b+K7c89rN077BHDt71tCSLp00bfMQN+WTex7n0jhMrtV/dffbKvE5Wpj9kxayt13HVPZ/VRqv7OmBN9NnV7U+S1dsf1qSVOV+vzt/F6j6Oq3sNmKzce52FixbmtSnPVrznX9F1AMDqZ0QXtco3v3p6npv4WK59aHCenzQq22y+Vxo3bJ73Pngrz098PA3qN8ywk59Iklx+9ymZ9t9J+dUJf664m/Ccfrfmh7/dLRfddmx+ecLDld4ctW+5dX5969HZb8cTs1mLThk/6Yn/3969x2ld1/n/f14Mh+EwqIA6oiigkAIChXm2IMGvpOQhU5NcM7NcJXRjwQ7b2uYRl82WzI3tZKESqWkqraZiSliGGoZIiSQmMmgjeGAEcWB+f/iL3YlDchiu+Yz3++3mzRufz/u65nWNzjWjj/m8P5n1+1sysPcHM3TQaevX7dxp1wzad2h++4ef57OjJm3T6zlg70Nz95zv5fq7v5K9dz8gpVKrHNpv1GZvpvyBgR/LIwtm5A9//m323/vgbfr4O8ItD/1Hnnru4Xz6wxMb/WZfRauKjD/t+g22MPzPWz6bZ5fNy4BeR+a1updz32M3bPR527frlCMGnJifP/Ld3D3n+9m5027Ze7cDNrk+SY448KQse/lP+cYtn0mrUqsc1v+EPPA3e+r/X/17Ht5stxXbVjXLn813ZoxP7z0G5RPDv9Lo3ElHjs2v5t26Q7YwfPSPv8jUe7+adm3aZ9C+Qzf7z29I3xFZ17Aul91watatW5sjD/xofj3/jk2u773HwPTuPjBfm3pKXn5taY4YcFIWL3syi5c9udH1u1TtniF9R2zza2qurrnl3NStfjWXfWpGo62Gdtu5Rz57/H9ssHXRg0/cnF8+MT2jDvvHvK/P0Y2e68KPfjvznp3VaOuilateyddv+XS6du6eC06c3Gj94QNOyNHvHd1oC8Nna+Zt0dfiLlXVueT6E7PqzZUZNvjjeWLRLze5vnvXfdOv52Fb/H5C8p27JmTpy4vyL5+Ynl067bb+eIfKqnz+Y9/dpi0Mt/Rr8Ue/uCSPL7w3PXbbP5VtO272/WH4kE9s8fvJtm7R1Fw99dxvcvODk3Lw/h/OsQd/qtG5T428Io8smLHV21TVr30rV08/KxUVbfLPp/2g0c9RffcaktOGXdxoC8OXX6tp8vfsLf33JNny90Peueb4c9yWfj9rqZr654Cmfs/emp8Bm/L9sNy29Pt1U34umvrreGt+Btza/9b5/Z8ezOo1dfnAwI9t8NybOwcAND2hixaldUWbXP6pGbnj19flvsem5ke/uCRJ0mWn7tm/x8EZMeSsJMm9j/4o9z9+Q04dOqHRNoX7731wzj728nxnxoTc8tDX87EPjlt/br8935fzRn09P7j7y7nr199Oh8rOOeGIMfnUsVdssGXOqMP+MZfdcFqeXvLYRrexeKfOHnl5Xn9jee54+FtZufqVNDQ0ZOoXn037LpsOXUMHnZZv3/n53Pf41GYfuv56o/oD9j40p/yfz/Vf9azuv8EWhn/d7unJZ3+VJ5/91Safe/dd9skRA05cv+aVlS/l6ulnbXaeqb2ezdNLHsua+tVJssHVJX/rn0/9QYsMXQ0NDZk0/ey8Vf9mJpz+ww3unVAqlXbYFoZPPfdwGhoa8uZbq/KNWze/z/5fI/ardbVJkmkzr9js+jNHXJLe3Qdm/uK3f9t49pO3ZfaTt21y/cDeH2yxoevu334/jyyYkVM/OH6jN+3+8CGfbrR1Ubed98o3bzs/1V165dzjNvxt112qdt9g66Jv3T42ta++kMs+NSOd2u+8wWP+dgvDLf1aHLTv0PXbtv78ke/k5498Z5PrRww5K/16HrbF7yfvdo8vvD93/ea/8oGBH8sHB526wfkhfUds0xaGW/q1+Nd/Zs+/9IdM/PGZm33u4UM+scXvJ0X7n5rvxJtvrcqk6Z9Mh3ZV+adTNvwaadem/TZtU3XDfZdm0dK5+dxJ38oeXXptcP5vtzCseXlRk79nb+m/J1v6fvhOtjDkfzW3n+Mq23Xa4u9nLdGO+Dmgqd+zky37GXDPXfs06fthOW3p9+shfUc06eeiqb+Ot/RnwAP2OXSr/1vnvsempktVdQ7vf8IGz725cwBA0ys1NDQ0lHuIlqquri6dOnVKkqxcuTIdO246Tuwoa9ckD0z+++tobMT4UkYMOSsTTr/+Ha1fu25tzvv6oOzbfXC+cMamf2Otqfx45lWZ9sCVmfrFZ9+127ABAADA9rD8tWX5h6t655wPX7XBPaQ3d665GjY2qWhb7ikAYPtxjy5oAhWtKvKZ4yflgbnT8tyLC3b4xz/5qItS1X6X3Pzgtm2dCAAAAO92P37gqnTbaa+MOuwft+gcALBjuKKrCbmiq+XY0iu6AAAAAJojV3QB0NK4ogsAAAAAAIBCal3uAaAI7v13Fz4CAAAAAEBz44ouAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkFp86Kqtrc2ECROy3377pbKyMj169MiFF16Yurq6nHPOOSmVSrn22mvLPSYAAAAAAABbqHW5B2hKc+fOzciRI7Ns2bJ07Ngx/fr1y9KlSzN58uQsWrQoy5cvT5IMHjy4vIM2Q6+9sTzT7r8iD8+/PX95dUk6tKtKz+oBOeuYr+XA3keVezwAAAAAAICWG7pqa2szatSoLFu2LOPGjcsll1ySqqqqJMnVV1+diy++OK1bt06pVMrAgQPLPG3z8uKK5/LP/zU0q9aszLEHn5O9uvVN3epX86ea36f2tRfKPR4AAAAAAECSFhy6xo4dmyVLlmTMmDGZNGlSo3MTJkzITTfdlCeeeCK9evVK586dyzRl83TVtE9k7br6TPn879O18x7lHgcAAAAAAGCjWuQ9uhYsWJDp06enW7duufLKKze6ZsiQIUmSQYMGbXDutttuy+GHH56OHTtmp512yhFHHJH58+c36czNxe//9FCefPZXOXXohHTtvEfq176V1WveKPdYAAAAAAAAG2iRV3RNmzYt69aty+jRo9OpU6eNrmnfvn2SDUPX5MmTM27cuPzTP/1TLr300rz55pt55JFHsmrVqiafuzn47R9+niTZbee985Xvj8pv//g/Wbdubfbs1iefGP6vGT7kE2WeEAAAAAAA4G0tMnTNnDkzSTJs2LBNrlmyZEmSxqFr0aJFGT9+fK655pqMGTNm/fEPf/jDTTRp87PkpT8mSa655dx079YnE077Yd5auya3PvgfmfjjM1O/7q0c+/6zyzwlAAAAAABACw1dzz33XJJkn3322ej5+vr6zJ49O0nj0PX9738/bdq0ybnnnrvdZ+rTp09atSr/TpFtW7fPf49ZuMnzb7z5epKkfbuqTDrvgbRp3TZJckT/E/MPV/XOD/7nSzlmyFnN4rUAAAAAsGX69O2TNfXvjp2LACiO6urqPProo1v12BYZuurq6pJkk9sNTp8+PbW1tamqqkqvXr3WH3/44Yfznve8JzfccEMuu+yyPP/88+nTp0/+9V//NR//+Me3aaaampptevz2Utmmw2bPt2vz9paOw9778fWRK0mqOuySw/p9JPc+9qM8/5c/Zp/dD2jSOQEAAADY/mqWLs3qt9yPHYCWo0WGrurq6qxYsSKPP/54DjvssEbnampqMn78+CTJwIEDUyqVGp174YUX8sUvfjETJ05Mjx498r3vfS9nnHFGdt111wwfPnyrZ9pjjz2axVVQbVu33+z5bjvtlSTZpap6g3NdOu+RJFm5asX2HwwAAACAJrdH9+6u6AKg2amu3rBJvFMtMnQNHz48CxYsyMSJEzNixIj07ds3STJnzpyceeaZqa2tTZIMHjy40ePWrVuXlStXZurUqTnxxBOTJEcffXSeeuqpXHrppdsUuhYuXJiOHTtu9eO3l7Vrkgcmb/r8e/Y+OHf95tupfXXJBudqX3n72M6ddmuq8QAAAABoQgufXpiKtn9/HQAURfkvMWoCEyZMSNeuXfP888+nf//+OfDAA9OnT58cfPDB6d27dz70oQ8laXx/riTp0qVLkjQKWqVSKcOHD8+TTz65415AGR3R/8R0aFeV+x+/IaveXLn++Muv1WT2/Nuz1659s2e3/co4IQAAAAAAwNtaZOjaa6+9MmvWrBx33HGprKzM4sWL06VLl0yZMiUzZszI008/nWTD0NW/f/9NPufq1aubdObmoqrDLvnM8ZNS++oLGfvNQ3PLg1/Pj2delbHfPDT1a9fkghO+We4RAQAAAAAAkiSlhoaGhnIPsSOtXLkynTt3TqlUyuuvv54OHTqsP3fHHXfkhBNOyK233pqTTz45ydvbGQ4ePDhdunTJL3/5yy36WHV1denUqdP6j1uErQv/ata8n+Ynv7w6i2vmpdSqVQ7Y+7CcOeKSDOh1RNMPCQAAAECTGDY2ti4EoEVpkffo2pz58+enoaEhffv2bRS5kmTUqFE56qij8pnPfCYvv/xy9t5773z3u9/N/Pnzc++995Zp4vI46sCTc9SBJ5d7DAAAAAAAgE1614WuefPmJdlw28Lk7ftx3XHHHbn44ovzpS99Ka+99loGDRqUn//85+vv6wUAAAAAAEDzIHT9jZ133jlTpkzJlClTduRYAAAAAAAAbKFW5R5gR/t7oQsAAAAAAIBieNdd0TVz5sxyjwAAAAAAAMB28K67ogsAAAAAAICWQegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJDeFaGrtrY2EyZMyH777ZfKysr06NEjF154Yerq6nLOOeekVCrl2muvLfeYzcKPfvHVjBhf2uRfx17cptwjAgAAAAAAJElal3uApjZ37tyMHDkyy5YtS8eOHdOvX78sXbo0kydPzqJFi7J8+fIkyeDBg8s7aDNx5ICT073rfhscf7bm9/nJg/+eQ/uNKsNUAAAAAAAAG2rRoau2tjajRo3KsmXLMm7cuFxyySWpqqpKklx99dW5+OKL07p165RKpQwcOLDM0zYPvbsPTO/uG34uvnHLZ5MkIw8+Z0ePBAAAAAAAsFEteuvCsWPHZsmSJRkzZkwmTZq0PnIlyYQJEzJo0KDU19enZ8+e6dy5cxknbd5WranLA0/8OLvutFcOes+x5R4HAAAAAAAgSQsOXQsWLMj06dPTrVu3XHnllRtdM2TIkCTJoEGD1h8bOnRoSqXSRv8677zzdsjszc1DT9ycN1a/lmMO+mQqWlWUexwAAAAAAIAkLXjrwmnTpmXdunUZPXp0OnXqtNE17du3T9I4dF133XV57bXXGq2bMWNGLrvsshx//PFNN3Azdvec76VUKuX/Hfypco8CAAAAAACwXosNXTNnzkySDBs2bJNrlixZkqRx6OrXr98G6y6//PLsuuuuOfbYd9+2fc+/9Mc8+eyv8t79js4eXXqVexwAAAAAAID1Wmzoeu6555Ik++yzz0bP19fXZ/bs2Ukah66/9Ze//CV33313zj///LRuvfWfrj59+qRVq/LvFNm2dfv895iF73j93b/9XpJk5CGfbqqRAAAAANhB+vTtkzX1q8o9BgA0Ul1dnUcffXSrHttiQ1ddXV2SZNWqjX/jnj59empra1NVVZVevTZ9pdK0adNSX1+fM888c5vmqamp2abHby+VbTq847Vr19bn3sd+lM4duuaIASc14VQAAAAA7Ag1S5dm9VtvlHsMANhuWmzoqq6uzooVK/L444/nsMMOa3SupqYm48ePT5IMHDgwpVJpk88zderUHHDAATnooIO2aZ499tij2VzR9U79+qk7s2LliznpyAvTtnW7JpwKAGDL/egXX83pw76Qtm0qc/WPP5n99hyck4+6aIueY/aTt2eXqur02+fQv7v2njnX57o7Lsye3frkugvf/i2zm+6/Ivc+9sO8ULswl/zDT3PEgBPXr7/yptH53cL7M3Tw6Tn/hG9s0VwAAE1lj+7dXdEFQLNTXV291Y9tsaFr+PDhWbBgQSZOnJgRI0akb9++SZI5c+bkzDPPTG1tbZJk8ODBm3yOP/zhD3n00UdzxRVXbPM8CxcuTMeOHbf5ebbV2jXJA5Pf2dq75/z/2xYefE4TTgQAsHWm3vtvOfmoi9K2TeVWP8fsJ2/PfnsOfkehK0kG7zss//bJ29f/+X19hmfY4NMz6Sef2mDtF8+4MT/6xVezctUrWz0fAMD2tvDphaloW+4pAGD7abGha8KECbnpppvy/PPPp3///tl///2zevXqPPPMMxk5cmR69uyZe+65Z7P355o6dWpKpVJGjx69AydvHmpfXZo5f7w7+/c4OL32OLDc4wAANPKNW89LkvzTdUelVakiXXfqnj+/uCDjpxydv7zyfHpWD8iXR/84bVq3Tf3at3L9PV/J3Gdm5q36Ndlr17656KNT8tRzv85vnrojjy+8N/fMuT4nHDEmhx5wfK646eN5Y/VrWVO/OoP2HZYLTpi8ySvz99/74B35sgEAAIC/Uf699JrIXnvtlVmzZuW4445LZWVlFi9enC5dumTKlCmZMWNGnn766STZZOhqaGjIjTfemKFDh2bvvffekaM3C7949PqsW7c2Iw/5dLlHAQDYwEUf/XaS5JrzZ2XK5+dm5467ZdHSubn07DvzvfELsuL1FzNr3q1Jkp/88t9T2aZjrh3720z5/Nz0qj4wP7j7X3LIAR/Oof0+klOHjs+Uz8/Nhw/5dDq13zmXnn1nrrvosUz5/O/z4orFefD3PynnSwUAAAA2o8Ve0ZUkBxxwQO66664Njq9cuTKLFy9Oq1atMmDAgI0+9qGHHspzzz2XSy65pKnHbJbOOPpLOePoL5V7DACAd+yIASelsm2HJG9faVXz8qIkycPzb0/d6lfXh6/6tWuye5eeG32OdQ3r8p0ZF2f+4l+loaEhr6x8KT2rB2TY4NN3yGsAAAAAtkyLDl2bMn/+/DQ0NKRv377p0KHDRtdMnTo17du3zymnnLKDpwMAYGv833t1tSpVZO26+iRvX6l/wQnfzEHvOebvPsetD309r9S9lG9+7pG0bVOZb9/x+ax5a3WTzQwAAABsmxa7deHmzJs3L8mmty1cvXp1brnllpx44ompqqrakaMBAPAOdWhXlbrVr/7ddYcPODE/nXVNVq95I0myes0bWbxsfpKkY2Xn1K363+d4fdWKdKmqTts2lVn+2rI89Pubm2Z4AAAAYLt4V17R9fdCV2VlZV555ZUdOBEAAFvqlA+My8X/PSLt2nRI1526b3Ld6UMvztT6N/O5bx6SUkpJktOGXZye1f0zfMiZ+ffpn8zs+bfnI4dfkJOPvDBfm3pKPj2pf7p27p739hm+2RluvO+y3PWbb+fVlX/J15c9mWtvH5P/uuh32bnTrtv1tQIAAAAbV2poaGgo9xA72oc+9KE88MADueuuu3Lcccc12cepq6tLp06dkrx9X7COHTs22cd6p9auSR6YXO4pAACK55451+fh+bfn3z55+zt+zI9+8dWsXPVKzj/hG002FwDAlhg2NqloW+4pAGD7eVduXThz5sw0NDQ0aeQCAKBlademfRYtnZvz//Ogd7T+yptG5/7Hb0iHys5NPBkAAAC8e70rr+jaUVzRBQAAAEBz4oouAFqad+UVXQAAAAAAABSf0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhtfjQVVtbmwkTJmS//fZLZWVlevTokQsvvDB1dXU555xzUiqVcu2115Z7TAAAAAAAALZQ63IP0JTmzp2bkSNHZtmyZenYsWP69euXpUuXZvLkyVm0aFGWL1+eJBk8eHB5B21mVr25Mrf9anIemDstL65YnDYV7bLXrn3z4UM+k2MOOiulUqncIwIAAAAAALTcK7pqa2szatSoLFu2LOPGjUtNTU0ef/zxLFu2LBMnTsyMGTMyZ86clEqlDBw4sNzjNhvr1q3Ll743Mj+85yt5T4/357PH/0dGD/+XrFu3NpN+cna++/MvlHtEAAAAAACAJC04dI0dOzZLlizJmDFjMmnSpFRVVa0/N2HChAwaNCj19fXp2bNnOnfuXMZJm5c//PmRPPnsr3LikWPzz6d+P8cd+pmcfNRF+fr5s1LdpVdm/GZKuUcEAAAAAABI0kJD14IFCzJ9+vR069YtV1555UbXDBkyJEkyaNCgRsdnzZqVo48+Ot26dcvOO++cQw89ND/96U+bfObmou7N15IkXTt3b3S8Teu22aljt1S27ViOsQAAAAAAADbQIkPXtGnTsm7duowePTqdOnXa6Jr27dsnaRy6nnjiiYwYMSIVFRW5/vrrM3369PTo0SOnnHJK7rrrrh0ye7nt3+PgdGq/c37yy6vz4BM356UVf86fX/pDvvfzL2bhksfyD8d8tdwjAgAAAAAAJElal3uApjBz5swkybBhwza5ZsmSJUkah67p06enVCrl9ttvT4cOHZIkw4cPT+/evXPjjTfm+OOPb8Kpm4eqDrvka5+8I1+/5dO57IZT1x/v0K4q//oPt+aIASeWbzgAAAAAAID/o0WGrueeey5Jss8++2z0fH19fWbPnp2kcehas2ZN2rZtu/5qrySpqKhIVVVV1q1bt00z9enTJ61alf8Curat2+e/xyzc7Jr27Tql5+4Dcli/j6TfPofn9VXLc8fD38qVN52Rf/vkzzKk74gdNC0AAAAA21Ofvn2ypn5VuccAgEaqq6vz6KOPbtVjW2ToqqurS5KsWrXxb9rTp09PbW1tqqqq0qtXr/XHzzzzzHzrW9/KuHHjcvHFF6d169aZMmVKFi5cmOuuu26bZqqpqdmmx28vlW06bPb8szXzcuG1h+e8j1yTUYedt/74sMEfz7n/MSDX3HJufviFRaloVdHUowIAAACwndUsXZrVb71R7jEAYLtpkaGruro6K1asyOOPP57DDjus0bmampqMHz8+STJw4MCUSqX15wYNGpT7778/J598cq655pokSceOHXPzzTfnAx/4wDbNtMceezSbK7o259ZZ12RN/ep8cODHGh2vbNshhxxwXH42+9q8uHxxunfbtynHBAAAAKAJ7NG9uyu6AGh2qqurt/qxLTJ0DR8+PAsWLMjEiRMzYsSI9O3bN0kyZ86cnHnmmamtrU2SDB48uNHjFi5cmNNOOy3vf//7c/7556eioiI33nhjTj/99Nx111350Ic+tNUzLVy4MB07dtzqx28va9ckD0ze9PnaV194e13D2g0fu7b+7b+vq2+S2QAAAABoWgufXpiKtuWeAgC2n/JfYtQEJkyYkK5du+b5559P//79c+CBB6ZPnz45+OCD07t37/XB6v/enytJvvSlL6VDhw657bbbMnLkyBxzzDH54Q9/mEMOOSTjxo0rx0vZ4fbZvV+S5Bdzrm90fOWqV/LwUz9LVftd0r3bfmWYDAAAAAAAoLEWGbr22muvzJo1K8cdd1wqKyuzePHidOnSJVOmTMmMGTPy9NNPJ9kwdM2bNy+DBg1K69aNL3Q76KCDsmDBgh02fzmdfNRFqerQJd/7ny/kqmln5s5ffzs33X9F/vGa92b5azX55LGXuT8XAAAAAADQLJQaGhoayj3EjrRy5cp07tw5pVIpr7/+ejp06LD+3NChQ7N06dI89dRTjWLX0KFD8/zzz2fRokVb9LHq6urSqVOn9R+3CFsXJsnS2kW54b6v5XfP3J8Vr7+Ydm3aZ9/ug3PSURflqANP3jGDAgAAALDdDRsbWxcC0KK0yHt0bc78+fPT0NCQvn37NopcSXLBBRfk1FNPzUknnZTPfvazqaioyE033ZQHH3ww//mf/1mmiXe87t32zYTTf1juMQAAAAAAADbrXRe65s2bl2TDbQuT5GMf+1juvPPOTJw4MWeddVbWrl2bvn375sYbb8wZZ5yxo0cFAAAAAABgM4Suv3H88cfn+OOP35EjAQAAAAAAsBValXuAHe3vhS4AAAAAAACK4V13RdfMmTPLPQIAAAAAAADbwbvuii4AAAAAAABaBqELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEJ6V4Su2traTJgwIfvtt18qKyvTo0ePXHjhhamrq8s555yTUqmUa6+9ttxjNgsrXn8x37j1vJxxWY+M/ELbnHH53vnWzy7MylWvlHs0AAAAAACARlqXe4CmNnfu3IwcOTLLli1Lx44d069fvyxdujSTJ0/OokWLsnz58iTJ4MGDyztoM7Bi5Uv53DcPycuvLc1xh342PXcfkMUvPpm7fv1fmfenh/KNC2ansm2Hco8JAAAAAACQpIWHrtra2owaNSrLli3LuHHjcskll6SqqipJcvXVV+fiiy9O69atUyqVMnDgwDJPW37T7r8iL654Ll8846Z86L0fX3+83z6H58qbzsitD309o4f/SxknBAAAAAAA+F8teuvCsWPHZsmSJRkzZkwmTZq0PnIlyYQJEzJo0KDU19enZ8+e6dy5cxknbR6eWPRA2rVpn2GDT290fOig09K2dWXumfODMk0GAAAAAACwoRYbuhYsWJDp06enW7duufLKKze6ZsiQIUmSQYMGNTp+33335dBDD01lZWV22223nHfeeXn11VebfOZye6v+zbRtXZlSqdToeKtWrdKuTfvULP9TXq2rLdN0AAAAAAAAjbXY0DVt2rSsW7cuo0ePTqdOnTa6pn379kkah64HH3wwxx57bPbcc8/cdtttufzyy3PLLbfkxBNPTENDww6ZvVz22b1/Xl+1Is+8MLfR8WdemJvXV61Ikry04s9lmAwAAAAAAGBDLfYeXTNnzkySDBs2bJNrlixZkqRx6Pra176WPn365Oabb06rVm93wK5du+ajH/1oZsyYkeOPP36r5unTp8/65yuntq3b57/HLNzouZOPuigPz789l91wav7xI99Ir+oBWfzi/PzXHReldUWb1K99K2++9cYOnhgAAACA7aVP3z5ZU7+q3GMAQCPV1dV59NFHt+qxLTZ0Pffcc0mSffbZZ6Pn6+vrM3v27CSNQ9cjjzySs88+u1GUOuaYY5Ikt99++1aHrpqamq163PZW2abDJs8d2PuofGn0j3Pdz8bmX75/XJKkVauKjDz409ln9/6Z/eRt6dDOvcwAAAAAiqpm6dKs9ovMALQgLTZ01dXVJUlWrdr4b6hMnz49tbW1qaqqSq9evdYfr6ioSNu2bRutbdOmTUqlUubPn79FM3To0CErV67MkUcemZdeemmDe1+VQ9vW7Td7/oODPpYjDzw5z9bMy6o3X89eu70nu3TaLWMmH5yKVq3Tvdt+O2hSAAAAALa3Pbp3d0UXAM1OdXX1Vj+2xYau6urqrFixIo8//ngOO+ywRudqamoyfvz4JMnAgQMbBai+ffvmkUceabR+zpw5aWhoyPLly7dohlKplI4dO+Z3v/vdVr6K7W/tmuSByZtfU9GqIvvtOXj9n5e/tizPvPC7DOz9wVS23fQVYQAAAAA0bwufXpiKtn9/HQAURflvGtVEhg8fniSZOHFinn766fXH58yZk2HDhqW2tjZJMnjw4EaPGzt2bGbPnp3LLrsstbW1mTt3bs4///xUVFQ0i3ts7Wjr1q3Lt342Nusa1uaMo79c7nEAAAAAAADWa7FXdE2YMCE33XRTnn/++fTv3z/7779/Vq9enWeeeSYjR45Mz549c8899zS6P1eSfOITn8j8+fNz6aWX5itf+UoqKipywQUXpG3btuncuWXfn2rVmyszZvLBOWLASanu0it1q1/NA3OnZeGSx3L2sZdn8H7Dyj0iAAAAAADAei02dO21116ZNWtWxo8fnwcffDCLFy9Ov379MmXKlJx77rnZd999k2SD0FUqlXLVVVfly1/+cp599tnsueee2WmnndK1a9d87nOfK8dL2WFaV7RN7+6D8sDvbsrLr9eksk2H9O3x/lzx6bvz/vf8v3KPBwAAAAAA0EipoaGhodxD7GgrV65M586dUyqV8vrrr6dDh83fd+o73/lOLrjggixYsGB9ICuqd3KPLgAAAABapmFj4x5dALQoLfaKrs2ZP39+Ghoa0rdv3w0i16OPPpp7770373vf+1JfX5/77rsvkydPzqRJkwofuQAAAAAAAFqSd2XomjdvXpINty1Mknbt2uXOO+/MlVdemfr6+hx44IGZPn16TjnllB09JgAAAAAAAJshdP2NAw88MA8//PCOHgkAAAAAAIAt1KrcA5TD5kIXAAAAAAAAxfCuvKJr5syZ5R4BAAAAAACAbfSuvKILAAAAAACA4hO6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACikUkNDQ0O5h2DHaWhI1r1V7ikAAAAAKIdWbZJSqdxTAMD2I3QBAAAAAABQSLYuBAAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJD+P0UGKtvQNBIEAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 31, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -930,27 +917,27 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.51330317 3.48868114]\n", + "[2.43769306 4.84557052]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.968684172213385\n", - " x: [ 3.260e+00 3.191e+00]\n", - " nfev: 37\n", + " fun: -7.96868416874958\n", + " x: [ 3.023e+00 6.333e+00]\n", + " nfev: 38\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 37 F =-7.968684E+00 MAXCV = 0.000000E+00\n", - " X = 3.259915E+00 3.191406E+00\n", + " NFVALS = 38 F =-7.968684E+00 MAXCV = 0.000000E+00\n", + " X = 3.023366E+00 6.332824E+00\n", "\n", - "Found ground energy: -7.968684172213385\n" + "Found ground energy: -7.96868416874958\n" ] } ], @@ -977,9 +964,179 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0\n", + "Maximum gradient: 0.2502515943160275\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.966906284793598\n", + " Iterations: 2\n", + " Function evaluations: 5\n", + " Gradient evaluations: 2\n", + "Result at iter 0: -7.966906284793598\n", + "Iter: 1\n", + "Maximum gradient: 0.07148481503619701\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.968684135389207\n", + " Iterations: 6\n", + " Function evaluations: 21\n", + " Gradient evaluations: 6\n", + "Result at iter 1: -7.968684135389207\n", + "Iter: 2\n", + "Maximum gradient: 0.06885672251558851\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.970337065973196\n", + " Iterations: 6\n", + " Function evaluations: 27\n", + " Gradient evaluations: 6\n", + "Result at iter 2: -7.970337065973196\n", + "Iter: 3\n", + "Maximum gradient: 0.03791655571908455\n", + "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 13\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.970872496782351\n", + " Iterations: 7\n", + " Function evaluations: 37\n", + " Gradient evaluations: 7\n", + "Result at iter 3: -7.970872496782351\n", + "Iter: 4\n", + "Maximum gradient: 0.0370299474918533\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.971383218746653\n", + " Iterations: 20\n", + " Function evaluations: 135\n", + " Gradient evaluations: 20\n", + "Result at iter 4: -7.971383218746653\n", + "Iter: 5\n", + "Maximum gradient: 0.03224685854317715\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.971773202172484\n", + " Iterations: 18\n", + " Function evaluations: 134\n", + " Gradient evaluations: 18\n", + "Result at iter 5: -7.971773202172484\n", + "Iter: 6\n", + "Maximum gradient: 0.010705739242569776\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.971978831060897\n", + " Iterations: 16\n", + " Function evaluations: 132\n", + " Gradient evaluations: 16\n", + "Result at iter 6: -7.971978831060897\n", + "Iter: 7\n", + "Maximum gradient: 0.009717164674363968\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.968225393431566\n", + " Iterations: 13\n", + " Function evaluations: 120\n", + " Gradient evaluations: 13\n", + "Result at iter 7: -7.968225393431566\n", + "Iter: 8\n", + "Maximum gradient: 0.06816889310847103\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.969120334779275\n", + " Iterations: 15\n", + " Function evaluations: 153\n", + " Gradient evaluations: 15\n", + "Result at iter 8: -7.969120334779275\n", + "Iter: 9\n", + "Maximum gradient: 0.07060449874596993\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.9716270972513525\n", + " Iterations: 40\n", + " Function evaluations: 443\n", + " Gradient evaluations: 40\n", + "Result at iter 9: -7.9716270972513525\n", + "Iter: 10\n", + "Maximum gradient: 0.020853916020903765\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.970921582203872\n", + " Iterations: 24\n", + " Function evaluations: 290\n", + " Gradient evaluations: 24\n", + "Result at iter 10: -7.970921582203872\n", + "Iter: 11\n", + "Maximum gradient: 0.04232508018126495\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.97174310731302\n", + " Iterations: 21\n", + " Function evaluations: 276\n", + " Gradient evaluations: 21\n", + "Result at iter 11: -7.97174310731302\n", + "Iter: 12\n", + "Maximum gradient: 0.01114875020605062\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.972156543559216\n", + " Iterations: 29\n", + " Function evaluations: 411\n", + " Gradient evaluations: 29\n", + "Result at iter 12: -7.972156543559216\n", + "Iter: 13\n", + "Maximum gradient: 0.005734779272457883\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.972174887679361\n", + " Iterations: 36\n", + " Function evaluations: 543\n", + " Gradient evaluations: 36\n", + "Result at iter 13: -7.972174887679361\n", + "Iter: 14\n", + "Maximum gradient: 0.002736550362458665\n", + "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", + "Iteration limit reached (Exit mode 9)\n", + " Current function value: -7.972132265604596\n", + " Iterations: 50\n", + " Function evaluations: 803\n", + " Gradient evaluations: 50\n", + "Result at iter 14: -7.972132265604596\n", + "Terminating: reached maximum iteration.\n", + "Found ground energy: -7.972132265604596\n" + ] + } + ], "source": [ "from qiskit.primitives import Estimator\n", "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", @@ -988,7 +1145,7 @@ "\n", "\n", "# Define the conditions for termination\n", - "gradient_threshold = 5e-3\n", + "gradient_threshold = 1e-3\n", "max_iter = 15\n", "terminate = False\n", "\n", @@ -1038,9 +1195,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:927: UserWarning: Starting a session using the /jobs endpoint will no longer be supported after March 31, 2024. Please update your code as soon as possible before this date. If you are using qiskit-ibm-runtime, you will need version 0.20.0 or higher. If you are using qiskit-ibm-provider, you will need version 0.10.0 or higher. If you are calling the API directly, please use the /sessions endpoint instead.\n", + " warnings.warn(warning_message)\n" + ] + } + ], "source": [ "# To continue running on real hardware use\n", "from qiskit_ibm_runtime import Estimator, Session, Options\n", From e6936e70477bda85832227b3a7a0bc54ee7cf6be Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Tue, 12 Mar 2024 14:24:45 -0700 Subject: [PATCH 14/17] check style --- .../tutorials/adapt-vqe-patterns.ipynb | 1307 ----------------- quantum_enablement/tutorials/adapt-vqe.ipynb | 742 +++++++--- 2 files changed, 508 insertions(+), 1541 deletions(-) delete mode 100644 quantum_enablement/tutorials/adapt-vqe-patterns.ipynb diff --git a/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb b/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb deleted file mode 100644 index 393f3e0..0000000 --- a/quantum_enablement/tutorials/adapt-vqe-patterns.ipynb +++ /dev/null @@ -1,1307 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit ADAPT-VQE tutorial\n", - "\n", - "ADAPT-VQE is a variation of the original VQE algorithm, which grows the ansatz at each iteration by selecting operators from an operator pool. This typically results in shorter depth circuits than fixed-depth ansatze designed for VQE. This algorithm was first introduced in https://arxiv.org/abs/1812.1117. For a ground state estimation problem from the quantum chemistry domain, steps are outlined as follows.\n", - "\n", - "1. We find the fermionic Hamiltonian by defining the molecular geometry, and map it onto qubit representation using a mapper such as the Jordan-Wigner transform. \n", - "2. The quantum computer is typically initiated in the Hartree-Fock state under the same transformation as an estimate to the ground state energy.\n", - "3. We define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian.\n", - "4. Until the algorithm terminates:\n", - " - we compute the gradient of each operator from the pool and select the operator with the maximum gradient,\n", - " - grow the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$,\n", - " - run VQE over all parameters $\\theta_i$,\n", - " - and terminate the algorithm if the gradient of all operators from the pool are smaller than some threshold (convergence) or if we reach the maximum number of allowed iterations.\n", - "\n", - "We note the following variants of the ADAPT-VQE algorithm:\n", - "- A hardware-efficient variant called qubit-ADAPT-VQE, which reduces the circuit depth by constructing the pool directly with individual Pauli operators: https://arxiv.org/abs/1911.10205.\n", - "- A utility scale ADAPT-VQE experiment for the Schwinger model using up to 100 qubits of IBM Quantum devices: https://arxiv.org/abs/2308.04481.\n", - "\n", - "In the following, we define the problem and implement the algorithm using Qiskit Patterns formalism in 4 steps:\n", - "1. Map classical inputs to a quantum problem\n", - "2. Optimize problem for quantum execution\n", - "3. Execute using Qiskit Primitives\n", - "4. Post-process and return result in classical format\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the molecule\n", - "We start by defining the molecule using ``pyscf``. As an example we select LiH and build it by providing its geometry.\n", - "Code to generate additional molecules can be found in ``Example_Molecules.ipynb`` at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyscf import ao2mo, gto, mcscf, scf\n", - "\n", - "# LiH\n", - "distance = 1.59\n", - "mol = gto.Mole()\n", - "mol.build(\n", - " verbose=0,\n", - " atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n", - " basis=\"sto-6g\",\n", - " spin=0,\n", - " charge=0,\n", - " symmetry=\"Coov\", \n", - " )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nuclear energy: 0.998447567773585\n", - "Electronic energy: -8.950577623117868\n", - "Total energy: -7.952130055344282\n", - "Total energy - nuclear energy: -8.950577623117868\n" - ] - } - ], - "source": [ - "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", - "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", - "print(f\"Total energy: {mol.energy_tot()}\")\n", - "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate the fermionic Hamiltonian\n", - "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "mf = scf.RHF(mol)\n", - "E1 = mf.kernel()\n", - "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", - "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n", - "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", - "E2 = mx.kernel(mo)[:2]\n", - "\n", - "h1e, ecore = mx.get_h1eff()\n", - "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit Patterns Step 1: Map classical inputs to a quantum problem\n", - "We will map the Hamiltonian operator, the initial state and the operator pool of the ansatz to a quantum problem using the Jordan-Wigner transform. We also define functions to compute gradients and the cost of these operators." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Map the fermionic Hamiltonian to a qubit operator\n", - "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", - "\n", - "import numpy as np\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "\n", - "\n", - "def cholesky(V, eps):\n", - " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", - " # see https://arxiv.org/abs/1808.02625\n", - " # see https://arxiv.org/abs/2104.08957\n", - " no = V.shape[0]\n", - " chmax, ng = 20 * no, 0\n", - " W = V.reshape(no**2, no**2)\n", - " L = np.zeros((no**2, chmax))\n", - " Dmax = np.diagonal(W).copy()\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " while vmax > eps:\n", - " L[:, ng] = W[:, nu_max]\n", - " if ng > 0:\n", - " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", - " L[:, ng] /= np.sqrt(vmax)\n", - " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", - " ng += 1\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " L = L[:, :ng].reshape((no, no, ng))\n", - " print(\n", - " \"accuracy of Cholesky decomposition \",\n", - " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", - " )\n", - " return L, ng\n", - "\n", - "\n", - "def identity(n):\n", - " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", - "\n", - "\n", - "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", - " c_list = []\n", - " if mapping == \"jordan_wigner\":\n", - " for p in range(n):\n", - " if p == 0:\n", - " l, r = \"I\" * (n - 1), \"\"\n", - " elif p == n - 1:\n", - " l, r = \"\", \"Z\" * (n - 1)\n", - " else:\n", - " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", - " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, -0.5j)])\n", - " c_list.append(cp)\n", - " else:\n", - " raise ValueError(\"Unsupported mapping.\")\n", - " d_list = [cp.adjoint() for cp in c_list]\n", - " return c_list, d_list\n", - "\n", - "\n", - "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", - " ncas, _ = h1e.shape\n", - "\n", - " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", - " Exc = []\n", - " for p in range(ncas):\n", - " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", - " for r in range(p + 1, ncas):\n", - " Excp.append(\n", - " C[p] @ D[r]\n", - " + C[ncas + p] @ D[ncas + r]\n", - " + C[r] @ D[p]\n", - " + C[ncas + r] @ D[ncas + p]\n", - " )\n", - " Exc.append(Excp)\n", - "\n", - " # low-rank decomposition of the Hamiltonian\n", - " Lop, ng = cholesky(h2e, 1e-6)\n", - " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", - "\n", - " H = ecore * identity(2 * ncas)\n", - " # one-body term\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " H += t1e[p, r] * Exc[p][r - p]\n", - " # two-body term\n", - " for g in range(ng):\n", - " Lg = 0 * identity(2 * ncas)\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " Lg += Lop[p, r, g] * Exc[p][r - p]\n", - " H += 0.5 * Lg @ Lg\n", - "\n", - " return H.chop().simplify()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "accuracy of Cholesky decomposition 1.1796119636642288e-16\n", - "The Hamiltonian consists of 276 10-qubit Pauli operators.\n" - ] - } - ], - "source": [ - "H = build_hamiltonian(ecore, h1e, h2e)\n", - "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initial state\n", - "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we implement using the functions below." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "\n", - "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", - " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", - " Raises:\n", - " ValueError: If the total number of particles is larger than the number of orbitals.\n", - " \"\"\"\n", - " # validate the input\n", - " assert num_spatial_orbitals >= 1\n", - " num_alpha, num_beta = num_particles\n", - "\n", - " if any(n > num_spatial_orbitals for n in num_particles):\n", - " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", - "\n", - " half_orbitals = num_spatial_orbitals\n", - " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", - " bitstr[:num_alpha] = True\n", - " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", - "\n", - " return bitstr.tolist()\n", - "\n", - "\n", - "def hartree_fock_circuit(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> QuantumCircuit:\n", - " \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing \n", - " the Hartree-Fock state for the specified system.\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " The quantum circuit preparing the Hartree-Fock state under the Jordan-Wigner transform.\n", - " \"\"\"\n", - " # Get the Hartree-Fock initial state in boolean bitstring representation\n", - " hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", - "\n", - " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an \n", - " # X-gate as indicated by the boolean list\n", - " hf_circuit = QuantumCircuit(len(hf_bitstring))\n", - " for i, hf_bit in enumerate(hf_bitstring):\n", - " if hf_bit:\n", - " hf_circuit.x(i)\n", - " \n", - " return hf_circuit\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAALAAAAKxCAYAAADzdCbSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqqUlEQVR4nO3df1Rc9Z3/8dflRxx+mgDpGZsZySAQA4GhAfkGtxtDllQpSZpqjKYkWr+0trsQaUsZ13q6vy1LmzZdDu5+UddGrbKzRs3GoN3asnUpahJKsUimwfIVyq/ZZQoJMCVfM8zn+0dP5+yUAcMAM74vr8c5/JH7uXd4g8/c3HsnEk0ppUAkVES4ByBaCgZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmESLCvcAFJhSCr/1zoZ7jKsWGxEJTdNC/nkZ8IfUb72zWNf6WrjHuGoTO3chLjL0OfESgkRjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJtFURsMvlgs1mQ3p6OgwGA8xmM6qrq+F2u1FRUQFN09DY2BjuMSkIug+4q6sLOTk5+Na3vgWn04msrCxcuXIFDQ0NuOuuu+BwOAAAeXl54R10hcw+eRxXPvFJeH/wwzlrSil4vvogrpTthXqvP/TDLQNdB+xyubBnzx44nU7U1NRgdHQUnZ2dcDqdqK+vR0tLC86dOwdN05CbmxvucVdExOFyYGMqZpsehxpz+a15XzwJ9YtuRBw+BM2yMTwDLpGuA37ggQcwNDSEqqoqHD16FAkJCb41m80Gq9UKj8eDjRs3IjExMYyTrhwtOhpRtTXA5cuY/c53fdvV4BC8x5+GduMmRNx5R/gGXCLdBuxwOGC325GSkoK6urqA++Tn5wMArFar3/b33nsPe/fuRUJCAtatW4d77rkHv/nNb1Z85pWiZaQj4u4DUD/rhLflVajZWcx+8yigFCJra6BFRoZ7xKDp9n8pam5uhtfrRXl5OeLj4wPuExMTA8A/4KmpKRQXFyMpKQnNzc2YmZmBzWbD7t270d7ejogImb/nI8oPwvvmGcw+/gQi+v4v1IVeRNz/OWhmU7hHWxLdBtza2goAKC4unnefoaEhAP4BP/bYYxgeHsZ//ud/4vrrrwcAmEwm3HzzzTh16hT27du3ckOvIC0qClG1X4HnyJfgPd0CbUs2Im7fF+6xlky3AQ8MDAAAUlNTA657PB60t7cD8A/49OnT+PjHP+6LFwCKioqQlpaGl19+OaiACwoK4HQ6F3WMWrMGaHp00Z9rQXFxQHQ04PFAu6kA2jL+aZKZkQnt/feDPt5oNKKjo2PRx+k2YLfbDQCYmZkJuG632+FyuZCQkACLxeLbfv78edx5551z9s/Ozsb58+eDmsXpdGJ4eHhxBxmuQXRQny0wpRRmv30M8FwBrjfD+9y/IOKW7dA+et2yvP7I6Ahw+f8ty2sthm4DNhqNmJiYQGdnJ4qKivzWRkdHUVtbCwDIzc31+3kGExMTWLt27ZzXS0pKwoULF4KeZbHUmjUYC+qzBeY9eQrq7V8g4r57EVG0DZ7KI5j99jFEHq1flp/n8NHrPrrkM3AwdBtwSUkJHA4H6uvrsWvXLmRmZgIAzp07h8OHD8Pl+t0z0VC8gRHMH43uWc+y/VwINTwM75PHoW3KRMSB/dAiIxFxqBze7z0F78lTiPz0p5b8OXrf7eXPhVhONpsNycnJGBwcRHZ2NnJycpCRkYHCwkKkpaVh586dAOY+Qlu3bh0uXrw45/XGx8eRlJQUitGXlfJ6Mfut7wBeLyJrv+J7ZBZxYD+0zAx4nzwONTIa5imDp9uATSYT2traUFZWBoPBgP7+fiQlJaGpqQktLS3o7e0FMDfgzZs3B7zWPX/+PDZv3hyS2ZeT98SLUOcdiLj3ELT/cWOqRUYi8qtfAbyzmP32MSilwjhl8HQbMPC7GE+fPo2pqSlMTU3hzJkzuP/+++F2u9Hf34+IiAhs2bLF75jdu3fjpz/9qe8RGwCcOXMGfX192LNnT6i/hCVRv/41vE89A23zjYi44/Y569rGVEQcKofqfgfek6fCMOHSaUrqb70lOHPmDLZt24ZNmzbhl7/8pd/a5OQkcnJykJKSgr/+67/G5cuXYbPZsH79erz55psheyNjOa+BQ4E/Gy2Euru7Acy9fACAxMREtLa24rrrrsPdd9+Nz33uc7j55ptx+vRpse/C6Zlun0IsZKGAAeCGG27A6dOnQzkSBWlVnlI+KGCSY1WegX//9yRIvlV5Bib9YMAkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0Vbl3weWgP/Y99VhwCQaLyFINAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJtioCdrlcsNlsSE9Ph8FggNlsRnV1NdxuNyoqKqBpGhobG8M9JgUhKtwDrLSuri6UlpbC6XQiLi4OWVlZGBkZQUNDA/r6+jA+Pg4AyMvLC++gFBylY2NjY8pkMikAqqamRk1OTvrW6uvrFQAVFRWlNE1Tly5dCuOkFCxdB3zw4EEFQFVVVQVct1qtCoCyWCwhnoyWi26vgR0OB+x2O1JSUlBXVxdwn/z8fACA1Wr1bRsaGkJVVRUKCwtxzTXXhOVf3qGrp9uAm5ub4fV6UV5ejvj4+ID7xMTEAPAP+Fe/+hVeeOEFGI1G3HTTTSGZlYKn24BbW1sBAMXFxfPuMzQ0BMA/4O3bt2N0dBSnTp1CSUnJyg5JS6bbpxADAwMAgNTU1IDrHo8H7e3tAPwDjohY/t/TBQUFcDqdy/66emI0GtHR0bHo43QbsNvtBgDMzMwEXLfb7XC5XEhISIDFYlnRWZxOJ4aHh1f0c6xWug3YaDRiYmICnZ2dKCoq8lsbHR1FbW0tACA3N3fFb9SMRuOKvr4eBPs90m3AJSUlcDgcqK+vx65du5CZmQkAOHfuHA4fPgyXywUgNG9gBPNHI10d3d7E2Ww2JCcnY3BwENnZ2cjJyUFGRgYKCwuRlpaGnTt3AvC//iV5dBuwyWRCW1sbysrKYDAY0N/fj6SkJDQ1NaGlpQW9vb0AGLB0ur2EAIDNmzfj9OnTc7ZPT0+jv78fERER2LJlSxgmo+Wi64Dn09PTA6UUMjMzERsbO2f9xIkTAIDz58/7/Xrjxo0oKCgI3aD0gVZlwN3d3QDmv3y48847A/763nvvxfHjx1d0NlocBhyAUiqU49AS6PYmbiEfFDDJoSmebkiwVXkGJv1gwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMoq2KgF0uF2w2G9LT02EwGGA2m1FdXQ23242KigpomobGxsZwj0lBiAr3ACutq6sLpaWlcDqdiIuLQ1ZWFkZGRtDQ0IC+vj6Mj48DAPLy8sI7KAVH6djY2JgymUwKgKqpqVGTk5O+tfr6egVARUVFKU3T1KVLl8I4KQVL1wEfPHhQAVBVVVUB161WqwKgLBZLiCej5aLba2CHwwG73Y6UlBTU1dUF3Cc/Px8AYLVafdtOnDiBO+64A6mpqYiNjcWNN96Ihx9+GNPT0yGZmxZHtwE3NzfD6/WivLwc8fHxAfeJiYkB4B/w0aNHERkZiW984xt49dVX8ad/+qf4p3/6J9x2223wer0hmZ2unm5v4lpbWwEAxcXF8+4zNDQEwD/gl19+GevXr/f9+pZbbsH69etRXl6On/70p9i+ffsKTUzB0G3AAwMDAIDU1NSA6x6PB+3t7QD8A/6f8f5eQUEBAGB4eDioWQoKCuB0OoM6drUwGo3o6OhY9HG6DdjtdgMAZmZmAq7b7Xa4XC4kJCTAYrEs+Fr/8R//AQDYvHlzULM4nc6g46eF6TZgo9GIiYkJdHZ2oqioyG9tdHQUtbW1AIDc3Fxomjbv6wwPD+PrX/86brvttqCfFRuNxqCOW02C/h6F+zHISjly5IgCoMxms7pw4YJv+9mzZ9WmTZtUdHS0AqAqKyvnfY2pqSmVn5+vNmzYoEZGRkIxNi2Sbp9C2Gw2JCcnY3BwENnZ2cjJyUFGRgYKCwuRlpaGnTt3AvC//v2fZmZmsGfPHrz33nv44Q9/iOuuuy6U49NV0m3AJpMJbW1tKCsrg8FgQH9/P5KSktDU1ISWlhb09vYCCBzwlStXsH//fnR0dODVV19FVlZWqMenq6QppVS4hwi16elpJCYmQtM0TE1NITY21rfm9Xpx991349SpU3jllVd8Z2r6cNLtTdxCenp6oJRCZmamX7wAUFlZieeffx5//ud/jtjYWLz11lu+tRtuuCHgYzYKozBfg4fF448/rgCoAwcOzFlLTU1VAAJ+fO973wv9sLSgVXkG7u7uBhD4+re/vz/E09BS6PYmbiELBUyyrMqbONKPVXkGJv1gwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJtFURsMvlgs1mQ3p6OgwGA8xmM6qrq+F2u1FRUQFN09DY2BjuMSkIUeEeYKV1dXWhtLQUTqcTcXFxyMrKwsjICBoaGtDX14fx8XEAQF5eXngHpeAoHRsbG1Mmk0kBUDU1NWpyctK3Vl9frwCoqKgopWmaunTpUhgnpWDpOuCDBw8qAKqqqirgutVqVQCUxWIJ8WS0XHR7DexwOGC325GSkoK6urqA++Tn5wMArFarb1tbWxtKSkpw3XXX4ZprroHJZMJdd90Fh8MRkrlpcXR7Ddzc3Ayv14vy8nLEx8cH3CcmJgaAf8ATExPIycnBF77wBXzkIx/B0NAQ6urqUFRUhHfeeQcmkykk89PV0W3Ara2tAIDi4uJ59xkaGgLgH/DevXuxd+9ev/1uuukmbNq0CS+88AKqq6tXYFoKlm4DHhgYAACkpqYGXPd4PGhvbwfgH3AgycnJAICoqOC+XQUFBXA6nUEdu1oYjUZ0dHQs+jjdBux2uwEAMzMzAdftdjtcLhcSEhJgsVjmrM/OzsLr9WJgYAAPPfQQjEYjDhw4ENQsTqcTw8PDQR1LC9NtwEajERMTE+js7ERRUZHf2ujoKGprawEAubm50DRtzvG33HKL7wydnp6O1tZWrF+/PuhZaGFBf4/C/RhkpRw5ckQBUGazWV24cMG3/ezZs2rTpk0qOjpaAVCVlZUBj//lL3+p3nrrLdXc3Ky2bt2qTCaTGhgYCNX4dJV0G/Dg4KBKTk72vVmxZcsWlZ6ergCo0tJSdeuttyoA6rHHHvvA15qYmFDXXnvtvLFT+Oj2ObDJZEJbWxvKyspgMBjQ39+PpKQkNDU1oaWlBb29vQA++AYOANauXYv09HT86le/WumxaZE0pZQK9xChNj09jcTERGiahqmpKcTGxi64/3//93/jhhtuwD333INHH300RFPS1dDtTdxCenp6oJRCZmbmnHgPHTqE9PR05OXlYe3atXj33Xdx7NgxREVF4ctf/nKYJqb5rMqAu7u7AQS+fNi2bRuefvpp/MM//AMuX74Ms9mM4uJifO1rX5v3mTKFDwP+A1VVVaiqqgr1SBQk3d7ELWShgEmWVXkTR/qxKs/ApB8MmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNN0H7HK5YLPZkJ6eDoPBALPZjOrqarjdblRUVEDTNDQ2NoZ7TApSVLgHWEldXV0oLS2F0+lEXFwcsrKyMDIygoaGBvT19WF8fBwAkJeXF95BKXhKp8bGxpTJZFIAVE1NjZqcnPSt1dfXKwAqKipKaZqmLl26FMZJaSl0G/DBgwcVAFVVVRVw3Wq1KgDKYrGEeDJaTrq8BnY4HLDb7UhJSUFdXV3AffLz8wEAVqt13tcpLS2Fpmn4q7/6q5UYk5aBLgNubm6G1+tFeXk54uPjA+4TExMDYP6A//Vf/xVdXV0rNSItE13exLW2tgIAiouL591naGgIQOCAJycn8aUvfQlHjx7FoUOHljxPQUEBnE7nkl9Hz4xGIzo6OhZ9nC4DHhgYAACkpqYGXPd4PGhvbwcQOOCHH34YmZmZKC8vX5aAnU4nhoeHl/w6NJcuA3a73QCAmZmZgOt2ux0ulwsJCQmwWCx+ax0dHXj88cfxs5/9bNnmMRqNy/ZaehXs90iXARuNRkxMTKCzsxNFRUV+a6Ojo6itrQUA5ObmQtM039rs7Cy+8IUvoKqqCtnZ2cs2TzB/NNLV0eVNXElJCQCgvr4evb29vu3nzp1DcXExXC4XgLlvYDQ2NuK//uu/+NRBEF0GbLPZkJycjMHBQWRnZyMnJwcZGRkoLCxEWloadu7cCcD/+tflcuHrX/86/uIv/gIejwcXL17ExYsXAQCXL1/GxYsX4fV6w/Hl0ELC/SB6pZw/f16VlZWp+Ph4FR8frwoLC1VTU5Pyer3KYrEoAOrMmTO+/X/+858rAAt+vPfee+H7giggTSmlwva7Jwymp6eRmJgITdMwNTWF2NhY3/ZA16rFxcW499578dnPfhbbtm2DwWAI9ci0AF3exC2kp6cHSilkZmb64gWA+Ph47NixI+AxGzdunHeNwkuX18AL6e7uBrDwW8gkx6o7Ay824FV2hSUOz8Ak2qq7iSN9WXVnYNIXBkyiMWASjQGTaAyYRGPAJBoDJtEYMInGgEk0BkyiMWASjQGTaAyYRGPAJBoDJtEYMInGgEk0BkyiMWASjQGTaAyYRGPAJBoDJtEYMInGgEk0BkyiMWASjQGTaAyYRGPAJNqq+wHXUiil8FvvbLjHuGqxEZF+/+ZeqDDgD6nfemexrvW1cI9x1SZ27kJcZOhz4iUEicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoqyJgl8sFm82G9PR0GAwGmM1mVFdXw+12o6KiApqmobGxMdxjrojZJ4/jyic+Ce8PfjhnTSkFz1cfxJWyvVDv9Yd+uGWg+79O2dXVhdLSUjidTsTFxSErKwsjIyNoaGhAX18fxsfHAQB5eXnhHXSFRBwuh/etM5htehxa/lZo61N8a94XT0L9ohsR//uz0CwbwzfkEuj6DOxyubBnzx44nU7U1NRgdHQUnZ2dcDqdqK+vR0tLC86dOwdN05CbmxvucVeEFh2NqNoa4PJlzH7nu77tanAI3uNPQ7txEyLuvCN8Ay6RrgN+4IEHMDQ0hKqqKhw9ehQJCQm+NZvNBqvVCo/Hg40bNyIxMTGMk64sLSMdEXcfgPpZJ7wtr0LNzmL2m0cBpRBZWwMtMjLcIwZNtwE7HA7Y7XakpKSgrq4u4D75+fkAAKvV6tv2k5/8BJqmzfmQfokRUX4QSEvD7ONPwPvo/4G60IuIz94DzWwK92hLottr4ObmZni9XpSXlyM+Pj7gPjExMQD8A/69Rx99FFu3bvX9Oi4ubmUGDREtKgpRtV+B58iX4D3dAm1LNiJu3xfusZZMtwG3trYCAIqLi+fdZ2hoCEDggLOysrBt27aVGS5c4uKA6GjA44F2UwG0CPl/AOs24IGBAQBAampqwHWPx4P29nYAgQNeTgUFBXA6nYs6Rq1ZAzQ9umwzKKUw++1jgOcKcL0Z3uf+BRG3bIf20euW5fUzMzKhvf9+0McbjUZ0dHQs+jjdBux2uwEAMzMzAdftdjtcLhcSEhJgsVjmrN91111wuVxITk7G3r178fd///dISUkJ8EofzOl0Ynh4eHEHGa5BdFCfLTDvyVNQb/8CEffdi4iibfBUHsHst48h8mj9svzv8COjI8Dl/7cMky6ObgM2Go2YmJhAZ2cnioqK/NZGR0dRW1sLAMjNzfX7D3jttdeitrYW27dvR3x8PN58803U1dXhrbfeQkdHBwwGQ1CzLJZaswZjiz5qntcaHob3yePQNmUi4sB+aJGRiDhUDu/3noL35ClEfvpTS/4cH73uo0s+AwdDtwGXlJTA4XCgvr4eu3btQmZmJgDg3LlzOHz4MFwuF4C5b2B87GMfw8c+9jHfr3fs2IEtW7Zg7969aG5uxn333bfoWYL5o9E961mWnwuhvF7Mfus7gNeLyNqv+B6ZRRzYD9X+BrxPHkfE/ypc8qVE77u9/LkQy8lmsyE5ORmDg4PIzs5GTk4OMjIyUFhYiLS0NOzcuRPA1V3/7t69G3FxcUGFGG7eEy9CnXcg4t5D0K6/3rddi4xE5Fe/AnhnMfvtY1BKhXHK4Ok2YJPJhLa2NpSVlcFgMKC/vx9JSUloampCS0sLent7ASzuBi4cPzppKdSvfw3vU89A23wjIu64fc66tjEVEYfKobrfgffkqTBMuHSakvpbbwmmp6eRmJgITdMwNTWF2NjYBff/t3/7N+zbtw9PPfUU7rnnnpDMuFyXEKESrh8tpdtr4IX09PRAKYXMzMw58R46dAhpaWnYunWr7ybum9/8JvLy8nD33XeHaWKaz6oMuLu7G0Dgy4fs7Gw899xz+O53v4uZmRmYTCZ8/vOfx1/+5V9izZo1oR6VPgAD/gMPPfQQHnrooVCPREHS7U3cQhYKmGRZlWfg3/89CZJvVZ6BST8YMInGgEk0BkyiMWASjQGTaAyYRGPAJBoDJtEYMInGgEm0VfkX2iXgP/Z9dRgwicZLCBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKLpPmCXywWbzYb09HQYDAaYzWZUV1fD7XajoqICmqahsbEx3GNSkKLCPcBK6urqQmlpKZxOJ+Li4pCVlYWRkRE0NDSgr68P4+PjAIC8vLzwDkrBUzo1NjamTCaTAqBqamrU5OSkb62+vl4BUFFRUUrTNHXp0qUwTkpLoduADx48qACoqqqqgOtWq1UBUBaLJcST0XLS5TWww+GA3W5HSkoK6urqAu6Tn58PALBarXPWXnrpJdx8882Ii4vDtddeiz/6oz9CT0/Pis5MwdFlwM3NzfB6vSgvL0d8fHzAfWJiYgDMDbihoQEHDhzAxz/+cZw6dQrNzc0oKSnBzMzMis9Ni6fLm7jW1lYAQHFx8bz7DA0NAfAPuK+vD7W1tTh27Biqqqp82z/5yU+u0KS0VLoMeGBgAACQmpoacN3j8aC9vR2Af8BPPvkkoqOj8fnPf35Z5ykoKIDT6VzW19Qbo9GIjo6OxR8Y7ovwlbBu3ToFQL3xxhsB17///e8rACohIUF5vV7f9h07dqitW7eqJ554Qm3cuFFFRkaqG2+8UT333HNLmmfDhg0KAD8W+NiwYUNQ31tdnoGNRiMmJibQ2dmJoqIiv7XR0VHU1tYCAHJzc/3+edTR0VEMDw/joYceQn19PcxmM/75n/8Zn/nMZ7B+/XqUlJQEPQ8tLOjv0ZJOLR9SR44cUQCU2WxWFy5c8G0/e/as2rRpk4qOjlYAVGVlpd9xGRkZCoB66aWXfNu8Xq/Kzc1V27dvD9X4tAi6fAphs9mQnJyMwcFBZGdnIycnBxkZGSgsLERaWhp27twJYO4TiKSkJADwO9NqmoaSkhK88847ofsC6KrpMmCTyYS2tjaUlZXBYDCgv78fSUlJaGpqQktLC3p7ewHMDTg7O3ve17x8+fKKzkzBWXX/Wv309DQSExOhaRqmpqYQGxvrWzt16hQ+9alP4YUXXsDtt98OAPB6vcjLy0NSUhJ+8pOfhGlqmo8ub+IW0tPTA6UUMjMz/eIFgD179uCP//iPcf/99+M3v/kNrr/+ejzxxBPo6enBa6+9FqaJaSGrLuDu7m4Agd9C1jQNp06dwoMPPoivfe1rmJychNVqxSuvvOK7bqYPFwb8B9auXYumpiY0NTWFciwKki5v4hbyQQGTLKvuJo70ZdWdgUlfGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2irImCXywWbzYb09HQYDAaYzWZUV1fD7XajoqICmqahsbEx3GNSEKLCPcBK6+rqQmlpKZxOJ+Li4pCVlYWRkRE0NDSgr68P4+PjAIC8vLzwDkrBUTo2NjamTCaTAqBqamrU5OSkb62+vl4BUFFRUUrTNHXp0qUwTkrB0nXABw8eVABUVVVVwHWr1aoAKIvFEuLJaLno9hrY4XDAbrcjJSUFdXV1AffJz88HAFitVt+2HTt2QNO0gB9f/OIXQzI7XT3dXgM3NzfD6/WivLwc8fHxAfeJiYkB4B/wP/7jP2JyctJvv5aWFvzd3/0ddu/evXIDU1B0G3BraysAoLi4eN59hoaGAPgHnJWVNWe/Rx55BOvXr8dtt922zFPSUuk24IGBAQBAampqwHWPx4P29nYA/gH/obGxMfzgBz/An/3ZnyEqKrhvV0FBAZxOZ1DHrhZGoxEdHR2LPk63AbvdbgDAzMxMwHW73Q6Xy4WEhARYLJZ5X6e5uRkejweHDx8Oehan04nh4eGgj6f56TZgo9GIiYkJdHZ2oqioyG9tdHQUtbW1AIDc3Fxomjbv6zzzzDPYvHkzCgoKljQLLSzo71G4H4OslCNHjigAymw2qwsXLvi2nz17Vm3atElFR0crAKqysnLe13A4HAqA+sY3vhGKkSkIun2MZrPZkJycjMHBQWRnZyMnJwcZGRkoLCxEWloadu7cCWDh699nnnkGmqahvLw8VGPTIuk2YJPJhLa2NpSVlcFgMKC/vx9JSUloampCS0sLent7AcwfsFIKzz77LHbs2IHrr78+lKPTImhKKRXuIUJtenoaiYmJ0DQNU1NTiI2NnbPP66+/jh07duDJJ5/EfffdF4Yp6Wro9gy8kJ6eHiilkJGRETBe4HeXDzExMdi/f3+Ip6PFWJUBd3d3A5j/8uHy5cs4ceIE9u3bh4SEhFCORouk28doC/mggA0GAy5evBjCiShYPAOTaKvyJo70Y1WegUk/GDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEo0Bk2gMmERjwCQaAybRGDCJxoBJNAZMojFgEk33AbtcLthsNqSnp8NgMMBsNqO6uhputxsVFRXQNA2NjY3hHpOCFBXuAVZSV1cXSktL4XQ6ERcXh6ysLIyMjKChoQF9fX0YHx8HAOTl5YV3UAqe0qmxsTFlMpkUAFVTU6MmJyd9a/X19QqAioqKUpqmqUuXLoVxUloK3QZ88OBBBUBVVVUFXLdarQqAslgsIZ6MlpMur4EdDgfsdjtSUlJQV1cXcJ/8/HwAgNVq9dve1taGP/mTP0FKSgrWrl2Lbdu24cUXX1zxmSk4ugy4ubkZXq8X5eXliI+PD7hPTEwMAP+A3377bezatQuRkZE4fvw47HY7zGYz9u/fj9OnT4dkdlocXd7Etba2AgCKi4vn3WdoaAiAf8B2ux2apuHkyZOIjY0FAJSUlCAtLQ3PPvssdu/evYJTUzB0GfDAwAAAIDU1NeC6x+NBe3s7AP+A33//faxZs8Z3dgaAyMhIJCQkwOv1Bj1PQUEBnE5n0MevBkajER0dHYs/MNwX4Sth3bp1CoB64403Aq5///vfVwBUQkKC8nq9vu1dXV3KYDCoL3/5y8rpdCqXy6UeeeQRtWbNGvX6668HPc+GDRsUAH4s8LFhw4agvre6PAMbjUZMTEygs7MTRUVFfmujo6Oora0FAOTm5kLTNN+a1WrFj3/8Y9x+++04duwYACAuLg7PP/88tm/fvqR5aGFBf4+CPq18iB05ckQBUGazWV24cMG3/ezZs2rTpk0qOjpaAVCVlZV+x/X29iqTyaR2796tXnnlFfXv//7v6p577lExMTHqxz/+cai/DLoKugx4cHBQJScn+96s2LJli0pPT1cAVGlpqbr11lsVAPXYY4/5Hbd//36VmZmprly54rd9x44dKi8vL5RfAl0lXT5GM5lMaGtrQ1lZGQwGA/r7+5GUlISmpia0tLSgt7cXwNxnwN3d3bBarYiK8r+yKigogMPhCNn8dPU0pZQK9xChND09jcTERGiahqmpKd/jMgDYsWMHRkZGcP78eb+Id+zYgcHBQfT19YVjZFqALs/AC+np6YFSChkZGX7xAkBlZSXeffddfPrTn8bp06fx6quv4vDhw3j99ddRXV0dpolpIbp8CrGQ7u5uAHMvHwDgzjvvxMsvv4z6+nrce++9mJ2dRWZmJp599ll85jOfCfWodBUY8B/YvXs333ETZNVdQnxQwCTLqruJI31ZdWdg0hcGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEWxUBu1wu2Gw2pKenw2AwwGw2o7q6Gm63GxUVFdA0DY2NjeEek4IQFe4BVlpXVxdKS0vhdDoRFxeHrKwsjIyMoKGhAX19fRgfHwcA5OXlhXdQCo7SsbGxMWUymRQAVVNToyYnJ31r9fX1CoCKiopSmqapS5cuhXFSCpauAz548KACoKqqqgKuW61WBUBZLJYQT0bLRbfXwA6HA3a7HSkpKairqwu4T35+PgDAarX6bf/Rj36Ebdu2wWAw4CMf+Qi++MUv4tKlSys+My2ebgNubm6G1+tFeXk54uPjA+4TExMDwD/g119/Hbfddhs2bNiAl156CY888ghOnDiBffv2QSkVktnp6un2Jq61tRUAUFxcPO8+Q0NDAPwD/pu/+RtkZGTg+eefR0TE735/Jycn44477kBLSwt27969glPTYuk24IGBAQBAampqwHWPx4P29nYA/gGfOXMG9913ny9eAPjEJz4BADh58mRQARcUFMDpdC76uNXEaDSio6Nj0cfpNmC32w0AmJmZCbhut9vhcrmQkJAAi8Xi2x4ZGYk1a9b47RsdHQ1N09DT0xPULE6nE8PDw0EdSwvTbcBGoxETExPo7OxEUVGR39ro6Chqa2sBALm5udA0zbeWmZmJM2fO+O1/7tw5KKV8z4yDmYUWFvT3KNyPQVbKkSNHFABlNpvVhQsXfNvPnj2rNm3apKKjoxUAVVlZ6Xfc008/rQCov/3bv1VjY2Pq5z//ucrJyVGRkZHqxhtvDPWXQR9AtwEPDg6q5ORk35sVW7ZsUenp6QqAKi0tVbfeeqsCoB577DG/47xer3rwwQfVmjVrFAAVGRmpHnjgAZWfn6+Ki4vD9NXQfHQbsFJKnT9/XpWVlan4+HgVHx+vCgsLVVNTk/J6vcpisSgA6syZMwGPnZycVG+//bZyuVzqypUrKjExUT388MMh/grog2hKrb6Hm9PT00hMTISmaZiamkJsbOyC+z/++OOorKyEw+HADTfcEKIp6Wro9iZuIT09PVBKITMzc068HR0deO2117B161Z4PB786Ec/QkNDA44ePcp4P4RWZcDd3d0A5r6FDADXXHMNXn75ZdTV1cHj8SAnJwd2ux379+8P9Zh0FRjwH8jJycEbb7wR6pEoSLr9uxALWShgkmVV3sSRfqzKMzDpBwMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBKNAZNoDJhEY8AkGgMm0RgwicaASTQGTKIxYBLt/wPyw/zmPTS4ogAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "num_spatial_orbitals = mx.ncas\n", - "num_particles = mx.nelecas\n", - "\n", - "hf_circuit = hartree_fock_circuit(num_spatial_orbitals, num_particles)\n", - "hf_circuit.draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operator pool\n", - "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we multiply them with the complex phase 1j so that they appear Hermitian." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def single_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", - " \"\"\"Compute single excitation operators under the Jordan-Wigner transform \n", - " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " A list of single excitation operators under the Jordan-Wigner transform.\n", - " \"\"\"\n", - " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", - "\n", - " num_alpha, num_beta = num_particles\n", - " half_orbitals = num_spatial_orbitals\n", - " indices_alpha = list(range(num_alpha))\n", - " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", - "\n", - " single_excitation_operators = []\n", - "\n", - " for p in indices_alpha:\n", - " for r in range(p + 1, half_orbitals):\n", - " if r not in indices_alpha:\n", - " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", - " single_excitation_operators.append(exc)\n", - "\n", - " for p in indices_beta:\n", - " for r in range(p + 1, 2 * half_orbitals):\n", - " if r not in indices_beta:\n", - " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", - " single_excitation_operators.append(exc)\n", - " \n", - " return single_excitation_operators" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def double_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", - " \"\"\"Compute double excitation operators under the Jordan-Wigner transform \n", - " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " A list of single excitation operators under the Jordan-Wigner transform.\n", - " \"\"\"\n", - " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", - "\n", - " num_alpha, num_beta = num_particles\n", - " half_orbitals = num_spatial_orbitals\n", - " indices_alpha = list(range(num_alpha))\n", - " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", - "\n", - " double_excitation_operators = []\n", - "\n", - " # Both excitations from alpha\n", - " if len(indices_alpha) > 1:\n", - " # from these indices\n", - " for p in indices_alpha:\n", - " for r in range(p + 1, num_alpha):\n", - " # to these indices\n", - " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", - " for b in range(a + 1, half_orbitals):\n", - " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", - " double_excitation_operators.append(exc)\n", - "\n", - " # Both excitations from beta\n", - " if len(indices_beta) > 1:\n", - " # from these indices\n", - " for p in indices_beta:\n", - " for r in range(p + 1, half_orbitals + num_beta):\n", - " # to these indices\n", - " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", - " for b in range(a + 1, 2 * half_orbitals):\n", - " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", - " double_excitation_operators.append(exc)\n", - "\n", - " # One excitation from alpha, one from beta\n", - " # from these indices\n", - " for p in indices_alpha:\n", - " for r in indices_beta:\n", - " # to these indices\n", - " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", - " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", - " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", - " double_excitation_operators.append(exc)\n", - " \n", - " return double_excitation_operators\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The excitation pool consists of 24 operators.\n" - ] - } - ], - "source": [ - "num_spatial_orbitals = mx.ncas\n", - "num_particles = mx.nelecas\n", - "\n", - "single_excitation_operators = single_excitation(num_spatial_orbitals, num_particles)\n", - "double_excitation_operators = double_excitation(num_spatial_orbitals, num_particles)\n", - "\n", - "excitation_pool = single_excitation_operators + double_excitation_operators\n", - "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Gradient of the excitation operators\n", - "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", - " \"\"\"\n", - " Computes the gradients for all available excitation operators.\n", - " Args:\n", - " ansatz: ansatz built so far.\n", - " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", - " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", - " estimator: an instance of the Qiskit Estimator primitive.\n", - " params: parameters to be assigned to the ansatz, if any.\n", - " Returns:\n", - " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", - " \"\"\"\n", - " # The excitations operators are applied later as exp(i*theta*excitation).\n", - " # For this commutator, we need to explicitly pull in the imaginary phase.\n", - " if params is not None:\n", - " ansatz_opt = ansatz.assign_parameters(params)\n", - " else:\n", - " ansatz_opt = ansatz\n", - " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", - " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", - " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", - " gradients = estimator.run(ansatz_list, commutators).result().values\n", - "\n", - " return gradients" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Cost function\n", - "We define the cost function as the expectation value of the Hamiltonian operator given an ansatz with its parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", - " return energy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit Patterns Step 2: Optimize problem for quantum execution" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by selecting a backend for execution." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ibm_cleveland\n" - ] - } - ], - "source": [ - "# To run on hardware:\n", - "from qiskit_ibm_runtime import QiskitRuntimeService\n", - "\n", - "#service = QiskitRuntimeService(channel=\"ibm_quantum\", instance=\"ibm-q/open/main\")\n", - "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", - "backend = service.least_busy(operational=True, simulator=False)\n", - "print(backend.name)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we optimize the circuit for running on a real backend by specifying the optimization_level and adding dynamical decoupling. The code below generates a mass manager using preset pass managers from qiskit.transpiler." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.transpiler import PassManager\n", - "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", - "from qiskit.transpiler.passes import ALAPScheduleAnalysis, PadDynamicalDecoupling, ConstrainedReschedule\n", - "from qiskit.circuit.library import XGate\n", - "\n", - "target = backend.target\n", - "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", - "pm.scheduling = PassManager(\n", - " [\n", - " ALAPScheduleAnalysis(target=target), \n", - " ConstrainedReschedule(target.acquire_alignment, target.pulse_alignment),\n", - " PadDynamicalDecoupling(target=target, dd_sequence=[XGate(), XGate()], pulse_alignment=target.pulse_alignment)\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we use the pass manager on the initial state. We can similarly apply device layout characteristics to the Hamiltonian to get a more physical representation." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "hf_circuit_ibm = pm.run(hf_circuit)\n", - "H_ibm = H.apply_layout(hf_circuit_ibm.layout) \n", - "excitation_pool_ibm = [exc.apply_layout(hf_circuit_ibm.layout) for exc in excitation_pool]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit Patterns Step 3: Execute using Qiskit Primitives\n", - "Before we execute on the selected hardware, it is a good idea to use a simulator for cursory debugging, and sometimes for estimates of error. For those reasons, we briefly show how to run ADAPT-VQE on a simulator. But it is critical to note that no classical computer, simulator or GPU can accurately simulate the full functionality of a highly-entangled 127-qubit quantum computer. In the present era of quantum utility, simulators will have limited use." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Recall that for each choice of parameters in the variational circuit, an expectation value must be calculated (since that is the value to be minimized). We do this with the Qiskit Primitive, Estimator." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hartree-Fock energy: -7.95213012467435\n" - ] - } - ], - "source": [ - "# To run on simulator\n", - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator()\n", - "\n", - "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", - "print(f\"Hartree-Fock energy: {hf_energy}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", - " 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", - " -2.42633656e-02 0.00000000e+00 0.00000000e+00 6.68086680e-02\n", - " 0.00000000e+00 -4.61492937e-02 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 -4.61492937e-02 0.00000000e+00\n", - " 6.68086680e-02 0.00000000e+00 0.00000000e+00 -2.50251594e-01]\n", - "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.2502515943160275 at index 23.\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "max_operator = excitation_pool[max_index]\n", - "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Expand the Ansatz\n", - "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABfgAAAKxCAYAAAAPTs3EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8XElEQVR4nOzdd5gV5f034M/SpCuIigYEFFABAcWGxoKBRFTU2CNiiTFqgpqIYDRvoqlGxRI0scVuROxRMZaILUQNSrASCxEUYdUVLCAIy+77h5FfVhbYRXbXs9z3dXFdMPPMzPfMmTlz+JxnnikqLy8vDwAAAAAAUFAa1HUBAAAAAABA9Qn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgAAn4AQAAAACgADWq6wKoXHl5eT4pW1LXZVRZ8wYNU1RUtMrLl5cnZYtXY0EAAAAAAHWkQePkS8SlVSbg/4r6pGxJ2kx4qK7LqLK5uw9Ki4arfjiVLU4eGbMaCwIAAAAAqCMDTkoaNqn57RiiBwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACpCAHwAAAAAACtAaEfCXlJRk1KhR6dq1a5o2bZqOHTvm5JNPzvz583PMMcekqKgol1xySV2XCQAAAAAAVdaorguoaVOmTMngwYNTXFycFi1apEePHpk1a1bGjBmTadOmZc6cOUmSvn371m2hNWTJ1dem7OZb0vCUH6XBHt+sMK+8vDxLRv4k5VOnptElY1LUpXPdFFlFZWVlufPvv8/4py5P8dzpWafFetmlz8E58lu/TLMmLeq6PAAAAACAWlWve/CXlJRkyJAhKS4uzogRIzJ79uxMnjw5xcXFOeecczJ+/PhMmjQpRUVF6d27d12XWyMaDBuadO6UJZdfmfL3SirMK7vjrpQ//0IaDDv8Kx/uJ8ml9/w4l91zSjbeoEeG73dxdul9UO76+5j8/OohKSsrq+vyAAAAAABqVb0O+E866aTMnDkzw4cPz+jRo9OqVaul80aNGpU+ffqktLQ0nTt3TuvWreuw0ppT1LhxGo0ckSxcmCUXXLR0evlbM1N27fUp2nyzNDjogLorsIqmF7+Uv0y8OF/vtX/OOvKO7Ln9sTl+nwty/JALMmXaI3n0uZvrukQAAAAAgFpVbwP+qVOnZty4cWnXrl3OPvvsStv069cvSdKnT58K0994443ss88+adWqVdq0aZMjjjgi77//fo3XXFOKunVNg0MPTvmzk1M2/q8pX7IkS84dnZSXp+HIESlq2LCuS1ypR6aMTXl5efbf+UcVpu+5/bFp2rh5/jb5xropDAAAAACgjtTbMfjHjh2bsrKyDB06NC1btqy0TbNmzZJUDPg//vjjDBgwIG3bts3YsWOzYMGCjBo1KnvvvXcmTpyYBg0K8zeRBkO/k7Inn86SK/+UBtP+k/JXXk2D738vRR071HVpVfLKW5PSoKhBNtt4uwrTmzRumk026ptX35pUR5UBAAAAANSNehvwT5gwIUkyYMCA5baZOXNmkooB/xVXXJG33347jz/+eDbeeOMkSYcOHbLjjjvm7rvvzn777VdzRdegokaN0mjkKSk98Ucpu3d8inr1TIP996vrsqrs/Y9mpXWLdmnSaK1l5rVb+2t5ecY/srh0URo3alIH1QEAAAAA1L56G/DPmDEjSdKpU6dK55eWlmbixIlJKgb89957b77+9a8vDfeTpH///tlkk01yzz33rFLAv80226S4uLhay5Q3aZJc/odqb2uFWrRIGjdOSktTtO02KVqNdyN079Y9RYsWrfLyTRo1yxXDX1vu/E8XfZLGlYT7ny3b9LM2iz8R8AMAAAAAda5b925ZVLqgyu3bt2+fZ555ptrbqbcB//z585MkCxZUvhPHjRuXkpKStGrVKl26dFk6/eWXX85BBx20TPuePXvm5ZdfXqVaiouL8/bbb1dvoaZrpfEqba1y5eXlWXL+hUnp4mTjjim76eY02HWXFG204WpZ/6zZs5KFn67y8k0bN1/h/LWaNM+Cee9WOm9R6cLP2qxkHQAAAAAAtWH2rFlZuPiTGt9OvQ3427dvn7lz52by5Mnp379/hXmzZ8/OyJEjkyS9e/dOUVHR0nlz587NOuuss8z62rZtm1deeWWVa6mu8iZN8t4qba1yZXfdnfLnnk+Do49Mg/47pPSHJ2bJ+Rem4ehzKrz+VbXRhht96R78K7Ju643y5jsvZ1Hpp8sM01Py4dtZu0U7vfcBAAAAgK+EDTfaqNo9+FdFvQ34Bw4cmKlTp+acc87JoEGD0r179yTJpEmTMmzYsJSUlCRJ+vbtW+O1rMqtFfOXlKbNhIdWy/bL3347ZVdfm6LNuqfBwQemqGHDNDh8aMquuS5ld92dht/e90tv49XXXk2Lhqt+OC1ZlDwyZvnzN+u4bZ599cG88uY/s+UmOy+dvmjxwvxn1pRsuckuq7xtAAAAAIDV6bVXX0vDWuiPvPoGYf+KGTVqVNZdd9289dZb6dmzZ7bccst069Yt2223XTbZZJPsvvvuSSqOv58kbdq0yQcffLDM+ubMmZO2bdvWRumrVXlZWZacd0FSVpaGI09JUcOGSfJZ0N+9W8quvjbls2bXcZUrt1ufQ1JUVJQ7nriowvT7nr4yCxd/kt23Glo3hQEAAAAA1JF6G/B36NAhTzzxRPbaa680bdo006dPT9u2bXP55Zdn/PjxefXVV5MsG/BvscUWlY61//LLL2eLLbaoldpXp7Lb7kj5y1PT4MjDU/Q/Dw4uatgwDU89JSlbkiXnX5jy8vI6rHLlumy4ZfbZ8Yf5+4t35Kzr9s99T/8pl90zIpfdc0p6b7Jrdt/qsLouEQAAAACgVtXbIXqSz8L6e++9d5np8+bNy/Tp09OgQYP06tWrwry99947Z5xxRmbOnJkOHTokSZ5++ulMmzYt5513Xq3UvbqUv/lmyq67IUVbbJ4GB+y/zPyizp1W+1A9NemEfS7KBm06576nr8g/p45P6xbtst9OJ+bIb/0yDRrU29+qAAAAAAAqVVT+Ve+6XQOefvrp7LDDDtlss83y73//u8K8jz76KFtuuWXatWuXX/ziF1m4cGFGjRqV9dZbL08++WStBcmrcwz+2jB390E1OgY/AAAAAEChGHBSjMFfU1544YUkyw7PkyStW7fOhAkTsuGGG+bQQw/N9773vey4446599579RIHAAAAAOAro14P0bM8Kwr4k2TTTTetdGgfAAAAAAD4qlgju6SvLOAHAAAAAICvujWyB/+ECRPqugQAAAAAAPhS1sge/AAAAAAAUOgE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAa1XUBVK55g4aZu/ugui6jypo3aFjXJQAAAAAArFEE/F9RRUVFadHQ2wMAAAAAQOUM0QMAAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVIwA8AAAAAAAVojQj4S0pKMmrUqHTt2jVNmzZNx44dc/LJJ2f+/Pk55phjUlRUlEsuuaSuywQAAAAAgCprVNcF1LQpU6Zk8ODBKS4uTosWLdKjR4/MmjUrY8aMybRp0zJnzpwkSd++feu2UFZq7ISz89rbk/PazGdTPOeNbNCmU248Y3pdlwUAAAAAUCfqdQ/+kpKSDBkyJMXFxRkxYkRmz56dyZMnp7i4OOecc07Gjx+fSZMmpaioKL17967rclmJq/96Rqa8PiEbrbtpWjVrU9flAAAAAADUqXod8J900kmZOXNmhg8fntGjR6dVq1ZL540aNSp9+vRJaWlpOnfunNatW9dhpVTF9T+Zljt+8X7O+f5DWbf1RnVdDgAAAABAnaq3Af/UqVMzbty4tGvXLmeffXalbfr165ck6dOnz9Jpn/8gsN1222WttdZKUVFRrdTLym247iZ1XQIAAAAAwFdGvQ34x44dm7KysgwdOjQtW7astE2zZs2SVAz4X3/99dx+++1p3759tt1221qpFQAAAAAAqqveBvwTJkxIkgwYMGC5bWbOnJmkYsC/yy67ZPbs2bn77rszcODAmi0SAAAAAABWUaO6LqCmzJgxI0nSqVOnSueXlpZm4sSJSSoG/A0arP7fPLbZZpsUFxev9vXWJ00aNcsVw1+r6zIAAAAAAL60bt27ZVHpgiq3b9++fZ555plqb6feBvzz589PkixYUPlOHDduXEpKStKqVat06dKlRmspLi7O22+/XaPbKHRNGzev6xIAAAAAAFaL2bNmZeHiT2p8O/U24G/fvn3mzp2byZMnp3///hXmzZ49OyNHjkyS9O7du8YfpNu+ffsaXX990KRRs7ouAQAAAABgtdhwo42q3YN/VdTbgH/gwIGZOnVqzjnnnAwaNCjdu3dPkkyaNCnDhg1LSUlJkqRv3741Xsuq3FqxplmyKHlkTF1XAQAAAADw5b326mtp2KTmt1NvH7I7atSorLvuunnrrbfSs2fPbLnllunWrVu22267bLLJJtl9992TVBx/HwAAAAAACkW97cHfoUOHPPHEExk5cmQee+yxTJ8+PT169Mjll1+eY489NptuumkSAX8heejZG/Lu3M8envzB/PdSumRR/vy3XydJ1m/TKYP6DavL8gAAAAAAalW9DfiTZIsttsi99967zPR58+Zl+vTpadCgQXr16lUHlbEq7v/nVXn+P49VmHbtAz9LkvTeZFcBPwAAAACwRqnXAf/yvPTSSykvL0/37t3TvHnzZebfdtttSZKXX365wr87d+6cbbbZpvYKpYLzT3i0rksAAAAAAPjKWCMD/hdeeCHJ8ofnOeiggyr995FHHplrr722RmsDAAAAAICqEPBXory8vDbLAQAAAACAamtQ1wXUhZUF/AAAAAAA8FW3RvbgnzBhQl2XAAAAAAAAX8oa2YMfAAAAAAAKnYAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAK0BoR8JeUlGTUqFHp2rVrmjZtmo4dO+bkk0/O/Pnzc8wxx6SoqCiXXHJJXZfJCsx879Vc+8DPc+LFO+TAs9bLPv+vVY67oG/+/PBvsmDR/LouDwAAAACg1jWq6wJq2pQpUzJ48OAUFxenRYsW6dGjR2bNmpUxY8Zk2rRpmTNnTpKkb9++dVsoK3T/pKtz9z/+kP499sk3thqahg0b57lpj+Ta+/9fHn/ulow58ams1bhZXZcJAAAAAFBr6nXAX1JSkiFDhqS4uDgjRozImWeemVatWiVJzj333Jx22mlp1KhRioqK0rt37zqulhXZecsD850Bp6dFs7WXThvS//h8rV233PTwb/LXf16V/XYaXocVAgAAAADUrno9RM9JJ52UmTNnZvjw4Rk9evTScD9JRo0alT59+qS0tDSdO3dO69at67BSVmazjttUCPc/t1ufQ5Ik04tfrO2SAAAAAADqVL0N+KdOnZpx48alXbt2Ofvssytt069fvyRJnz59lk677bbbcsABB6RTp05p3rx5Nt988/z0pz/NvHnzaqVuque9D2cmSdq03KCOKwEAAAAAqF31NuAfO3ZsysrKMnTo0LRs2bLSNs2afTZm+/8G/KNHj07Dhg3z29/+Nn/9619zwgkn5NJLL80ee+yRsrKyWqmdqllStiR//tuv0rBBo+y+1WF1XQ4AAAAAQK2qt2PwT5gwIUkyYMCA5baZOfOz3t//G/Dfc889WW+99Zb+e9ddd816662XoUOH5u9//3t22WWXGqqY6rr07h/l5RlP5ruDf5uO629W1+UAAAAAANSqehvwz5gxI0nSqVOnSueXlpZm4sSJSSoG/P8b7n9um222SZK8/fbbq1TLNttsk+Li4lVadk3RpFGzXDH8tSq3v/b+n+UvEy/JXtt/P9/Z/fQarAwAAAAAoHq6de+WRaULqty+ffv2eeaZZ6q9nXob8M+fPz9JsmBB5Ttx3LhxKSkpSatWrdKlS5cVruuRRx5JkmyxxRarVEtxcfEq/ziwpmjauHmV217/4Fn588O/zre2PTonH3BZDVYFAAAAAFB9s2fNysLFn9T4duptwN++ffvMnTs3kydPTv/+/SvMmz17dkaOHJkk6d27d4qKipa7nrfffjs/+9nPsscee6Rv376rXAsr1qRRsyq1u/7Bs3LDQ7/IoH5H5pQD/7TC9w4AAAAAoC5suNFG1e7BvyrqbcA/cODATJ06Neecc04GDRqU7t27J0kmTZqUYcOGpaSkJElWGNrPmzcv++67b5o0aZKrr756lWtZlVsr1jRLFiWPjFlxmxse+mVueOgXGbj1sJx68NVp0KDePiMaAAAAAChgr736Who2qfnt1NuAf9SoUbnpppvy1ltvpWfPntl8882zcOHCvP766xk8eHA6d+6cBx54oML4+/9rwYIFGTJkSN5444088cQT2XDDDWv5FfC//jLxD7n+wTOz/jobZ+tuAzPhXzdVmN+m1Qbp131QHVUHAAAAAFD76m3A36FDhzzxxBMZOXJkHnvssUyfPj09evTI5ZdfnmOPPTabbrppklQa8C9evDgHHnhgnnnmmTz88MPp0aNHbZfPF7zy1qQkybsfvJlzxx25zPzem+wq4AcAAAAA1ihF5eXl5XVdRG2bN29eWrdunaKionz88cdp3vz/HvBaVlaWQw89NHfffXfuu+++7L777nVY6ZqjKkP0AAAAAAAUggEnxRA9NeWll15KeXl5unfvXiHcT5If/vCHufXWW/OTn/wkzZs3z1NPPbV03qabbpr11luvtssFAAAAAIBlrJFPKX3hhReSVD48z1//+tckye9+97v079+/wp/x48fXap0AAAAAALA8a2QP/hUF/NOnT6/lagAAAAAAoPr04AcAAAAAgAK0RvbgnzBhQl2XAAAAAAAAX8oa2YMfAAAAAAAKnYAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAKkIAfAAAAAAAK0BoR8JeUlGTUqFHp2rVrmjZtmo4dO+bkk0/O/Pnzc8wxx6SoqCiXXHJJXZcJAAAAAABV1qiuC6hpU6ZMyeDBg1NcXJwWLVqkR48emTVrVsaMGZNp06Zlzpw5SZK+ffvWbaGs0FvvvpIb//bLvPb25Lz/0awsWbI466+zcbbbfM8ctNvIrNt6w7ouEQAAAACgVtXrgL+kpCRDhgxJcXFxRowYkTPPPDOtWrVKkpx77rk57bTT0qhRoxQVFaV37951XC0r8t6HMzPno9nZqde3s97aHdKwQaO8UfxCxj99RR557uZc9uMpadNy/bouEwAAAACg1hSVl5eX13URNeWwww7L2LFjM3z48Fx88cXLzO/bt2+ee+65dOnSJf/5z3/qoEI+t2RR8siY6i/32HO35tc3Hpzv7XlODhkwavUXBgAAAABQTQNOSho2qfnt1Nsx+KdOnZpx48alXbt2Ofvssytt069fvyRJnz59lk574oknMnDgwGy44YZZa6210qFDhxxyyCGZOnVqrdRN9WzQplOSZN6CuXVcCQAAAABA7aq3Q/SMHTs2ZWVlGTp0aFq2bFlpm2bNmiWpGPDPnTs3W265ZY477risv/76mTlzZs4+++z0798/L774Yjp06FAr9VO5RYsXZsGieVm0eGFmvPNy/nTfaUmS7Tbfs44rAwAAAACoXfU24J8wYUKSZMCAActtM3PmzCQVA/599tkn++yzT4V22267bTbbbLPcfvvtOfnkk2ugWqrqvn/+KX+468Sl/27fpnN+8p0bs+UmO9dhVQAAAAAAta/eBvwzZsxIknTq1KnS+aWlpZk4cWKSigF/ZdZdd90kSaNGq7a7ttlmmxQXF6/SsmuKJo2a5Yrhr6203U4998vG622eBYvm5fW3/5UnX747H84vqYUKAQAAAACqplv3bllUuqDK7du3b59nnnmm2tuptwH//PnzkyQLFlS+E8eNG5eSkpK0atUqXbp0WWb+kiVLUlZWlhkzZuT0009P+/btc/DBB69SLcXFxXn77bdXadk1RdPGzavUbr11OmS9dT4bJmmnXvtl5y0PyPAx2+bTxZ/kO7ufXpMlAgAAAABUyexZs7Jw8Sc1vp16G/C3b98+c+fOzeTJk9O/f/8K82bPnp2RI0cmSXr37p2ioqJllt91112X9vDv2rVrJkyYkPXWW2+Va2HFmjRqtkrLbbJR72z6ta1yzz/+KOAHAAAAAL4SNtxoo2r34F8V9TbgHzhwYKZOnZpzzjkngwYNSvfu3ZMkkyZNyrBhw1JS8tmwLn379q10+auuuioffPBB3njjjZx33nn55je/mYkTJ2bjjTeudi2rcmvFmmbJouSRMau27KLFC/LxJ3NWb0EAAAAAAKvotVdfS8MmNb+dBjW/iboxatSorLvuunnrrbfSs2fPbLnllunWrVu22267bLLJJtl9992TLH/8/c022yzbb799Dj300Dz88MP5+OOPc+6559bmS+B/zPmo8mcYTHn9kUwvfjGbd9qhlisCAAAAAKhb9bYHf4cOHfLEE09k5MiReeyxxzJ9+vT06NEjl19+eY499thsuummSVb+gN0kWWedddK1a9e8/vrrNV02yzHmjhPy/sez07fr7tlgnU5ZVLowr818No8+d3OardUqx+19fl2XCAAAAABQq+ptwJ8kW2yxRe69995lps+bNy/Tp09PgwYN0qtXr5Wu5913380rr7yS7bffvibKpAoGbPWdPPTs9Xn42Rvywfz3UpSibNCmU/ba4bgcvOvIrN+m+kMnAQAAAAAUsnod8C/PSy+9lPLy8nTv3j3NmzevMO/www9P165d07dv36yzzjp57bXXcuGFF6ZRo0b58Y9/XEcVs2ufg7Nrn4PrugwAAAAAgK+MNTLgf+GFF5JUPjzPDjvskOuvvz6///3vs3DhwnTs2DEDBgzIGWeckU6dOtV2qQAAAAAAUCkB/xcMHz48w4cPr+2SAAAAAACgWhrUdQF1YUUBPwAAAAAAFII1sgf/hAkT6roEAAAAAAD4UtbIHvwAAAAAAFDoBPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCABPwAAAAAAFCA6n3AX1JSklGjRqVr165p2rRpOnbsmJNPPjnz58/PMccck6KiolxyySV1XSarYOGiTzLs7E0yaGRRLr5zeF2XAwAAAABQqxrVdQE1acqUKRk8eHCKi4vTokWL9OjRI7NmzcqYMWMybdq0zJkzJ0nSt2/fui2UVXLdAz/Ph/Pfq+syAAAAAADqRL3twV9SUpIhQ4akuLg4I0aMyOzZszN58uQUFxfnnHPOyfjx4zNp0qQUFRWld+/edV0u1fTazMm54+8X5YhBv6jrUgAAAAAA6kS9DfhPOumkzJw5M8OHD8/o0aPTqlWrpfNGjRqVPn36pLS0NJ07d07r1q3rsFKqa0nZklx427HZdrM98vUt96/rcgAAAAAA6kS9DPinTp2acePGpV27djn77LMrbdOvX78kSZ8+fZa7nsGDB6eoqChnnXVWTZTJKrrj8Qvz1rv/zvD9PDsBAAAAAFhz1cuAf+zYsSkrK8vQoUPTsmXLSts0a9YsyfID/ltuuSVTpkypqRJZRbPnvJHrHzwzQwf9PO3bdq7rcgAAAAAA6ky9fMjuhAkTkiQDBgxYbpuZM2cmqTzg/+ijj/KjH/0oo0ePzuGHH/6l69lmm21SXFz8pddTnzVp1CxXDH9tpe1+f/vxab/uJjlwl1NqoSoAAAAAgOrr1r1bFpUuqHL79u3b55lnnqn2duplwD9jxowkSadOnSqdX1pamokTJyapPOD/6U9/mu7du2fo0KGrJeAvLi7O22+//aXXU581bdx8pW3+9uyNmfzaQ7nghMfTqGHjWqgKAAAAAKD6Zs+alYWLP6nx7dTLgH/+/PlJkgULKv+FZNy4cSkpKUmrVq3SpUuXCvOeeeaZXHnllXn22WdXWz3t27dfbeuqr5o0arbC+YtKP83l95yS7TbfM21atc/bJa8nSUo+/OyHk/kLP8zbJa9n7Rbt0rLZOjVdLgAAAADAcm240UbV7sG/KuplwN++ffvMnTs3kydPTv/+/SvMmz17dkaOHJkk6d27d4qKipbOW7JkSY477rgMHz48PXv2XG31rMqtFWuaJYuSR8Ysf/6ixQvywfz38vTU8Xl66vhl5j88+cY8PPnGfH+v83LQbqfWYKUAAAAAACv22quvpWGTmt9OvQz4Bw4cmKlTp+acc87JoEGD0r179yTJpEmTMmzYsJSUlCRJ+vbtW2G5Sy65JO+8807OOuusWq6YlWnapEV+NuzWZaZ/OO+9jLnzB9l2sz2yx3bHZJMNe9dBdQAAAAAAta9eBvyjRo3KTTfdlLfeeis9e/bM5ptvnoULF+b111/P4MGD07lz5zzwwAMVxt8vKSnJz372s4wePTqlpaX54IMPls5buHBhPvjgg7Ru3ToNGjSog1dEo4aNs0vvA5eZXjxnepJkw3U3rXQ+AAAAAEB9VS/T6g4dOuSJJ57IXnvtlaZNm2b69Olp27ZtLr/88owfPz6vvvpqkooP2J05c2Y+/vjjHHfccWnTps3SP0lyzjnnpE2bNnnzzTfr5PUAAAAAAMAXFZWXl5fXdRG1ad68eWndunWKiory8ccfp3nz5kunVzZW/oABA3LkkUfmqKOOyg477JCmTZvWdslrhJWNwQ8AAAAAUCgGnBRj8NeEl156KeXl5enevfvScD9JWrZsmd12263SZTp37rzceQAAAAAAUBfq5RA9K/LCCy8kqTg8DwAAAAAAFJo1rgd/dQP+NWwEIwAAAAAACoQe/AAAAAAAUIDWuB78EyZMqOsSAAAAAADgS1vjevADAAAAAEB9IOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIACJOAHAAAAAIAC1KiuC6By5eXl+aRsSV2XUWXNGzRMUVFRXZcBAAAAALDGEPB/RX1StiRtJjxU12VU2dzdB6VFQ4cTAAAAAEBtMUQPAAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUIAE/AAAAAAAUoDUi4C8pKcmoUaPStWvXNG3aNB07dszJJ5+c+fPn55hjjklRUVEuueSSui6zRiy5+tos/uaeKbv/wWXmlZeXp/TU07J4r31S/sb02i+umgaNLKr0z5Cftqzr0gAAAAAAal2jui6gpk2ZMiWDBw9OcXFxWrRokR49emTWrFkZM2ZMpk2bljlz5iRJ+vbtW7eF1pAGw4am7Kmns+TyK1PUb+sUrddu6byyO+5K+fMvpMF3j0pRl851V2Q1bNll5+y5/fcrTGvUsHEdVQMAAAAAUHfqdcBfUlKSIUOGpLi4OCNGjMiZZ56ZVq1aJUnOPffcnHbaaWnUqFGKiorSu3fvOq62ZhQ1bpxGI0ek9KQfZ8kFF6XR2b9OkpS/NTNl116fos03S4ODDqjjKquufdtNMrDf4XVdBgAAAABAnavXQ/ScdNJJmTlzZoYPH57Ro0cvDfeTZNSoUenTp09KS0vTuXPntG7dug4rrVlF3bqmwaEHp/zZySkb/9eUL1mSJeeOTsrL03DkiBQ1bFjXJVbL4tJFWfDpvLouAwAAAACgTtXbgH/q1KkZN25c2rVrl7PPPrvSNv369UuS9OnTZ+m0Rx99NEVFRcv8KfQhfBoM/U6yySZZcuWfUvaHy1L+yqtpcNQRKerYoa5Lq5YnXrgte/+0efb5f61y0Fnr55K7Tsz8BR/WdVkAAAAAALWu3g7RM3bs2JSVlWXo0KFp2bLyh7A2a9YsScWA/3N/+MMfsvXWWy/9d4sWLWqm0FpS1KhRGo08JaUn/ihl945PUa+eabD/fnVdVrVs3nG77NL7oGzUrms+WfhR/vnv+/KXiZfk+WmP5ffD/5Fma3nYLgAAAACw5qi3Af+ECROSJAMGDFhum5kzZyapPODv0aNHdthhh5oprq60aJE0bpyUlqZo221S1KCwbuC4+KSnK/x70DZHpMuGvXPN/T/NHX//fYZ+46d1VBkAAAAAQO2rtwH/jBkzkiSdOnWqdH5paWkmTpyYpPKAf3XaZpttUlxcXK1lyps0SS7/w2qroby8PEvOvzApXZxs3DFlN92cBrvukqKNNlwt6+/erXuKFi1a5eWbNGqWK4a/Vu3lDt5tZG586Bf559TxAn4AAAAA4CuhW/duWVS6oMrt27dvn2eeeaba26m3Af/8+fOTJAsWVL4Tx40bl5KSkrRq1SpdunRZZv4hhxySkpKSrLvuutlnn33yu9/9Lu3atVulWoqLi/P2229Xb6Gma6XxKm2tcmV33Z3y555Pg6OPTIP+O6T0hydmyfkXpuHoc1JUVPSl1z9r9qxk4aervHzTxs1XablGDRtn3dYb5cP5Jau8bT7zz3//NT+7ZkiuHPFiNl5/85W2P/y3nbNBm845/4RHv/S2Fy1emO+et3l232povjv4N196fQAAAAB89Vx694/z9NTx+dOpL6VRw8ZVnleIZs+alYWLP6nx7dTbgL99+/aZO3duJk+enP79+1eYN3v27IwcOTJJ0rt37woB99prr52RI0dml112ScuWLfPkk0/m7LPPzlNPPZVnnnkmTZs2XaVaqqu8SZO8V+2llrOut99O2dXXpmiz7mlw8IEpatgwDQ4fmrJrrkvZXXen4bf3/dLb2GjDjb50D/5VsWjxwrz34cxs0ameDadUy5YsKc3l94zIN7YaWqVwf3nueOKitGi6Tr617VHVWu62xy/IvAUf5KBdT02S3PX3i/OHv5yUo/f4TQ77xhnLtP/okzk5dnTPNGnUNJef8nx+ds2QPP+fx1a6nWGDzswR3zwr1z94Vm546Bcrbd97k11z/gmP5rlpj+bUy5Y/3Nf/eui88vzy+gMz8cU7c/4Jj6VXl68v0+bFN/6eEZfump16fTs/P+K2XPXXM3LzhLMz4qCrssd2363Qtry8PKdeNiBTZzyZP/zo2XRp3yvn3nxUHnr2upXWMqjfkRl16LV5YNK1GX3L0Sttv0GbTrnxjOkpnjM9w85e9ofPytxw+hu5a+LFuf3xC3L6YX/O7lsdtkybt0tez/EX9EnnDbfMRT+cmIYNGlZp3V/WwkWf5LgL+2T+gg9y5akvpU3L9SvMn/HOyznhoq2zWcdtc/7xj6VBgwYZNLJqP3iOPv6R9Nl0t4y4dLcaO/Z+dfQ9Oe6C3llUujBXnvpSWjdvu0y7mx7+ba65/6f54b5jcvvjF1St7X4Xp0v7XtU6ppPU6L7p32OfnHTJDumz6YD87tgHKm33kyu/leemPZIxw59Ktw5bV9qmJhT6+dm+beeMf+qKXHT7cRk68Gc56lu/XKbd78YOy8OTb8zZ33sg22z2zcz5qDjfO79n1mmxXi798b+yVuOK1+jJrz2cn1w5KAP6fienH/bnVarp8N92zjtzZ6y0/akHX5NvbXtUtfbr0Xv8Osee3yvrrdMxfzz52TRu1GSZdhfe9v3c9/SV+dXR92SHHntXqfYv67J7RlTrs/LI321aY/toVY69JPntnw/Lo8/dnN8d+1C27vaNCu0+Xbwgx1/YNx/OL8mfRryUx5+/dY26lteWNe387Nt194K+lp9/wqMpKyvLiMt2zStvTcqlP/pXOm2wRYV2cz9+J8ee3ystmq2Ty3/8XJo2WbWOT9X13gczq/VefDi/pMavV9U59lq3WDc/v2af7Ln9sfnxgVcs02Zx6aL84Pf98t4Hb+WH+12cc28+okptrxzxYq65//8V/LW8tlT3s7I+nJ/VfS9q+nqVVP97+jOvPJjT//StDNx6WE77zvXLtLv2/p/lzw//Oj8+8Irsuf2xVVr36rKm7d9tNxtc0J/F39r2qLxR/GJ+eFG/bNGpf0Yf/8gynYj/+s+rcsGt38t3dj9jaYfOQ3Y7LeOfujz3PHlpvv31kyq0X9G8QrThRhtVuwf/qqi3Af/AgQMzderUnHPOORk0aFC6d++eJJk0aVKGDRuWkpLPenz37du3wnJbbbVVttpqq6X/3m233dKrV6/ss88+GTt2bI4+euUn0hetyq0V85eUps2Eh6q93BeVl5VlyXkXJGVlaTjylBQ1/CxYa3DwgSmf+I+UXX1tGmy/3ZcequfV115Ni4arfjgtWZQ8Mmb58z+a/35at1h3menXPvCzLCkrzQ5bDFnlbZM89vytefPdqTlj6NgqL3P1qFdSlIof3Hc8cVE2aNO5WgH/p4sX5NbHzsu3tj06rZq3SZLsu9PwTHzprtz40C+ywxZ7Z5ONeldY5uI7f5i5897JecdNSPOmrXLYN36awdt9r9L1L17yaS6755Qs+PTj9Oi0Y5Lk6732z0brdl1uTbc+Njr/mf3c0i+pG6+/RU479Ibltn/63+Pz6JSb07PzTkmSk/a/NC+88UTOG3dULjvluTRr8n8P6V646JOcN+6otG7RLicfcFmS5IhBZ+Wpl+/JZfeckn7dv5n11umwtP0dT1yU5//zWI4ZfHa6tO+VJNl7h+OydbeBldZSnvJc89cz8t6HM5fW33uTXVZY/0PPXpfJr/0tvTp/1n7tluutsP0rb/0zd028OF9r1y3rtFw/393jN5n077/mkrtOTJ9NB2Td1v/3eVJWVpbzxh2V8pRn1CHX1Vq4nyRNmzTPyIOvyYhLd82Y20/ImUfevnTekiWlOefmI9KwQaOMPPjaNPjvM0lW9Lpnz/lPrn/wzKzdol06rLdZktTosde8aaucesg1GXn57rn4jh/kp4ffXKHtG7NfyI0P/SJbdf1G9t1peLpsuGXV2u74w3ww791qHdM1vW+6ddg6h+3+01z/0Fm558nLMqT/8RXa3/vk5Xn21QdzxDd/UavhflL452eS7LXD9/PEC7fn5glnZ6ee+1XYh39/4c48PPnG7LXDcUsDgbat22f4fhfn7JuG5pq//jTH73PB0vbzF36U82/5btq0ap8f7nfxKtd0wj4XZcGn8ypt//GCObn8nhFp2KBRunfol6R6+3W9dTrkB/v+PueNOyrXPfjzfG/P31VoP+mVB3Lf01fmW9seXWvhfpJqf1bW5D5Kqn/sJcnwb1+S56Y9kgtuPSZXnPJCmjdttXTen+77SWa+92rOGDo2bVu3X+Ou5bVlTTw/C/laniQNGjTIqQdfk+Mv6JPzxh2Z3w9/ssL3oYtuPy4ffzInZx15V62F+0mq/V7Mfv8/NX69qs6x12XDLfPNbY7KfU9fma/32j/bbr5HhfbXP3hmphe/mFGHXJdB/YZlyusTqtR2vXU61ItreW2p7mdlfTg/q/te1PT1Kqn+ft1ms29mz+2PzX1PX5mdex+YHXvus7T9K29Nys2P/C7bdP9WrYf7yZq5fwv5szhJurTvlcMHnZlr7v9p7pp4cYVQ/p25M3LZPaekS/stM2zQmUunt23dPrv1PTQ3P/K77NP/B2n4P3niiuYVotdefS0Nl/3dZrUrKi8vL6/5zdS+mTNnpm/fvnn//ffTqFGjbL755lm4cGFef/31DB48OGVlZXnggQdyxRVX5NhjV/yhVV5enlatWuXII4/MH/6w+sbFX5HVFfAvueW2lP3p6jT43tFpePBBFeaVT5+R0h+emKLNN//SQ/XM3X1QjQb8l97940yd8VT6dB2Q9dfZOAs/nZd//vu+TJn2SDbfePuMPv6RZXowUXU//uPO+WThR7n8lOe+1HpWZdiez3/NvfRHk9P1a//349o7c2fk+xf0zoZtN8klJ/1z6a1ZT7xwR355/QHZf+cf5YR9Llzp+s+/9Xu5/59X5Yhv/iLDBv18pe3/9uyNOefmYdm628D89nv3rzSQnvHO1Jx08fZpulbLXHry5LRt/dmvrRNfvCtnXfftDOn/g5y0//99blxy14n5y8RL8osj78qOvf7v7pnXZk7OiRdvn75dd1/ag/mtd1/JCRdtlS4b9q5yz/cbH/pVrnvw5/nWtkfn1IOvXmn756Y9mtOuGJSO62+eMSc+VeFLeWXmfvxOfvD7fpm/8MOMGf5UOrfvmSR55a1ncvIl/bPNZt/Kr79779L2tz52fq6499ScsM9F2X/nk1dazxd93iPq894Eq+Kyu0/J7U9cWKHX7A0P/iLXP3RWhu93Sfbd6YcrXcfCRZ/k5Ev6Z/o7L+V3xz6YrbruvtJlVtex98e//Ch3/v33+X+H35Jd+3z2Ob5kSWmGX7xdZr0/LVee8kLWb7Nxtdsuz/KO6ZreN0uWlObES3bIzPdeyeWnPJ8N237W0+SduTPy/fO3TIf1NsuY4U+u0he8QSOLlvbsWhWFfn4mybsfvJXvn79lhd5BH8x7L8ee3ytNm7TIFac8n2Zrtaywvl9cd0D+8dJdFXrlnTfu6Dz4zLX59XfvzfZb7LXS17CimipTVlaWM64anGdfffCzUGabI1a6jeXt1zOv3S9PTb03F/7g7+nx3zv95i/4MMee3ytFRQ1yxYgX0qJp65Wu/4sO/23n9N5kt4w69NpqL7s6PitX5z5anhUde/946e6cee2+FXrCPjft0Yy8fPd8fcsD8vNhty5tu6Zdy6vq896Gn/cMXBVr2vlZ6NfyJLnz72Pyx7+cXOGulgefuS7njTsqB+16ar6/93krXX9lvux3pdXxWbk6r1eVWd6xN3/hR/n++VumrHxJrhzxYlo2WydJ8u83/5mT/7Bj+m8xJGcddWe1265IoV3Lq+rLfFdaHZ+VhXZ+rq73YnVdr5ZnRfv1k4Uf5/sXbJnFpZ8uvQN40eKFOeGirTPn49m5csSLabf211b6GirzZb4rJWvm/i3kz+IkWVK2JCdf0j8zil/KZac8l6+165ry8vKMumJgXnzjiVx84tMV8p4kmfL6Ixl5+e75+bDbsnPvA6o8r9AMOCm1EvA3qPlN1I0OHTrkiSeeyF577ZWmTZtm+vTpadu2bS6//PKMHz8+r776apLqPWB3dYxVX5vK33wzZdfdkKItNk+DA/ZfZn5R505pcPjQlL/wYsruursOKqy6PpvsluZNW+ehZ67LpXf/KNc/eGY++mROjt7jNzn/+EcLOtxfVPppbnr4t/ne6J7Z8/Sm2e9n6+RnVw/J62//a2mb9z6Ymf3PXDfHju6VTxdXvLXn7JuG5pujGmTyq39bOm3QyKKce/NRmfzq33LixTtk7zOa5+BftM8f/nLyMr/EzvmoOC++8fdst/me1ar78N92zohLd6uwzXfmzsjz/3ksg0YWLf1TPGf6Ctfz+HO3pm2r9st82G/QplNOGHJhps2akhsf+uzWvA/nl2TMHSek43qb5buDf7vSGu/5x6W5/59XZYceQ3L4wJ+ttP3rb/8rF93+/WzQplN+OvTmlX4BmL/gw5x13X5ZXPppzhx2e4UvADv12i8Dtx6We5+6NJNfezjJZxfcu//xhwzqd8QyX3K7ddg6h+5+ep599cGMf+qKLClbknNvPuKzi2IVe74/PfW+3PDQWeneYZuc9O0/rrT9u3PfzK9vODjN1mqZs468c6VfAEqXLM4vbzgwJR++nVMPvqbCF4DNOm6TQ3c/PU9PHZ+//vOqJJ8FoNfe///SZ9Pd6vTWuqMH/yYd1uueS+46MXM+Ks5rMyfnpgm/Sd+uu2efHX9QpXWcf8t385/Zz+d7e55Tpf9wrM5j75g9z07H9TbLxXf+IHM/fidJctPDv8nrb/8rJ+xzUYXAvjptK7OiY3p5Vte+adiwUU479PqULlmc0eOOTnl5ecrLyzP6lu+mdMnijDr0+jrrvVHo52eSrL9Oxxw/5IJML34x1z90VpJkzB0n5MP57+XUg6+u9D9JJx1waVo1b5vzbjk6Cxd9kidfvicPPnNtvrXt0VUKD1dWU2Wu+utn+3nfnYZXKTxc0X790YFXpFWzNjlv3JFLr51/vPtHKfno7Zx6yDWrFO5/Wavjs3J17qPKrOzY27HnPhm49bDc9/SVmfTKA/lk4ccZPe7orN1ivZy8/6UV2q5p1/LatKadn4V+LU+S/XY6Mb032TU3PvSLvFH8Yt77YGb++JeTs/H6W+Sob/2qSq+hJnzZz8rVfb2qzPKOvRZNW2fEwVfn/Y9m5ZK7Tkzy2RCu5407Kq2btc3JB16+Sm2XpxCv5bVhdXxWFtr5uTrei9V5vVqeFe3X5k1b5ZSDrsrcee/kkjuHJ0muvv+nefPdqfnBPr9f5XB/dVgT928hfxYnScMGDTPykOuypHxJRt9ydMrKyvKXiZdkyusTctg3/t8yeU+SbLnJLmnapEUef/7Was2jcoV9n8NKbLHFFrn33nuXmT5v3rxMnz49DRo0SK9evVa6nrvvvjvz58/PdtttVxNl1piijTdO4/F/WWGbht85JA2/c0gtVbTqduy1b53+J6qmlC5ZnDP+tEdenv6PfKPfsOy74/DMX/hh7nv6yvzoDzvl/BMez2Ydt8l663TIqQdfkzOv3TeX/uVH+dF/v4De/8+rM+FfN+XQAT/J1t0r3kb6+tuT88QLt2XP7Y/NoH5HZMq0R3LX38dkevGLOefYh5bexvz5mIabdfxyx/dph96Qy+75cVq3aJfDdv/p0ulrt1xvucssKVuSl2ZMTN9NK/8St8d2383EF+/MzY/8Lv177pNbHj0vH33yfn519D0r/VHnxTcm5o93n5wO63XPTw69YaU/0H04vyRnXfftJMlZR95Z6ZBQ/6u8vDy/G3t4Zr73ak7a/9L06Nx/mTY/3G9Mnpv2SM6/5bv5/fAnM/qW76Zd66/lh/tWfrvK4QN/lidfujtX3Htqps2akn+/9c8ct/f56bj+ZiusJUlmvvdafjd2aFo3XzdnHnlHmjRe8fNCFi1emLOu3z8fffJ+fnn0Pflau+Xf1vi5P/7lR3nxjb/nkAGnZZfeB1Za/9NT781l95ySvpsOyHnjjkqjho1z6sHX1OkPpGs1bpaRh1yXH//x6zn/1mPy7gdvpkmjpjn14KurVNctj56XR58bl936HJKDdh2x0var+9hbq3GzjDz0uvzoDzvlotuPy7BBZ+WmCb/JDj2GZI9tj17ltl9UlWP6i1b3vum0QY8c/a1f54rxI3PHExelUcMmmfL6hHx/79HLjIla2wr9/Ew++0x94oXbc8uj56a0dFGeeOH27LfTiemz6W6Vtm/Tcv2c+O0/5tc3Hpwxd5yQZ199MOut3SEnDFl5j+uq1vS/Hnvu1tzy6Lnp1eXrOX7IBSttv7L92qbl+jlp/0vzqxsOyp/u+0m26f7NPPjMtdl3p+FVCg9qypf5rFzd++iLqnrs/XC/MZkybUIuvPV72XKTXVI8d3p+fsTtWbtFu2XarmnX8tqypp2fhX4tTz7rLHbqIdfkuAt659ybj0jr5u2yYNG8jDr0upWemzXpy3xW1tT16n+t7Njbuts3MqT/D3L3P/6Qr/faPy/P+EfefHdqfj7stmWe2VCdtl9UqNfy2vJlPisL9fz8Mu9FTVyvvqgq+3Xrbt/I3juckHue/GParf213PnERenfY58q/Yhb09a0/Vvon8VJ0mmDz34Qu3L8qPzx7pPzwD+vTrevbZ3Ddl/2WUzJZz8KbNZx20qfs7GieVSu3vbgX5GXXnop5eXl6datW5o3rzjO4eGHH56f//znueuuu/K3v/0tv/rVr3L44Yenb9++OfTQQ+uoYuqrv0y8JM9NezS/OPrujDjoTxmy4wk5dPef5NIf/yutW7TLFfeeurTtjj33yX47nZjxT1+Rx5+/LW++++/84a4Ts8XGO1Taq+CN4hfyk+/cmBP2uTD77PiD/HzYrdnv6ydlyusT8tjztyxtN+Odl5MkG6276Zd6LQP7HZ6mTVqkTcsNMrDf4Uv/rOiX43c/eDMLPp23wm3/+MAr06Lp2vnpVXvm8edvzaEDfpLNN17xjxElH87Kr244MI0brZWzjrwzLZqtvcL2S8qW5Nc3HJx35s7IyQdcXumvy1903YNn5qmp92aPbb+7zHjhn2vZbJ2cctBVefeDN3P8hX3yztzpGXHw1cutp1HDxhl16HVZVLow9zx5aXp1+Xr23/lHK61lwafzctZ1++WTTz/OTw8fl/XX6bjSZS66/bi8NvPZDBt0VrbfYuV3b9w/6Zrc8+Qfs3W3QTl6j9+soP7rs7j005x48faZ+uZTOW7IBas8tM7q1KPTDjlwlxH557/vy/TiF3PckPOzQZtOK11u8qt/y1V/PT1d2m+ZUw6+aqXta+rY22Lj7XPIbqflHy/9JT+5clCar9U6Pz5g2YfEVbft/6rKMf2/amrfHLDLKenV5eu55v6f5k/3nZYtu+ycA3b+8UrXX9MK/fz83I8PvDIt1mqd2x4/Pxu165pjvjDO5xft2ueg7Nrn4Dz07PWZ83FxTjnoqpUe19WtKfnsORGjbzk667beKD87/NalQ7ksT1X36y69D8zuWx2Wv0y8OOfcfES+1q5bvrfnOSutpyat6mdlTe2j/1XVY69ls3Xy4wOvzHsfzsyEf92U3bc6LDtvuezdop9bk67ltWlNOz8L/VqeJBu27ZJj9zw3r7/9r0x+7aEcsttp2azjtiutqaat6mdlTV6vkqofe8fudW42atc1F9x6TG5//IJ8Y6uhyx3SoTptP1fo1/LasKqflYV+fq7Ke1FT16v/VZ39euze52bDtpvk1sdGp0WzdfKjA1Z+N0ttWdP2b6F/FifJgbuMSI9O/fOXiZdkSVlpRh563Qrvwt5w3U0z5+PifDT//WrNY1lrZMD/wgsvJKl8eJ6ePXvmzjvvzBFHHJHBgwfn6quvzrHHHptHH300TZrUwqBJrFEennxjOq6/ebp36JcP55cs/VO6ZFH6dRuUF6f/vcKQPMfufV66fm2rXHjbsfnV9QemYcPGOWPo2Eo/MDuut1l26rVfhWmHDvhJkmTii/83vuSH899LkrRq3rYGXuGKfThv5dtu2/qzB8V9OL8kndv3qvBglsosLl2UX15/QOZ8XJyRB1+bThv0WGkdV947MlOmPZL9djoxg/oNW2n7f7z4l9z08K+zWcdtc+L+K749d5vNvpm9tv9+Ppxfkj23Ozb9ug9aYfsWTddO40ZrJUm223zPpXdarMh5447KjHdezrF7npu+XQestP2dfx+Th569Pv177JOhA//fStu/8takjLnjhLRv0zk/HTp2hbc3dvnve/Th/JL06/7N7Ll95Q/FqkzpksUVzoMP55dkwaLPhpSat2DuMvOqa50Wn91N0rBBo2yz2R4raZ0Uz5me3/z50DRfq1WVbnOs6WNv2KAz07l9r3w4vyQ/3O/iFd42Wp22SfWO6aRm902DBg0y6pDrUl5enrKyJRl5yLVVOg8+9/EnlR8rny76ZJnpi0o/rfJ6k8I/P5PPHj691n8fErfVprtX6YGOa//33Fm7Rbv06LTyHk3VrenjT+bmrOu+nSVLFufnw26r0i3R1dmvw/e7JOu0WD8ffzInow65rloPsZy/4MNljpuy8rIsXvLpMtMXLvqkyuut7mdlTe+jpPrHXqvmbdOg6LNzYPstVvyw4jXtWv6/FpUue6x8+t9j5YvTP/5kbpXX+7k17fws9Gt5UvHu1h1Wcu58UU1+V6rue1HT16vqHHtNmzTPaYdcn48XzM3aLdZb+pDpL9v2c/XhWv6/auq7UnU/K+vD+bkq70VNXq+S6u/Xxg2bpPl/h3/p3mGbKn3O/6+a+q6UrJn7t5A/i5PP/i/3eb6zUbuu2Xj9Fd+F3br5Z3dXzJ33brXmsax6PUTP8qwo4D/99NNz+umn13ZJrKHefHdqPl28IAeetfxhbD6cX7K0l0iTRmvljMPG5nvn98z0d17K6Yf9ebk9/ir7IF239YZp2WydzH7/P/8z9bNbGstT8UFvi0sX5eNP5lSY1mytlqt1bMfPb6dc2bO+P/8Pa7ev9Vtpr7FL7hqeqW8+lUMH/KRKD2OZ8K+bcvsTF2bLLjvnuCHnr7T9m+/+O+eMOyJrN2+Xnx9xe5r8N+xbkS069c/4p6/IFiv5j/dn440fndLSRdl4/S1y099+nV17H5yN2i3/DoebHv5tnnjh9uzW99AcuOspK63l+f88nsvvGZEO63XPad9Z+S2tc+e9m19ct38aFDXImUfesdLbG5P/e7+qEjT8r5emT8ypl1X+n6YTLtp6mWnVeTjhjHem5toHfpbO7XvlrXf/nQtvPTZnH3v/ctsvXPRJzrru25m3YG5+9d17V/gefK6mj73GjZqk29f6ZXrxiyvdt9VpW91jujb2zYbrbpI2rTZY+vfqOOGirfLO3BnLTL/lsfNyy2MVH5B26sHX5FvbHlWl9daX8/OPfzk5JR++nU027JO//vNPGdjviPTqstNy2//r9Qm558k/ZtON+mbarCm54t5Tlw4TtzpqKisry9k3HZZZ70/LyftfVqVboqu7X1s1b5OO62+eufPeqdL6/9fPr9230luDH51ycx6dcnOFadV9OGFVPytrYx9V99hbtHhhzrv5yLRotk6aNmmRy+85JdtutkdaNW+z3GXWlGv5Fz3yr7EZfUvlQ6R98fvfBm065cYzpld53Wva+VkfruVz5737WbDStks++uT9XHT7cfnDyc+kcaOqdSSrye9K1Xkvavp6tSrH3udtOq6/+Qo/i6rbtj5cy7+opr4rJVX/rKwv52d134uavl6tyn79899+nWmzpmTTjfrm2VcfzIR/jc3uW31npct9ria/K62J+7fQP4vvn3RNnp46ful3k1sePTff2X0FGet/s6BKa1/RPJYh4Ic6VF5eni7tt1zhWKaf91T63NNTx6esbEmSzx4cs/tWh32pGtb5by+Fjz+ZU+F205dn/GOZ/0BU94K8Mp/3Ovt4wZyVtKya8U9dkfuevjL9un+zSreaTZv1XC689di0W/tr+dmwld9yPn/hRznrum/n00Wf5Jff/0uVbs+tjrsmXpznpj2ao/f4TXbsuW9+cNHWGX3rd3P+8Y9WelGb9O/7c90DP8smG/bOiINWfkvrex/MzK9uOChrNW6Ws468a6UP6lmypDS/uuGgvPfhzJx26A1Vur3xy9hkwz4559iHKkx79tUHc8tj5+Un37kxbVpusErrXVK2JOeNOzINihrkrCPvzIPPXJubHv5N/vrPqzJ4u2MqXebC247NtFlTctS3fpXtNh+80m3U9LFXU1blmK7pffNl/eQ7f86iLzyM/LQrB2Xg1sMyqF/F8S47VeFhUp+rD+fnP166Ow89e3323P7YHPWtX+V7o3vm/Fu/m8t+PKXSsdA/Wfhxzr/lu2nTcoOce9zD+eNdJ2X801dkl94HLfPcl1Wt6ZoH/l8mvXJ/9tjumOzd/7iVtq/ufv2yjhtyfuZ9oVf178Yenk026pODdx1ZYXp1f4yqqpreR9U99pLk6r+ekbfeeyWnH/bnrN1ivfzkym/mD385KT/5zg1Vek0rUujX8i/aZrNvLXNte+jZ6/O3yTcsM73JSp5J8L/WtPOzvlzLf3/78fn4kzk568g78+a7/86Ftx2bP//tVzlqj6o9ZLemvitVR21cr6p77NWU+nAtr0xNfVeqjvpwflb3vaiN61V19+trMydn7ITfpl/3b+asI+/M8Rf2zR/uOjFbdd19aWeblamp70r274p9FT+L3/3grVx294/TuX2vjBn+ZH5y5Tdzw0O/yI49913uHTcf/TcL+mLutbJ5LGuNDPgnTJhQ1yVAkuRr7brlw/nvpW/X3as01MOrM5/N1X89PVt3G5S1W7TLbY+fn627Dco2m31zmbZvvjt1mWnvfzQ78xZ8UOHC2rn9Zw+afrvktWy60f/96FXZfyBWdkEuSvV+WV1vnY5p3rR13i55rVrLVeblGU/lD3edmPZtu+SMoWNXuj8/+mTOZ7ealZXmZ8NuW+kFtry8POfefETeevffOX7IBav9QVYz33stV993ejbruG0OGXBaGjZomGHfPCtX//WM3DXx4nz76ydVaD+rZFrOvumwtGi6ds484o6V3rq3qPTT/OL6/fPBvHfz8yNur9IDSy+755S88J/Hs9/XT8rAfod/qddXFa2at1kmlHjvw5lJkp6dd1rlsfxvfuR3eeWtSfnBvr/P19p1zeEDf55/vPSXXHbPKenX/ZvLfJm77bELMuFfN2XHnvvmsG/8dDlr/T81fezVlFU5pmt636wOy+vVs+G6m1QaelVFfTg/P5r/fi667fvZoE2nHLf3+WnetFV+uN/FOfumw3LNX3+a4/dZ9ofmy+45Je/MnZFfHPWXtG7eNj/Yb0z+9frDueC27+WKU15I86atvlRNT7xwR8Y98rvPbon+9h9W2r66+3V16N6h3zLTmjRumratNlzl46k6anofrcqx98J/nsidf/99vt5r/6WdDPba/vtLw+Ude+5TtRdXiUK/lldm3dYbZt3WG1aY9uL0vyfJlzqG1rTzsz5cyx+e/OdMfPHOHLDzj9Ory9fTq8vX8/jzt+bmR36XnXp9O906LNsD/4tq6rtSVdXG9aq6x15NqS/X8srUxHel6qgP52d134vauF5Vd78uKv005958RJo2aZFTDvpTmjZpnlMPvjojLt01v7/jhJx15B0rXUdSM9+V7N+Vr/ur+Fl8/i3HZOGi+Rl1yGcPpx5x8NU5/oI+OW/cUfn98CcrHQ5oVsnraduqfaV3E6xoHstaI8fgh6+KQf2OyJyPi3P745V/GZv78TtL/77g03n5zZ8PTctmbfKT79yQkw+4LO3bdMm5Nx9R6Zhkb733Sia+eFeFaeMe+ewBLTv23G/ptN6b7JokmTrjqQptP/8PxP/+WVnA33StlssM67MiDRs0zJZdds6/33y6ystUZs5Hxfnl9QekQYOGOfOIO9J6Jc8TWFK2JL+58dAUz3kjP9h3THp02mGl27jxb7/KP176Swb0/U4O2GX1PvCzrKws5407KkvKl2TkIdctvfAdvNuodO+wTa6+7/TMKpm2tP2CRfNz1nXfzvyFH+Ynh/25SrcGXnzHD/LKW5M+u6V1BQ9C/NxDz96QuyZenC277Jzj91757Y1fVf+Z9Xz+/NAv03uTXbPfTicm+Wz4mpGHXJtPF32SC289tkL7Ka8/kivvG5WO622WUYdev9LbAWvj2Ksp1T2ma3rffFXVl/Pz4jt/mA/mv5tTDrpqafC3+1bfyU4998udf/99XnxjYoX2k/59/2e3Qm89bGlg27p525y8/2V5Z+6MCg+BX5WaZrzzcs4bd2TWbt4uZx5xx0pviV6V/VroamMfVffYW7BofkbfcnRaNW+bkw64dOn07+89Ouuvs3F+f/txqzSOfFL41/LatKadn/XhWv7+R7Pzh7tOTIf1uufowf/X+/iUg/6UtZo0z3njjsri0kUrXU9dq+nrVXWPvZpSX67lX0X15fyszntRG9er6u7XJLn+wTMz/Z2XcvyQC5b+SNqry9ez39dPysQX78yEf41d6Tpqiv27Yl/Fz+J7nrwsk197KIfufvrSH8S+1q5rjh7827zy1qTc8ui5yyyzpGxJXp35zNJMqqrzqNwa2YMfviq+vfPJefa1h3LF+JH517QJ2WrT3dO8aeu8+8Gb+ddrD6dJ46YZffwjSZLf33FCZr8/Lb895v6lv0ifMXRsfvzHr+e8m4/Mb465r8KFpkv7LfO7sYdnz+2PzdfadcuUaY/kiedvS+9Nds1ufQ5Z2m6dluulz6a75Z//vi/HDRn9pV7PFhvvkPsnXZVr7/9ZNt5gixQVNcgOPYas8MEzu/Q+KE9PHZ9/v/nPbL7xdqu03V/ecGDe/2hWdur17UwvfjHTi1+stF2bVhukX/dBuf7BMzP5tYfScf3N07RJi/zt2RuXu+6B/Q7PM688mBseOitrNW6WPpvutsL2/boPqnaP7NsePz8vz/hHvrfnORV+fW/YoGFGHnLtMkOB/P624/JG8Qvp1eXr+Wj++8utp9laLbNTr/1y39N/yv2Trs46LdfPxutvscL6d9ry2yl+/z+56Lbvp0FRg/TvuW8e+cLYif+rZ+cda2xYii+rdMninDvuyDRs2DinHnJNhfOje4d+OWTAaRVu73//o9n59Y0Hp6xsSb6+5QF58qW7l7vuTTbsnU026l3jx15Nqe4xXVZeVuP75quqPpyfjz13ax59blyG9D8hW3f7RoU2Jx9wWV5444kKtzzPW/BBLrjte1m39Ub54X5jKrTfsde++cZWQysMBfLG7BeqVVObVu1z5rX7ZcGn8zKg73fy3LRHl9t+o3U3TY/O/au9XwvdwkWf1Pg+qu6x16xJi1x576jMen9a/t/h49Km5fpL5zdv2iqnHPSnLzVUT6Ffy2vLmnZ+1pdr+YW3HZv5Cz/Mr787vsLQEuuv0zHH7X1+tYfqqQs1fb1alWOvptSHa/lXUX05P6v7XtT09WpVvqe/POOp3PrY6Gy3+Z7ZY7vvVmjz3cG/zdNTx6+2oWSqy/5dsa/iZ/HsOW/kyvEjs8mGfXL4wJ9VaPPtr5+Uv79we6VD9Tz/n8eycNH87NL7oGXWvaJ5VE7AD3WoUcPG+c13x+fuJ/+Yvz17Q65/8MwkSdu1N8rmHbfLoH5HJkkeeub6PDz5xhy826gKw/FsvvF2OXqP3+TK8aNy2+MX5KBdRyyd1/VrW+f4IRfkmvt/mnufvCzNm7bOvjsNz3f3+O0ytzUO6X9Cfn3jIXl15rOV3mJXVUcP/k0+/mRO7v7HHzJv4QcpLy/PDae/kWZtlx/w79bnkFx2zyn52+QbVjngf2n6Z7/gT3zxzkx88c7ltuu9ya7p131QXnzjs1vj33r33znn5mErXPfAfofn5Rn/SHl5eT5dvCAX3b7isedGH/9ItS7Snz8wbouNd8iB//P+fa5z+57LDAXy+a39L77x96WvpTIbtOmUnXrtt7TNB/PezbnjjlxhPTd0eSOvznw2i0oXJskyvQC/6NSDr/nKBvw3/u1XmTZrSk789h+yYdsuy8z/4u39s9+flg/nlyRJxk747QrXPWzQmdlko941fuzVlOoe00lqfN98FdWH87PpWi1z8Z0/SPu2XXLsXsv2nGnTaoNlbnn+w10npeTDt/Pr745Py2brLLPMF4cCqW5NfTbdbenQbPc9fWXue/rK5bYf1O/I9Ojcv9r7tdB9MO/dGt9H1T32pr7/VO596tLs0vug7Nrn4GXa9Os+6EsN1VPI1/LatKadn/XhWn7/P6/O01PH5+BdR1YaSu+5/feqPVRPXajp69WqHHs1pT5cy7+KZr73SsGfn+3W6VDt96Kmr1dJ9b6nf229bhk97qg0X6tVfnzgsufZWo2brbahZKpr7rx37d+V+Kp9Fm/RaYeMHnd0Fpd+mlGHXrfMsw+KioqWO1TP3569IW1btc+OPfddZt0rmkflisrL//tYYr5S5i8pTZsJD6284VfE3N0HpUXDVf+9aMmi5JExK29H1QwaWZRB/Y7MqEOvrVL7JWVLcvwFfbLpRn3zk8OW/wtwTbl5wu8y9pGzc8PpbxTsMB4AAAAArNicj4pzxO82yTF7/m6Z55mtaF4hGnBS0rBJzW/HGPxAGjZomO/vPTqPTBmbGe8s+3Demrb/zj9Kq2ZtcutjX26IIAAAAAC+um5+5Hdpt3aHDOl/QrXmsXx68H9F6cHPl1HdHvwAAAAAwOqjBz8AAAAAALBcHrIL9dBD57kxBwAAAADqOz34AQAAAACgAAn4AQAAAACgAAn4AQAAAACgABmD/yuqeYOGmbv7oLouo8qaN2hY1yUAAAAAAKxRBPxfUUVFRWnR0NsDAAAAAEDlDNEDAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFSMAPAAAAAAAFqN4H/CUlJRk1alS6du2apk2bpmPHjjn55JMzf/78HHPMMSkqKsoll1xS12UCAAAAAEC1NKrrAmrSlClTMnjw4BQXF6dFixbp0aNHZs2alTFjxmTatGmZM2dOkqRv3751WyhV9tEnczL24d/mHy/dlfc+nJnma7VK5/a9cuQ3f5ktN9m5rssDAAAAAKg19TbgLykpyZAhQ1JcXJwRI0bkzDPPTKtWrZIk5557bk477bQ0atQoRUVF6d27dx1XS1W8M3dGTr10tyxYNC97bHdMOrTrnvkLP8x/Zj+fko/eruvyAAAAAABqVb0N+E866aTMnDkzw4cPz+jRoyvMGzVqVG666aY899xz6dKlS1q3bl1HVVIdvxt7eJaUlebyU57Puq03rOtyAAAAAADqVL0cg3/q1KkZN25c2rVrl7PPPrvSNv369UuS9OnTZ5l5d955Z3bccce0aNEia6+9dnbaaae89NJLNVozK/b8fx7Pi2/8PQfvNirrtt4wpUsWZ+GiT+q6LAAAAACAOlMve/CPHTs2ZWVlGTp0aFq2bFlpm2bNmiVZNuAfM2ZMRowYkR//+Mf51a9+lU8//TRPP/10FixYUON1s3z//Pd9SZL119k4P7t6SP75yl9TVrYkX2vXLYcP/HkG9ju8jisEAAAAAKhd9TLgnzBhQpJkwIABy20zc+bMJBUD/mnTpmXkyJG58MILM3z48KXT99xzzxqqlKqa+e4rSZILbzs2G7XrllGHXJfFSxbl9sfOzzk3D0tp2eLsse3RdVwlAAAAAEDtqZcB/4wZM5IknTp1qnR+aWlpJk6cmKRiwH/11VencePGOfbYY1drPdtss02Ki4tX6zrrmyaNmuWK4a8td/4nn36cJGm2VquMPv6RNG7UJEmyU8/9csTvNsk1fz0j3+x3ZBo0qJejTgEAAAAABaRb925ZVFr1UWHat2+fZ555ptrbqZcB//z585NkucPqjBs3LiUlJWnVqlW6dOmydPo//vGPbLbZZrnxxhvz61//Om+99Va6deuWn//85/nOd76zyvUUFxfn7bffXuXl1wRNGzdf4fy1Gn82pNKArb6zNNxPklbN26R/j33y0LPX5633XkmnDbao0ToBAAAAAFZm9qxZWbi45p8hWi8D/vbt22fu3LmZPHly+vfvX2He7NmzM3LkyCRJ7969U1RUVGHe22+/ndNPPz3nnHNOOnbsmKuuuiqHHXZY1ltvvQwcOHCV62HFmjRqtsL57dbukCRp02rZfdm29YZJknkL5q7+wgAAAAAAqmnDjTaqdg/+VVEvA/6BAwdm6tSpOeecczJo0KB07949STJp0qQMGzYsJSUlSZK+fftWWK6srCzz5s3LDTfckP322y9J8o1vfCMvv/xyfvWrX61ywL8qt1asaZYsSh4Zs/z5m228Xe596rKUfDhzmXklH3w2bZ2W69dUeQAAAAAAVfbaq6+lYZOVt/uy6uWA5aNGjcq6666bt956Kz179syWW26Zbt26Zbvttssmm2yS3XffPUnF8feTpG3btklSIcgvKirKwIED8+KLL9beC2AZO/XcL83XapWHJ9+YBZ/OWzr9/Y9mZ+JLd6XDet3ztXZd67BCAAAAAIDaVS8D/g4dOuSJJ57IXnvtlaZNm2b69Olp27ZtLr/88owfPz6vvvpqkmUD/p49ey53nQsXLqzRmlmxVs3b5Pt7j07Jh2/npIt3yG2PXZCbJ/wuJ128Q0qXLMoP9724rksEAAAAAKhVReXl5eV1XURtmjdvXlq3bp2ioqJ8/PHHad78/x7uevfdd2fffffN7bffnv333z/JZ8P29O3bN23bts2jjz5aR1XXfysboudzT7xwR2559NxMn/1Ciho0yBYb98+wQWemV5edar5IAAAAAIAqGHBSamWInno5Bv+KvPTSSykvL0/37t0rhPtJMmTIkOy88875/ve/n/fffz8bb7xx/vSnP+Wll17KQw89VEcV87923nL/7Lzl/nVdBgAAAABAnVvjAv4XXnghybLD8ySfjbd/991357TTTssZZ5yRjz76KH369Ml99923dNx+AAAAAAD4KhDwf8E666yTyy+/PJdffnltlgUAAAAAANVSLx+yuyIrC/gBAAAAAKAQrHE9+CdMmFDXJQAAAAAAwJe2xvXgBwAAAACA+kDADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABUjADwAAAAAABWiNCPhLSkoyatSodO3aNU2bNk3Hjh1z8sknZ/78+TnmmGNSVFSUSy65pK7LZAWuf/CsDBpZtNw/e5zWuK5LBAAAAACoVY3quoCaNmXKlAwePDjFxcVp0aJFevTokVmzZmXMmDGZNm1a5syZkyTp27dv3RbKCn291/7ZaN2uy0x/Y/bzueWx87JDjyF1UBUAAAAAQN2p1wF/SUlJhgwZkuLi4owYMSJnnnlmWrVqlSQ599xzc9ppp6VRo0YpKipK796967haVmSTjXpnk42WfY8uuu24JMng7Y6p7ZIAAAAAAOpUvR6i56STTsrMmTMzfPjwjB49emm4nySjRo1Knz59Ulpams6dO6d169Z1WCmrYsGi+XnkuZuz3todss1me9R1OQAAAAAAtareBvxTp07NuHHj0q5du5x99tmVtunXr1+SpE+fPkun7bbbbikqKqr0z/HHH18rtVM1jz93az5Z+FG+uc1RadigYV2XAwAAAABQq+rtED1jx45NWVlZhg4dmpYtW1baplmzZkkqBvx//OMf89FHH1VoN378+Pz617/O3nvvXXMFU233T7oqRUVF+dZ2363rUgAAAAAAal29DfgnTJiQJBkwYMBy28ycOTNJxYC/R48ey7T7zW9+k/XWWy977GEYmK+Kt959JS++8fds1fUb2bBtl7ouBwAAAACg1tXbgH/GjBlJkk6dOlU6v7S0NBMnTkxSMeD/ovfeey/3339/fvCDH6RRo1XbXdtss02Ki4tXadk1RZNGzXLF8Neq3P7+f16VJBm8/fdqqiQAAAAAgFXSrXu3LCpdUOX27du3zzPPPFPt7dTbgH/+/PlJkgULKt+J48aNS0lJSVq1apUuXZbfA3zs2LEpLS3NsGHDVrmW4uLivP3226u8/JqgaePmVW67ZElpHnr2+rRuvm526vXtGqwKAAAAAKD6Zs+alYWLP6nx7dTbgL99+/aZO3duJk+enP79+1eYN3v27IwcOTJJ0rt37xQVFS13PTfccEO22GKLbLPNNl+qFlasSaNmVW775Mv3ZO68d/Ltr5+cJo3WqsGqAAD4qrr+wbNy6ICfpEnjpjn35qPS9Wt9s//OP6rWOia+eFfatGqfHp12WGnbByZdmz/efXK+1q5b/njyZz2r5s57N+eOPSKz5kxLk4Zr5cT9/5jem+ySJDn7pqH512sPZ7e+h+YH+15U3ZcHAECB23Cjjardg39V1NuAf+DAgZk6dWrOOeecDBo0KN27d0+STJo0KcOGDUtJSUmSpG/fvstdx7///e8888wz+e1vf/ulalmVWyvWNEsWJY+MqVrb+yf9d3ie7Y6pwYoAAPgqu+GhX2T/nX+UJo2brvI6Jr54V7p+rW+VAv4k6bvpgPziqLuW/vuq+36SLTrtkLOPvT+vvDUpZ1337dxw+htp1LBxTj/sz7n+wbMyb8EHq1wfAACF67VXX0vDJjW/nXob8I8aNSo33XRT3nrrrfTs2TObb755Fi5cmNdffz2DBw9O586d88ADD6xw/P0bbrghRUVFGTp0aC1WzoqUfDgrk165P5t33C5dNtyyrssBAKAOXHT78UmSH/9x5zQoaph1194ob74zNSMv/0be++CtdG7fKz8denMaN2qS0iWLc+0DP8uU1ydkcemidFive350wOV5ecaTeerluzP5tYfywKRrs+9Ow7PDFnvntzd9J58s/CiLShemz6YD8sN9x6RBgwaV1vHYc7fkutNeT5Js1nHbrNt6ozw/7bFs3X1gre0LAADWbJV/U60HOnTokCeeeCJ77bVXmjZtmunTp6dt27a5/PLLM378+Lz66qtJlv+A3fLy8vz5z3/Obrvtlo033rg2S2cFHnzm2pSVLfFwXQCANdiPDrgsSXLhD57I5adMyTot1s+0WVPyq6PvyVUjp2bux+/kiRduT5Lc8uh5adq4RS456Z+5/JQp6dJ+y1xz///L9lvsmR167JODdxuZy0+Zkj23/15aNlsnvzr6nvzxR8/m8lOezztzp+ex52+ptIaP5r+fJUsWp23r/7uVeoM2nfPuB2/W/A4AAID/qrc9+JNkiy22yL333rvM9Hnz5mX69Olp0KBBevXqVemyjz/+eGbMmJEzzzyzpsukGg77xhk57Btn1HUZAAB8xezU69tp2qR5kmTzjbfL7PenJUn+8dJdmb/ww6WBf+mSRdmgbedK11FWXpYrx5+Wl6b/PeXl5flg3rvp3L5XBvQ9tFZeAwAAVFe9DviX56WXXkp5eXm6d++e5s2bV9rmhhtuSLNmzXLggQfWcnUAAEB1/e9Y/A2KGmZJWWmSz+7M/eG+F2ebzb650nXc/vgF+WD+u7n4xKfTpHHTXHb3KVm0eGGlbVu3WDcNGzTKnI+Kl/bif2fu9Ky/jrt/AQCoPfV2iJ4VeeGFF5Isf3iehQsX5rbbbst+++2XVq1a1WZpAABAFTRfq1XmL/xwpe127LVf7njiwixc9EmSZOGiTzK9+KUkSYumrTN/wf+t4+MFc9O2Vfs0adw0cz4qzuPP37rCde/c+6Dc+9RnwwW98taklHz4dnpvuuuqviQAAKi2NbIH/8oC/qZNm+aDDz6oxYoAAIDqOHCXETntikFZq3HzrLv2Rsttd+hup+WG0k9z4sXbpyhFSZJDBpyWzu17ZmC/YTlv3FGZ+NJd2WfHH2b/r5+cX95wYL43umfWbb1Rtuq24oflHrvXOfnd2GE58pxuadywSX7ynRvTqGHj1fo6AQBgRYrKy8vL67qI2rb77rvnkUceyb333pu99tqrrsshyZJFySNj6roKAACo3AOTrs0/Xrorvzjqriovc/2DZ2Xegg/yg30vqrG6AAD4ahpwUtKwSc1vZ40comfChAkpLy8X7gMAAFWyVuNmmTZrSn7w+22q1P7sm4bm4ck3pnnT1jVcGQAAa7I1sgc/Xz168AMAAAAA9YUe/AAAAAAAwHIJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoAAJ+AEAAAAAoADV+4C/pKQko0aNSteuXdO0adN07NgxJ598cubPn59jjjkmRUVFueSSS+q6TAAAAAAAqJZGdV1ATZoyZUoGDx6c4uLitGjRIj169MisWbMyZsyYTJs2LXPmzEmS9O3bt24LpUoWfDovd/59TB6ZMjbvzJ2exg3XSof1umfP7b+fb25zZIqKiuq6RAAAAACAWlNve/CXlJRkyJAhKS4uzogRIzJ79uxMnjw5xcXFOeecczJ+/PhMmjQpRUVF6d27d12Xy0qUlZXljKsG57oHfpbNOm6b4/Y+P0MH/r+UlS3J6FuOzp/u+0ldlwgAAAAAUKuKysvLy+u6iJpw2GGHZezYsRk+fHguvvjiZeb37ds3zz33XLp06ZL//Oc/dVAh/2vJouSRMcuf//L0J3PyH3bM/jv/KCfsc+HS6YtLF+W7522ejz+Zk7t+9UHNFwoAAAAAsBIDTkoaNqn57dTLHvxTp07NuHHj0q5du5x99tmVtunXr1+SpE+fPhWmP/HEE/nGN76Rdu3aZZ111skOO+yQO+64o8ZrZsXmf/pRkmTd1htVmN64UZOs3aJdmjZpURdlAQAAAADUmXoZ8I8dOzZlZWUZOnRoWrZsWWmbZs2aJakY8D/33HMZNGhQGjZsmGuvvTbjxo1Lx//f3r0GaVnedxz/7YFlWV2NQnRFGQLCpgILm4goSU3EApURM2o8BYOGSRyJB3SGARLN1MZoEMeGhKopyaStMwG71YwYoIcEsYTBjIUYHYK0IhHDabUbqAGC4sL2hS3tlpPgsE/u3c/nDTPXfd1z/599+eV+rqdPn1x11VVZtGhRh8zOwf1RnxE5sceH8vf/8mCWvfRE3tz+m/zmzX/LD/7hq1m36Re5Yeyfl3pEAAAAAIAO1Sl/ZHfp0qVJklGjRh1yz6ZNm5K0D/xNTU0pKyvLggULUlNTkyQZPXp0+vfvn3nz5mX8+PHHcWoOp7bmlNz7hR/nW09+Kff98Jr96zXda/NnN/wonxxyeemGAwAAAAAogU4Z+F9//fUkSd++fQ96vbW1NStWrEjSPvDv2bMnVVVV+9/uT5KKiorU1tZm3759xzzP8OHD09zcfMz3dwVVlT3yvdvWHXZPj+4n5iOnD8nIQZ/JoL6fyI7d2/Lj5x7JzPkT8vUvPJ1z68d00LQAAAAAAIc2sH5g9rTuft/76+rqsmrVqqN+TqcM/Lt27UqS7N598D9gU1NTWlpaUltbm379+u1fnzhxYh555JFMnTo1M2bMSGVlZebOnZt169bl0UcfPeZ5mpubs3nz5mO+vyuo7lZz2OuvbV2dOx7+RCZ/ZnYuGzl5//qoxs/lpr8YktlP3pTHvrI+FeUVx3tUAAAAAIDD2rplS95+9/fH/TmdMvDX1dVl+/bteeGFFzJy5Mh217Zu3Zpp06YlSYYOHZqysrL914YNG5ZnnnkmV155ZWbPnp0kOeGEE/LEE0/kU5/61Aeah8Orquxx2Os/Wj47e1rfzqeHXt1uvbqqJuefc2meXvFw3ti2Ib17nX08xwQAAAAAOKIzevc+6jf4j0WnDPyjR4/O2rVrM2vWrIwZMyb19fVJkpUrV2bixIlpaWlJkjQ2Nra7b926dbn22mtz3nnn5ZZbbklFRUXmzZuX6667LosWLcrFF198TPMcy1crupq9e5Jn5xz6estb730DYm/b3gPv3dv63r/7Wo/LbAAAAAAAR2PdK+tSUXX8n1N+/B/R8aZPn56ePXtm48aNGTx4cBoaGjJw4MCMGDEi/fv33x/q/+/5+0ly1113paamJk899VTGjRuXsWPH5rHHHsv555+fqVOnluKj8N/6nj4oSfKTlX/bbn3n7v/Mcy8/ndoep6R3rwElmAwAAAAAoDQ6ZeA/66yzsnz58lx66aWprq7Ohg0bcuqpp2bu3LlZvHhxXnnllSQHBv7Vq1dn2LBhqaxs/8WG4cOHZ+3atR02Pwe68sI7U1tzan7wj1/JA49PzMKf/1XmP/PNfHn2x7Ltd1vzhUvuc/4+AAAAANCllLW1tbWVeoiOtHPnzpx00kkpKyvLjh07UlPzvz/uetFFF2XLli15+eWX20X+iy66KBs3bsz69etLMXKXcKQjepJkS8v6/HDJvfnlq89k+4430r1bj5zduzFXXHhnLmy4smMGBQAAAAA4glFT0iFH9HTKM/gPZ82aNWlra0t9fX27uJ8kt956a6655ppcccUVufnmm1NRUZH58+dn2bJl+c53vlOiifkfvXudnenXPVbqMQAAAAAA/iB0ucC/evXqJAcez5MkV199dRYuXJhZs2blxhtvzN69e1NfX5958+ZlwoQJHT0qAAAAAAAcksD//4wfPz7jx4/vyJEAAAAAAOCodcof2T2cIwV+AAAAAAAogi73Bv/SpUtLPQIAAAAAAHxgXe4NfgAAAAAA6AwEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACkjgBwAAAACAAhL4AQAAAACggAR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCAukTgb2lpyfTp0zNgwIBUV1enT58+ueOOO7Jr16588YtfTFlZWR5++OFSjwkAAAAAAO9bZakHON5efPHFjBs3Ls3NzTnhhBMyaNCgbNmyJXPmzMn69euzbdu2JEljY2NpB+WItu94I4/95J7869rF2b7zjZxSW5dPDrkiN479ek7s8aFSjwcAAAAA0KE6deBvaWnJZZddlubm5kydOjX33HNPamtrkyQPPvhgZsyYkcrKypSVlWXo0KElnpbD2b7zzdz+l+fnt7/bkksvuDkfOX1INrzxqyz6+Xez+tc/y7dvXZHqqppSjwkAAAAA0GE6deCfMmVKNm3alNtuuy0PPfRQu2vTp0/P/Pnz89JLL6Vfv3456aSTSjQl78fjz3wzb2x/PV+dMD8Xf+xz+9cH9f1EZs6fkB/97Fu5fvTXSjghAAAAAEDH6rRn8K9duzZNTU3p1atXZs6cedA95557bpJk2LBh7daXLFmSCy64INXV1TnttNMyefLkvPXWW8d9Zg7tpfXPpnu3HhnVeF279YuGXZuqyur888q/KdFkAAAAAACl0WkD/+OPP559+/bl+uuvz4knnnjQPT169EjSPvAvW7Ysl1xySc4888w89dRTuf/++/Pkk0/m8ssvT1tbW4fMzoHebX0nVZXVKSsra7deXl6e7t16ZOu2X+etXS0lmg4AAAAAoON12iN6li5dmiQZNWrUIfds2rQpSfvAf++992bgwIF54oknUl7+3v9/9OzZM5/97GezePHijB8//jhOzaH0PX1wNv7Hv+fVzS9mwJmN+9df3fxiduzeniR5c/tvcvIJvUo0IQAAAABAx+q0gf/1119PkvTt2/eg11tbW7NixYok7QP/888/n0mTJu2P+0kyduzYJMmCBQuOKfAPHz48zc3NR31fV1JV2SPfu23dIa9feeGdeW7Ngtz3w2vy5c98O/3qhmTDG2vy3R/fmcqKbmnd+27eeff3HTgxAAAAAMDBDawfmD2tu9/3/rq6uqxateqon9NpA/+uXbuSJLt3H/yP2NTUlJaWltTW1qZfv3771ysqKlJVVdVub7du3VJWVpY1a9Yc0yzNzc3ZvHnzMd3bVVR3qzns9Yb+F+au6/8ujz49JV/760uTJOXlFRk34kvpe/rgrPjVU6np7oeSAQAAAIDS27plS97ugBeSO23gr6ury/bt2/PCCy9k5MiR7a5t3bo106ZNS5IMHTq03bnu9fX1ef7559vtX7lyZdra2rJt27ZjnoXDq6rsccQ9nx52df644cq8tnV1dr+zI2ed9tGccuJpuW3OiFSUV6Z3rwEdMCkAAAAAwOGd0bv3Ub/Bfyw6beAfPXp01q5dm1mzZmXMmDGpr69P8l6snzhxYlpa3vtB1sbGxnb3TZkyJTfccEPuu+++TJ48OZs2bcott9ySioqKdsf2HI1j+WpFV7N3T/LsnCPvqyivaHcG/7bfNefVzb/M0P6fTnXV4b8FAAAAAADQEda9si4VVUfe90EdW7EugOnTp6dnz57ZuHFjBg8enIaGhgwcODAjRoxI//79c/HFFydpf/5+knz+85/PjBkz8o1vfCMf/vCHM3z48IwaNSqNjY0544wzSvFROIR9+/blkaenZF/b3kz4k7tLPQ4AAAAAQIfqtG/wn3XWWVm+fHmmTZuWZcuWZcOGDRk0aFDmzp2bm266KWeffXaSAwN/WVlZHnjggdx999157bXXcuaZZ+bkk09Oz549c/vtt5fio5Bk9zs7c9ucEfnkkCtSd2q/7Hr7rTz74uNZt+kXmXTJ/WkcMKrUIwIAAAAAdKhOG/iT5JxzzsmiRYsOWN+5c2c2bNiQ8vLyDBky5KD31tbWZujQoUmS73//+9m9e3cmTZp0XOfl0CorqtK/97A8+8v5+e2OranuVpP6Puflm1/6p5z30T8t9XgAAAAAAB2uUwf+Q1mzZk3a2tpSX1+fmpr257avWrUqP/3pT/Pxj388ra2tWbJkSebMmZOHHnpo/1v/dLxulVW5+/rHSz0GAAAAAMAfjC4Z+FevXp3kwON5kqR79+5ZuHBhZs6cmdbW1jQ0NKSpqSlXXXVVR48JAAAAAACHJPD/Pw0NDXnuuec6eiQAAAAAADgq5aUeoBQOF/gBAAAAAKAIuuQb/EuXLi31CAAAAAAA8IF0yTf4AQAAAACg6AR+AAAAAAAoIIEfAAAAAAAKSOAHAAAAAIACEvgBAAAAAKCABH4AAAAAACgggR8AAAAAAApI4AcAAAAAgAIS+AEAAAAAoIAEfgAAAAAAKCCBHwAAAAAACqisra2trdRDQFtbsu/dUk8BAAAAAPDBlXdLysqO/3MEfgAAAAAAKCBH9AAAAAAAQAEJ/AAAAAAAUEACPwAAAAAAFJDADwAAAAAABSTwAwAAAABAAQn8AAAAAABQQAI/AAAAAAAUkMAPAAAAAAAFJPADAAAAAEABCfwAAAAAAFBAAj8AAAAAABSQwA8AAAAAAAUk8AMAAAAAQAEJ/AAAAAAAUEACPwAAAAAAFJDADwAAAAAABSTwAwAAAABAAQn8AAAAAABQQAI/AAAAAAAUkMAPAAAAAAAFJPADAAAAAEABCfwAAAAAAFBAAj8AAAAAABSQwA8AAAAAAAUk8AMAAAAAQAH9F2bxnQFWTxAbAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import LieTrotter\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit)\n", - "ansatz.decompose().draw(output = 'mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run VQE\n", - "We are now ready to run a full VQE on the ansatz that we have so far. We use the cost function and the Estimator primitive as defined above and randomly initiate the parameters to be optimized." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[3.36448432]\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -7.966906275781369\n", - " x: [ 3.024e+00]\n", - " nfev: 24\n", - " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 24 F =-7.966906E+00 MAXCV = 0.000000E+00\n", - " X = 3.023952E+00\n", - "\n" - ] - } - ], - "source": [ - "from scipy.optimize import minimize\n", - "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Step 4: Post-process, return result in classical format\n", - "We now interpret the results and decide if we need another iteration of the algorithm." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found ground energy: -7.966906275781369\n", - "[3.02395229]\n" - ] - } - ], - "source": [ - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}\")\n", - "\n", - "# Optimal parameters so far\n", - "x_opt = getattr(res, 'x')\n", - "print(x_opt)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.00708851 0. 0. -0.00171134 0.00708851 0.\n", - " 0. -0.00171134 -0.01804218 0. 0. 0.07148705\n", - " 0. -0.04084253 0. 0. 0. 0.\n", - " -0.04084253 0. 0.07148705 0. 0. 0.00020266]\n", - "Found maximum gradient 0.07148705093020453 at index 11\n", - "Maximum gradient is below the threshold: False\n" - ] - } - ], - "source": [ - "gradient_threshold = 1e-3\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "\n", - "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", - "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Initiate the list of operators with the first one \n", - "operator_list = [max_operator]\n", - "# Append the second operator\n", - "operator_list.append(excitation_pool[max_index])\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", - "ansatz.decompose().draw(output = 'mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2.43769306 4.84557052]\n", - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -7.96868416874958\n", - " x: [ 3.023e+00 6.333e+00]\n", - " nfev: 38\n", - " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 38 F =-7.968684E+00 MAXCV = 0.000000E+00\n", - " X = 3.023366E+00 6.332824E+00\n", - "\n", - "Found ground energy: -7.96868416874958\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)\n", - "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Putting it all together\n", - "Now we automate the algorithm in a single loop." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iter: 0\n", - "Maximum gradient: 0.2502515943160275\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.966906284793598\n", - " Iterations: 2\n", - " Function evaluations: 5\n", - " Gradient evaluations: 2\n", - "Result at iter 0: -7.966906284793598\n", - "Iter: 1\n", - "Maximum gradient: 0.07148481503619701\n", - "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 11\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.968684135389207\n", - " Iterations: 6\n", - " Function evaluations: 21\n", - " Gradient evaluations: 6\n", - "Result at iter 1: -7.968684135389207\n", - "Iter: 2\n", - "Maximum gradient: 0.06885672251558851\n", - "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 20\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970337065973196\n", - " Iterations: 6\n", - " Function evaluations: 27\n", - " Gradient evaluations: 6\n", - "Result at iter 2: -7.970337065973196\n", - "Iter: 3\n", - "Maximum gradient: 0.03791655571908455\n", - "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 13\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970872496782351\n", - " Iterations: 7\n", - " Function evaluations: 37\n", - " Gradient evaluations: 7\n", - "Result at iter 3: -7.970872496782351\n", - "Iter: 4\n", - "Maximum gradient: 0.0370299474918533\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971383218746653\n", - " Iterations: 20\n", - " Function evaluations: 135\n", - " Gradient evaluations: 20\n", - "Result at iter 4: -7.971383218746653\n", - "Iter: 5\n", - "Maximum gradient: 0.03224685854317715\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971773202172484\n", - " Iterations: 18\n", - " Function evaluations: 134\n", - " Gradient evaluations: 18\n", - "Result at iter 5: -7.971773202172484\n", - "Iter: 6\n", - "Maximum gradient: 0.010705739242569776\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971978831060897\n", - " Iterations: 16\n", - " Function evaluations: 132\n", - " Gradient evaluations: 16\n", - "Result at iter 6: -7.971978831060897\n", - "Iter: 7\n", - "Maximum gradient: 0.009717164674363968\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.968225393431566\n", - " Iterations: 13\n", - " Function evaluations: 120\n", - " Gradient evaluations: 13\n", - "Result at iter 7: -7.968225393431566\n", - "Iter: 8\n", - "Maximum gradient: 0.06816889310847103\n", - "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 20\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.969120334779275\n", - " Iterations: 15\n", - " Function evaluations: 153\n", - " Gradient evaluations: 15\n", - "Result at iter 8: -7.969120334779275\n", - "Iter: 9\n", - "Maximum gradient: 0.07060449874596993\n", - "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 11\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.9716270972513525\n", - " Iterations: 40\n", - " Function evaluations: 443\n", - " Gradient evaluations: 40\n", - "Result at iter 9: -7.9716270972513525\n", - "Iter: 10\n", - "Maximum gradient: 0.020853916020903765\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970921582203872\n", - " Iterations: 24\n", - " Function evaluations: 290\n", - " Gradient evaluations: 24\n", - "Result at iter 10: -7.970921582203872\n", - "Iter: 11\n", - "Maximum gradient: 0.04232508018126495\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.97174310731302\n", - " Iterations: 21\n", - " Function evaluations: 276\n", - " Gradient evaluations: 21\n", - "Result at iter 11: -7.97174310731302\n", - "Iter: 12\n", - "Maximum gradient: 0.01114875020605062\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972156543559216\n", - " Iterations: 29\n", - " Function evaluations: 411\n", - " Gradient evaluations: 29\n", - "Result at iter 12: -7.972156543559216\n", - "Iter: 13\n", - "Maximum gradient: 0.005734779272457883\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972174887679361\n", - " Iterations: 36\n", - " Function evaluations: 543\n", - " Gradient evaluations: 36\n", - "Result at iter 13: -7.972174887679361\n", - "Iter: 14\n", - "Maximum gradient: 0.002736550362458665\n", - "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", - "Iteration limit reached (Exit mode 9)\n", - " Current function value: -7.972132265604596\n", - " Iterations: 50\n", - " Function evaluations: 803\n", - " Gradient evaluations: 50\n", - "Result at iter 14: -7.972132265604596\n", - "Terminating: reached maximum iteration.\n", - "Found ground energy: -7.972132265604596\n" - ] - } - ], - "source": [ - "from qiskit.primitives import Estimator\n", - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import LieTrotter\n", - "from scipy.optimize import minimize\n", - "\n", - "\n", - "# Define the conditions for termination\n", - "gradient_threshold = 1e-3\n", - "max_iter = 15\n", - "terminate = False\n", - "\n", - "# Initiate the problem\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "excitation_pool = single_excitation_operators + double_excitation_operators\n", - "estimator = Estimator()\n", - "params = None\n", - "\n", - "iter = 0\n", - "operator_list = []\n", - "while not terminate:\n", - " print(f\"Iter: {iter}\")\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " print(f\"Maximum gradient: {max_gradient}\")\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(np.abs(gradients))\n", - " max_operator = excitation_pool[max_index]\n", - " print(f\"Operator: {max_operator} at index {max_index}\")\n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, 'x')\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " print(\"Terminating: reached maximum iteration.\")\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " print(\"Terminating: converged.\")\n", - " terminate = True\n", - " \n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iter: 0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:927: UserWarning: Starting a session using the /jobs endpoint will no longer be supported after March 31, 2024. Please update your code as soon as possible before this date. If you are using qiskit-ibm-runtime, you will need version 0.20.0 or higher. If you are using qiskit-ibm-provider, you will need version 0.10.0 or higher. If you are calling the API directly, please use the /sessions endpoint instead.\n", - " warnings.warn(warning_message)\n" - ] - } - ], - "source": [ - "# To continue running on real hardware use\n", - "from qiskit_ibm_runtime import Estimator, Session, Options\n", - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import LieTrotter\n", - "from scipy.optimize import minimize\n", - "\n", - "\n", - "hf_circuit_ibm = pm.run(hf_circuit)\n", - "H_ibm = H.apply_layout(hf_circuit_ibm.layout) \n", - "\n", - "# Define the conditions for termination\n", - "gradient_threshold = 5e-3\n", - "max_iter = 15\n", - "terminate = False\n", - "\n", - "with Session(backend=backend):\n", - " session_options = Options()\n", - " session_options.execution.shots = 2000\n", - " session_options.resilience_level = 1\n", - "\n", - " # Initiate the problem\n", - " ansatz = hf_circuit_ibm\n", - " hamiltonian = H_ibm\n", - " excitation_pool = single_excitation_operators + double_excitation_operators\n", - " estimator = Estimator(session=Session(service, backend=backend), options=session_options)\n", - " params = None\n", - "\n", - " iter = 0\n", - " operator_list = []\n", - " while not terminate:\n", - " print(f\"Iter: {iter}\")\n", - " excitation_pool_ibm = [exc.apply_layout(ansatz.layout) for exc in excitation_pool]\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool_ibm, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " print(f\"Maximum gradient: {max_gradient}\")\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(np.abs(gradients))\n", - " max_operator = excitation_pool[max_index]\n", - " print(f\"Operator: {max_operator} at index {max_index}\")\n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", - " ansatz = pm.run(ansatz)\n", - " hamiltonian = H.apply_layout(ansatz.layout) \n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(cost_func, x0, args=(ansatz, hamiltonian, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, 'x')\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " print(\"Terminating: reached maximum iteration.\")\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " print(\"Terminating: converged.\")\n", - " terminate = True\n", - " \n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "quantum", - "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.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/quantum_enablement/tutorials/adapt-vqe.ipynb b/quantum_enablement/tutorials/adapt-vqe.ipynb index 9724f8e..ae9f8e2 100644 --- a/quantum_enablement/tutorials/adapt-vqe.ipynb +++ b/quantum_enablement/tutorials/adapt-vqe.ipynb @@ -20,6 +20,12 @@ "We note the following variants of the ADAPT-VQE algorithm:\n", "- A hardware-efficient variant called qubit-ADAPT-VQE, which reduces the circuit depth by constructing the pool directly with individual Pauli operators: https://arxiv.org/abs/1911.10205.\n", "- A utility scale ADAPT-VQE experiment for the Schwinger model using up to 100 qubits of IBM Quantum devices: https://arxiv.org/abs/2308.04481.\n", + "\n", + "In the following, we define the problem and implement the algorithm using Qiskit Patterns formalism in 4 steps:\n", + "1. Map classical inputs to a quantum problem\n", + "2. Optimize problem for quantum execution\n", + "3. Execute using Qiskit Primitives\n", + "4. Post-process and return result in classical format\n", "\n" ] }, @@ -29,7 +35,7 @@ "source": [ "### Define the molecule\n", "We start by defining the molecule using ``pyscf``. As an example we select LiH and build it by providing its geometry.\n", - "This part of the code is based on ``Example_Molecules.ipynb`` jupyter notebook found at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." + "Code to generate additional molecules can be found in ``Example_Molecules.ipynb`` at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." ] }, { @@ -40,7 +46,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -60,8 +66,8 @@ " basis=\"sto-6g\",\n", " spin=0,\n", " charge=0,\n", - " symmetry=\"Coov\", \n", - " )\n" + " symmetry=\"Coov\",\n", + ")" ] }, { @@ -112,6 +118,14 @@ "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 1: Map classical inputs to a quantum problem\n", + "We will map the Hamiltonian operator, the initial state and the operator pool of the ansatz to a quantum problem using the Jordan-Wigner transform. We also define functions to compute gradients and the cost of these operators." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -126,7 +140,7 @@ "metadata": {}, "outputs": [], "source": [ - "#------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", + "# ------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", "\n", "import numpy as np\n", "from qiskit.quantum_info import SparsePauliOp\n", @@ -191,10 +205,7 @@ " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", " for r in range(p + 1, ncas):\n", " Excp.append(\n", - " C[p] @ D[r]\n", - " + C[ncas + p] @ D[ncas + r]\n", - " + C[r] @ D[p]\n", - " + C[ncas + r] @ D[ncas + p]\n", + " C[p] @ D[r] + C[ncas + p] @ D[ncas + r] + C[r] @ D[p] + C[ncas + r] @ D[ncas + p]\n", " )\n", " Exc.append(Excp)\n", "\n", @@ -237,36 +248,6 @@ "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Reference value\n", - "We compute the exact ground state energy of the Hamiltonian below to compare later with the algorithm." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Exact ground state of the Hamiltonian: -7.97217974623641\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "H_matrix = H.to_matrix()\n", - "eigvals = np.linalg.eigvals(H_matrix)\n", - "min_eigval = np.min(eigvals).real\n", - "print(f\"Exact ground state of the Hamiltonian: {min_eigval}\")\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -277,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -310,8 +291,10 @@ " return bitstr.tolist()\n", "\n", "\n", - "def hartree_fock_circuit(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> QuantumCircuit:\n", - " \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing \n", + "def hartree_fock_circuit(\n", + " num_spatial_orbitals: int, num_particles: tuple[int, int]\n", + ") -> QuantumCircuit:\n", + " \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing\n", " the Hartree-Fock state for the specified system.\n", " Args:\n", " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", @@ -323,14 +306,14 @@ " # Get the Hartree-Fock initial state in boolean bitstring representation\n", " hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", "\n", - " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an \n", + " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an\n", " # X-gate as indicated by the boolean list\n", " hf_circuit = QuantumCircuit(len(hf_bitstring))\n", " for i, hf_bit in enumerate(hf_bitstring):\n", " if hf_bit:\n", " hf_circuit.x(i)\n", - " \n", - " return hf_circuit\n" + "\n", + " return hf_circuit" ] }, { @@ -342,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -360,7 +343,7 @@ "
" ] }, - "execution_count": 36, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -370,28 +353,7 @@ "num_particles = mx.nelecas\n", "\n", "hf_circuit = hartree_fock_circuit(num_spatial_orbitals, num_particles)\n", - "hf_circuit.draw(output = 'mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hartree-Fock energy: -7.95213012467435, exact_energy: -7.97217974623641, difference: 0.020049621562059805\n" - ] - } - ], - "source": [ - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", - "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", - "print(f\"Hartree-Fock energy: {hf_energy}, exact_energy: {min_eigval}, difference: {hf_energy - min_eigval}\")" + "hf_circuit.draw(output=\"mpl\")" ] }, { @@ -399,17 +361,19 @@ "metadata": {}, "source": [ "### Operator pool\n", - "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we omit the complex phase 1j for simplicity. Therefore, they appear Hermitian." + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we multiply them with the complex phase 1j so that they appear Hermitian." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "def single_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", - " \"\"\"Compute single excitation operators under the Jordan-Wigner transform \n", + "def single_excitation(\n", + " num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n", + ") -> list[SparsePauliOp]:\n", + " \"\"\"Compute single excitation operators under the Jordan-Wigner transform\n", " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", " Args:\n", " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", @@ -438,18 +402,20 @@ " if r not in indices_beta:\n", " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", " single_excitation_operators.append(exc)\n", - " \n", + "\n", " return single_excitation_operators" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "def double_excitation(num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\") -> list[SparsePauliOp]:\n", - " \"\"\"Compute double excitation operators under the Jordan-Wigner transform \n", + "def double_excitation(\n", + " num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n", + ") -> list[SparsePauliOp]:\n", + " \"\"\"Compute double excitation operators under the Jordan-Wigner transform\n", " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", " Args:\n", " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", @@ -475,7 +441,9 @@ " # to these indices\n", " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", " for b in range(a + 1, half_orbitals):\n", - " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " exc = (\n", + " 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " )\n", " double_excitation_operators.append(exc)\n", "\n", " # Both excitations from beta\n", @@ -486,7 +454,9 @@ " # to these indices\n", " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", " for b in range(a + 1, 2 * half_orbitals):\n", - " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " exc = (\n", + " 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " )\n", " double_excitation_operators.append(exc)\n", "\n", " # One excitation from alpha, one from beta\n", @@ -498,13 +468,13 @@ " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", " double_excitation_operators.append(exc)\n", - " \n", - " return double_excitation_operators\n" + "\n", + " return double_excitation_operators" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -536,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -570,13 +540,159 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter. For now, we use an exact simulator by defining the options of the Qiskit Estimator primitive." + "### Cost function\n", + "We define the cost function as the expectation value of the Hamiltonian operator given an ansatz with its parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 2: Optimize problem for quantum execution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by selecting a backend for execution." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibm_kyoto\n" + ] + } + ], + "source": [ + "# To run on hardware:\n", + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "service = QiskitRuntimeService(channel=\"ibm_quantum\", instance=\"ibm-q/open/main\")\n", + "backend = service.least_busy(operational=True, simulator=False)\n", + "print(backend.name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we optimize the circuit for running on a real backend by specifying the optimization_level and adding dynamical decoupling. The code below generates a mass manager using preset pass managers from qiskit.transpiler." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import XGate\n", + "from qiskit.transpiler import PassManager\n", + "from qiskit.transpiler.passes import (\n", + " ALAPScheduleAnalysis,\n", + " ConstrainedReschedule,\n", + " PadDynamicalDecoupling,\n", + ")\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "target = backend.target\n", + "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", + "pm.scheduling = PassManager(\n", + " [\n", + " ALAPScheduleAnalysis(target=target),\n", + " ConstrainedReschedule(target.acquire_alignment, target.pulse_alignment),\n", + " PadDynamicalDecoupling(\n", + " target=target, dd_sequence=[XGate(), XGate()], pulse_alignment=target.pulse_alignment\n", + " ),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we use the pass manager on the initial state. We can similarly apply device layout characteristics to the Hamiltonian to get a more physical representation." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "hf_circuit_ibm = pm.run(hf_circuit)\n", + "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n", + "excitation_pool_ibm = [exc.apply_layout(hf_circuit_ibm.layout) for exc in excitation_pool]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 3: Execute using Qiskit Primitives\n", + "Before we execute on the selected hardware, it is a good idea to use a simulator for cursory debugging, and sometimes for estimates of error. For those reasons, we briefly show how to run ADAPT-VQE on a simulator. But it is critical to note that no classical computer, simulator or GPU can accurately simulate the full functionality of a highly-entangled 127-qubit quantum computer. In the present era of quantum utility, simulators will have limited use." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that for each choice of parameters in the variational circuit, an expectation value must be calculated (since that is the value to be minimized). We do this with the Qiskit Primitive, Estimator." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hartree-Fock energy: -7.95213012467435\n" + ] + } + ], + "source": [ + "# To run on simulator\n", + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator()\n", + "\n", + "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", + "print(f\"Hartree-Fock energy: {hf_energy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -596,11 +712,9 @@ ], "source": [ "import numpy as np\n", - "from qiskit.primitives import Estimator\n", "\n", "ansatz = hf_circuit\n", "hamiltonian = H\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", "\n", "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", "print(gradients)\n", @@ -621,7 +735,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -639,7 +753,7 @@ "
" ] }, - "execution_count": 16, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -648,8 +762,13 @@ "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", "from qiskit.synthesis import LieTrotter\n", "\n", - "ansatz = EvolvedOperatorAnsatz(operators=max_operator, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit)\n", - "ansatz.decompose().draw(output = 'mpl')" + "ansatz = EvolvedOperatorAnsatz(\n", + " operators=max_operator,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + ")\n", + "ansatz.decompose().draw(output=\"mpl\")" ] }, { @@ -664,30 +783,19 @@ "metadata": {}, "source": [ "### Run VQE\n", - "We are now ready to run a full VQE on the ansatz that we have so far. We define the cost function as the expectation of the Hamiltonian as usual, and set up the Estimator primitive and randomly initiate the parameters to be optimized." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", - " return energy" + "We are now ready to run a full VQE on the ansatz that we have so far. We use the cost function and the Estimator primitive as defined above and randomly initiate the parameters to be optimized." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.96645199]\n" + "[1.41042304]\n" ] } ], @@ -706,7 +814,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -716,72 +824,77 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.966906278898801\n", + " fun: -7.966906274198754\n", " x: [ 3.024e+00]\n", - " nfev: 22\n", + " nfev: 24\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 22 F =-7.966906E+00 MAXCV = 0.000000E+00\n", - " X = 3.023969E+00\n", + " NFVALS = 24 F =-7.966906E+00 MAXCV = 0.000000E+00\n", "\n", - "Found ground energy: -7.966906278898801, exact energy: -7.97217974623641, difference: 0.005273467337609361\n" + " X = 3.024148E+00\n" ] } ], "source": [ "from scipy.optimize import minimize\n", "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", - "print(res)\n", - "\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {min_eigval}, difference: {ground_energy - min_eigval}\")" + "res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, H, estimator),\n", + " method=\"cobyla\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + ")\n", + "print(res)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Post-process, return result in classical format\n", + "We now interpret the results and decide if we need another iteration of the algorithm." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.02396918]\n" + "Found ground energy: -7.966906274198754\n", + "[3.02414843]\n" ] } ], "source": [ + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")\n", + "\n", "# Optimal parameters so far\n", - "x_opt = getattr(res, 'x')\n", + "x_opt = getattr(res, \"x\")\n", "print(x_opt)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another iteration of the algorithm\n", - "We now compute the gradients again to see if we need another iteration." - ] - }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00708751 0. 0. -0.00171107 0.00708751 0.\n", - " 0. -0.00171107 -0.0180431 0. 0. 0.07148652\n", - " 0. -0.04084337 0. 0. 0. 0.\n", - " -0.04084337 0. 0.07148652 0. 0. 0.00016635]\n", - "Found maximum gradient 0.07148652482967087 at index 11\n", + "[ 0.00707691 0. 0. -0.00170823 0.00707691 0.\n", + " 0. -0.00170823 -0.01805292 0. 0. 0.07148094\n", + " 0. -0.04085228 0. 0. 0. 0.\n", + " -0.04085228 0. 0.07148094 0. 0. -0.0002188 ]\n", + "Found maximum gradient 0.07148094085709761 at index 11\n", "Maximum gradient is below the threshold: False\n" ] } @@ -808,17 +921,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, { "data": { "image/png": "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", @@ -826,19 +931,24 @@ "
" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Initiate the list of operators with the first one \n", + "# Initiate the list of operators with the first one\n", "operator_list = [max_operator]\n", "# Append the second operator\n", "operator_list.append(excitation_pool[max_index])\n", "\n", - "ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", - "ansatz.decompose().draw(output = 'mpl')" + "ansatz = EvolvedOperatorAnsatz(\n", + " operators=operator_list,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + ")\n", + "ansatz.decompose().draw(output=\"mpl\")" ] }, { @@ -850,20 +960,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "[3.3397298 2.86894403]\n", + "[2.14630704 5.75231296]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.9686841760049925\n", - " x: [ 3.260e+00 3.191e+00]\n", - " nfev: 31\n", + " fun: -7.9686841642530375\n", + " x: [ 3.023e+00 6.333e+00]\n", + " nfev: 40\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 31 F =-7.968684E+00 MAXCV = 0.000000E+00\n", - " X = 3.259967E+00 3.191270E+00\n", + " NFVALS = 40 F =-7.968684E+00 MAXCV = 0.000000E+00\n", + " X = 3.023174E+00 6.332813E+00\n", "\n", - "Found ground energy: -7.9686841760049925, exact energy: -7.97217974623641, difference: 0.003495570231417666\n" + "Found ground energy: -7.9686841642530375\n" ] } ], @@ -872,19 +982,25 @@ "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", "print(x0)\n", "\n", - "res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"cobyla\", options={'maxiter': 50, 'disp': True})\n", + "res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, H, estimator),\n", + " method=\"cobyla\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + ")\n", "print(res)\n", "\n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {min_eigval}, difference: {ground_energy - min_eigval}\")" + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Putting it all together\n", + "## Putting it all together\n", "Now we automate the algorithm in a single loop." ] }, @@ -903,127 +1019,174 @@ " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.966906285252653\n", - " Iterations: 6\n", - " Function evaluations: 14\n", - " Gradient evaluations: 6\n", - "Result at iter 0: -7.966906285252653\n", + " Current function value: -7.966906284793598\n", + " Iterations: 2\n", + " Function evaluations: 5\n", + " Gradient evaluations: 2\n", + "Result at iter 0: -7.966906284793598\n", "Iter: 1\n", - "Maximum gradient: 0.07148439188181017\n", + "Maximum gradient: 0.07148481503619701\n", "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.968684170219699\n", + " Current function value: -7.968684135389207\n", " Iterations: 6\n", - " Function evaluations: 18\n", + " Function evaluations: 21\n", " Gradient evaluations: 6\n", - "Result at iter 1: -7.968684170219699\n", + "Result at iter 1: -7.968684135389207\n", "Iter: 2\n", - "Maximum gradient: 0.06886672061476416\n", + "Maximum gradient: 0.06885672251558851\n", "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970337004852715\n", + " Current function value: -7.970337065973196\n", " Iterations: 6\n", - " Function evaluations: 24\n", + " Function evaluations: 27\n", " Gradient evaluations: 6\n", - "Result at iter 2: -7.970337004852715\n", + "Result at iter 2: -7.970337065973196\n", "Iter: 3\n", - "Maximum gradient: 0.03793394213567434\n", + "Maximum gradient: 0.03791655571908455\n", "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 13\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970872587753581\n", - " Iterations: 8\n", - " Function evaluations: 45\n", - " Gradient evaluations: 8\n", - "Result at iter 3: -7.970872587753581\n", + " Current function value: -7.970872496782351\n", + " Iterations: 7\n", + " Function evaluations: 37\n", + " Gradient evaluations: 7\n", + "Result at iter 3: -7.970872496782351\n", "Iter: 4\n", - "Maximum gradient: 0.037038123475672986\n", + "Maximum gradient: 0.0370299474918533\n", "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 18\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971382963416607\n", - " Iterations: 21\n", - " Function evaluations: 132\n", - " Gradient evaluations: 21\n", - "Result at iter 4: -7.971382963416607\n", + " Current function value: -7.971383218746653\n", + " Iterations: 20\n", + " Function evaluations: 135\n", + " Gradient evaluations: 20\n", + "Result at iter 4: -7.971383218746653\n", "Iter: 5\n", - "Maximum gradient: 0.03229833589401405\n", + "Maximum gradient: 0.03224685854317715\n", "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971773233908281\n", - " Iterations: 20\n", - " Function evaluations: 151\n", - " Gradient evaluations: 20\n", - "Result at iter 5: -7.971773233908281\n", + " Current function value: -7.971773202172484\n", + " Iterations: 18\n", + " Function evaluations: 134\n", + " Gradient evaluations: 18\n", + "Result at iter 5: -7.971773202172484\n", "Iter: 6\n", - "Maximum gradient: 0.01078583265147669\n", + "Maximum gradient: 0.010705739242569776\n", "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.9719789847206\n", - " Iterations: 21\n", - " Function evaluations: 177\n", - " Gradient evaluations: 21\n", - "Result at iter 6: -7.9719789847206\n", + " Current function value: -7.971978831060897\n", + " Iterations: 16\n", + " Function evaluations: 132\n", + " Gradient evaluations: 16\n", + "Result at iter 6: -7.971978831060897\n", "Iter: 7\n", - "Maximum gradient: 0.009758560644558783\n", + "Maximum gradient: 0.009717164674363968\n", "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972146459034053\n", - " Iterations: 15\n", - " Function evaluations: 140\n", - " Gradient evaluations: 15\n", - "Result at iter 7: -7.972146459034053\n", + " Current function value: -7.968225393431566\n", + " Iterations: 13\n", + " Function evaluations: 120\n", + " Gradient evaluations: 13\n", + "Result at iter 7: -7.968225393431566\n", "Iter: 8\n", - "Maximum gradient: 0.007087554378849258\n", - "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", + "Maximum gradient: 0.06816889310847103\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.969773091701047\n", - " Iterations: 32\n", - " Function evaluations: 321\n", - " Gradient evaluations: 32\n", - "Result at iter 8: -7.969773091701047\n", + " Current function value: -7.969120334779275\n", + " Iterations: 15\n", + " Function evaluations: 153\n", + " Gradient evaluations: 15\n", + "Result at iter 8: -7.969120334779275\n", "Iter: 9\n", - "Maximum gradient: 0.06970259970154505\n", + "Maximum gradient: 0.07060449874596993\n", "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 11\n", - "Iteration limit reached (Exit mode 9)\n", - " Current function value: -7.972003744865285\n", - " Iterations: 50\n", - " Function evaluations: 554\n", - " Gradient evaluations: 50\n", - "Result at iter 9: -7.972003744865285\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.9716270972513525\n", + " Iterations: 40\n", + " Function evaluations: 443\n", + " Gradient evaluations: 40\n", + "Result at iter 9: -7.9716270972513525\n", "Iter: 10\n", - "Maximum gradient: 0.010146956387318147\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Maximum gradient: 0.020853916020903765\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.970921582203872\n", + " Iterations: 24\n", + " Function evaluations: 290\n", + " Gradient evaluations: 24\n", + "Result at iter 10: -7.970921582203872\n", + "Iter: 11\n", + "Maximum gradient: 0.04232508018126495\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.97174310731302\n", + " Iterations: 21\n", + " Function evaluations: 276\n", + " Gradient evaluations: 21\n", + "Result at iter 11: -7.97174310731302\n", + "Iter: 12\n", + "Maximum gradient: 0.01114875020605062\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972177628337713\n", + " Current function value: -7.972156543559216\n", + " Iterations: 29\n", + " Function evaluations: 411\n", + " Gradient evaluations: 29\n", + "Result at iter 12: -7.972156543559216\n", + "Iter: 13\n", + "Maximum gradient: 0.005734779272457883\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.972174887679361\n", " Iterations: 36\n", - " Function evaluations: 437\n", + " Function evaluations: 543\n", " Gradient evaluations: 36\n", - "Result at iter 10: -7.972177628337713\n", - "Iter: 11\n", - "Maximum gradient: 0.0014615495206443262\n", - "Terminating: converged.\n", - "Found ground energy: -7.972177628337713, exact energy: -7.97217974623641, difference: 2.1178986973069414e-06\n" + "Result at iter 13: -7.972174887679361\n", + "Iter: 14\n", + "Maximum gradient: 0.002736550362458665\n", + "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", + "Iteration limit reached (Exit mode 9)\n", + " Current function value: -7.972132265604596\n", + " Iterations: 50\n", + " Function evaluations: 803\n", + " Gradient evaluations: 50\n", + "Result at iter 14: -7.972132265604596\n", + "Terminating: reached maximum iteration.\n", + "Found ground energy: -7.972132265604596\n" ] } ], "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.primitives import Estimator\n", + "from qiskit.synthesis import LieTrotter\n", + "from scipy.optimize import minimize\n", + "\n", "# Define the conditions for termination\n", - "gradient_threshold = 5e-3\n", + "gradient_threshold = 1e-3\n", "max_iter = 15\n", "terminate = False\n", "\n", @@ -1031,7 +1194,7 @@ "ansatz = hf_circuit\n", "hamiltonian = H\n", "excitation_pool = single_excitation_operators + double_excitation_operators\n", - "estimator = Estimator(options={\"shots\": None, \"approximation\": True})\n", + "estimator = Estimator()\n", "params = None\n", "\n", "iter = 0\n", @@ -1049,12 +1212,23 @@ " print(f\"Operator: {max_operator} at index {max_index}\")\n", " # Grow the ansatz\n", " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(operators=operator_list, evolution=LieTrotter(), parameter_prefix='theta', initial_state=hf_circuit) \n", + " ansatz = EvolvedOperatorAnsatz(\n", + " operators=operator_list,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + " )\n", " # Run VQE on the current ansatz\n", " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(cost_func, x0, args=(ansatz, H, estimator), method=\"slsqp\", options={'maxiter': 50, 'disp': True})\n", + " res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, H, estimator),\n", + " method=\"slsqp\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + " )\n", " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, 'x')\n", + " x_opt = getattr(res, \"x\")\n", " params = x_opt\n", " # Terminate if maximum number of iterations reached\n", " iter += 1\n", @@ -1065,10 +1239,110 @@ " else:\n", " print(\"Terminating: converged.\")\n", " terminate = True\n", - " \n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:927: UserWarning: Starting a session using the /jobs endpoint will no longer be supported after March 31, 2024. Please update your code as soon as possible before this date. If you are using qiskit-ibm-runtime, you will need version 0.20.0 or higher. If you are using qiskit-ibm-provider, you will need version 0.10.0 or higher. If you are calling the API directly, please use the /sessions endpoint instead.\n", + " warnings.warn(warning_message)\n" + ] + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter\n", + "\n", + "# To continue running on real hardware use\n", + "from qiskit_ibm_runtime import Estimator, Options, Session\n", + "from scipy.optimize import minimize\n", + "\n", + "hf_circuit_ibm = pm.run(hf_circuit)\n", + "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n", + "\n", + "# Define the conditions for termination\n", + "gradient_threshold = 5e-3\n", + "max_iter = 15\n", + "terminate = False\n", + "\n", + "with Session(backend=backend):\n", + " session_options = Options()\n", + " session_options.execution.shots = 2000\n", + " session_options.resilience_level = 1\n", + "\n", + " # Initiate the problem\n", + " ansatz = hf_circuit_ibm\n", + " hamiltonian = H_ibm\n", + " excitation_pool = single_excitation_operators + double_excitation_operators\n", + " estimator = Estimator(session=Session(service, backend=backend), options=session_options)\n", + " params = None\n", + "\n", + " iter = 0\n", + " operator_list = []\n", + " while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " excitation_pool_ibm = [exc.apply_layout(ansatz.layout) for exc in excitation_pool]\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool_ibm, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(\n", + " operators=operator_list,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + " )\n", + " ansatz = pm.run(ansatz)\n", + " hamiltonian = H.apply_layout(ansatz.layout)\n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, hamiltonian, estimator),\n", + " method=\"slsqp\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + " )\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, \"x\")\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration.\")\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " print(\"Terminating: converged.\")\n", + " terminate = True\n", + "\n", "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, 'fun')\n", - "print(f\"Found ground energy: {ground_energy}, exact energy: {min_eigval}, difference: {ground_energy - min_eigval}\")" + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")" ] } ], From 91929b9ea267288927a32955ee299ec07d92ef9e Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Thu, 28 Mar 2024 21:05:55 -0700 Subject: [PATCH 15/17] make requested changes --- docs/tutorials/adapt-vqe.ipynb | 1301 +++++++++++++++++ quantum_enablement/tutorials/adapt-vqe.ipynb | 1370 ------------------ 2 files changed, 1301 insertions(+), 1370 deletions(-) create mode 100644 docs/tutorials/adapt-vqe.ipynb delete mode 100644 quantum_enablement/tutorials/adapt-vqe.ipynb diff --git a/docs/tutorials/adapt-vqe.ipynb b/docs/tutorials/adapt-vqe.ipynb new file mode 100644 index 0000000..cf58921 --- /dev/null +++ b/docs/tutorials/adapt-vqe.ipynb @@ -0,0 +1,1301 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit ADAPT-VQE tutorial\n", + "\n", + "[ADAPT-VQE](https://www.nature.com/articles/s41467-019-10988-2) is a variation of the original VQE algorithm, which grows the ansatz at each iteration by selecting operators from an operator pool. This typically results in shorter depth circuits than fixed-depth ansatze designed for VQE. For a ground state estimation problem from the quantum chemistry domain, steps are outlined as follows.\n", + "\n", + "1. We find the fermionic Hamiltonian by defining the molecular geometry, and map it onto qubit representation using a mapper such as the Jordan-Wigner transform. \n", + "2. The quantum computer is typically initiated in the Hartree-Fock state under the same transformation as an estimate to the ground state energy.\n", + "3. We define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian.\n", + "4. Until the algorithm terminates:\n", + " - we compute the gradient of each operator from the pool and select the operator with the maximum gradient,\n", + " - grow the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$,\n", + " - run VQE over all parameters $\\theta_i$,\n", + " - and terminate the algorithm if the gradient of all operators from the pool are smaller than some threshold (convergence) or if we reach the maximum number of allowed iterations.\n", + "\n", + "We note the following variants of the ADAPT-VQE algorithm:\n", + "- A hardware-efficient variant called [qubit-ADAPT-VQE](https://arxiv.org/abs/1911.10205), which reduces the circuit depth by constructing the pool directly with individual Pauli operators.\n", + "- A [utility scale ADAPT-VQE experiment](https://arxiv.org/abs/2308.04481) for the Schwinger model using up to 100 qubits of IBM Quantum devices.\n", + "\n", + "In the following, we define the problem and implement the algorithm using Qiskit Patterns formalism in 4 steps:\n", + "1. Map classical inputs to a quantum problem\n", + "2. Optimize problem for quantum execution\n", + "3. Execute using Qiskit Primitives\n", + "4. Post-process and return result in classical format\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the molecule\n", + "We start by defining the molecule using ``pyscf``. As an example we select LiH and build it by providing its geometry.\n", + "Code to generate additional molecules can be found in at [``Example_Molecules.ipynb``](https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyscf import ao2mo, gto, mcscf, scf\n", + "\n", + "# LiH\n", + "distance = 1.59\n", + "mol = gto.Mole()\n", + "mol.build(\n", + " verbose=0,\n", + " atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n", + " basis=\"sto-6g\",\n", + " spin=0,\n", + " charge=0,\n", + " symmetry=\"Coov\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nuclear energy: 0.998447567773585\n", + "Electronic energy: -8.950577623117868\n", + "Total energy: -7.952130055344282\n", + "Total energy - nuclear energy: -8.950577623117868\n" + ] + } + ], + "source": [ + "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", + "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", + "print(f\"Total energy: {mol.energy_tot()}\")\n", + "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the fermionic Hamiltonian\n", + "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mf = scf.RHF(mol)\n", + "E1 = mf.kernel()\n", + "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", + "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n", + "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", + "E2 = mx.kernel(mo)[:2]\n", + "\n", + "h1e, ecore = mx.get_h1eff()\n", + "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 1: Map classical inputs to a quantum problem\n", + "We will map the Hamiltonian operator, the initial state and the operator pool of the ansatz to a quantum problem using the Jordan-Wigner transform. We also define functions to compute gradients and the cost of these operators." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map the fermionic Hamiltonian to a qubit operator\n", + "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented [here](https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# ------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", + "\n", + "import numpy as np\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "\n", + "def cholesky(V, eps):\n", + " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", + " # see https://arxiv.org/abs/1808.02625\n", + " # see https://arxiv.org/abs/2104.08957\n", + " no = V.shape[0]\n", + " chmax, ng = 20 * no, 0\n", + " W = V.reshape(no**2, no**2)\n", + " L = np.zeros((no**2, chmax))\n", + " Dmax = np.diagonal(W).copy()\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " while vmax > eps:\n", + " L[:, ng] = W[:, nu_max]\n", + " if ng > 0:\n", + " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", + " L[:, ng] /= np.sqrt(vmax)\n", + " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", + " ng += 1\n", + " nu_max = np.argmax(Dmax)\n", + " vmax = Dmax[nu_max]\n", + " L = L[:, :ng].reshape((no, no, ng))\n", + " print(\n", + " \"accuracy of Cholesky decomposition \",\n", + " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", + " )\n", + " return L, ng\n", + "\n", + "\n", + "def identity(n):\n", + " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", + "\n", + "\n", + "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", + " c_list = []\n", + " if mapping == \"jordan_wigner\":\n", + " for p in range(n):\n", + " if p == 0:\n", + " l, r = \"I\" * (n - 1), \"\"\n", + " elif p == n - 1:\n", + " l, r = \"\", \"Z\" * (n - 1)\n", + " else:\n", + " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", + " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, -0.5j)])\n", + " c_list.append(cp)\n", + " else:\n", + " raise ValueError(\"Unsupported mapping.\")\n", + " d_list = [cp.adjoint() for cp in c_list]\n", + " return c_list, d_list\n", + "\n", + "\n", + "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", + " ncas, _ = h1e.shape\n", + "\n", + " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", + " Exc = []\n", + " for p in range(ncas):\n", + " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", + " for r in range(p + 1, ncas):\n", + " Excp.append(\n", + " C[p] @ D[r] + C[ncas + p] @ D[ncas + r] + C[r] @ D[p] + C[ncas + r] @ D[ncas + p]\n", + " )\n", + " Exc.append(Excp)\n", + "\n", + " # low-rank decomposition of the Hamiltonian\n", + " Lop, ng = cholesky(h2e, 1e-6)\n", + " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", + "\n", + " H = ecore * identity(2 * ncas)\n", + " # one-body term\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " H += t1e[p, r] * Exc[p][r - p]\n", + " # two-body term\n", + " for g in range(ng):\n", + " Lg = 0 * identity(2 * ncas)\n", + " for p in range(ncas):\n", + " for r in range(p, ncas):\n", + " Lg += Lop[p, r, g] * Exc[p][r - p]\n", + " H += 0.5 * Lg @ Lg\n", + "\n", + " return H.chop().simplify()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy of Cholesky decomposition 1.1796119636642288e-16\n", + "The Hamiltonian consists of 276 10-qubit Pauli operators.\n" + ] + } + ], + "source": [ + "H = build_hamiltonian(ecore, h1e, h2e)\n", + "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial state\n", + "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we implement using the functions below." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "\n", + "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", + " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", + " Raises:\n", + " ValueError: If the total number of particles is larger than the number of orbitals.\n", + " \"\"\"\n", + " # validate the input\n", + " assert num_spatial_orbitals >= 1\n", + " num_alpha, num_beta = num_particles\n", + "\n", + " if any(n > num_spatial_orbitals for n in num_particles):\n", + " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", + "\n", + " half_orbitals = num_spatial_orbitals\n", + " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", + " bitstr[:num_alpha] = True\n", + " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", + "\n", + " return bitstr.tolist()\n", + "\n", + "\n", + "def hartree_fock_circuit(\n", + " num_spatial_orbitals: int, num_particles: tuple[int, int]\n", + ") -> QuantumCircuit:\n", + " \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing\n", + " the Hartree-Fock state for the specified system.\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " The quantum circuit preparing the Hartree-Fock state under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " # Get the Hartree-Fock initial state in boolean bitstring representation\n", + " hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", + "\n", + " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an\n", + " # X-gate as indicated by the boolean list\n", + " hf_circuit = QuantumCircuit(len(hf_bitstring))\n", + " for i, hf_bit in enumerate(hf_bitstring):\n", + " if hf_bit:\n", + " hf_circuit.x(i)\n", + "\n", + " return hf_circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mx.nelecas\n", + "\n", + "hf_circuit = hartree_fock_circuit(num_spatial_orbitals, num_particles)\n", + "hf_circuit.draw(output=\"mpl\", style=\"iqp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator pool\n", + "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we multiply them with the complex phase 1j so that they appear Hermitian." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def single_excitation(\n", + " num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n", + ") -> list[SparsePauliOp]:\n", + " \"\"\"Compute single excitation operators under the Jordan-Wigner transform\n", + " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " A list of single excitation operators under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "\n", + " num_alpha, num_beta = num_particles\n", + " half_orbitals = num_spatial_orbitals\n", + " indices_alpha = list(range(num_alpha))\n", + " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + "\n", + " single_excitation_operators = []\n", + "\n", + " for p in indices_alpha:\n", + " for r in range(p + 1, half_orbitals):\n", + " if r not in indices_alpha:\n", + " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)\n", + "\n", + " for p in indices_beta:\n", + " for r in range(p + 1, 2 * half_orbitals):\n", + " if r not in indices_beta:\n", + " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", + " single_excitation_operators.append(exc)\n", + "\n", + " return single_excitation_operators" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def double_excitation(\n", + " num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n", + ") -> list[SparsePauliOp]:\n", + " \"\"\"Compute double excitation operators under the Jordan-Wigner transform\n", + " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", + " Args:\n", + " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", + " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", + " electrons in the first and second number, respectively.\n", + " Returns:\n", + " A list of single excitation operators under the Jordan-Wigner transform.\n", + " \"\"\"\n", + " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", + "\n", + " num_alpha, num_beta = num_particles\n", + " half_orbitals = num_spatial_orbitals\n", + " indices_alpha = list(range(num_alpha))\n", + " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", + "\n", + " double_excitation_operators = []\n", + "\n", + " # Both excitations from alpha\n", + " if len(indices_alpha) > 1:\n", + " # from these indices\n", + " for p in indices_alpha:\n", + " for r in range(p + 1, num_alpha):\n", + " # to these indices\n", + " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", + " for b in range(a + 1, half_orbitals):\n", + " exc = (\n", + " 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " )\n", + " double_excitation_operators.append(exc)\n", + "\n", + " # Both excitations from beta\n", + " if len(indices_beta) > 1:\n", + " # from these indices\n", + " for p in indices_beta:\n", + " for r in range(p + 1, half_orbitals + num_beta):\n", + " # to these indices\n", + " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", + " for b in range(a + 1, 2 * half_orbitals):\n", + " exc = (\n", + " 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " )\n", + " double_excitation_operators.append(exc)\n", + "\n", + " # One excitation from alpha, one from beta\n", + " # from these indices\n", + " for p in indices_alpha:\n", + " for r in indices_beta:\n", + " # to these indices\n", + " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", + " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", + " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", + " double_excitation_operators.append(exc)\n", + "\n", + " return double_excitation_operators" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The excitation pool consists of 24 operators.\n" + ] + } + ], + "source": [ + "num_spatial_orbitals = mx.ncas\n", + "num_particles = mx.nelecas\n", + "\n", + "single_excitation_operators = single_excitation(num_spatial_orbitals, num_particles)\n", + "double_excitation_operators = double_excitation(num_spatial_orbitals, num_particles)\n", + "\n", + "excitation_pool = single_excitation_operators + double_excitation_operators\n", + "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient of the excitation operators\n", + "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_ibm_runtime import EstimatorV2\n", + "\n", + "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", + " \"\"\"\n", + " Computes the gradients for all available excitation operators.\n", + " Args:\n", + " ansatz: ansatz built so far.\n", + " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", + " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", + " estimator: an instance of the Qiskit Estimator primitive.\n", + " params: parameters to be assigned to the ansatz, if any.\n", + " Returns:\n", + " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", + " \"\"\"\n", + " # The excitations operators are applied later as exp(i*theta*excitation).\n", + " # For this commutator, we need to explicitly pull in the imaginary phase.\n", + " if params is not None:\n", + " ansatz_opt = ansatz.assign_parameters(params)\n", + " else:\n", + " ansatz_opt = ansatz\n", + " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", + " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", + " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", + " if isinstance(estimator, EstimatorV2):\n", + " gradients = estimator.run([(a, c) for a, c in zip(ansatz_list, commutators)]).result().values\n", + " else:\n", + " gradients = estimator.run(ansatz_list, commutators).result().values\n", + "\n", + " return gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cost function\n", + "We define the cost function as the expectation value of the Hamiltonian operator given an ansatz with its parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def cost_func(params, ansatz, H, estimator):\n", + " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " return energy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 2: Optimize problem for quantum execution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by selecting a backend for execution." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibm_osaka\n" + ] + } + ], + "source": [ + "# To run on hardware:\n", + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "service = QiskitRuntimeService(channel=\"ibm_quantum\", instance=\"ibm-q/open/main\")\n", + "backend = service.least_busy(operational=True, simulator=False)\n", + "print(backend.name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we optimize the circuit for running on a real backend by specifying the optimization_level and adding dynamical decoupling. The code below generates a mass manager using preset pass managers from qiskit.transpiler." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import XGate\n", + "from qiskit.transpiler import PassManager\n", + "from qiskit.transpiler.passes import (\n", + " ALAPScheduleAnalysis,\n", + " ConstrainedReschedule,\n", + " PadDynamicalDecoupling,\n", + ")\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "target = backend.target\n", + "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", + "pm.scheduling = PassManager(\n", + " [\n", + " ALAPScheduleAnalysis(target=target),\n", + " ConstrainedReschedule(target.acquire_alignment, target.pulse_alignment),\n", + " PadDynamicalDecoupling(\n", + " target=target, dd_sequence=[XGate(), XGate()], pulse_alignment=target.pulse_alignment\n", + " ),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we use the pass manager on the initial state. We can similarly apply device layout characteristics to the Hamiltonian to get a more physical representation." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "hf_circuit_ibm = pm.run(hf_circuit)\n", + "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n", + "excitation_pool_ibm = [exc.apply_layout(hf_circuit_ibm.layout) for exc in excitation_pool]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit Patterns Step 3: Execute using Qiskit Primitives\n", + "Before we execute on the selected hardware, it is a good idea to use a simulator for cursory debugging, and sometimes for estimates of error. For those reasons, we briefly show how to run ADAPT-VQE on a simulator. But it is critical to note that no classical computer, simulator or GPU can accurately simulate the full functionality of a highly-entangled 127-qubit quantum computer. In the present era of quantum utility, simulators will have limited use." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that for each choice of parameters in the variational circuit, an expectation value must be calculated (since that is the value to be minimized). We do this with the Qiskit Primitive, Estimator." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hartree-Fock energy: -7.95213012467435\n" + ] + } + ], + "source": [ + "# To run on simulator\n", + "from qiskit.primitives import Estimator\n", + "\n", + "estimator = Estimator()\n", + "\n", + "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", + "print(f\"Hartree-Fock energy: {hf_energy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", + " 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", + " -2.42633656e-02 0.00000000e+00 0.00000000e+00 6.68086680e-02\n", + " 0.00000000e+00 -4.61492937e-02 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 -4.61492937e-02 0.00000000e+00\n", + " 6.68086680e-02 0.00000000e+00 0.00000000e+00 -2.50251594e-01]\n", + "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.2502515943160275 at index 23.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "max_operator = excitation_pool[max_index]\n", + "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expand the Ansatz\n", + "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(\n", + " operators=max_operator,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + ")\n", + "ansatz.decompose().draw(output=\"mpl\", style=\"iqp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run VQE\n", + "We are now ready to run a full VQE on the ansatz that we have so far. We use the cost function and the Estimator primitive as defined above and randomly initiate the parameters to be optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6.18650154]\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -7.966906280631417\n", + " x: [ 6.166e+00]\n", + " nfev: 21\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 21 F =-7.966906E+00 MAXCV = 0.000000E+00\n", + " X = 6.165705E+00\n", + "\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "\n", + "res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, H, estimator),\n", + " method=\"cobyla\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + ")\n", + "print(res)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Post-process, return result in classical format\n", + "We now interpret the results and decide if we need another iteration of the algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found ground energy: -7.966906280631417\n", + "[6.16570545]\n" + ] + } + ], + "source": [ + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")\n", + "\n", + "# Optimal parameters so far\n", + "x_opt = getattr(res, \"x\")\n", + "print(x_opt)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.00707901 0. 0. -0.00170879 0.00707901 0.\n", + " 0. -0.00170879 -0.01805097 0. 0. 0.07148205\n", + " 0. -0.04085051 0. 0. 0. 0.\n", + " -0.04085051 0. 0.07148205 0. 0. -0.00014222]\n", + "Found maximum gradient 0.07148205138959425 at index 11\n", + "Maximum gradient is below the threshold: False\n" + ] + } + ], + "source": [ + "gradient_threshold = 1e-3\n", + "\n", + "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", + "print(gradients)\n", + "\n", + "max_gradient = np.max(np.abs(gradients))\n", + "max_index = np.argmax(np.abs(gradients))\n", + "\n", + "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", + "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Initiate the list of operators with the first one\n", + "operator_list = [max_operator]\n", + "# Append the second operator\n", + "operator_list.append(excitation_pool[max_index])\n", + "\n", + "ansatz = EvolvedOperatorAnsatz(\n", + " operators=operator_list,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + ")\n", + "ansatz.decompose().draw(output=\"mpl\", style=\"iqp\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.88075153 2.90894229]\n", + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 1\n", + " fun: -7.968684164775403\n", + " x: [ 3.260e+00 3.191e+00]\n", + " nfev: 40\n", + " maxcv: 0.0\n", + " Normal return from subroutine COBYLA\n", + "\n", + " NFVALS = 40 F =-7.968684E+00 MAXCV = 0.000000E+00\n", + " X = 3.259814E+00 3.191388E+00\n", + "\n", + "Found ground energy: -7.968684164775403\n" + ] + } + ], + "source": [ + "# Random start for the ansatz parameters\n", + "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + "print(x0)\n", + "\n", + "res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, H, estimator),\n", + " method=\"cobyla\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + ")\n", + "print(res)\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Putting it all together\n", + "Now we automate the algorithm in a single loop." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0\n", + "Maximum gradient: 0.2502515943160275\n", + "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 23\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.966906248550616\n", + " Iterations: 5\n", + " Function evaluations: 12\n", + " Gradient evaluations: 5\n", + "Result at iter 0: -7.966906248550616\n", + "Iter: 1\n", + "Maximum gradient: 0.07148987524972958\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.96868417953405\n", + " Iterations: 8\n", + " Function evaluations: 27\n", + " Gradient evaluations: 8\n", + "Result at iter 1: -7.96868417953405\n", + "Iter: 2\n", + "Maximum gradient: 0.068868892894845\n", + "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 20\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.970337106127032\n", + " Iterations: 6\n", + " Function evaluations: 25\n", + " Gradient evaluations: 6\n", + "Result at iter 2: -7.970337106127032\n", + "Iter: 3\n", + "Maximum gradient: 0.037927928716381794\n", + "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 13\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.970872593313668\n", + " Iterations: 11\n", + " Function evaluations: 59\n", + " Gradient evaluations: 11\n", + "Result at iter 3: -7.970872593313668\n", + "Iter: 4\n", + "Maximum gradient: 0.037029338016181614\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.971383219968869\n", + " Iterations: 9\n", + " Function evaluations: 58\n", + " Gradient evaluations: 9\n", + "Result at iter 4: -7.971383219968869\n", + "Iter: 5\n", + "Maximum gradient: 0.032246779954544474\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.971773034651897\n", + " Iterations: 8\n", + " Function evaluations: 59\n", + " Gradient evaluations: 8\n", + "Result at iter 5: -7.971773034651897\n", + "Iter: 6\n", + "Maximum gradient: 0.01066557969828447\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.971979053610505\n", + " Iterations: 24\n", + " Function evaluations: 198\n", + " Gradient evaluations: 24\n", + "Result at iter 6: -7.971979053610505\n", + "Iter: 7\n", + "Maximum gradient: 0.009733825023488506\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.575750153251004\n", + " Iterations: 18\n", + " Function evaluations: 166\n", + " Gradient evaluations: 18\n", + "Result at iter 7: -7.575750153251004\n", + "Iter: 8\n", + "Maximum gradient: 0.003801700281861138\n", + "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.969374151774823\n", + " Iterations: 15\n", + " Function evaluations: 151\n", + " Gradient evaluations: 15\n", + "Result at iter 8: -7.969374151774823\n", + "Iter: 9\n", + "Maximum gradient: 0.07242697313687708\n", + "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 11\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.972016127080447\n", + " Iterations: 39\n", + " Function evaluations: 432\n", + " Gradient evaluations: 39\n", + "Result at iter 9: -7.972016127080447\n", + "Iter: 10\n", + "Maximum gradient: 0.009157872586500545\n", + "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.972179299161537\n", + " Iterations: 22\n", + " Function evaluations: 269\n", + " Gradient evaluations: 22\n", + "Result at iter 10: -7.972179299161537\n", + "Iter: 11\n", + "Maximum gradient: 0.0005877035461707937\n", + "Terminating: converged.\n", + "Found ground energy: -7.972179299161537\n" + ] + } + ], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.primitives import Estimator\n", + "from qiskit.synthesis import LieTrotter\n", + "from scipy.optimize import minimize\n", + "\n", + "# Define the conditions for termination\n", + "gradient_threshold = 1e-3\n", + "max_iter = 15\n", + "terminate = False\n", + "\n", + "# Initiate the problem\n", + "ansatz = hf_circuit\n", + "hamiltonian = H\n", + "excitation_pool = single_excitation_operators + double_excitation_operators\n", + "estimator = Estimator()\n", + "params = None\n", + "\n", + "iter = 0\n", + "operator_list = []\n", + "while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(\n", + " operators=operator_list,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + " )\n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, H, estimator),\n", + " method=\"slsqp\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + " )\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, \"x\")\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration.\")\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " print(\"Terminating: converged.\")\n", + " terminate = True\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", + "from qiskit.synthesis import LieTrotter\n", + "\n", + "# To continue running on real hardware use\n", + "from qiskit_ibm_runtime import EstimatorV2, EstimatorOptions, Session\n", + "from scipy.optimize import minimize\n", + "\n", + "hf_circuit_ibm = pm.run(hf_circuit)\n", + "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n", + "\n", + "# Define the conditions for termination\n", + "gradient_threshold = 5e-3\n", + "max_iter = 15\n", + "terminate = False\n", + "\n", + "with Session(backend=backend):\n", + " session_options = EstimatorOptions()\n", + " session_options.default_shots = 10000\n", + " session_options.resilience_level = 1\n", + "\n", + " # Initiate the problem\n", + " ansatz = hf_circuit_ibm\n", + " hamiltonian = H_ibm\n", + " excitation_pool = single_excitation_operators + double_excitation_operators\n", + " estimator = EstimatorV2(session=Session(service, backend=backend), options=session_options)\n", + " params = None\n", + "\n", + " iter = 0\n", + " operator_list = []\n", + " while not terminate:\n", + " print(f\"Iter: {iter}\")\n", + " excitation_pool_ibm = [exc.apply_layout(ansatz.layout) for exc in excitation_pool]\n", + " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool_ibm, estimator, params)\n", + " max_gradient = np.max(np.abs(gradients))\n", + " print(f\"Maximum gradient: {max_gradient}\")\n", + " # Check convergence\n", + " if max_gradient > gradient_threshold:\n", + " # Find the operator with the largest gradient\n", + " max_index = np.argmax(np.abs(gradients))\n", + " max_operator = excitation_pool[max_index]\n", + " print(f\"Operator: {max_operator} at index {max_index}\")\n", + " # Grow the ansatz\n", + " operator_list.append(max_operator)\n", + " ansatz = EvolvedOperatorAnsatz(\n", + " operators=operator_list,\n", + " evolution=LieTrotter(),\n", + " parameter_prefix=\"theta\",\n", + " initial_state=hf_circuit,\n", + " )\n", + " ansatz = pm.run(ansatz)\n", + " hamiltonian = H.apply_layout(ansatz.layout)\n", + " # Run VQE on the current ansatz\n", + " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", + " res = minimize(\n", + " cost_func,\n", + " x0,\n", + " args=(ansatz, hamiltonian, estimator),\n", + " method=\"slsqp\",\n", + " options={\"maxiter\": 50, \"disp\": True},\n", + " )\n", + " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", + " x_opt = getattr(res, \"x\")\n", + " params = x_opt\n", + " # Terminate if maximum number of iterations reached\n", + " iter += 1\n", + " if iter >= max_iter:\n", + " print(\"Terminating: reached maximum iteration.\")\n", + " terminate = True\n", + " # Terminate if converged\n", + " else:\n", + " print(\"Terminating: converged.\")\n", + " terminate = True\n", + "\n", + "# Note this returns the total energy, and we are often interested in the electronic energy\n", + "ground_energy = getattr(res, \"fun\")\n", + "print(f\"Found ground energy: {ground_energy}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/quantum_enablement/tutorials/adapt-vqe.ipynb b/quantum_enablement/tutorials/adapt-vqe.ipynb deleted file mode 100644 index ae9f8e2..0000000 --- a/quantum_enablement/tutorials/adapt-vqe.ipynb +++ /dev/null @@ -1,1370 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit ADAPT-VQE tutorial\n", - "\n", - "ADAPT-VQE is a variation of the original VQE algorithm, which grows the ansatz at each iteration by selecting operators from an operator pool. This typically results in shorter depth circuits than fixed-depth ansatze designed for VQE. This algorithm was first introduced in https://arxiv.org/abs/1812.1117. For a ground state estimation problem from the quantum chemistry domain, steps are outlined as follows.\n", - "\n", - "1. We find the fermionic Hamiltonian by defining the molecular geometry, and map it onto qubit representation using a mapper such as the Jordan-Wigner transform. \n", - "2. The quantum computer is typically initiated in the Hartree-Fock state under the same transformation as an estimate to the ground state energy.\n", - "3. We define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian.\n", - "4. Until the algorithm terminates:\n", - " - we compute the gradient of each operator from the pool and select the operator with the maximum gradient,\n", - " - grow the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$,\n", - " - run VQE over all parameters $\\theta_i$,\n", - " - and terminate the algorithm if the gradient of all operators from the pool are smaller than some threshold (convergence) or if we reach the maximum number of allowed iterations.\n", - "\n", - "We note the following variants of the ADAPT-VQE algorithm:\n", - "- A hardware-efficient variant called qubit-ADAPT-VQE, which reduces the circuit depth by constructing the pool directly with individual Pauli operators: https://arxiv.org/abs/1911.10205.\n", - "- A utility scale ADAPT-VQE experiment for the Schwinger model using up to 100 qubits of IBM Quantum devices: https://arxiv.org/abs/2308.04481.\n", - "\n", - "In the following, we define the problem and implement the algorithm using Qiskit Patterns formalism in 4 steps:\n", - "1. Map classical inputs to a quantum problem\n", - "2. Optimize problem for quantum execution\n", - "3. Execute using Qiskit Primitives\n", - "4. Post-process and return result in classical format\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the molecule\n", - "We start by defining the molecule using ``pyscf``. As an example we select LiH and build it by providing its geometry.\n", - "Code to generate additional molecules can be found in ``Example_Molecules.ipynb`` at https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyscf import ao2mo, gto, mcscf, scf\n", - "\n", - "# LiH\n", - "distance = 1.59\n", - "mol = gto.Mole()\n", - "mol.build(\n", - " verbose=0,\n", - " atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n", - " basis=\"sto-6g\",\n", - " spin=0,\n", - " charge=0,\n", - " symmetry=\"Coov\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nuclear energy: 0.998447567773585\n", - "Electronic energy: -8.950577623117868\n", - "Total energy: -7.952130055344282\n", - "Total energy - nuclear energy: -8.950577623117868\n" - ] - } - ], - "source": [ - "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n", - "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n", - "print(f\"Total energy: {mol.energy_tot()}\")\n", - "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate the fermionic Hamiltonian\n", - "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "mf = scf.RHF(mol)\n", - "E1 = mf.kernel()\n", - "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n", - "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n", - "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n", - "E2 = mx.kernel(mo)[:2]\n", - "\n", - "h1e, ecore = mx.get_h1eff()\n", - "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit Patterns Step 1: Map classical inputs to a quantum problem\n", - "We will map the Hamiltonian operator, the initial state and the operator pool of the ansatz to a quantum problem using the Jordan-Wigner transform. We also define functions to compute gradients and the cost of these operators." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Map the fermionic Hamiltonian to a qubit operator\n", - "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented in https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# ------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n", - "\n", - "import numpy as np\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "\n", - "\n", - "def cholesky(V, eps):\n", - " # see https://arxiv.org/pdf/1711.02242.pdf section B2\n", - " # see https://arxiv.org/abs/1808.02625\n", - " # see https://arxiv.org/abs/2104.08957\n", - " no = V.shape[0]\n", - " chmax, ng = 20 * no, 0\n", - " W = V.reshape(no**2, no**2)\n", - " L = np.zeros((no**2, chmax))\n", - " Dmax = np.diagonal(W).copy()\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " while vmax > eps:\n", - " L[:, ng] = W[:, nu_max]\n", - " if ng > 0:\n", - " L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n", - " L[:, ng] /= np.sqrt(vmax)\n", - " Dmax[: no**2] -= L[: no**2, ng] ** 2\n", - " ng += 1\n", - " nu_max = np.argmax(Dmax)\n", - " vmax = Dmax[nu_max]\n", - " L = L[:, :ng].reshape((no, no, ng))\n", - " print(\n", - " \"accuracy of Cholesky decomposition \",\n", - " np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n", - " )\n", - " return L, ng\n", - "\n", - "\n", - "def identity(n):\n", - " return SparsePauliOp.from_list([(\"I\" * n, 1)])\n", - "\n", - "\n", - "def creators_destructors(n, mapping=\"jordan_wigner\"):\n", - " c_list = []\n", - " if mapping == \"jordan_wigner\":\n", - " for p in range(n):\n", - " if p == 0:\n", - " l, r = \"I\" * (n - 1), \"\"\n", - " elif p == n - 1:\n", - " l, r = \"\", \"Z\" * (n - 1)\n", - " else:\n", - " l, r = \"I\" * (n - p - 1), \"Z\" * p\n", - " cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, -0.5j)])\n", - " c_list.append(cp)\n", - " else:\n", - " raise ValueError(\"Unsupported mapping.\")\n", - " d_list = [cp.adjoint() for cp in c_list]\n", - " return c_list, d_list\n", - "\n", - "\n", - "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n", - " ncas, _ = h1e.shape\n", - "\n", - " C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n", - " Exc = []\n", - " for p in range(ncas):\n", - " Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n", - " for r in range(p + 1, ncas):\n", - " Excp.append(\n", - " C[p] @ D[r] + C[ncas + p] @ D[ncas + r] + C[r] @ D[p] + C[ncas + r] @ D[ncas + p]\n", - " )\n", - " Exc.append(Excp)\n", - "\n", - " # low-rank decomposition of the Hamiltonian\n", - " Lop, ng = cholesky(h2e, 1e-6)\n", - " t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n", - "\n", - " H = ecore * identity(2 * ncas)\n", - " # one-body term\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " H += t1e[p, r] * Exc[p][r - p]\n", - " # two-body term\n", - " for g in range(ng):\n", - " Lg = 0 * identity(2 * ncas)\n", - " for p in range(ncas):\n", - " for r in range(p, ncas):\n", - " Lg += Lop[p, r, g] * Exc[p][r - p]\n", - " H += 0.5 * Lg @ Lg\n", - "\n", - " return H.chop().simplify()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "accuracy of Cholesky decomposition 1.1796119636642288e-16\n", - "The Hamiltonian consists of 276 10-qubit Pauli operators.\n" - ] - } - ], - "source": [ - "H = build_hamiltonian(ecore, h1e, h2e)\n", - "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initial state\n", - "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we implement using the functions below." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "\n", - "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n", - " \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " The bitstring representing the state of the Hartree-Fock state as array of bools.\n", - " Raises:\n", - " ValueError: If the total number of particles is larger than the number of orbitals.\n", - " \"\"\"\n", - " # validate the input\n", - " assert num_spatial_orbitals >= 1\n", - " num_alpha, num_beta = num_particles\n", - "\n", - " if any(n > num_spatial_orbitals for n in num_particles):\n", - " raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n", - "\n", - " half_orbitals = num_spatial_orbitals\n", - " bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n", - " bitstr[:num_alpha] = True\n", - " bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n", - "\n", - " return bitstr.tolist()\n", - "\n", - "\n", - "def hartree_fock_circuit(\n", - " num_spatial_orbitals: int, num_particles: tuple[int, int]\n", - ") -> QuantumCircuit:\n", - " \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing\n", - " the Hartree-Fock state for the specified system.\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " The quantum circuit preparing the Hartree-Fock state under the Jordan-Wigner transform.\n", - " \"\"\"\n", - " # Get the Hartree-Fock initial state in boolean bitstring representation\n", - " hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n", - "\n", - " # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an\n", - " # X-gate as indicated by the boolean list\n", - " hf_circuit = QuantumCircuit(len(hf_bitstring))\n", - " for i, hf_bit in enumerate(hf_bitstring):\n", - " if hf_bit:\n", - " hf_circuit.x(i)\n", - "\n", - " return hf_circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "num_spatial_orbitals = mx.ncas\n", - "num_particles = mx.nelecas\n", - "\n", - "hf_circuit = hartree_fock_circuit(num_spatial_orbitals, num_particles)\n", - "hf_circuit.draw(output=\"mpl\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operator pool\n", - "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we multiply them with the complex phase 1j so that they appear Hermitian." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def single_excitation(\n", - " num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n", - ") -> list[SparsePauliOp]:\n", - " \"\"\"Compute single excitation operators under the Jordan-Wigner transform\n", - " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " A list of single excitation operators under the Jordan-Wigner transform.\n", - " \"\"\"\n", - " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", - "\n", - " num_alpha, num_beta = num_particles\n", - " half_orbitals = num_spatial_orbitals\n", - " indices_alpha = list(range(num_alpha))\n", - " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", - "\n", - " single_excitation_operators = []\n", - "\n", - " for p in indices_alpha:\n", - " for r in range(p + 1, half_orbitals):\n", - " if r not in indices_alpha:\n", - " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", - " single_excitation_operators.append(exc)\n", - "\n", - " for p in indices_beta:\n", - " for r in range(p + 1, 2 * half_orbitals):\n", - " if r not in indices_beta:\n", - " exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n", - " single_excitation_operators.append(exc)\n", - "\n", - " return single_excitation_operators" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def double_excitation(\n", - " num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n", - ") -> list[SparsePauliOp]:\n", - " \"\"\"Compute double excitation operators under the Jordan-Wigner transform\n", - " (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n", - " Args:\n", - " num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n", - " num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n", - " electrons in the first and second number, respectively.\n", - " Returns:\n", - " A list of single excitation operators under the Jordan-Wigner transform.\n", - " \"\"\"\n", - " C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n", - "\n", - " num_alpha, num_beta = num_particles\n", - " half_orbitals = num_spatial_orbitals\n", - " indices_alpha = list(range(num_alpha))\n", - " indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n", - "\n", - " double_excitation_operators = []\n", - "\n", - " # Both excitations from alpha\n", - " if len(indices_alpha) > 1:\n", - " # from these indices\n", - " for p in indices_alpha:\n", - " for r in range(p + 1, num_alpha):\n", - " # to these indices\n", - " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", - " for b in range(a + 1, half_orbitals):\n", - " exc = (\n", - " 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", - " )\n", - " double_excitation_operators.append(exc)\n", - "\n", - " # Both excitations from beta\n", - " if len(indices_beta) > 1:\n", - " # from these indices\n", - " for p in indices_beta:\n", - " for r in range(p + 1, half_orbitals + num_beta):\n", - " # to these indices\n", - " for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", - " for b in range(a + 1, 2 * half_orbitals):\n", - " exc = (\n", - " 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", - " )\n", - " double_excitation_operators.append(exc)\n", - "\n", - " # One excitation from alpha, one from beta\n", - " # from these indices\n", - " for p in indices_alpha:\n", - " for r in indices_beta:\n", - " # to these indices\n", - " for a in range(indices_alpha[-1] + 1, half_orbitals):\n", - " for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n", - " exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n", - " double_excitation_operators.append(exc)\n", - "\n", - " return double_excitation_operators" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The excitation pool consists of 24 operators.\n" - ] - } - ], - "source": [ - "num_spatial_orbitals = mx.ncas\n", - "num_particles = mx.nelecas\n", - "\n", - "single_excitation_operators = single_excitation(num_spatial_orbitals, num_particles)\n", - "double_excitation_operators = double_excitation(num_spatial_orbitals, num_particles)\n", - "\n", - "excitation_pool = single_excitation_operators + double_excitation_operators\n", - "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Gradient of the excitation operators\n", - "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", - " \"\"\"\n", - " Computes the gradients for all available excitation operators.\n", - " Args:\n", - " ansatz: ansatz built so far.\n", - " hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n", - " excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n", - " estimator: an instance of the Qiskit Estimator primitive.\n", - " params: parameters to be assigned to the ansatz, if any.\n", - " Returns:\n", - " List of computed gradients in the same order as the excitation operators in the excitation pool.\n", - " \"\"\"\n", - " # The excitations operators are applied later as exp(i*theta*excitation).\n", - " # For this commutator, we need to explicitly pull in the imaginary phase.\n", - " if params is not None:\n", - " ansatz_opt = ansatz.assign_parameters(params)\n", - " else:\n", - " ansatz_opt = ansatz\n", - " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", - " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", - " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", - " gradients = estimator.run(ansatz_list, commutators).result().values\n", - "\n", - " return gradients" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Cost function\n", - "We define the cost function as the expectation value of the Hamiltonian operator given an ansatz with its parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", - " return energy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit Patterns Step 2: Optimize problem for quantum execution" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by selecting a backend for execution." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ibm_kyoto\n" - ] - } - ], - "source": [ - "# To run on hardware:\n", - "from qiskit_ibm_runtime import QiskitRuntimeService\n", - "\n", - "service = QiskitRuntimeService(channel=\"ibm_quantum\", instance=\"ibm-q/open/main\")\n", - "backend = service.least_busy(operational=True, simulator=False)\n", - "print(backend.name)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we optimize the circuit for running on a real backend by specifying the optimization_level and adding dynamical decoupling. The code below generates a mass manager using preset pass managers from qiskit.transpiler." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.circuit.library import XGate\n", - "from qiskit.transpiler import PassManager\n", - "from qiskit.transpiler.passes import (\n", - " ALAPScheduleAnalysis,\n", - " ConstrainedReschedule,\n", - " PadDynamicalDecoupling,\n", - ")\n", - "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", - "\n", - "target = backend.target\n", - "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", - "pm.scheduling = PassManager(\n", - " [\n", - " ALAPScheduleAnalysis(target=target),\n", - " ConstrainedReschedule(target.acquire_alignment, target.pulse_alignment),\n", - " PadDynamicalDecoupling(\n", - " target=target, dd_sequence=[XGate(), XGate()], pulse_alignment=target.pulse_alignment\n", - " ),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we use the pass manager on the initial state. We can similarly apply device layout characteristics to the Hamiltonian to get a more physical representation." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "hf_circuit_ibm = pm.run(hf_circuit)\n", - "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n", - "excitation_pool_ibm = [exc.apply_layout(hf_circuit_ibm.layout) for exc in excitation_pool]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Qiskit Patterns Step 3: Execute using Qiskit Primitives\n", - "Before we execute on the selected hardware, it is a good idea to use a simulator for cursory debugging, and sometimes for estimates of error. For those reasons, we briefly show how to run ADAPT-VQE on a simulator. But it is critical to note that no classical computer, simulator or GPU can accurately simulate the full functionality of a highly-entangled 127-qubit quantum computer. In the present era of quantum utility, simulators will have limited use." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Recall that for each choice of parameters in the variational circuit, an expectation value must be calculated (since that is the value to be minimized). We do this with the Qiskit Primitive, Estimator." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hartree-Fock energy: -7.95213012467435\n" - ] - } - ], - "source": [ - "# To run on simulator\n", - "from qiskit.primitives import Estimator\n", - "\n", - "estimator = Estimator()\n", - "\n", - "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", - "print(f\"Hartree-Fock energy: {hf_energy}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", - " 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", - " -2.42633656e-02 0.00000000e+00 0.00000000e+00 6.68086680e-02\n", - " 0.00000000e+00 -4.61492937e-02 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 -4.61492937e-02 0.00000000e+00\n", - " 6.68086680e-02 0.00000000e+00 0.00000000e+00 -2.50251594e-01]\n", - "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.2502515943160275 at index 23.\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "max_operator = excitation_pool[max_index]\n", - "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Expand the Ansatz\n", - "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import LieTrotter\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(\n", - " operators=max_operator,\n", - " evolution=LieTrotter(),\n", - " parameter_prefix=\"theta\",\n", - " initial_state=hf_circuit,\n", - ")\n", - "ansatz.decompose().draw(output=\"mpl\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run VQE\n", - "We are now ready to run a full VQE on the ansatz that we have so far. We use the cost function and the Estimator primitive as defined above and randomly initiate the parameters to be optimized." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1.41042304]\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -7.966906274198754\n", - " x: [ 3.024e+00]\n", - " nfev: 24\n", - " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 24 F =-7.966906E+00 MAXCV = 0.000000E+00\n", - "\n", - " X = 3.024148E+00\n" - ] - } - ], - "source": [ - "from scipy.optimize import minimize\n", - "\n", - "res = minimize(\n", - " cost_func,\n", - " x0,\n", - " args=(ansatz, H, estimator),\n", - " method=\"cobyla\",\n", - " options={\"maxiter\": 50, \"disp\": True},\n", - ")\n", - "print(res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Step 4: Post-process, return result in classical format\n", - "We now interpret the results and decide if we need another iteration of the algorithm." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found ground energy: -7.966906274198754\n", - "[3.02414843]\n" - ] - } - ], - "source": [ - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, \"fun\")\n", - "print(f\"Found ground energy: {ground_energy}\")\n", - "\n", - "# Optimal parameters so far\n", - "x_opt = getattr(res, \"x\")\n", - "print(x_opt)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.00707691 0. 0. -0.00170823 0.00707691 0.\n", - " 0. -0.00170823 -0.01805292 0. 0. 0.07148094\n", - " 0. -0.04085228 0. 0. 0. 0.\n", - " -0.04085228 0. 0.07148094 0. 0. -0.0002188 ]\n", - "Found maximum gradient 0.07148094085709761 at index 11\n", - "Maximum gradient is below the threshold: False\n" - ] - } - ], - "source": [ - "gradient_threshold = 1e-3\n", - "\n", - "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n", - "print(gradients)\n", - "\n", - "max_gradient = np.max(np.abs(gradients))\n", - "max_index = np.argmax(np.abs(gradients))\n", - "\n", - "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n", - "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Initiate the list of operators with the first one\n", - "operator_list = [max_operator]\n", - "# Append the second operator\n", - "operator_list.append(excitation_pool[max_index])\n", - "\n", - "ansatz = EvolvedOperatorAnsatz(\n", - " operators=operator_list,\n", - " evolution=LieTrotter(),\n", - " parameter_prefix=\"theta\",\n", - " initial_state=hf_circuit,\n", - ")\n", - "ansatz.decompose().draw(output=\"mpl\")" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2.14630704 5.75231296]\n", - " message: Optimization terminated successfully.\n", - " success: True\n", - " status: 1\n", - " fun: -7.9686841642530375\n", - " x: [ 3.023e+00 6.333e+00]\n", - " nfev: 40\n", - " maxcv: 0.0\n", - " Normal return from subroutine COBYLA\n", - "\n", - " NFVALS = 40 F =-7.968684E+00 MAXCV = 0.000000E+00\n", - " X = 3.023174E+00 6.332813E+00\n", - "\n", - "Found ground energy: -7.9686841642530375\n" - ] - } - ], - "source": [ - "# Random start for the ansatz parameters\n", - "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - "print(x0)\n", - "\n", - "res = minimize(\n", - " cost_func,\n", - " x0,\n", - " args=(ansatz, H, estimator),\n", - " method=\"cobyla\",\n", - " options={\"maxiter\": 50, \"disp\": True},\n", - ")\n", - "print(res)\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, \"fun\")\n", - "print(f\"Found ground energy: {ground_energy}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Putting it all together\n", - "Now we automate the algorithm in a single loop." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iter: 0\n", - "Maximum gradient: 0.2502515943160275\n", - "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 23\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.966906284793598\n", - " Iterations: 2\n", - " Function evaluations: 5\n", - " Gradient evaluations: 2\n", - "Result at iter 0: -7.966906284793598\n", - "Iter: 1\n", - "Maximum gradient: 0.07148481503619701\n", - "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 11\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.968684135389207\n", - " Iterations: 6\n", - " Function evaluations: 21\n", - " Gradient evaluations: 6\n", - "Result at iter 1: -7.968684135389207\n", - "Iter: 2\n", - "Maximum gradient: 0.06885672251558851\n", - "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 20\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970337065973196\n", - " Iterations: 6\n", - " Function evaluations: 27\n", - " Gradient evaluations: 6\n", - "Result at iter 2: -7.970337065973196\n", - "Iter: 3\n", - "Maximum gradient: 0.03791655571908455\n", - "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 13\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970872496782351\n", - " Iterations: 7\n", - " Function evaluations: 37\n", - " Gradient evaluations: 7\n", - "Result at iter 3: -7.970872496782351\n", - "Iter: 4\n", - "Maximum gradient: 0.0370299474918533\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971383218746653\n", - " Iterations: 20\n", - " Function evaluations: 135\n", - " Gradient evaluations: 20\n", - "Result at iter 4: -7.971383218746653\n", - "Iter: 5\n", - "Maximum gradient: 0.03224685854317715\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971773202172484\n", - " Iterations: 18\n", - " Function evaluations: 134\n", - " Gradient evaluations: 18\n", - "Result at iter 5: -7.971773202172484\n", - "Iter: 6\n", - "Maximum gradient: 0.010705739242569776\n", - "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971978831060897\n", - " Iterations: 16\n", - " Function evaluations: 132\n", - " Gradient evaluations: 16\n", - "Result at iter 6: -7.971978831060897\n", - "Iter: 7\n", - "Maximum gradient: 0.009717164674363968\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.968225393431566\n", - " Iterations: 13\n", - " Function evaluations: 120\n", - " Gradient evaluations: 13\n", - "Result at iter 7: -7.968225393431566\n", - "Iter: 8\n", - "Maximum gradient: 0.06816889310847103\n", - "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 20\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.969120334779275\n", - " Iterations: 15\n", - " Function evaluations: 153\n", - " Gradient evaluations: 15\n", - "Result at iter 8: -7.969120334779275\n", - "Iter: 9\n", - "Maximum gradient: 0.07060449874596993\n", - "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 11\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.9716270972513525\n", - " Iterations: 40\n", - " Function evaluations: 443\n", - " Gradient evaluations: 40\n", - "Result at iter 9: -7.9716270972513525\n", - "Iter: 10\n", - "Maximum gradient: 0.020853916020903765\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970921582203872\n", - " Iterations: 24\n", - " Function evaluations: 290\n", - " Gradient evaluations: 24\n", - "Result at iter 10: -7.970921582203872\n", - "Iter: 11\n", - "Maximum gradient: 0.04232508018126495\n", - "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 18\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.97174310731302\n", - " Iterations: 21\n", - " Function evaluations: 276\n", - " Gradient evaluations: 21\n", - "Result at iter 11: -7.97174310731302\n", - "Iter: 12\n", - "Maximum gradient: 0.01114875020605062\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972156543559216\n", - " Iterations: 29\n", - " Function evaluations: 411\n", - " Gradient evaluations: 29\n", - "Result at iter 12: -7.972156543559216\n", - "Iter: 13\n", - "Maximum gradient: 0.005734779272457883\n", - "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", - " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) at index 8\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972174887679361\n", - " Iterations: 36\n", - " Function evaluations: 543\n", - " Gradient evaluations: 36\n", - "Result at iter 13: -7.972174887679361\n", - "Iter: 14\n", - "Maximum gradient: 0.002736550362458665\n", - "Operator: SparsePauliOp(['IIIIIXZZZY', 'IIIIIYZZZX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 3\n", - "Iteration limit reached (Exit mode 9)\n", - " Current function value: -7.972132265604596\n", - " Iterations: 50\n", - " Function evaluations: 803\n", - " Gradient evaluations: 50\n", - "Result at iter 14: -7.972132265604596\n", - "Terminating: reached maximum iteration.\n", - "Found ground energy: -7.972132265604596\n" - ] - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.primitives import Estimator\n", - "from qiskit.synthesis import LieTrotter\n", - "from scipy.optimize import minimize\n", - "\n", - "# Define the conditions for termination\n", - "gradient_threshold = 1e-3\n", - "max_iter = 15\n", - "terminate = False\n", - "\n", - "# Initiate the problem\n", - "ansatz = hf_circuit\n", - "hamiltonian = H\n", - "excitation_pool = single_excitation_operators + double_excitation_operators\n", - "estimator = Estimator()\n", - "params = None\n", - "\n", - "iter = 0\n", - "operator_list = []\n", - "while not terminate:\n", - " print(f\"Iter: {iter}\")\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " print(f\"Maximum gradient: {max_gradient}\")\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(np.abs(gradients))\n", - " max_operator = excitation_pool[max_index]\n", - " print(f\"Operator: {max_operator} at index {max_index}\")\n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(\n", - " operators=operator_list,\n", - " evolution=LieTrotter(),\n", - " parameter_prefix=\"theta\",\n", - " initial_state=hf_circuit,\n", - " )\n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(\n", - " cost_func,\n", - " x0,\n", - " args=(ansatz, H, estimator),\n", - " method=\"slsqp\",\n", - " options={\"maxiter\": 50, \"disp\": True},\n", - " )\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, \"x\")\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " print(\"Terminating: reached maximum iteration.\")\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " print(\"Terminating: converged.\")\n", - " terminate = True\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, \"fun\")\n", - "print(f\"Found ground energy: {ground_energy}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iter: 0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/quantum/lib/python3.10/site-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:927: UserWarning: Starting a session using the /jobs endpoint will no longer be supported after March 31, 2024. Please update your code as soon as possible before this date. If you are using qiskit-ibm-runtime, you will need version 0.20.0 or higher. If you are using qiskit-ibm-provider, you will need version 0.10.0 or higher. If you are calling the API directly, please use the /sessions endpoint instead.\n", - " warnings.warn(warning_message)\n" - ] - } - ], - "source": [ - "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.synthesis import LieTrotter\n", - "\n", - "# To continue running on real hardware use\n", - "from qiskit_ibm_runtime import Estimator, Options, Session\n", - "from scipy.optimize import minimize\n", - "\n", - "hf_circuit_ibm = pm.run(hf_circuit)\n", - "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n", - "\n", - "# Define the conditions for termination\n", - "gradient_threshold = 5e-3\n", - "max_iter = 15\n", - "terminate = False\n", - "\n", - "with Session(backend=backend):\n", - " session_options = Options()\n", - " session_options.execution.shots = 2000\n", - " session_options.resilience_level = 1\n", - "\n", - " # Initiate the problem\n", - " ansatz = hf_circuit_ibm\n", - " hamiltonian = H_ibm\n", - " excitation_pool = single_excitation_operators + double_excitation_operators\n", - " estimator = Estimator(session=Session(service, backend=backend), options=session_options)\n", - " params = None\n", - "\n", - " iter = 0\n", - " operator_list = []\n", - " while not terminate:\n", - " print(f\"Iter: {iter}\")\n", - " excitation_pool_ibm = [exc.apply_layout(ansatz.layout) for exc in excitation_pool]\n", - " gradients = compute_gradients(ansatz, hamiltonian, excitation_pool_ibm, estimator, params)\n", - " max_gradient = np.max(np.abs(gradients))\n", - " print(f\"Maximum gradient: {max_gradient}\")\n", - " # Check convergence\n", - " if max_gradient > gradient_threshold:\n", - " # Find the operator with the largest gradient\n", - " max_index = np.argmax(np.abs(gradients))\n", - " max_operator = excitation_pool[max_index]\n", - " print(f\"Operator: {max_operator} at index {max_index}\")\n", - " # Grow the ansatz\n", - " operator_list.append(max_operator)\n", - " ansatz = EvolvedOperatorAnsatz(\n", - " operators=operator_list,\n", - " evolution=LieTrotter(),\n", - " parameter_prefix=\"theta\",\n", - " initial_state=hf_circuit,\n", - " )\n", - " ansatz = pm.run(ansatz)\n", - " hamiltonian = H.apply_layout(ansatz.layout)\n", - " # Run VQE on the current ansatz\n", - " x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n", - " res = minimize(\n", - " cost_func,\n", - " x0,\n", - " args=(ansatz, hamiltonian, estimator),\n", - " method=\"slsqp\",\n", - " options={\"maxiter\": 50, \"disp\": True},\n", - " )\n", - " print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n", - " x_opt = getattr(res, \"x\")\n", - " params = x_opt\n", - " # Terminate if maximum number of iterations reached\n", - " iter += 1\n", - " if iter >= max_iter:\n", - " print(\"Terminating: reached maximum iteration.\")\n", - " terminate = True\n", - " # Terminate if converged\n", - " else:\n", - " print(\"Terminating: converged.\")\n", - " terminate = True\n", - "\n", - "# Note this returns the total energy, and we are often interested in the electronic energy\n", - "ground_energy = getattr(res, \"fun\")\n", - "print(f\"Found ground energy: {ground_energy}\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "quantum", - "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.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 64a4068d33ee8ba95b58fe492e333b07a70d6966 Mon Sep 17 00:00:00 2001 From: Meltem Tolunay Date: Fri, 29 Mar 2024 14:58:58 -0700 Subject: [PATCH 16/17] make requested changes 2 --- docs/tutorials/adapt-vqe.ipynb | 244 +++++++++++++++++---------------- pyproject.toml | 2 + 2 files changed, 130 insertions(+), 116 deletions(-) diff --git a/docs/tutorials/adapt-vqe.ipynb b/docs/tutorials/adapt-vqe.ipynb index cf58921..daf6eff 100644 --- a/docs/tutorials/adapt-vqe.ipynb +++ b/docs/tutorials/adapt-vqe.ipynb @@ -46,7 +46,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -502,8 +502,6 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit_ibm_runtime import EstimatorV2\n", - "\n", "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n", " \"\"\"\n", " Computes the gradients for all available excitation operators.\n", @@ -525,12 +523,12 @@ " # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n", " commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n", " ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n", - " if isinstance(estimator, EstimatorV2):\n", - " gradients = estimator.run([(a, c) for a, c in zip(ansatz_list, commutators)]).result().values\n", - " else:\n", - " gradients = estimator.run(ansatz_list, commutators).result().values\n", + " gradients = estimator.run([(a, c) for a, c in zip(ansatz_list, commutators)]).result()\n", + " gradients_list = []\n", + " for pub_result in gradients:\n", + " gradients_list.append(pub_result.data.evs)\n", "\n", - " return gradients" + " return gradients_list" ] }, { @@ -548,7 +546,7 @@ "outputs": [], "source": [ "def cost_func(params, ansatz, H, estimator):\n", - " energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]\n", + " energy = estimator.run([(ansatz, H, params)]).result()[0].data.evs\n", " return energy" ] }, @@ -575,7 +573,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "ibm_osaka\n" + "ibm_brisbane\n" ] } ], @@ -671,11 +669,11 @@ ], "source": [ "# To run on simulator\n", - "from qiskit.primitives import Estimator\n", + "from qiskit.primitives import StatevectorEstimator as Estimator\n", "\n", "estimator = Estimator()\n", "\n", - "hf_energy = estimator.run(hf_circuit, H).result().values[0]\n", + "hf_energy = estimator.run([(hf_circuit, H)]).result()[0].data.evs\n", "print(f\"Hartree-Fock energy: {hf_energy}\")" ] }, @@ -695,15 +693,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", - " 3.30587015e-08 0.00000000e+00 0.00000000e+00 1.08648412e-09\n", - " -2.42633656e-02 0.00000000e+00 0.00000000e+00 6.68086680e-02\n", - " 0.00000000e+00 -4.61492937e-02 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 -4.61492937e-02 0.00000000e+00\n", - " 6.68086680e-02 0.00000000e+00 0.00000000e+00 -2.50251594e-01]\n", + "[array(3.30587015e-08), array(0.), array(0.), array(1.0864841e-09), array(3.30587015e-08), array(0.), array(0.), array(1.0864841e-09), array(-0.02426337), array(0.), array(0.), array(0.06680867), array(0.), array(-0.04614929), array(0.), array(0.), array(0.), array(0.), array(-0.04614929), array(0.), array(0.06680867), array(0.), array(0.), array(-0.25025159)]\n", "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", - " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.2502515943160275 at index 23.\n" + " 0.125+0.j, 0.125+0.j]) with maximum gradient 0.2502515943160271 at index 23.\n" ] } ], @@ -727,7 +720,7 @@ "metadata": {}, "source": [ "### Expand the Ansatz\n", - "We found that a double-excitation operator in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*\\textrm{max\\_operator})$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." + "We found that a double-excitation operator $O_n$ in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*O_n)$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems." ] }, { @@ -784,7 +777,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[6.18650154]\n" + "[2.58036611]\n" ] } ], @@ -813,15 +806,15 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.966906280631417\n", - " x: [ 6.166e+00]\n", - " nfev: 21\n", + " fun: -7.966906269077601\n", + " x: [ 3.024e+00]\n", + " nfev: 24\n", " maxcv: 0.0\n", + "\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 21 F =-7.966906E+00 MAXCV = 0.000000E+00\n", - " X = 6.165705E+00\n", - "\n" + " NFVALS = 24 F =-7.966906E+00 MAXCV = 0.000000E+00\n", + " X = 3.024170E+00\n" ] } ], @@ -855,8 +848,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found ground energy: -7.966906280631417\n", - "[6.16570545]\n" + "Found ground energy: -7.966906269077601\n", + "[3.02416963]\n" ] } ], @@ -879,11 +872,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00707901 0. 0. -0.00170879 0.00707901 0.\n", - " 0. -0.00170879 -0.01805097 0. 0. 0.07148205\n", - " 0. -0.04085051 0. 0. 0. 0.\n", - " -0.04085051 0. 0.07148205 0. 0. -0.00014222]\n", - "Found maximum gradient 0.07148205138959425 at index 11\n", + "[array(0.00707565), array(0.), array(0.), array(-0.0017079), array(0.00707565), array(0.), array(0.), array(-0.0017079), array(-0.01805408), array(0.), array(0.), array(0.07148028), array(0.), array(-0.04085333), array(0.), array(0.), array(0.), array(0.), array(-0.04085333), array(0.), array(0.07148028), array(0.), array(0.), array(-0.00026435)]\n", + "Found maximum gradient 0.07148028012540592 at index 11\n", "Maximum gradient is below the threshold: False\n" ] } @@ -949,20 +939,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "[1.88075153 2.90894229]\n", + "[3.69347678 1.31200293]\n", " message: Optimization terminated successfully.\n", " success: True\n", " status: 1\n", - " fun: -7.968684164775403\n", + " fun: -7.968684162211259\n", " x: [ 3.260e+00 3.191e+00]\n", - " nfev: 40\n", + " nfev: 38\n", " maxcv: 0.0\n", " Normal return from subroutine COBYLA\n", "\n", - " NFVALS = 40 F =-7.968684E+00 MAXCV = 0.000000E+00\n", - " X = 3.259814E+00 3.191388E+00\n", + " NFVALS = 38 F =-7.968684E+00 MAXCV = 0.000000E+00\n", + " X = 3.259787E+00 3.191352E+00\n", "\n", - "Found ground energy: -7.968684164775403\n" + "Found ground energy: -7.968684162211259\n" ] } ], @@ -1003,132 +993,154 @@ "output_type": "stream", "text": [ "Iter: 0\n", - "Maximum gradient: 0.2502515943160275\n", + "Maximum gradient: 0.2502515943160271\n", "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 23\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.966906248550616\n", - " Iterations: 5\n", - " Function evaluations: 12\n", - " Gradient evaluations: 5\n", - "Result at iter 0: -7.966906248550616\n", + " Current function value: -7.96690628533084\n", + " Iterations: 2\n", + " Function evaluations: 5\n", + " Gradient evaluations: 2\n", + "Result at iter 0: -7.96690628533084\n", "Iter: 1\n", - "Maximum gradient: 0.07148987524972958\n", + "Maximum gradient: 0.07148403096724774\n", "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.96868417953405\n", - " Iterations: 8\n", - " Function evaluations: 27\n", - " Gradient evaluations: 8\n", - "Result at iter 1: -7.96868417953405\n", + " Current function value: -7.968684179381521\n", + " Iterations: 4\n", + " Function evaluations: 14\n", + " Gradient evaluations: 4\n", + "Result at iter 1: -7.968684179381521\n", "Iter: 2\n", - "Maximum gradient: 0.068868892894845\n", + "Maximum gradient: 0.06886933068636508\n", "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 20\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970337106127032\n", - " Iterations: 6\n", - " Function evaluations: 25\n", - " Gradient evaluations: 6\n", - "Result at iter 2: -7.970337106127032\n", + " Current function value: -7.970337033804881\n", + " Iterations: 9\n", + " Function evaluations: 38\n", + " Gradient evaluations: 9\n", + "Result at iter 2: -7.970337033804881\n", "Iter: 3\n", - "Maximum gradient: 0.037927928716381794\n", + "Maximum gradient: 0.037913688371952387\n", "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 13\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.970872593313668\n", - " Iterations: 11\n", - " Function evaluations: 59\n", - " Gradient evaluations: 11\n", - "Result at iter 3: -7.970872593313668\n", + " Current function value: -7.970872545712573\n", + " Iterations: 13\n", + " Function evaluations: 70\n", + " Gradient evaluations: 13\n", + "Result at iter 3: -7.970872545712573\n", "Iter: 4\n", - "Maximum gradient: 0.037029338016181614\n", + "Maximum gradient: 0.0370331504791646\n", "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 18\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971383219968869\n", - " Iterations: 9\n", - " Function evaluations: 58\n", - " Gradient evaluations: 9\n", - "Result at iter 4: -7.971383219968869\n", + " Current function value: -7.9713831777419575\n", + " Iterations: 8\n", + " Function evaluations: 51\n", + " Gradient evaluations: 8\n", + "Result at iter 4: -7.9713831777419575\n", "Iter: 5\n", - "Maximum gradient: 0.032246779954544474\n", + "Maximum gradient: 0.03222663915985274\n", "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 8\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971773034651897\n", - " Iterations: 8\n", - " Function evaluations: 59\n", - " Gradient evaluations: 8\n", - "Result at iter 5: -7.971773034651897\n", + " Current function value: -7.971773096075161\n", + " Iterations: 11\n", + " Function evaluations: 79\n", + " Gradient evaluations: 11\n", + "Result at iter 5: -7.971773096075161\n", "Iter: 6\n", - "Maximum gradient: 0.01066557969828447\n", - "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", - " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", - "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.971979053610505\n", - " Iterations: 24\n", - " Function evaluations: 198\n", - " Gradient evaluations: 24\n", - "Result at iter 6: -7.971979053610505\n", - "Iter: 7\n", - "Maximum gradient: 0.009733825023488506\n", + "Maximum gradient: 0.010822180643551265\n", "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.575750153251004\n", - " Iterations: 18\n", - " Function evaluations: 166\n", - " Gradient evaluations: 18\n", - "Result at iter 7: -7.575750153251004\n", + " Current function value: -7.843848009002418\n", + " Iterations: 17\n", + " Function evaluations: 140\n", + " Gradient evaluations: 17\n", + "Result at iter 6: -7.843848009002418\n", + "Iter: 7\n", + "Maximum gradient: 0.027309663041504336\n", + "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n", + " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.9721464190570135\n", + " Iterations: 19\n", + " Function evaluations: 176\n", + " Gradient evaluations: 19\n", + "Result at iter 7: -7.9721464190570135\n", "Iter: 8\n", - "Maximum gradient: 0.003801700281861138\n", + "Maximum gradient: 0.007078468872372422\n", "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.969374151774823\n", - " Iterations: 15\n", - " Function evaluations: 151\n", - " Gradient evaluations: 15\n", - "Result at iter 8: -7.969374151774823\n", + " Current function value: -7.969650196128157\n", + " Iterations: 35\n", + " Function evaluations: 354\n", + " Gradient evaluations: 35\n", + "Result at iter 8: -7.969650196128157\n", "Iter: 9\n", - "Maximum gradient: 0.07242697313687708\n", + "Maximum gradient: 0.062120282561613935\n", "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n", " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", " 0.125+0.j, 0.125+0.j]) at index 11\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972016127080447\n", - " Iterations: 39\n", - " Function evaluations: 432\n", - " Gradient evaluations: 39\n", - "Result at iter 9: -7.972016127080447\n", + " Current function value: -7.970433246503186\n", + " Iterations: 20\n", + " Function evaluations: 221\n", + " Gradient evaluations: 20\n", + "Result at iter 9: -7.970433246503186\n", "Iter: 10\n", - "Maximum gradient: 0.009157872586500545\n", + "Maximum gradient: 0.04600075108884966\n", + "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 8\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.97202896422045\n", + " Iterations: 40\n", + " Function evaluations: 484\n", + " Gradient evaluations: 40\n", + "Result at iter 10: -7.97202896422045\n", + "Iter: 11\n", + "Maximum gradient: 0.007578946243724553\n", "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n", " coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n", "Optimization terminated successfully (Exit mode 0)\n", - " Current function value: -7.972179299161537\n", - " Iterations: 22\n", - " Function evaluations: 269\n", - " Gradient evaluations: 22\n", - "Result at iter 10: -7.972179299161537\n", - "Iter: 11\n", - "Maximum gradient: 0.0005877035461707937\n", + " Current function value: -7.971706856193244\n", + " Iterations: 28\n", + " Function evaluations: 369\n", + " Gradient evaluations: 28\n", + "Result at iter 11: -7.971706856193244\n", + "Iter: 12\n", + "Maximum gradient: 0.03538610952465948\n", + "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n", + " coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j, 0.125+0.j, -0.125+0.j, 0.125+0.j,\n", + " 0.125+0.j, 0.125+0.j]) at index 18\n", + "Optimization terminated successfully (Exit mode 0)\n", + " Current function value: -7.972179565844087\n", + " Iterations: 35\n", + " Function evaluations: 496\n", + " Gradient evaluations: 35\n", + "Result at iter 12: -7.972179565844087\n", + "Iter: 13\n", + "Maximum gradient: 0.00030622409164124463\n", "Terminating: converged.\n", - "Found ground energy: -7.972179299161537\n" + "Found ground energy: -7.972179565844087\n" ] } ], "source": [ "from qiskit.circuit.library import EvolvedOperatorAnsatz\n", - "from qiskit.primitives import Estimator\n", + "from qiskit.primitives import StatevectorEstimator as Estimator\n", "from qiskit.synthesis import LieTrotter\n", "from scipy.optimize import minimize\n", "\n", @@ -1202,7 +1214,7 @@ "from qiskit.synthesis import LieTrotter\n", "\n", "# To continue running on real hardware use\n", - "from qiskit_ibm_runtime import EstimatorV2, EstimatorOptions, Session\n", + "from qiskit_ibm_runtime import EstimatorV2 as Estimator, EstimatorOptions, Session\n", "from scipy.optimize import minimize\n", "\n", "hf_circuit_ibm = pm.run(hf_circuit)\n", @@ -1222,7 +1234,7 @@ " ansatz = hf_circuit_ibm\n", " hamiltonian = H_ibm\n", " excitation_pool = single_excitation_operators + double_excitation_operators\n", - " estimator = EstimatorV2(session=Session(service, backend=backend), options=session_options)\n", + " estimator = Estimator(session=Session(service, backend=backend), options=session_options)\n", " params = None\n", "\n", " iter = 0\n", diff --git a/pyproject.toml b/pyproject.toml index 93f7264..cacb17c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -75,6 +75,8 @@ notebook = [ "qiskit-aer >= 0.11.0", "nbqa >= 1.3.1", "treon >= 0.1.3", + # EXTRA + "pyscf >= 2.4.0" ] [project.urls] From 71b5669c27df15de527a6859a3f04b328bf3ce7c Mon Sep 17 00:00:00 2001 From: Pedro Rivero Date: Sat, 30 Mar 2024 05:41:19 -0400 Subject: [PATCH 17/17] docs: move file from tutorials to notebooks directory --- docs/{tutorials => notebooks}/adapt-vqe.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/{tutorials => notebooks}/adapt-vqe.ipynb (100%) diff --git a/docs/tutorials/adapt-vqe.ipynb b/docs/notebooks/adapt-vqe.ipynb similarity index 100% rename from docs/tutorials/adapt-vqe.ipynb rename to docs/notebooks/adapt-vqe.ipynb