From c8513f108f8d7761348367b1b9cc2ab1639f3726 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 25 Jan 2024 14:17:35 +0800 Subject: [PATCH 001/116] dbi scheduling first commit: added feature 3 options of scheduling methods. --- examples/dbi/dbi_scheduling.ipynb | 275 ++++++++++++++++++++++++++ src/qibo/models/dbi/double_bracket.py | 139 ++++++++++++- 2 files changed, 411 insertions(+), 3 deletions(-) create mode 100644 examples/dbi/dbi_scheduling.ipynb diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb new file mode 100644 index 0000000000..066d56640d --- /dev/null +++ b/examples/dbi/dbi_scheduling.ipynb @@ -0,0 +1,275 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-bracket Iteration Scheduling Strategies\n", + "\n", + "This notebook presents the different strategies for scheduling the step durations for the double-bracket iteration algorithm and their resepctive accuracies." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import the dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", + "from qibo.models.dbi.utils import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Canonical\n", + "Set up the basic test case with the transverse field ising model hamiltonian and the canonical bracket as the generator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first generate the relationship between the step duration and the off-diagoanl norm (loss function) for the first step of the iteration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "s_space = np.linspace(1e-5, 0.6, 100)\n", + "off_diagonal_norm_diff = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The default scheduling strategy is grid search: `DoubleBracketScheduling.use_grid_serach`. This strategy specifies a list of step durations to test one by one and finds the one that maximizes the cost function (off-digonal norm of Hamiltonian)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial expansion\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=5)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('hyperopt first step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specified diagonal operator\n", + "\n", + "While for the cannonical case, all the scheduling methods are accurate, it is important to realize that the global minimum of the loss function is not always so obvious. It is thus necessary to show whether the 3 converges to an agreeable step duration using different iteration generators, such as the Pauli 'ZZ..Z' operator and 'ZZ..I' operator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate the digaonal operators\n", + "Z_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*nqubits)).dense.matrix\n", + "ZI_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*(nqubits-1)+\"I\")).dense.matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", + "d = Z_op\n", + "# generate data for plotting sigma decrease of the first step\n", + "s_space = np.linspace(1e-5, 0.6, 100)\n", + "off_diagonal_norm_diff = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_max=0.6, d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial expansion\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, d=d, n=5)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('hyperopt first step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that there are two similar \"minimal point\" at 0.03 and 0.22, with the latter being the absolute minimum by an insignificant advantage. However, for practical reasons, we prefer taking the first close-minimum calculated by polynomial approximation. Hence, we can use the polynomial approximation to restrict the search area and obtain better results. For example, we define a search range of 0.1 around the polynomial step." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use polynomial expansion as an restriction of hyperopt/grid range" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "search_range = 0.1\n", + "if step_poly < search_range/2:\n", + " step_min = 0\n", + " step_max = search_range\n", + "else:\n", + " step_min = step_poly - search_range/2\n", + " step_max = step_poly + search_range/2\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_min=step_min, step_max=step_max, d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, step_min=step_min, step_max=step_max, max_evals=100, d=d,)\n", + "print('hyperopt_search step:', step_hyperopt)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('hyperopt first step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DBF_qibo", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 15ffdb007e..bb002d3f90 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -1,6 +1,8 @@ +import math from copy import deepcopy from enum import Enum, auto from functools import partial +from typing import Optional import hyperopt import numpy as np @@ -21,6 +23,17 @@ class DoubleBracketGeneratorType(Enum): # TODO: add double commutator (does it converge?) +class DoubleBracketScheduling(Enum): + """Define the DBI scheduling strategies.""" + + use_hyperopt = auto() + """Use hyperopt package.""" + use_grid_search = auto() + """Use greedy grid search.""" + use_polynomial_approximation = auto() + """Use polynomial expansion (analytical) of the loss function.""" + + class DoubleBracketIteration: """ Class implementing the Double Bracket iteration algorithm. @@ -49,10 +62,12 @@ def __init__( self, hamiltonian: Hamiltonian, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, ): self.h = hamiltonian self.h0 = deepcopy(self.h) self.mode = mode + self.scheduling = scheduling def __call__( self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None @@ -115,6 +130,36 @@ def backend(self): """Get Hamiltonian's backend.""" return self.h0.backend + def grid_search_step( + self, + step_min: float = 1e-5, + step_max: float = 1, + num_evals: int = 100, + space: Optional[np.array] = None, + d: Optional[np.array] = None, + ): + """ + Greedy optimization of the iteration step. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + mnum_evals: number of iterations between step_min and step_max; + d: diagonal operator for generating double-bracket iterations. + + Returns: + (float): optimized best iteration step (minimizing off-diagonal norm). + """ + if space is None: + space = np.linspace(step_min, step_max, num_evals) + + if d is None: + d = self.diagonal_h_matrix + + loss_list = [self.loss(step, d=d) for step in space] + idx_max_loss = loss_list.index(min(loss_list)) + return space[idx_max_loss] + def hyperopt_step( self, step_min: float = 1e-5, @@ -124,10 +169,10 @@ def hyperopt_step( optimizer: callable = None, look_ahead: int = 1, verbose: bool = False, - d: np.array = None, + d: Optional[np.array] = None, ): """ - Optimize iteration step. + Optimize iteration step using hyperopt. Args: step_min: lower bound of the search grid; @@ -140,12 +185,14 @@ def hyperopt_step( d: diagonal operator for generating double-bracket iterations. Returns: - (float): optimized best iteration step. + (float): optimized best iteration step (minimizing off-diagonal norm). """ if space is None: space = hyperopt.hp.uniform if optimizer is None: optimizer = hyperopt.tpe + if d is None: + d = self.diagonal_h_matrix space = space("step", step_min, step_max) best = hyperopt.fmin( @@ -157,6 +204,92 @@ def hyperopt_step( ) return best["step"] + def polynomial_step( + self, + n: int = 3, + n_max: int = 5, + d: np.array = None, + backup_scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, + ): + r""" + Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. + e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) + Args: + n (int, optional): The order to which the loss function is expanded. Defaults to 3. + n_max (int, optional): The maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. + d (np.array, optional): The diagonal operator, default as $\delta(H)$. + """ + + if d is None: + d = self.diagonal_h_matrix + + def sigma(h: np.array): + return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) + + def Gamma(k: int): + r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" + if k == 0: + return self.h.matrix + else: + W = self.commutator(d, sigma(self.h.matrix)) + result = self.h.matrix + for _ in range(k): + result = self.commutator(W, result) + return result + + # list starting from s^n highest order to s^0 + sigma_gamma_list = np.array([sigma(Gamma(k)) for k in range(n + 2)]) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients for rotation with [W,H] and H + c1 = [ + exp_coef * delta_gamma + for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[1:]) + ] + c2 = [ + exp_coef * delta_gamma + for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[:-1]) + ] + # product coefficient + trace_coefficients = [0] * (2 * n + 1) + for k in range(n + 1): + for j in range(n + 1): + power = k + j + product_matrix = c1[k] @ c2[j] + trace_coefficients[power] += 2 * np.trace(product_matrix) + roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + error = 1e-3 + real_positive_roots = [ + np.real(root) + for root in roots + if np.imag(root) < error and np.real(root) > 0 + ] + # solution exists, return minimum s + if len(real_positive_roots) > 0: + return min(real_positive_roots) + # solution does not exist, resort to backup scheduling + elif ( + backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation + and n < n_max + 1 + ): + return self.polynomial_step(d, n=n + 1, backup_scheduling=backup_scheduling) + else: + return self.choose_step(d, backup_scheduling) + + def choose_step( + self, + d: Optional[np.array] = None, + scheduling: Optional[DoubleBracketScheduling] = None, + **kwargs, + ): + if scheduling is None: + scheduling = self.scheduling + if scheduling is DoubleBracketScheduling.use_grid_search: + return self.grid_search_step(d=d, **kwargs) + if scheduling is DoubleBracketScheduling.use_hyperopt: + return self.hyperopt_step(d=d, **kwargs) + if scheduling is DoubleBracketScheduling.use_polynomial_approximation: + return self.polynomial_step(d=d, **kwargs) + def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ Compute loss function distance between `look_ahead` steps. From 5567114a50519c477569d4a2c6da6fea4e45aeef Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 29 Jan 2024 18:15:22 +0800 Subject: [PATCH 002/116] Tests for double_bracket.py scheduling: test_double_bracket_iteration_scheduling_polynomial; test_double_bracket_iteration_scheduling_grid_hyperopt --- examples/dbi/dbi_scheduling.ipynb | 11 +++- src/qibo/models/dbi/double_bracket.py | 11 +++- tests/test_models_dbi.py | 92 ++++++++++++++++++++------- 3 files changed, 87 insertions(+), 27 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 066d56640d..15f4de2339 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -65,7 +65,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We first generate the relationship between the step duration and the off-diagoanl norm (loss function) for the first step of the iteration." + "We first run a sweep of step duration to map the off-diagonal norm in this range." ] }, { @@ -152,7 +152,7 @@ "outputs": [], "source": [ "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", - "d = Z_op\n", + "d = ZI_op\n", "# generate data for plotting sigma decrease of the first step\n", "s_space = np.linspace(1e-5, 0.6, 100)\n", "off_diagonal_norm_diff = []\n", @@ -249,6 +249,13 @@ "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hence, we see that the strategy is indeed effective for finding the first minimum of the loss funciton for both the Z operator and the ZI operator." + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index bb002d3f90..6749c378a8 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -209,7 +209,7 @@ def polynomial_step( n: int = 3, n_max: int = 5, d: np.array = None, - backup_scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, + backup_scheduling: DoubleBracketScheduling = None, ): r""" Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. @@ -223,6 +223,9 @@ def polynomial_step( if d is None: d = self.diagonal_h_matrix + if backup_scheduling is None: + backup_scheduling = DoubleBracketScheduling.use_grid_search + def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) @@ -271,9 +274,11 @@ def Gamma(k: int): backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation and n < n_max + 1 ): - return self.polynomial_step(d, n=n + 1, backup_scheduling=backup_scheduling) + return self.polynomial_step( + n=n + 1, d=d, backup_scheduling=backup_scheduling + ) else: - return self.choose_step(d, backup_scheduling) + return self.choose_step(d=d, scheduling=backup_scheduling) def choose_step( self, diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 90c0c1804b..6ee130f71e 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -6,74 +6,75 @@ from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, + DoubleBracketScheduling, ) from qibo.quantum_info import random_hermitian -NSTEPS = 50 +NSTEPS = 1 """Number of steps for evolution.""" @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_canonical(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) - dbf = DoubleBracketIteration( + dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.canonical, ) - initial_off_diagonal_norm = dbf.off_diagonal_norm + initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - dbf(step=np.sqrt(0.001)) + dbi(step=np.sqrt(0.001)) - assert initial_off_diagonal_norm > dbf.off_diagonal_norm + assert initial_off_diagonal_norm > dbi.off_diagonal_norm @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_group_commutator(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) - dbf = DoubleBracketIteration( + dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.group_commutator, ) - initial_off_diagonal_norm = dbf.off_diagonal_norm + initial_off_diagonal_norm = dbi.off_diagonal_norm with pytest.raises(ValueError): - dbf(mode=DoubleBracketGeneratorType.group_commutator, step=0.01) + dbi(mode=DoubleBracketGeneratorType.group_commutator, step=0.01) for _ in range(NSTEPS): - dbf(step=0.01, d=d) + dbi(step=0.01, d=d) - assert initial_off_diagonal_norm > dbf.off_diagonal_norm + assert initial_off_diagonal_norm > dbi.off_diagonal_norm @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_single_commutator(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) - dbf = DoubleBracketIteration( + dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, ) - initial_off_diagonal_norm = dbf.off_diagonal_norm + initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - dbf(step=0.01, d=d) - dbf(step=0.01) + dbi(step=0.01, d=d) + dbi(step=0.01) - assert initial_off_diagonal_norm > dbf.off_diagonal_norm + assert initial_off_diagonal_norm > dbi.off_diagonal_norm @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_hyperopt_step(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) - dbf = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) + dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) # find initial best step with look_ahead = 1 initial_step = 0.01 delta = 0.02 - step = dbf.hyperopt_step( + step = dbi.hyperopt_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100 ) @@ -81,12 +82,12 @@ def test_hyperopt_step(backend, nqubits): # evolve following the optimized first step for generator in DoubleBracketGeneratorType: - dbf(mode=generator, step=step, d=d) + dbi(mode=generator, step=step, d=d) # find the following step size with look_ahead look_ahead = 3 - step = dbf.hyperopt_step( + step = dbi.hyperopt_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100, @@ -95,12 +96,59 @@ def test_hyperopt_step(backend, nqubits): # evolve following the optimized first step for gentype in range(look_ahead): - dbf(mode=DoubleBracketGeneratorType(gentype + 1), step=step, d=d) + dbi(mode=DoubleBracketGeneratorType(gentype + 1), step=step, d=d) def test_energy_fluctuations(backend): h0 = np.array([[1, 0], [0, -1]]) state = np.array([1, 0]) - dbf = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend)) - energy_fluctuation = dbf.energy_fluctuation(state=state) + dbi = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend)) + energy_fluctuation = dbi.energy_fluctuation(state=state) assert energy_fluctuation == 0 + + +@pytest.mark.parametrize( + "scheduling", + [DoubleBracketScheduling.use_grid_search, DoubleBracketScheduling.use_hyperopt], +) +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +def test_double_bracket_iteration_scheduling_grid_hyperopt( + backend, nqubits, scheduling +): + h0 = random_hermitian(2**nqubits, backend=backend) + d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + ) + initial_off_diagonal_norm = dbi.off_diagonal_norm + for _ in range(NSTEPS): + step1 = dbi.choose_step(d=d, scheduling=scheduling) + dbi(d=d, step=step1) + step2 = dbi.choose_step(scheduling=scheduling) + dbi(step=step2) + assert initial_off_diagonal_norm > dbi.off_diagonal_norm + + +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("n", [2, 3]) +@pytest.mark.parametrize( + "backup_scheduling", [None, DoubleBracketScheduling.use_polynomial_approximation] +) +def test_double_bracket_iteration_scheduling_polynomial( + backend, nqubits, n, backup_scheduling +): + h0 = random_hermitian(2**nqubits, backend=backend) + d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + scheduling=DoubleBracketScheduling.use_polynomial_approximation, + ) + initial_off_diagonal_norm = dbi.off_diagonal_norm + for _ in range(NSTEPS): + step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) + dbi(d=d, step=step1) + step2 = dbi.polynomial_step(n=n) + dbi(step=step2) + assert initial_off_diagonal_norm > dbi.off_diagonal_norm From abddfaee79de8e68d2b2794d608937762b1de2ad Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 29 Jan 2024 23:58:15 +0800 Subject: [PATCH 003/116] Updated utils and Pauli-Z notebook for scheduling --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 50 +++++-------------- src/qibo/models/dbi/utils.py | 27 +++------- 2 files changed, 20 insertions(+), 57 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 0f76a36245..d89fdd5e74 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -122,31 +122,16 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.4|INFO|2024-01-24 19:59:31]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 8.48528137423857\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# set the qibo backend (we suggest qibojit if N >= 20)\n", "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", "set_backend(\"qibojit\", \"numba\")\n", "\n", "# hamiltonian parameters\n", - "nqubits = 2\n", + "nqubits = 5\n", "h = 3\n", "\n", "# define the hamiltonian\n", @@ -160,20 +145,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[-2.-0.j -0.-0.j -0.-0.j -0.-0.j]\n", - " [-0.-0.j 2.-0.j -0.-0.j -0.-0.j]\n", - " [-0.-0.j -0.-0.j 2.-0.j -0.-0.j]\n", - " [-0.-0.j -0.-0.j -0.-0.j -2.-0.j]]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(H_TFIM.matrix)" ] @@ -219,8 +193,9 @@ "# add in initial values for plotting\n", "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", "steps = [0]\n", + "scheduling = DoubleBracketScheduling.use_hyperopt\n", "for _ in range(NSTEPS):\n", - " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", + " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", " if flip_sign < 0:\n", @@ -294,7 +269,6 @@ " step_max = 1,\n", " space = hp.uniform,\n", " optimizer = tpe,\n", - " max_evals = max_evals,\n", " )\n", " dbi_canonical(step=step)\n", " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", @@ -389,7 +363,7 @@ "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", - " dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, compare_canonical=True, max_evals=max_evals)\n", + " dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, scheduling=scheduling, compare_canonical=True, max_evals=max_evals, step_max=step_max)\n", " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", " if idx == len(Z_ops):\n", @@ -479,7 +453,7 @@ "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n", "for _ in range(remaining_NSTEPS):\n", - " dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, compare_canonical=False)\n", + " dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", " off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n", " steps_mixed_can.append(step)\n", " if idx == len(Z_ops):\n", diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 5969637b62..f354a9398b 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -11,6 +11,7 @@ from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, + DoubleBracketScheduling, ) @@ -71,11 +72,9 @@ def select_best_dbr_generator( dbi_object: DoubleBracketIteration, d_list: list, step: Optional[float] = None, - step_min: float = 1e-5, - step_max: float = 1, - max_evals: int = 200, compare_canonical: bool = True, - mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.single_commutator, + scheduling: DoubleBracketScheduling = None, + **kwargs, ): """Selects the best double bracket rotation generator from a list and runs the @@ -88,11 +87,12 @@ def select_best_dbr_generator( step_max (float): Maximally allowed iteration duration. max_evals (int): Maximally allowed number of evaluation in hyperopt. compare_canonical (bool): If `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - mode (_DoubleBracketGeneratorType): DBI generator type used for the selection. Returns: The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. """ + if scheduling is None: + scheduling = dbi_object.scheduling norms_off_diagonal_restriction = [ dbi_object.off_diagonal_norm for _ in range(len(d_list)) ] @@ -104,13 +104,8 @@ def select_best_dbr_generator( flip_list[i] = CS_angle_sgn(dbi_eval, d) if flip_list[i] != 0: if step is None: - step_best = dbi_eval.hyperopt_step( - d=flip_list[i] * d, - step_min=step_min, - step_max=step_max, - space=hp.uniform, - optimizer=tpe, - max_evals=max_evals, + step_best = dbi_eval.choose_step( + d=flip_list[i] * d, scheduling=scheduling, **kwargs ) else: step_best = step @@ -123,13 +118,7 @@ def select_best_dbr_generator( dbi_eval = deepcopy(dbi_object) dbi_eval.mode = DoubleBracketGeneratorType.canonical if step is None: - step_best = dbi_eval.hyperopt_step( - step_min=step_min, - step_max=step_max, - space=hp.uniform, - optimizer=tpe, - max_evals=max_evals, - ) + step_best = dbi_eval.choose_step(scheduling=scheduling, **kwargs) else: step_best = step dbi_eval(step=step_best) From 1948c012166fec7c92e3bc6307c79b8ece389646 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 30 Jan 2024 14:34:55 +0800 Subject: [PATCH 004/116] Notebook section shows difference of scheduling techniques in Pauli-Z strategies --- examples/dbi/dbi_scheduling.ipynb | 110 ++++++++++++++++++++++++++++-- 1 file changed, 106 insertions(+), 4 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 15f4de2339..275d2dea73 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -170,13 +170,16 @@ "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_max=0.6, d=d)\n", - "print('grid_search step:', step_grid)\n", + "grid_min = dbi.loss(step=step_grid, d=d)-dbi.off_diagonal_norm\n", + "print('grid_search step:', step_grid, 'loss', grid_min)\n", "# hyperopt\n", "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, d=d, max_evals=100, step_max=0.6)\n", - "print('hyperopt_search step:', step_hyperopt)\n", + "hyperopt_min = dbi.loss(step=step_hyperopt, d=d)-dbi.off_diagonal_norm\n", + "print('hyperopt_search step:', step_hyperopt, 'loss', hyperopt_min)\n", "# polynomial expansion\n", "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, d=d, n=5)\n", - "print('polynomial_approximation step:', step_poly)" + "poly_min = dbi.loss(step=step_poly, d=d)-dbi.off_diagonal_norm\n", + "print('polynomial_approximation step:', step_poly, 'loss', poly_min)" ] }, { @@ -188,6 +191,8 @@ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.text(x=step_grid, y=grid_min, s=f'grid min \\n{round(grid_min,3)}')\n", + "plt.text(x=step_poly, y=poly_min, s=f'grid min \\n{round(poly_min,3)}')\n", "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", @@ -208,7 +213,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Use polynomial expansion as an restriction of hyperopt/grid range" + "## Use polynomial expansion as an restriction for hyperopt/grid range" ] }, { @@ -256,6 +261,103 @@ "source": [ "Hence, we see that the strategy is indeed effective for finding the first minimum of the loss funciton for both the Z operator and the ZI operator." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare in Pauli-Z strategy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qibo.quantum_info import random_hermitian\n", + "from qibo.hamiltonians import Hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "nqubits = 4\n", + "h0 = random_hermitian(2**nqubits)\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(Hamiltonian(nqubits=nqubits, matrix=h0)),mode=DoubleBracketGeneratorType.single_commutator)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "generate_local_Z = generate_Z_operators(nqubits)\n", + "Z_ops = list(generate_local_Z.values())\n", + "Z_names = list(generate_local_Z.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NSTEPS = 8\n", + "scheduling_list = [DoubleBracketScheduling.use_grid_search,\n", + " DoubleBracketScheduling.use_hyperopt,\n", + " DoubleBracketScheduling.use_polynomial_approximation,]\n", + "scheduling_labels = ['grid search',\n", + " 'hyperopt',\n", + " 'polynomial',]\n", + "Z_optimal_scheduling = []\n", + "s_scheduling = []\n", + "off_norm_scheduling =[]\n", + "for i,scheduling in enumerate(scheduling_list):\n", + " # reinitialize\n", + " dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=deepcopy(h0)), mode=DoubleBracketGeneratorType.single_commutator)\n", + " Z_optimal = []\n", + " # add in initial values for plotting\n", + " off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", + " steps = [0]\n", + " print(f'----------Scheduling {scheduling_labels[i]}----------')\n", + " for _ in range(NSTEPS):\n", + " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False)\n", + " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", + " steps.append(steps[-1]+step)\n", + " if flip_sign < 0:\n", + " Z_optimal.append('-' + Z_names[idx])\n", + " else:\n", + " Z_optimal.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi.off_diagonal_norm}\")\n", + " Z_optimal_scheduling.append(Z_optimal)\n", + " s_scheduling.append(steps)\n", + " off_norm_scheduling.append(off_diagonal_norm_history)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "for i, scheduling in enumerate(scheduling_labels):\n", + " plt.plot(s_scheduling[i], off_norm_scheduling[i], '-o', label=scheduling)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Norm off-diagonal restriction\")\n", + "plt.title(\"Compare Variational Pauli-Z using different scheduling strategies\")\n", + "plt.legend()" + ] } ], "metadata": { From 15e52e2b9f301fa20f1766ce5dce0dcb949641c5 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 2 Feb 2024 10:25:51 +0100 Subject: [PATCH 005/116] Create group_commutator_iteration_transpiler #This will contain a class inheriting from double bracket and it will extend it by connecting to functionalities of TrotterHamiltonian --- src/qibo/models/dbi/group_commutator_iteration_transpiler | 1 + 1 file changed, 1 insertion(+) create mode 100644 src/qibo/models/dbi/group_commutator_iteration_transpiler diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler b/src/qibo/models/dbi/group_commutator_iteration_transpiler new file mode 100644 index 0000000000..787e352503 --- /dev/null +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler @@ -0,0 +1 @@ +#This will contain a class inheriting from double bracket and it will extend it by connecting to functionalities of TrotterHamiltonian From d50d13bb50816a6268bd48e8dc22cf40485351ac Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 2 Feb 2024 10:29:45 +0100 Subject: [PATCH 006/116] adding the code structure from this week. More work needed to fill in the gaps. Next simplify, assume the oracles are numpy and then pass on to Matteo, Andrea, Edoardo to generalize the code to be backend independent --- .../group_commutator_iteration_transpiler.py | 221 ++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 src/qibo/models/dbi/group_commutator_iteration_transpiler.py diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py new file mode 100644 index 0000000000..4018d9d412 --- /dev/null +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -0,0 +1,221 @@ +from qibo import * +from qibo.models.dbi import * +from qibo.hamiltonians import SymbolicHamiltonian +from qibo import symbols +from qibo.models.dbi.double_bracket import * + +from copy import deepcopy +from enum import Enum, auto +from functools import partial + +import hyperopt +import numpy as np + +from qibo.config import raise_error +from qibo.hamiltonians import Hamiltonian + +class DoubleBracketGeneratorType(Enum): + """Define the evolution generator of a variant of the double-bracket iterations.""" + + canonical = auto() + """Use canonical commutator.""" + + custom = auto() + """Use some input diagonal matrix""" + +class DoubleBracketRotationType(Enum): + #The dbr types below need a diagonal input matrix $\hat D_k$ : + + single_commutator = auto() + """Use single commutator.""" + + group_commutator = auto() + """Use group commutator approximation""" + + group_commutator_reduced = auto() + """Use group commutator approximation with a reduction using symmetry + + """ + + group_commutator_imperfect = auto() + """Use group commutator approximation""" + + group_commutator_reduced_imperfect = auto() + """Use group commutator approximation: + symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. + We extrapolate that symmetry to the imperfect inversion. + Note that while may not be performing a similarity operation on the generator of the double bracket iteration, + the unfolded operation applied to a state vector will still be unitary: + + """ + + class EvolutionOracleType(Enum): + numpy = auto() + TrotterSuzuki = auto() + + +class GroupCommutatorIterationWithEvolutionOracles(DoubleBracketIteration): + """ + Class which will be later merged into the @super but for now develops new tricks in a private repository. + """ + + def __init__( + self, + hamiltonian: Hamiltonian, + mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, + mode_GCI_inversion: EvolutionOracleInputHamiltonianReversalType = None, + ): + super().__init__( hamiltonian, mode ) + + self.mode_GCI_inversion = mode_GCI_inversion + self.mode_DBR = mode_DBR + def __call__( + self, step: float, mode_DBR: DoubleBracketRotationType = None, d: np.array = None + ): + + if mode_DBR is None: + mode_DBR= self.mode_DBR + if d is None: + if self.mode is DoubleBracketGeneratorType.canonical: + d = self.diagonal_h_matrix + else: + raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") + + if mode_DBR is DoubleBracketRotationType.group_commutator_reduced: + + double_bracket_rotation = self.group_commutator_reduced(step, d) + double_bracket_rotation_dagger = double_bracket_rotation.T.conj() + else: + super().__call__(step, d ) + + self.h.matrix = double_bracket_rotation_dagger @ self.h.matrix @ double_bracket_rotation + + + def group_commutator_reduced(self, step, d = None): + if d is None: + if mode is DoubleBracketRotationType.canonical: + d = self.diagonal_h_matrix + else: + raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") + return ( + self.backend.calculate_matrix_exp(-step, d) + @ self.h.exp(step) + @ self.backend.calculate_matrix_exp(step, d) + ) + + class DBI_step: + def __init__( + self, + s_step: double, + d: Hamiltonian, + mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, + mode_GCI_inversion: EvolutionOracleInputHamiltonianReversalType = None, + ): + self.s_step = s_step + self.d = d + self.mode = mode #@TODO: this should allow to request gradient search or other operator optimization + self.mode_GCI_inversion = mode_GCI_inversion + self.mode_DBR = mode_DBR + @property + def circuit_sequence(self): + if mode_DBR = DoubleBracketRotationType.group_commutator_reduced + return [EvolutionOracleDiagonalInput(s_step, d), EvolutionOracleInputHamiltonian(s_step), EvolutionOracleDiagonalInput(s_step,d) ] + class EvolutionOracle: + def __init__(h: TrotterHamiltonian = None): + self.h = h + def get_circuit(self, t_duration) + freturn self.h.circuit(t_duration) + class EvolutionOracleDiagonalInput(EvolutionOracle): + def __init__(): + self.name = 'DiagonalInput' + + class EvolutionOracleInputHamiltonian(EvolutionOracle): + def __init__(): + self.name = 'Input Hamiltonian' + + def unfold_DBI_circuit_symbolic(self, nmb_DBI_steps = 1, s_list, d_list = None): + if d is None: + if mode is DoubleBracketRotationType.canonical: + d = self.diagonal_h_matrix + else: + print( DoubleBracketRotationType.canonical) + raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") + if nmb_DBI_steps == 1: + return [ DBI_step( s_list[0], d_list[0], mode_DBR= DoubleBracketRotationType.group_commutator_reduced).circuit_sequence ] + else: + circuit_sequence_so_far = self.unfold_DBI_circuit_symbolic( nmb_DBI_steps = nmb_DBI_steps - 1, s_list,d_list ) + shift_frame_Hk_H0 = reverse(circuit_sequence_so_far) + [EvolutionOracleInputHamiltonian(s_step[nmb_DBI_steps]) ] + circuit_sequence_so_far + return circuit_sequence_so_far.append(EvolutionOracleDiagonalInput(s_step, d[nmb_DBI_steps])) + + shift_frame_Hk_H0.append(EvolutionOracleDiagonalInput(-s_step, d[nmb_DBI_steps])) + + + + def group_commutator_reduced_unfold(self, step, d = None): + if d is None: + if mode is DoubleBracketRotationType.canonical: + d = self.diagonal_h_matrix + else: + print( DoubleBracketRotationType.canonical) + raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") + return ( + self.backend.calculate_matrix_exp(-step, d) + @ self.unfold_DBI_circuit( nmb_dbi_steps = k ).T.conj() + @ self.evolution_oracle_reverse_h(step, self.h0) + @ self.unfold_DBI_circuit( nmb_dbi_steps = k ) + @ self.backend.calculate_matrix_exp(step, d) + ) + + def evolution_oracle_reverse_h(self, step, h): + if self.mode_GCI_inversion is None: + raise_error(ValueError, f"You need to specify what is {self.mode_GCI_inversion} when running a GCI step with the imperfect group commutator") + + if self.mode_GCI_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites: + R = self.evolution_oracle_reversal_conjugation_by_flips(step) + elif self.mode_GCI_inversion is EvolutionOracleInputHamiltonianReversalType.product_Hadamards: + R = self.evolution_oracle_reversal_conjugation_by_hadamards(step) + elif self.mode_GCI_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites_and_NN_Ising_correction: + R = self.evolution_oracle_reversal_conjugation_by_flips(step) + Z = self.evolution_oracle_reversal_conjugation_by_unitary_diagonal_correction(R, step, h) + return R.matrix @ h.exp(step) @ R.matrix @ Z.matrix + else: + raise_error(TypeError, "Not implemented") + return R.matrix @ h.exp(step) @ R.matrix + + def evolution_oracle_reversal_conjugation_by_flips(self,step): + + R = symbols.I(0) + for qubit_nmb in range(self.h.nqubits): + if np.mod(qubit_nmb,2) == 0: + R *= symbols.X(qubit_nmb) + + return SymbolicHamiltonian(R, nqubits = self.h.nqubits) + + def evolution_oracle_reversal_conjugation_by_hadamards(self,step): + + R = symbols.I(0) + for qubit_nmb in range(self.h.nqubits): + if np.mod(qubit_nmb,2) == 0: + R *= ( symbols.X(qubit_nmb)+symbols.Z(qubit_nmb))/np.sqrt(2) + + return SymbolicHamiltonian(R, nqubits = self.nqubits) + + def evolution_oracle_reversal_conjugation_by_unitary_diagonal_correction(self,R, step, h, how = 'default'): + """This function takes an input reversal unitary and searches for the correction of diagonal terms variationally""" + @TODO use hyperopt to find d + if how is 'hyperopt': + def loss( d, s): + np.linalg.norm( R.matrix @ h.exp(s) @ R.matrix @ d @ h.exp(s) - h.exp(0) ) + raise_error(TypeError, "Not implemented") + else: + d0 = np.inv( R.matrix @ h.exp(s) @ R.matrix @ h.exp(s) ) + d1 = self.backend.cast(np.diag(np.diag(self.backend.to_numpy( d0 )))) + from import scipy.linalg import polar + return polar(d1)[0] + def evolution_oracle_input_hamiltonian(self,step, diagonal_correction): + raise_error(TypeError, "Not implemented") + + return None + #Questions + From ffac68e4e2385ad39ce72da617b90f040af2077b Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 5 Feb 2024 05:37:35 +0100 Subject: [PATCH 007/116] removing stray file --- src/qibo/models/dbi/group_commutator_iteration_transpiler | 1 - 1 file changed, 1 deletion(-) delete mode 100644 src/qibo/models/dbi/group_commutator_iteration_transpiler diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler b/src/qibo/models/dbi/group_commutator_iteration_transpiler deleted file mode 100644 index 787e352503..0000000000 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler +++ /dev/null @@ -1 +0,0 @@ -#This will contain a class inheriting from double bracket and it will extend it by connecting to functionalities of TrotterHamiltonian From 9d7db21fedaa63a1bae2e7cd7846bf888ea87a34 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 5 Feb 2024 08:11:53 +0100 Subject: [PATCH 008/116] Making a mess and exploring how to meaningfully structure evolution types --- src/qibo/models/dbi/double_bracket.py | 389 +++++++++++++----- .../group_commutator_iteration_transpiler.py | 76 +--- 2 files changed, 303 insertions(+), 162 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 976fcbc021..983733d1c9 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -8,33 +8,318 @@ from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian - -class DoubleBracketGeneratorType(Enum): - """Define DBF evolution.""" - +class DoubleBracketDiagonalAssociationType(Enum): + """Define the evolution generator of a variant of the double-bracket iterations.""" + canonical = auto() """Use canonical commutator.""" + + custom = auto() + """Use some input diagonal matrix for each step: general diagonalization DBI""" + + custom_constant = auto() + """Use same input diagonal matrix in each step: BHMM DBI""" + +class DiagonalAssociation: + + def __init__( + self, + k_step_number: list = None, + s_step_duration: double = None, + d: EvolutionHamiltonian, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString + ): + z=1 +class EvolutionHamiltonian: + def __init__(mode_EvolutionOracle: EvolutionOracleType + def queryEvolution(self, t_duration): + return 0 + +class DiagonalAssociationDephasing(DiagonalAssociation): + + def __init__( + self, + H: AbstractHamiltonian, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString + ): + def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_duration = None ): + if mode_EvolutionOracle is EvolutionOracleType.nameString: + if t_duration is None: + #iterate over all Z ops + return '\Delta(' + J_input.name + ')' + else: + return 'exp( i'+ str(t_duration) +'\Delta(' + J_input.name + ')' + elif mode_EvolutionOracle is EvolutionOracleType.numerical: + if t_duration is None: + #iterate over all Z ops + return sum Z @ J_input @ Z + else: + return sum Z @ J_input.exp(t_duration) @Z + if mode_EvolutionOracle is EvolutionOracleType.TrotterSuzuki: + if t_duration is None: + #iterate over all Z ops + return sum Z @ J_input @ Z + else: + return sum Z @ J_input.circuit(t_duration) @Z + +class DiagonalAssociationFromList(DiagonalAssociation): + + def __init__( + self, + d_k_list: list = None, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString +): + self.d_k_list = d_k_list + + def __call__(self, k_step_number: list = None, t_duration = None ): + if mode_EvolutionOracle is EvolutionOracleType.nameString: + if t_duration is None: + return 'D_' + str(k_step_number) + else: + return 'exp( i'+ str(t_duration) +'D_k' + elif mode_EvolutionOracle is EvolutionOracleType.numerical: + if t_duration is None: + return + else: + return sum Z @ J_input.exp(t_duration) @Z + if mode_EvolutionOracle is EvolutionOracleType.TrotterSuzuki: + if t_duration is None: + raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") + else: + return sum Z @ J_input.circuit(t_duration) @Z + +class DiagonalAssociationFromOptimization(DiagonalAssociation): + + def __init__( + self, + d_k_list: list = None, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString +): + self.d_k_list = d_k_list + + def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duration = None ): + if mode_EvolutionOracle is EvolutionOracleType.nameString: + if t_duration is None: + return 'Optimize $\mu$ D_' + str(k_step_number) + else: + return 'Optimize $\mu$ exp( i'+ str(t_duration) +'D_k' + elif mode_EvolutionOracle is EvolutionOracleType.numerical: + if t_duration is None: + return + else: + return sum Z @ J_input.exp(t_duration) @Z + if mode_EvolutionOracle is EvolutionOracleType.TrotterSuzuki: + if t_duration is None: + raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") + else: + return sum Z @ J_input.circuit(t_duration) @Z + + + +class DoubleBracketRotationType(Enum): + #The dbr types below need a diagonal input matrix $\hat D_k$ : + single_commutator = auto() """Use single commutator.""" + group_commutator = auto() """Use group commutator approximation""" - # TODO: add double commutator (does it converge?) + + group_commutator_reduced = auto() + """Use group commutator approximation with a reduction using symmetry + + """ + + ## Reserving for later development + group_commutator_imperfect = auto() + """Use group commutator approximation""" + + group_commutator_reduced_imperfect = auto() + """Use group commutator approximation: + symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. + We extrapolate that symmetry to the imperfect reversal. + Note that while may not be performing a similarity operation on the generator of the double bracket iteration, + the unfolded operation applied to a state vector will still be unitary: + + """ + +class EvolutionOracleType(Enum): + nameString = auto() + """If you only want to get a sequence of names of the oracle""" + + numerical = auto() + """If you will work with exp(is_k J_k) as a numerical matrix""" + + TrotterSuzuki = auto() + """If you will use SymbolicHamiltonian""" + +class EvolutionOracle: + def __init__( J: AbstractHamiltonian = None, + name = None, + mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString ): + self.h = h + self.mode_EvolutionOracle = mode_EvolutionOracle + self.name = name + def __call__(self, t_duration: double = None, d: np.array = None): + """ Returns either the name or the circuit """ + if t is None: + return self.name + else: + return self.get_circuit( t_duration = t_duration, d = d ) + + def get_circuit(self, t_duration: double = None): + + if self.mode_EvolutionOracle is EvolutionOracleType.nameString: + return self(t_duration) + elif self.mode_EvolutionOracle is EvolutionOracleType.SymbolicHamiltonian: + return self.h.circuit(t_duration) + else: + raise_error(ValueError, + f"You are using an EvolutionOracle type which is not yet supported.") + @property + def name(self, ): + return None + + def circuit_sequence(self, k_step_number: int = None): + EvolutionOracleDiagonalInput = EvolutionOracle( + name = "DiagonalInput", + mode_EvolutionOracle = self.mode_EvolutionOracle) + EvolutionOracleInputHamiltonian = EvolutionOracle( name = "InputHamiltonian" ) + + if mode_DBR = DoubleBracketRotationType.group_commutator_reduced + return [ + EvolutionOracleDiagonalInput(s_step, d), + EvolutionOracleInputHamiltonian(s_step), + EvolutionOracleDiagonalInput(s_step,d) ] class DoubleBracketIteration: + def __init__( + self, + hamiltonian: AbstractHamiltonian, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + ): + self.h = hamiltonian + self.h0 = deepcopy(self.h) + self.mode = mode + +class doubleBracketStep: + def __init__( + self, + s_step: double = None, + d_Z: DiagonalAssociation = None, + mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, + mode_evolutiom_reversal: EvolutionOracleInputHamiltonianReversalType = None, + mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString +): + self.s_step = s_step + self.diagonalAssociation = d_Z + self.mode_DBR = mode_DBR #@TODO: this should allow to request gradient search or other operator optimization + self.mode_GCI_reversal = mode_GCI_reversal + self.mode_DBR = mode_DBR + self.mode_EvolutionOracle = mode_EvolutionOracle + + def loss(self, step: float, look_ahead: int = 1): + """ + Compute loss function distance between `look_ahead` steps. + + Args: + step: iteration step. + look_ahead: number of iteration steps to compute the loss function; + """ + # copy initial hamiltonian + h_copy = deepcopy(self.h) + + for _ in range(look_ahead): + self.__call__(mode=self.mode, step=step) + + # off_diagonal_norm's value after the steps + loss = self.off_diagonal_norm + + # set back the initial configuration + self.h = h_copy + + return loss + + def energy_fluctuation(self, state): + """ + Evaluate energy fluctuation + + .. math:: + \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, + + for a given state :math:`|\\mu\\rangle`. + + Args: + state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. + """ + return self.h.energy_fluctuation(state) + + @property + def backend(self): + """Get Hamiltonian's backend.""" + return self.h0.backend + + def hyperopt_step( + self, + step_min: float = 1e-5, + step_max: float = 1, + max_evals: int = 1000, + space: callable = None, + optimizer: callable = None, + look_ahead: int = 1, + verbose: bool = False, + ): + """ + Optimize iteration step. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + max_evals: maximum number of iterations done by the hyperoptimizer; + space: see hyperopt.hp possibilities; + optimizer: see hyperopt algorithms; + look_ahead: number of iteration steps to compute the loss function; + verbose: level of verbosity. + + Returns: + (float): optimized best iteration step. + """ + if space is None: + space = hyperopt.hp.uniform + if optimizer is None: + optimizer = hyperopt.tpe + + space = space("step", step_min, step_max) + best = hyperopt.fmin( + fn=partial(self.loss, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + + return best["step"] + + +class DoubleBracketIterationNumpy(DoubleBracketIteration): """ Class implementing the Double Bracket iteration algorithm. For more details, see https://arxiv.org/pdf/2206.11772.pdf Args: hamiltonian (Hamiltonian): Starting Hamiltonian; - mode (DoubleBracketGeneratorType): type of generator of the evolution. + mode (DoubleBracketDiagonalAssociationType): type of generator of the evolution. Example: .. testcode:: import numpy as np - from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketGeneratorType + from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketDiagonalAssociationType from qibo.hamiltonians import Hamiltonian from qibo.quantum_info import random_hermitian @@ -49,31 +334,31 @@ class DoubleBracketIteration: def __init__( self, hamiltonian: Hamiltonian, - mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, ): self.h = hamiltonian self.h0 = deepcopy(self.h) self.mode = mode def __call__( - self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None + self, step: float, mode: DoubleBracketDiagonalAssociationType = None, d: np.array = None ): if mode is None: mode = self.mode - if mode is DoubleBracketGeneratorType.canonical: + if mode is DoubleBracketDiagonalAssociationType.canonical: operator = self.backend.calculate_matrix_exp( 1.0j * step, self.commutator(self.diagonal_h_matrix, self.h.matrix), ) - elif mode is DoubleBracketGeneratorType.single_commutator: + elif mode is DoubleBracketDiagonalAssociationType.single_commutator: if d is None: raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") operator = self.backend.calculate_matrix_exp( 1.0j * step, self.commutator(d, self.h.matrix), ) - elif mode is DoubleBracketGeneratorType.group_commutator: + elif mode is DoubleBracketDiagonalAssociationType.group_commutator: if d is None: raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") operator = ( @@ -111,84 +396,4 @@ def off_diagonal_norm(self): np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h)) ) - @property - def backend(self): - """Get Hamiltonian's backend.""" - return self.h0.backend - - def hyperopt_step( - self, - step_min: float = 1e-5, - step_max: float = 1, - max_evals: int = 1000, - space: callable = None, - optimizer: callable = None, - look_ahead: int = 1, - verbose: bool = False, - ): - """ - Optimize iteration step. - - Args: - step_min: lower bound of the search grid; - step_max: upper bound of the search grid; - max_evals: maximum number of iterations done by the hyperoptimizer; - space: see hyperopt.hp possibilities; - optimizer: see hyperopt algorithms; - look_ahead: number of iteration steps to compute the loss function; - verbose: level of verbosity. - - Returns: - (float): optimized best iteration step. - """ - if space is None: - space = hyperopt.hp.uniform - if optimizer is None: - optimizer = hyperopt.tpe - - space = space("step", step_min, step_max) - best = hyperopt.fmin( - fn=partial(self.loss, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, - ) - - return best["step"] - - def loss(self, step: float, look_ahead: int = 1): - """ - Compute loss function distance between `look_ahead` steps. - - Args: - step: iteration step. - look_ahead: number of iteration steps to compute the loss function; - """ - # copy initial hamiltonian - h_copy = deepcopy(self.h) - - for _ in range(look_ahead): - self.__call__(mode=self.mode, step=step) - - # off_diagonal_norm's value after the steps - loss = self.off_diagonal_norm - - # set back the initial configuration - self.h = h_copy - - return loss - - def energy_fluctuation(self, state): - """ - Evaluate energy fluctuation - - .. math:: - \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, - for a given state :math:`|\\mu\\rangle`. - - Args: - state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. - """ - return self.h.energy_fluctuation(state) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 4018d9d412..2cb31f9684 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -14,44 +14,7 @@ from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian -class DoubleBracketGeneratorType(Enum): - """Define the evolution generator of a variant of the double-bracket iterations.""" - - canonical = auto() - """Use canonical commutator.""" - - custom = auto() - """Use some input diagonal matrix""" - -class DoubleBracketRotationType(Enum): - #The dbr types below need a diagonal input matrix $\hat D_k$ : - - single_commutator = auto() - """Use single commutator.""" - - group_commutator = auto() - """Use group commutator approximation""" - - group_commutator_reduced = auto() - """Use group commutator approximation with a reduction using symmetry - - """ - - group_commutator_imperfect = auto() - """Use group commutator approximation""" - - group_commutator_reduced_imperfect = auto() - """Use group commutator approximation: - symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. - We extrapolate that symmetry to the imperfect inversion. - Note that while may not be performing a similarity operation on the generator of the double bracket iteration, - the unfolded operation applied to a state vector will still be unitary: - - """ - class EvolutionOracleType(Enum): - numpy = auto() - TrotterSuzuki = auto() class GroupCommutatorIterationWithEvolutionOracles(DoubleBracketIteration): @@ -62,14 +25,15 @@ class GroupCommutatorIterationWithEvolutionOracles(DoubleBracketIteration): def __init__( self, hamiltonian: Hamiltonian, - mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + mode_DA: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, mode_GCI_inversion: EvolutionOracleInputHamiltonianReversalType = None, ): - super().__init__( hamiltonian, mode ) - + super().__init__( hamiltonian, mode_DBR ) + self.mode_DA = mode_DA self.mode_GCI_inversion = mode_GCI_inversion self.mode_DBR = mode_DBR + def __call__( self, step: float, mode_DBR: DoubleBracketRotationType = None, d: np.array = None ): @@ -104,36 +68,8 @@ def group_commutator_reduced(self, step, d = None): @ self.backend.calculate_matrix_exp(step, d) ) - class DBI_step: - def __init__( - self, - s_step: double, - d: Hamiltonian, - mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, - mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, - mode_GCI_inversion: EvolutionOracleInputHamiltonianReversalType = None, - ): - self.s_step = s_step - self.d = d - self.mode = mode #@TODO: this should allow to request gradient search or other operator optimization - self.mode_GCI_inversion = mode_GCI_inversion - self.mode_DBR = mode_DBR - @property - def circuit_sequence(self): - if mode_DBR = DoubleBracketRotationType.group_commutator_reduced - return [EvolutionOracleDiagonalInput(s_step, d), EvolutionOracleInputHamiltonian(s_step), EvolutionOracleDiagonalInput(s_step,d) ] - class EvolutionOracle: - def __init__(h: TrotterHamiltonian = None): - self.h = h - def get_circuit(self, t_duration) - freturn self.h.circuit(t_duration) - class EvolutionOracleDiagonalInput(EvolutionOracle): - def __init__(): - self.name = 'DiagonalInput' - - class EvolutionOracleInputHamiltonian(EvolutionOracle): - def __init__(): - self.name = 'Input Hamiltonian' + + def unfold_DBI_circuit_symbolic(self, nmb_DBI_steps = 1, s_list, d_list = None): if d is None: From 019736369b39f6dede99fa563053d96ff331f27e Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 5 Feb 2024 09:40:00 +0100 Subject: [PATCH 009/116] moving things around and thinking about the structure --- src/qibo/models/dbi/double_bracket_oracles.py | 405 ++++++++++++++++++ 1 file changed, 405 insertions(+) create mode 100644 src/qibo/models/dbi/double_bracket_oracles.py diff --git a/src/qibo/models/dbi/double_bracket_oracles.py b/src/qibo/models/dbi/double_bracket_oracles.py new file mode 100644 index 0000000000..799b55f19d --- /dev/null +++ b/src/qibo/models/dbi/double_bracket_oracles.py @@ -0,0 +1,405 @@ +from copy import deepcopy +from enum import Enum, auto +from functools import partial + +import hyperopt +import numpy as np + +from qibo.config import raise_error +from qibo.hamiltonians import Hamiltonian + +class DoubleBracketDiagonalAssociationType(Enum): + """Define the evolution generator of a variant of the double-bracket iterations.""" + + canonical = auto() + """Use canonical commutator.""" + + custom = auto() + """Use some input diagonal matrix for each step: general diagonalization DBI""" + + custom_constant = auto() + """Use same input diagonal matrix in each step: BHMM DBI""" + +class DiagonalAssociation: + + def __init__( + self, + k_step_number: list = None, + s_step_duration: double = None, + d: EvolutionHamiltonian, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + ): + z=1 +class EvolutionHamiltonian: + def __init__(mode_evolution_oracle: EvolutionOracleType + def queryEvolution(self, t_duration): + return 0 + +class DiagonalAssociationDephasing(DiagonalAssociation): + + def __init__( + self, + H: AbstractHamiltonian, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + ): + def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_duration = None ): + if mode_evolution_oracle is EvolutionOracleType.nameString: + if t_duration is None: + #iterate over all Z ops + return '\Delta(' + J_input.name + ')' + else: + return 'exp( i'+ str(t_duration) +'\Delta(' + J_input.name + ')' + elif mode_evolution_oracle is EvolutionOracleType.numerical: + if t_duration is None: + return J_input.h.diag() + else: + return J_input.diag().exp(t_duration) + if mode_evolution_oracle is EvolutionOracleType.TrotterSuzuki: + if t_duration is None: + #iterate over all Z ops + return sum Z @ J_input @ Z + else: + return sum Z @ J_input.circuit(t_duration) @Z + +class DiagonalAssociationFromList(DiagonalAssociation): + + def __init__( + self, + d_k_list: list = None, + mode_diagonal_association: DoubleBracketDiagonalAssociationType = None, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + ): + if mode_diagonal_association is not None: + self.mode_diagonal_association = mode_diagonal_association + + self.d_k_list = d_k_list + + def __call__(self, k_step_number: list = None, t_duration = None ): + + if mode_evolution_oracle is EvolutionOracleType.nameString: + if t_duration is None: + return 'D_' + str(k_step_number) + else: + return 'exp( i'+ str(t_duration) +'D_k' + elif mode_evolution_oracle is EvolutionOracleType.numerical: + if t_duration is None: + return d_k_list[k_step_number] + else: + return d_k_list[k_step_number].exp(t_duration) + if mode_evolution_oracle is EvolutionOracleType.TrotterSuzuki: + if t_duration is None: + raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") + else: + return d_k_list[k_step_number.circuit(t_duration) + +class DiagonalAssociationFromOptimization(DiagonalAssociation): + + def __init__( + self, + loss_function: None, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString +): + self.loss = loss_function + + def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duration = None ): + if self.mode_evolution_oracle is EvolutionOracleType.nameString: + if t_duration is None: + return 'Optimize $\mu$ D_' + str(k_step_number) + else: + return 'Optimize $\mu$ exp( i'+ str(t_duration) +'D_k' + elif self.mode_evolution_oracle is EvolutionOracleType.numerical: + if t_duration is None: + raise_error(TypeError, "Not implemented") + return 0 + else: + raise_error(TypeError, "Not implemented") + return 0 + if self.mode_evolution_oracle is EvolutionOracleType.TrotterSuzuki: + if t_duration is None: + raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") + else: + raise_error(TypeError, "Not implemented") + return sum Z @ J_input.circuit(t_duration) @Z + + + +class DoubleBracketRotationType(Enum): + #The dbr types below need a diagonal input matrix $\hat D_k$ : + + single_commutator = auto() + """Use single commutator.""" + + group_commutator = auto() + """Use group commutator approximation""" + + group_commutator_reduced = auto() + """Use group commutator approximation with a reduction using symmetry + + """ + + ## Reserving for later development + group_commutator_imperfect = auto() + """Use group commutator approximation""" + + group_commutator_reduced_imperfect = auto() + """Use group commutator approximation: + symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. + We extrapolate that symmetry to the imperfect reversal. + Note that while may not be performing a similarity operation on the generator of the double bracket iteration, + the unfolded operation applied to a state vector will still be unitary: + + """ + +class EvolutionOracleType(Enum): + nameString = auto() + """If you only want to get a sequence of names of the oracle""" + + numerical = auto() + """If you will work with exp(is_k J_k) as a numerical matrix""" + + TrotterSuzuki = auto() + """If you will use SymbolicHamiltonian""" + +class EvolutionOracle: + def __init__( J: AbstractHamiltonian = None, + name = None, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString ): + self.h = h + self.mode_evolution_oracle = mode_evolution_oracle + self.name = name + def __call__(self, t_duration: double = None, d: np.array = None): + """ Returns either the name or the circuit """ + if t is None: + return self.name + else: + return self.get_circuit( t_duration = t_duration, d = d ) + + def get_circuit(self, t_duration: double = None): + + if self.mode_evolution_oracle is EvolutionOracleType.nameString: + return self(t_duration) + elif self.mode_evolution_oracle is EvolutionOracleType.SymbolicHamiltonian: + return self.h.circuit(t_duration) + else: + raise_error(ValueError, + f"You are using an EvolutionOracle type which is not yet supported.") + @property + def name(self, ): + return None + + def circuit_sequence(self, k_step_number: int = None): + EvolutionOracleDiagonalInput = EvolutionOracle( + name = "DiagonalInput", + mode_evolution_oracle = self.mode_evolution_oracle) + EvolutionOracleInputHamiltonian = EvolutionOracle( name = "InputHamiltonian" ) + + if mode_DBR = DoubleBracketRotationType.group_commutator_reduced + return [ + EvolutionOracleDiagonalInput(s_step, d), + EvolutionOracleInputHamiltonian(s_step), + EvolutionOracleDiagonalInput(s_step,d) ] + + +class DoubleBracketIteration: + def __init__( + self, + hamiltonian: AbstractHamiltonian, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + ): + self.h = hamiltonian + self.h0 = deepcopy(self.h) + self.mode = mode + +class doubleBracketStep: + def __init__( + self, + s_step: double = None, + d_Z: DiagonalAssociation = None, + mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, + mode_evolutiom_reversal: EvolutionOracleInputHamiltonianReversalType = None, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString +): + self.s_step = s_step + self.diagonal_association = d_Z + self.mode_dbr = mode_DBR #@TODO: this should allow to request gradient search or other operator optimization + self.mode_gci_reversal = mode_GCI_reversal + self.mode_dbr = mode_DBR + self.mode_evolution_oracle = mode_evolution_oracle + + def loss(self, step: float, look_ahead: int = 1): + """ + Compute loss function distance between `look_ahead` steps. + + Args: + step: iteration step. + look_ahead: number of iteration steps to compute the loss function; + """ + # copy initial hamiltonian + h_copy = deepcopy(self.h) + + for _ in range(look_ahead): + self.__call__(mode=self.mode, step=step) + + # off_diagonal_norm's value after the steps + loss = self.off_diagonal_norm + + # set back the initial configuration + self.h = h_copy + + return loss + + def energy_fluctuation(self, state): + """ + Evaluate energy fluctuation + + .. math:: + \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, + + for a given state :math:`|\\mu\\rangle`. + + Args: + state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. + """ + return self.h.energy_fluctuation(state) + + @property + def backend(self): + """Get Hamiltonian's backend.""" + return self.h0.backend + + def hyperopt_step( + self, + step_min: float = 1e-5, + step_max: float = 1, + max_evals: int = 1000, + space: callable = None, + optimizer: callable = None, + look_ahead: int = 1, + verbose: bool = False, + ): + """ + Optimize iteration step. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + max_evals: maximum number of iterations done by the hyperoptimizer; + space: see hyperopt.hp possibilities; + optimizer: see hyperopt algorithms; + look_ahead: number of iteration steps to compute the loss function; + verbose: level of verbosity. + + Returns: + (float): optimized best iteration step. + """ + if space is None: + space = hyperopt.hp.uniform + if optimizer is None: + optimizer = hyperopt.tpe + + space = space("step", step_min, step_max) + best = hyperopt.fmin( + fn=partial(self.loss, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + + return best["step"] + + +class DoubleBracketIterationNumpy(DoubleBracketIteration): + """ + Class implementing the Double Bracket iteration algorithm. + For more details, see https://arxiv.org/pdf/2206.11772.pdf + + Args: + hamiltonian (Hamiltonian): Starting Hamiltonian; + mode (DoubleBracketDiagonalAssociationType): type of generator of the evolution. + + Example: + .. testcode:: + + import numpy as np + from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketDiagonalAssociationType + from qibo.hamiltonians import Hamiltonian + from qibo.quantum_info import random_hermitian + + nqubits = 4 + h0 = random_hermitian(2**nqubits) + dbf = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) + + # diagonalized matrix + dbf.h + """ + + def __init__( + self, + hamiltonian: Hamiltonian, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + ): + self.h = hamiltonian + self.h0 = deepcopy(self.h) + self.mode = mode + + def __call__( + self, step: float, mode: DoubleBracketDiagonalAssociationType = None, d: np.array = None + ): + if mode is None: + mode = self.mode + + if mode is DoubleBracketDiagonalAssociationType.canonical: + operator = self.backend.calculate_matrix_exp( + 1.0j * step, + self.commutator(self.diagonal_h_matrix, self.h.matrix), + ) + elif mode is DoubleBracketDiagonalAssociationType.single_commutator: + if d is None: + raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") + operator = self.backend.calculate_matrix_exp( + 1.0j * step, + self.commutator(d, self.h.matrix), + ) + elif mode is DoubleBracketDiagonalAssociationType.group_commutator: + if d is None: + raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") + operator = ( + self.h.exp(-step) + @ self.backend.calculate_matrix_exp(-step, d) + @ self.h.exp(step) + @ self.backend.calculate_matrix_exp(step, d) + ) + operator_dagger = self.backend.cast( + np.matrix(self.backend.to_numpy(operator)).getH() + ) + self.h.matrix = operator @ self.h.matrix @ operator_dagger + + @staticmethod + def commutator(a, b): + """Compute commutator between two arrays.""" + return a @ b - b @ a + + @property + def diagonal_h_matrix(self): + """Diagonal H matrix.""" + return self.backend.cast(np.diag(np.diag(self.backend.to_numpy(self.h.matrix)))) + + @property + def off_diag_h(self): + return self.h.matrix - self.diagonal_h_matrix + + @property + def off_diagonal_norm(self): + """Norm of off-diagonal part of H matrix.""" + off_diag_h_dag = self.backend.cast( + np.matrix(self.backend.to_numpy(self.off_diag_h)).getH() + ) + return np.real( + np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h)) + ) + + From 3951877fce1ea15d31fec0295df6026a4623967b Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 5 Feb 2024 10:37:06 +0100 Subject: [PATCH 010/116] namings in progress --- src/qibo/models/dbi/double_bracket_oracles.py | 88 +++++++++---------- 1 file changed, 43 insertions(+), 45 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_oracles.py b/src/qibo/models/dbi/double_bracket_oracles.py index 799b55f19d..19381a82ea 100644 --- a/src/qibo/models/dbi/double_bracket_oracles.py +++ b/src/qibo/models/dbi/double_bracket_oracles.py @@ -11,41 +11,50 @@ class DoubleBracketDiagonalAssociationType(Enum): """Define the evolution generator of a variant of the double-bracket iterations.""" - canonical = auto() - """Use canonical commutator.""" + dephasing = auto() + """Use dephasing for a canonical bracket.""" - custom = auto() + prescribed = auto() """Use some input diagonal matrix for each step: general diagonalization DBI""" - custom_constant = auto() + fixed = auto() """Use same input diagonal matrix in each step: BHMM DBI""" + optimization = auto() + """Perform optimization to find best diagonal operator""" + class DiagonalAssociation: - def __init__( - self, - k_step_number: list = None, - s_step_duration: double = None, - d: EvolutionHamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + def __init__( name = None, + mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): - z=1 + self.name = Name + self.mode_diagonal_association = mode_diagonal_association + self.mode_evolution_oracle = mode_evolution_oracle + @property + def name(self): + return self.name + class EvolutionHamiltonian: - def __init__(mode_evolution_oracle: EvolutionOracleType + def __init__(name: String = None, mode_evolution_oracle: EvolutionOracleType): + self.name = name def queryEvolution(self, t_duration): return 0 + @property + def name(self): + return self.name class DiagonalAssociationDephasing(DiagonalAssociation): def __init__( self, - H: AbstractHamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): + super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.dephasing, mode_evolution_oracle = mode_evolution_oracle) + def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_duration = None ): - if mode_evolution_oracle is EvolutionOracleType.nameString: + if mode_evolution_oracle is EvolutionOracleType.text_strings: if t_duration is None: #iterate over all Z ops return '\Delta(' + J_input.name + ')' @@ -68,17 +77,14 @@ class DiagonalAssociationFromList(DiagonalAssociation): def __init__( self, d_k_list: list = None, - mode_diagonal_association: DoubleBracketDiagonalAssociationType = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): - if mode_diagonal_association is not None: - self.mode_diagonal_association = mode_diagonal_association - + super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.prescribed, mode_evolution_oracle = mode_evolution_oracle) self.d_k_list = d_k_list def __call__(self, k_step_number: list = None, t_duration = None ): - if mode_evolution_oracle is EvolutionOracleType.nameString: + if mode_evolution_oracle is EvolutionOracleType.text_strings: if t_duration is None: return 'D_' + str(k_step_number) else: @@ -100,12 +106,12 @@ def __init__( self, loss_function: None, mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): self.loss = loss_function def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duration = None ): - if self.mode_evolution_oracle is EvolutionOracleType.nameString: + if self.mode_evolution_oracle is EvolutionOracleType.text_strings: if t_duration is None: return 'Optimize $\mu$ D_' + str(k_step_number) else: @@ -154,7 +160,7 @@ class DoubleBracketRotationType(Enum): """ class EvolutionOracleType(Enum): - nameString = auto() + text_strings = auto() """If you only want to get a sequence of names of the oracle""" numerical = auto() @@ -166,21 +172,22 @@ class EvolutionOracleType(Enum): class EvolutionOracle: def __init__( J: AbstractHamiltonian = None, name = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString ): + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): self.h = h self.mode_evolution_oracle = mode_evolution_oracle self.name = name + def __call__(self, t_duration: double = None, d: np.array = None): """ Returns either the name or the circuit """ if t is None: return self.name else: - return self.get_circuit( t_duration = t_duration, d = d ) + return self.circuit( t_duration = t_duration ) - def get_circuit(self, t_duration: double = None): + def circuit(self, t_duration: double = None): - if self.mode_evolution_oracle is EvolutionOracleType.nameString: - return self(t_duration) + if self.mode_evolution_oracle is EvolutionOracleType.text_strings: + return self.name + str(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.SymbolicHamiltonian: return self.h.circuit(t_duration) else: @@ -196,37 +203,28 @@ def circuit_sequence(self, k_step_number: int = None): mode_evolution_oracle = self.mode_evolution_oracle) EvolutionOracleInputHamiltonian = EvolutionOracle( name = "InputHamiltonian" ) - if mode_DBR = DoubleBracketRotationType.group_commutator_reduced + if mode_dbr = DoubleBracketRotationType.group_commutator_reduced return [ EvolutionOracleDiagonalInput(s_step, d), EvolutionOracleInputHamiltonian(s_step), EvolutionOracleDiagonalInput(s_step,d) ] -class DoubleBracketIteration: - def __init__( - self, - hamiltonian: AbstractHamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - ): - self.h = hamiltonian - self.h0 = deepcopy(self.h) - self.mode = mode class doubleBracketStep: def __init__( self, s_step: double = None, d_Z: DiagonalAssociation = None, - mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, + mode_dbr: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, mode_evolutiom_reversal: EvolutionOracleInputHamiltonianReversalType = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.nameString + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): self.s_step = s_step self.diagonal_association = d_Z - self.mode_dbr = mode_DBR #@TODO: this should allow to request gradient search or other operator optimization + self.mode_dbr = mode_dbr #@TODO: this should allow to request gradient search or other operator optimization self.mode_gci_reversal = mode_GCI_reversal - self.mode_dbr = mode_DBR + self.mode_dbr = mode_dbr self.mode_evolution_oracle = mode_evolution_oracle def loss(self, step: float, look_ahead: int = 1): From 358c4237afda763b16edc911b70ba6c8c7d16061 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 5 Feb 2024 12:57:24 +0100 Subject: [PATCH 011/116] sorted evolution oracles --- src/qibo/models/dbi/double_bracket.py | 389 +++++------------- src/qibo/models/dbi/double_bracket_oracles.py | 163 +++----- .../group_commutator_iteration_transpiler.py | 90 ++-- 3 files changed, 224 insertions(+), 418 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 983733d1c9..976fcbc021 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -8,318 +8,33 @@ from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian -class DoubleBracketDiagonalAssociationType(Enum): - """Define the evolution generator of a variant of the double-bracket iterations.""" - - canonical = auto() - """Use canonical commutator.""" - - custom = auto() - """Use some input diagonal matrix for each step: general diagonalization DBI""" - - custom_constant = auto() - """Use same input diagonal matrix in each step: BHMM DBI""" - -class DiagonalAssociation: - - def __init__( - self, - k_step_number: list = None, - s_step_duration: double = None, - d: EvolutionHamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString - ): - z=1 -class EvolutionHamiltonian: - def __init__(mode_EvolutionOracle: EvolutionOracleType - def queryEvolution(self, t_duration): - return 0 -class DiagonalAssociationDephasing(DiagonalAssociation): +class DoubleBracketGeneratorType(Enum): + """Define DBF evolution.""" - def __init__( - self, - H: AbstractHamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString - ): - def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_duration = None ): - if mode_EvolutionOracle is EvolutionOracleType.nameString: - if t_duration is None: - #iterate over all Z ops - return '\Delta(' + J_input.name + ')' - else: - return 'exp( i'+ str(t_duration) +'\Delta(' + J_input.name + ')' - elif mode_EvolutionOracle is EvolutionOracleType.numerical: - if t_duration is None: - #iterate over all Z ops - return sum Z @ J_input @ Z - else: - return sum Z @ J_input.exp(t_duration) @Z - if mode_EvolutionOracle is EvolutionOracleType.TrotterSuzuki: - if t_duration is None: - #iterate over all Z ops - return sum Z @ J_input @ Z - else: - return sum Z @ J_input.circuit(t_duration) @Z - -class DiagonalAssociationFromList(DiagonalAssociation): - - def __init__( - self, - d_k_list: list = None, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString -): - self.d_k_list = d_k_list - - def __call__(self, k_step_number: list = None, t_duration = None ): - if mode_EvolutionOracle is EvolutionOracleType.nameString: - if t_duration is None: - return 'D_' + str(k_step_number) - else: - return 'exp( i'+ str(t_duration) +'D_k' - elif mode_EvolutionOracle is EvolutionOracleType.numerical: - if t_duration is None: - return - else: - return sum Z @ J_input.exp(t_duration) @Z - if mode_EvolutionOracle is EvolutionOracleType.TrotterSuzuki: - if t_duration is None: - raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") - else: - return sum Z @ J_input.circuit(t_duration) @Z - -class DiagonalAssociationFromOptimization(DiagonalAssociation): - - def __init__( - self, - d_k_list: list = None, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString -): - self.d_k_list = d_k_list - - def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duration = None ): - if mode_EvolutionOracle is EvolutionOracleType.nameString: - if t_duration is None: - return 'Optimize $\mu$ D_' + str(k_step_number) - else: - return 'Optimize $\mu$ exp( i'+ str(t_duration) +'D_k' - elif mode_EvolutionOracle is EvolutionOracleType.numerical: - if t_duration is None: - return - else: - return sum Z @ J_input.exp(t_duration) @Z - if mode_EvolutionOracle is EvolutionOracleType.TrotterSuzuki: - if t_duration is None: - raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") - else: - return sum Z @ J_input.circuit(t_duration) @Z - - - -class DoubleBracketRotationType(Enum): - #The dbr types below need a diagonal input matrix $\hat D_k$ : - + canonical = auto() + """Use canonical commutator.""" single_commutator = auto() """Use single commutator.""" - group_commutator = auto() """Use group commutator approximation""" - - group_commutator_reduced = auto() - """Use group commutator approximation with a reduction using symmetry - - """ - - ## Reserving for later development - group_commutator_imperfect = auto() - """Use group commutator approximation""" - - group_commutator_reduced_imperfect = auto() - """Use group commutator approximation: - symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. - We extrapolate that symmetry to the imperfect reversal. - Note that while may not be performing a similarity operation on the generator of the double bracket iteration, - the unfolded operation applied to a state vector will still be unitary: - - """ - -class EvolutionOracleType(Enum): - nameString = auto() - """If you only want to get a sequence of names of the oracle""" - - numerical = auto() - """If you will work with exp(is_k J_k) as a numerical matrix""" - - TrotterSuzuki = auto() - """If you will use SymbolicHamiltonian""" - -class EvolutionOracle: - def __init__( J: AbstractHamiltonian = None, - name = None, - mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString ): - self.h = h - self.mode_EvolutionOracle = mode_EvolutionOracle - self.name = name - def __call__(self, t_duration: double = None, d: np.array = None): - """ Returns either the name or the circuit """ - if t is None: - return self.name - else: - return self.get_circuit( t_duration = t_duration, d = d ) - - def get_circuit(self, t_duration: double = None): - - if self.mode_EvolutionOracle is EvolutionOracleType.nameString: - return self(t_duration) - elif self.mode_EvolutionOracle is EvolutionOracleType.SymbolicHamiltonian: - return self.h.circuit(t_duration) - else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") - @property - def name(self, ): - return None - - def circuit_sequence(self, k_step_number: int = None): - EvolutionOracleDiagonalInput = EvolutionOracle( - name = "DiagonalInput", - mode_EvolutionOracle = self.mode_EvolutionOracle) - EvolutionOracleInputHamiltonian = EvolutionOracle( name = "InputHamiltonian" ) - - if mode_DBR = DoubleBracketRotationType.group_commutator_reduced - return [ - EvolutionOracleDiagonalInput(s_step, d), - EvolutionOracleInputHamiltonian(s_step), - EvolutionOracleDiagonalInput(s_step,d) ] + # TODO: add double commutator (does it converge?) class DoubleBracketIteration: - def __init__( - self, - hamiltonian: AbstractHamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - ): - self.h = hamiltonian - self.h0 = deepcopy(self.h) - self.mode = mode - -class doubleBracketStep: - def __init__( - self, - s_step: double = None, - d_Z: DiagonalAssociation = None, - mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, - mode_evolutiom_reversal: EvolutionOracleInputHamiltonianReversalType = None, - mode_EvolutionOracle: EvolutionOracleType = EvolutionOracleType.nameString -): - self.s_step = s_step - self.diagonalAssociation = d_Z - self.mode_DBR = mode_DBR #@TODO: this should allow to request gradient search or other operator optimization - self.mode_GCI_reversal = mode_GCI_reversal - self.mode_DBR = mode_DBR - self.mode_EvolutionOracle = mode_EvolutionOracle - - def loss(self, step: float, look_ahead: int = 1): - """ - Compute loss function distance between `look_ahead` steps. - - Args: - step: iteration step. - look_ahead: number of iteration steps to compute the loss function; - """ - # copy initial hamiltonian - h_copy = deepcopy(self.h) - - for _ in range(look_ahead): - self.__call__(mode=self.mode, step=step) - - # off_diagonal_norm's value after the steps - loss = self.off_diagonal_norm - - # set back the initial configuration - self.h = h_copy - - return loss - - def energy_fluctuation(self, state): - """ - Evaluate energy fluctuation - - .. math:: - \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, - - for a given state :math:`|\\mu\\rangle`. - - Args: - state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. - """ - return self.h.energy_fluctuation(state) - - @property - def backend(self): - """Get Hamiltonian's backend.""" - return self.h0.backend - - def hyperopt_step( - self, - step_min: float = 1e-5, - step_max: float = 1, - max_evals: int = 1000, - space: callable = None, - optimizer: callable = None, - look_ahead: int = 1, - verbose: bool = False, - ): - """ - Optimize iteration step. - - Args: - step_min: lower bound of the search grid; - step_max: upper bound of the search grid; - max_evals: maximum number of iterations done by the hyperoptimizer; - space: see hyperopt.hp possibilities; - optimizer: see hyperopt algorithms; - look_ahead: number of iteration steps to compute the loss function; - verbose: level of verbosity. - - Returns: - (float): optimized best iteration step. - """ - if space is None: - space = hyperopt.hp.uniform - if optimizer is None: - optimizer = hyperopt.tpe - - space = space("step", step_min, step_max) - best = hyperopt.fmin( - fn=partial(self.loss, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, - ) - - return best["step"] - - -class DoubleBracketIterationNumpy(DoubleBracketIteration): """ Class implementing the Double Bracket iteration algorithm. For more details, see https://arxiv.org/pdf/2206.11772.pdf Args: hamiltonian (Hamiltonian): Starting Hamiltonian; - mode (DoubleBracketDiagonalAssociationType): type of generator of the evolution. + mode (DoubleBracketGeneratorType): type of generator of the evolution. Example: .. testcode:: import numpy as np - from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketDiagonalAssociationType + from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketGeneratorType from qibo.hamiltonians import Hamiltonian from qibo.quantum_info import random_hermitian @@ -334,31 +49,31 @@ class DoubleBracketIterationNumpy(DoubleBracketIteration): def __init__( self, hamiltonian: Hamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, ): self.h = hamiltonian self.h0 = deepcopy(self.h) self.mode = mode def __call__( - self, step: float, mode: DoubleBracketDiagonalAssociationType = None, d: np.array = None + self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None ): if mode is None: mode = self.mode - if mode is DoubleBracketDiagonalAssociationType.canonical: + if mode is DoubleBracketGeneratorType.canonical: operator = self.backend.calculate_matrix_exp( 1.0j * step, self.commutator(self.diagonal_h_matrix, self.h.matrix), ) - elif mode is DoubleBracketDiagonalAssociationType.single_commutator: + elif mode is DoubleBracketGeneratorType.single_commutator: if d is None: raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") operator = self.backend.calculate_matrix_exp( 1.0j * step, self.commutator(d, self.h.matrix), ) - elif mode is DoubleBracketDiagonalAssociationType.group_commutator: + elif mode is DoubleBracketGeneratorType.group_commutator: if d is None: raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") operator = ( @@ -396,4 +111,84 @@ def off_diagonal_norm(self): np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h)) ) + @property + def backend(self): + """Get Hamiltonian's backend.""" + return self.h0.backend + + def hyperopt_step( + self, + step_min: float = 1e-5, + step_max: float = 1, + max_evals: int = 1000, + space: callable = None, + optimizer: callable = None, + look_ahead: int = 1, + verbose: bool = False, + ): + """ + Optimize iteration step. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + max_evals: maximum number of iterations done by the hyperoptimizer; + space: see hyperopt.hp possibilities; + optimizer: see hyperopt algorithms; + look_ahead: number of iteration steps to compute the loss function; + verbose: level of verbosity. + + Returns: + (float): optimized best iteration step. + """ + if space is None: + space = hyperopt.hp.uniform + if optimizer is None: + optimizer = hyperopt.tpe + + space = space("step", step_min, step_max) + best = hyperopt.fmin( + fn=partial(self.loss, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + + return best["step"] + + def loss(self, step: float, look_ahead: int = 1): + """ + Compute loss function distance between `look_ahead` steps. + + Args: + step: iteration step. + look_ahead: number of iteration steps to compute the loss function; + """ + # copy initial hamiltonian + h_copy = deepcopy(self.h) + + for _ in range(look_ahead): + self.__call__(mode=self.mode, step=step) + + # off_diagonal_norm's value after the steps + loss = self.off_diagonal_norm + + # set back the initial configuration + self.h = h_copy + + return loss + + def energy_fluctuation(self, state): + """ + Evaluate energy fluctuation + + .. math:: + \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, + for a given state :math:`|\\mu\\rangle`. + + Args: + state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. + """ + return self.h.energy_fluctuation(state) diff --git a/src/qibo/models/dbi/double_bracket_oracles.py b/src/qibo/models/dbi/double_bracket_oracles.py index 19381a82ea..b300fb4d4b 100644 --- a/src/qibo/models/dbi/double_bracket_oracles.py +++ b/src/qibo/models/dbi/double_bracket_oracles.py @@ -8,6 +8,8 @@ from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian + + class DoubleBracketDiagonalAssociationType(Enum): """Define the evolution generator of a variant of the double-bracket iterations.""" @@ -23,29 +25,67 @@ class DoubleBracketDiagonalAssociationType(Enum): optimization = auto() """Perform optimization to find best diagonal operator""" -class DiagonalAssociation: - def __init__( name = None, - mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings - ): - self.name = Name - self.mode_diagonal_association = mode_diagonal_association - self.mode_evolution_oracle = mode_evolution_oracle - @property - def name(self): - return self.name +class EvolutionOracleType(Enum): + text_strings = auto() + """If you only want to get a sequence of names of the oracle""" -class EvolutionHamiltonian: - def __init__(name: String = None, mode_evolution_oracle: EvolutionOracleType): - self.name = name - def queryEvolution(self, t_duration): - return 0 + numerical = auto() + """If you will work with exp(is_k J_k) as a numerical matrix""" + + hamiltonian_simulation = auto() + """If you will use SymbolicHamiltonian""" + + +class EvolutionOracle: + def __init__( h_generator: AbstractHamiltonian = None, + name = None, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation and if type(h_generator) is not SymbolicHamiltonian: + raise_error(TypeError, "If the evolution oracle mode will be to make Trotter-Suzuki decompositions then you must use the SymbolicHamiltonian generator") + + self.h = h_generator + self.mode_evolution_oracle = mode_evolution_oracle + self.name = name + + def __call__(self, t_duration: double = None): + """ Returns either the name or the circuit """ + if t_duration is None: + return self.name + else: + return self.circuit( t_duration = t_duration ) + + def circuit(self, t_duration: double = None): + + if self.mode_evolution_oracle is EvolutionOracleType.text_strings: + return self.name + str(t_duration) + elif self.mode_evolution_oracle is EvolutionOracleType.numerical: + raise_error(NotImplementedError, "The following should add a big single gate and return a circuit") + return qibo.Circuit.add_custom_gate(self.h.exp(t_duration)) + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + return self.h.circuit(t_duration) + else: + raise_error(ValueError, + f"You are using an EvolutionOracle type which is not yet supported.") @property def name(self): return self.name -class DiagonalAssociationDephasing(DiagonalAssociation): +#class DiagonalAssociation(EvolutionOracle): +# +# def __init__( h_generator: AbstractHamiltonian = None, +# name = None, +# mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, +# mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings +# ): +# self.name = name +# self.mode_diagonal_association = mode_diagonal_association +# self.mode_evolution_oracle = mode_evolution_oracle +# @property +# def name(self): +# return self.name +# +class DiagonalAssociationDephasing(EvolutionOracle): def __init__( self, @@ -65,14 +105,14 @@ def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_ return J_input.h.diag() else: return J_input.diag().exp(t_duration) - if mode_evolution_oracle is EvolutionOracleType.TrotterSuzuki: + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if t_duration is None: #iterate over all Z ops return sum Z @ J_input @ Z else: return sum Z @ J_input.circuit(t_duration) @Z -class DiagonalAssociationFromList(DiagonalAssociation): +class DiagonalAssociationFromList(EvolutionOracle): def __init__( self, @@ -94,13 +134,13 @@ def __call__(self, k_step_number: list = None, t_duration = None ): return d_k_list[k_step_number] else: return d_k_list[k_step_number].exp(t_duration) - if mode_evolution_oracle is EvolutionOracleType.TrotterSuzuki: + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if t_duration is None: - raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") + raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") else: return d_k_list[k_step_number.circuit(t_duration) -class DiagonalAssociationFromOptimization(DiagonalAssociation): +class DiagonalAssociationFromOptimization(EvolutionOracle): def __init__( self, @@ -123,91 +163,18 @@ def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duratio else: raise_error(TypeError, "Not implemented") return 0 - if self.mode_evolution_oracle is EvolutionOracleType.TrotterSuzuki: + if self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if t_duration is None: - raise_error(ValueError, f"In the TrotterSuzuki mode you need to work with evolution operators so please specify a time.") + raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") else: raise_error(TypeError, "Not implemented") return sum Z @ J_input.circuit(t_duration) @Z -class DoubleBracketRotationType(Enum): - #The dbr types below need a diagonal input matrix $\hat D_k$ : - - single_commutator = auto() - """Use single commutator.""" - - group_commutator = auto() - """Use group commutator approximation""" - - group_commutator_reduced = auto() - """Use group commutator approximation with a reduction using symmetry - - """ - - ## Reserving for later development - group_commutator_imperfect = auto() - """Use group commutator approximation""" - - group_commutator_reduced_imperfect = auto() - """Use group commutator approximation: - symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. - We extrapolate that symmetry to the imperfect reversal. - Note that while may not be performing a similarity operation on the generator of the double bracket iteration, - the unfolded operation applied to a state vector will still be unitary: - - """ - -class EvolutionOracleType(Enum): - text_strings = auto() - """If you only want to get a sequence of names of the oracle""" - - numerical = auto() - """If you will work with exp(is_k J_k) as a numerical matrix""" - - TrotterSuzuki = auto() - """If you will use SymbolicHamiltonian""" - -class EvolutionOracle: - def __init__( J: AbstractHamiltonian = None, - name = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): - self.h = h - self.mode_evolution_oracle = mode_evolution_oracle - self.name = name - def __call__(self, t_duration: double = None, d: np.array = None): - """ Returns either the name or the circuit """ - if t is None: - return self.name - else: - return self.circuit( t_duration = t_duration ) - - def circuit(self, t_duration: double = None): +### @TODO discuss with others if its not better to formulate it like this - if self.mode_evolution_oracle is EvolutionOracleType.text_strings: - return self.name + str(t_duration) - elif self.mode_evolution_oracle is EvolutionOracleType.SymbolicHamiltonian: - return self.h.circuit(t_duration) - else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") - @property - def name(self, ): - return None - - def circuit_sequence(self, k_step_number: int = None): - EvolutionOracleDiagonalInput = EvolutionOracle( - name = "DiagonalInput", - mode_evolution_oracle = self.mode_evolution_oracle) - EvolutionOracleInputHamiltonian = EvolutionOracle( name = "InputHamiltonian" ) - - if mode_dbr = DoubleBracketRotationType.group_commutator_reduced - return [ - EvolutionOracleDiagonalInput(s_step, d), - EvolutionOracleInputHamiltonian(s_step), - EvolutionOracleDiagonalInput(s_step,d) ] diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 2cb31f9684..bc91e1d897 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -14,39 +14,72 @@ from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian - +class DoubleBracketRotationType(Enum): + #The dbr types below need a diagonal input matrix $\hat D_k$ : + + single_commutator = auto() + """Use single commutator.""" + + group_commutator = auto() + """Use group commutator approximation""" + + group_commutator_reduced = auto() + """Use group commutator approximation with a reduction using symmetry + + """ + + ## Reserving for later development + group_commutator_imperfect = auto() + """Use group commutator approximation""" + + group_commutator_reduced_imperfect = auto() + """Use group commutator approximation: + symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. + We extrapolate that symmetry to the imperfect reversal. + Note that while may not be performing a similarity operation on the generator of the double bracket iteration, + the unfolded operation applied to a state vector will still be unitary: + + """ class GroupCommutatorIterationWithEvolutionOracles(DoubleBracketIteration): """ - Class which will be later merged into the @super but for now develops new tricks in a private repository. - """ + Class which will be later merged into the @super somehow """ def __init__( self, - hamiltonian: Hamiltonian, - mode_DA: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_DBR: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, - mode_GCI_inversion: EvolutionOracleInputHamiltonianReversalType = None, + input_hamiltonian_evolution_oracle: EvolutionOracle, + mode_double_bracket_rotation: DoubleBracketRotationType = DoubleBracketRotationType.group_commutator, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.numerical, + mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing ): - super().__init__( hamiltonian, mode_DBR ) - self.mode_DA = mode_DA - self.mode_GCI_inversion = mode_GCI_inversion - self.mode_DBR = mode_DBR + if mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator + mode_double_bracket_rotation_old = DoubleBracketGeneratorType.single_commutator + + super().__init__( input_hamiltonian_evolution_oracle.h, mode_double_bracket_rotation_old ) + + self.input_hamiltonian_evolution_oracle = input_hamiltonian_evolution_oracle + + self.mode_diagonal_association = mode_diagonal_association + self.mode_gci_inversion = mode_gci_inversion + self.mode_double_bracket_rotation = mode_double_bracket_rotation def __call__( - self, step: float, mode_DBR: DoubleBracketRotationType = None, d: np.array = None - ): + self, + step: float, + mode_double_bracket_rotation: DoubleBracketRotationType = None, + d: np.array = None + ) - if mode_DBR is None: - mode_DBR= self.mode_DBR + if mode_double_bracket_rotation is None: + mode_double_bracket_rotation= self.mode_double_bracket_rotation if d is None: if self.mode is DoubleBracketGeneratorType.canonical: d = self.diagonal_h_matrix else: raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") - if mode_DBR is DoubleBracketRotationType.group_commutator_reduced: + if mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: double_bracket_rotation = self.group_commutator_reduced(step, d) double_bracket_rotation_dagger = double_bracket_rotation.T.conj() @@ -55,7 +88,18 @@ def __call__( self.h.matrix = double_bracket_rotation_dagger @ self.h.matrix @ double_bracket_rotation - + + def circuit_sequence(self, k_step_number: int = None): + EvolutionOracleDiagonalInput = EvolutionOracle( + name = "DiagonalInput", + mode_evolution_oracle = self.mode_evolution_oracle) + EvolutionOracleInputHamiltonian = EvolutionOracle( name = "InputHamiltonian" ) + + if mode_dbr = DoubleBracketRotationType.group_commutator_reduced + return [ + EvolutionOracleDiagonalInput(s_step, d), + EvolutionOracleInputHamiltonian(s_step), + EvolutionOracleDiagonalInput(s_step,d) ] def group_commutator_reduced(self, step, d = None): if d is None: if mode is DoubleBracketRotationType.canonical: @@ -79,7 +123,7 @@ def unfold_DBI_circuit_symbolic(self, nmb_DBI_steps = 1, s_list, d_list = None): print( DoubleBracketRotationType.canonical) raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") if nmb_DBI_steps == 1: - return [ DBI_step( s_list[0], d_list[0], mode_DBR= DoubleBracketRotationType.group_commutator_reduced).circuit_sequence ] + return [ DBI_step( s_list[0], d_list[0], mode_double_bracket_rotation= DoubleBracketRotationType.group_commutator_reduced).circuit_sequence ] else: circuit_sequence_so_far = self.unfold_DBI_circuit_symbolic( nmb_DBI_steps = nmb_DBI_steps - 1, s_list,d_list ) shift_frame_Hk_H0 = reverse(circuit_sequence_so_far) + [EvolutionOracleInputHamiltonian(s_step[nmb_DBI_steps]) ] + circuit_sequence_so_far @@ -104,14 +148,14 @@ def group_commutator_reduced_unfold(self, step, d = None): ) def evolution_oracle_reverse_h(self, step, h): - if self.mode_GCI_inversion is None: - raise_error(ValueError, f"You need to specify what is {self.mode_GCI_inversion} when running a GCI step with the imperfect group commutator") + if self.mode_gci_inversion is None: + raise_error(ValueError, f"You need to specify what is {self.mode_gci_inversion} when running a gci step with the imperfect group commutator") - if self.mode_GCI_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites: + if self.mode_gci_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites: R = self.evolution_oracle_reversal_conjugation_by_flips(step) - elif self.mode_GCI_inversion is EvolutionOracleInputHamiltonianReversalType.product_Hadamards: + elif self.mode_gci_inversion is EvolutionOracleInputHamiltonianReversalType.product_Hadamards: R = self.evolution_oracle_reversal_conjugation_by_hadamards(step) - elif self.mode_GCI_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites_and_NN_Ising_correction: + elif self.mode_gci_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites_and_NN_Ising_correction: R = self.evolution_oracle_reversal_conjugation_by_flips(step) Z = self.evolution_oracle_reversal_conjugation_by_unitary_diagonal_correction(R, step, h) return R.matrix @ h.exp(step) @ R.matrix @ Z.matrix From 7d7324cd3f4c474e72789547d89193ed9e0f9a01 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 5 Feb 2024 15:59:31 +0100 Subject: [PATCH 012/116] preparing for merge with transpiling branch --- .../dbi/double_bracket_evolution_oracles.py | 162 ++++++++ src/qibo/models/dbi/double_bracket_oracles.py | 370 ------------------ .../group_commutator_iteration_transpiler.py | 199 ++++------ 3 files changed, 241 insertions(+), 490 deletions(-) create mode 100644 src/qibo/models/dbi/double_bracket_evolution_oracles.py delete mode 100644 src/qibo/models/dbi/double_bracket_oracles.py diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py new file mode 100644 index 0000000000..18941c8a4a --- /dev/null +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -0,0 +1,162 @@ +from copy import deepcopy +from enum import Enum, auto +from functools import partial + +import hyperopt +import numpy as np + +from qibo.config import raise_error +from qibo.hamiltonians import Hamiltonian + + + + +class EvolutionOracleType(Enum): + text_strings = auto() + """If you only want to get a sequence of names of the oracle""" + + numerical = auto() + """If you will work with exp(is_k J_k) as a numerical matrix""" + + hamiltonian_simulation = auto() + """If you will use SymbolicHamiltonian""" + + +class EvolutionOracle: + def __init__( h_generator: AbstractHamiltonian = None, + name = None, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation and if type(h_generator) is not SymbolicHamiltonian: + raise_error(TypeError, "If the evolution oracle mode will be to make Trotter-Suzuki decompositions then you must use the SymbolicHamiltonian generator") + if h_generator is None and name is None: + raise_error(NotImplementedError, "You have to specify either a matrix and then work in the numerical mode, or SymbolicHamiltonian and work in hamiltonian_simulation mode or at least a name and work with text_strings to list DBI query lists") + + self.h = h_generator + self.mode_evolution_oracle = mode_evolution_oracle + self.name = name + + def __call__(self, t_duration: double = None): + """ Returns either the name or the circuit """ + if t_duration is None: + return self.name + else: + return self.circuit( t_duration = t_duration ) + + def circuit(self, t_duration: double = None): + + if self.mode_evolution_oracle is EvolutionOracleType.text_strings: + return self.name + str(t_duration) + elif self.mode_evolution_oracle is EvolutionOracleType.numerical: + return self.h.exp(t_duration) + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + return self.h.circuit(t_duration) + else: + raise_error(ValueError, + f"You are using an EvolutionOracle type which is not yet supported.") + @property + def name(self): + return self.name + +class DoubleBracketDiagonalAssociationType(Enum): + """Define the evolution generator of a variant of the double-bracket iterations.""" + + dephasing = auto() + """Use dephasing for a canonical bracket.""" + + prescribed = auto() + """Use some input diagonal matrix for each step: general diagonalization DBI""" + + fixed = auto() + """Use same input diagonal matrix in each step: BHMM DBI""" + + optimization = auto() + """Perform optimization to find best diagonal operator""" + + +class DiagonalAssociationDephasing(EvolutionOracle): + + def __init__( + self, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings + ): + super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.dephasing, mode_evolution_oracle = mode_evolution_oracle) + + def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_duration = None ): + if mode_evolution_oracle is EvolutionOracleType.text_strings: + if t_duration is None: + #iterate over all Z ops + return '\Delta(' + J_input.name + ')' + else: + return 'exp( i'+ str(t_duration) +'\Delta(' + J_input.name + ')' + elif mode_evolution_oracle is EvolutionOracleType.numerical: + if t_duration is None: + return J_input.h.diag() + else: + return J_input.diag().exp(t_duration) + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + if t_duration is None: + #iterate over all Z ops + return sum Z @ J_input @ Z + else: + return sum Z @ J_input.circuit(t_duration) @Z + +class DiagonalAssociationFromList(EvolutionOracle): + + def __init__( + self, + d_k_list: list = None, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings + ): + super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.prescribed, mode_evolution_oracle = mode_evolution_oracle) + self.d_k_list = d_k_list + + def __call__(self, k_step_number: list = None, t_duration = None ): + + if mode_evolution_oracle is EvolutionOracleType.text_strings: + if t_duration is None: + return 'D_' + str(k_step_number) + else: + return 'exp( i'+ str(t_duration) +'D_k' + elif mode_evolution_oracle is EvolutionOracleType.numerical: + if t_duration is None: + return d_k_list[k_step_number] + else: + return d_k_list[k_step_number].exp(t_duration) + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + if t_duration is None: + raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") + else: + return d_k_list[k_step_number.circuit(t_duration) + +class DiagonalAssociationFromOptimization(EvolutionOracle): + + def __init__( + self, + loss_function: None, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings +): + self.loss = loss_function + + def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duration = None ): + if self.mode_evolution_oracle is EvolutionOracleType.text_strings: + if t_duration is None: + return 'Optimize $\mu$ D_' + str(k_step_number) + else: + return 'Optimize $\mu$ exp( i'+ str(t_duration) +'D_k' + elif self.mode_evolution_oracle is EvolutionOracleType.numerical: + if t_duration is None: + raise_error(TypeError, "Not implemented") + return 0 + else: + raise_error(TypeError, "Not implemented") + return 0 + if self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + if t_duration is None: + raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") + else: + raise_error(TypeError, "Not implemented") + return sum Z @ J_input.circuit(t_duration) @Z + + + diff --git a/src/qibo/models/dbi/double_bracket_oracles.py b/src/qibo/models/dbi/double_bracket_oracles.py deleted file mode 100644 index b300fb4d4b..0000000000 --- a/src/qibo/models/dbi/double_bracket_oracles.py +++ /dev/null @@ -1,370 +0,0 @@ -from copy import deepcopy -from enum import Enum, auto -from functools import partial - -import hyperopt -import numpy as np - -from qibo.config import raise_error -from qibo.hamiltonians import Hamiltonian - - - -class DoubleBracketDiagonalAssociationType(Enum): - """Define the evolution generator of a variant of the double-bracket iterations.""" - - dephasing = auto() - """Use dephasing for a canonical bracket.""" - - prescribed = auto() - """Use some input diagonal matrix for each step: general diagonalization DBI""" - - fixed = auto() - """Use same input diagonal matrix in each step: BHMM DBI""" - - optimization = auto() - """Perform optimization to find best diagonal operator""" - - -class EvolutionOracleType(Enum): - text_strings = auto() - """If you only want to get a sequence of names of the oracle""" - - numerical = auto() - """If you will work with exp(is_k J_k) as a numerical matrix""" - - hamiltonian_simulation = auto() - """If you will use SymbolicHamiltonian""" - - -class EvolutionOracle: - def __init__( h_generator: AbstractHamiltonian = None, - name = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): - if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation and if type(h_generator) is not SymbolicHamiltonian: - raise_error(TypeError, "If the evolution oracle mode will be to make Trotter-Suzuki decompositions then you must use the SymbolicHamiltonian generator") - - self.h = h_generator - self.mode_evolution_oracle = mode_evolution_oracle - self.name = name - - def __call__(self, t_duration: double = None): - """ Returns either the name or the circuit """ - if t_duration is None: - return self.name - else: - return self.circuit( t_duration = t_duration ) - - def circuit(self, t_duration: double = None): - - if self.mode_evolution_oracle is EvolutionOracleType.text_strings: - return self.name + str(t_duration) - elif self.mode_evolution_oracle is EvolutionOracleType.numerical: - raise_error(NotImplementedError, "The following should add a big single gate and return a circuit") - return qibo.Circuit.add_custom_gate(self.h.exp(t_duration)) - elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.h.circuit(t_duration) - else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") - @property - def name(self): - return self.name - -#class DiagonalAssociation(EvolutionOracle): -# -# def __init__( h_generator: AbstractHamiltonian = None, -# name = None, -# mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, -# mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings -# ): -# self.name = name -# self.mode_diagonal_association = mode_diagonal_association -# self.mode_evolution_oracle = mode_evolution_oracle -# @property -# def name(self): -# return self.name -# -class DiagonalAssociationDephasing(EvolutionOracle): - - def __init__( - self, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings - ): - super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.dephasing, mode_evolution_oracle = mode_evolution_oracle) - - def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_duration = None ): - if mode_evolution_oracle is EvolutionOracleType.text_strings: - if t_duration is None: - #iterate over all Z ops - return '\Delta(' + J_input.name + ')' - else: - return 'exp( i'+ str(t_duration) +'\Delta(' + J_input.name + ')' - elif mode_evolution_oracle is EvolutionOracleType.numerical: - if t_duration is None: - return J_input.h.diag() - else: - return J_input.diag().exp(t_duration) - if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - if t_duration is None: - #iterate over all Z ops - return sum Z @ J_input @ Z - else: - return sum Z @ J_input.circuit(t_duration) @Z - -class DiagonalAssociationFromList(EvolutionOracle): - - def __init__( - self, - d_k_list: list = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings - ): - super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.prescribed, mode_evolution_oracle = mode_evolution_oracle) - self.d_k_list = d_k_list - - def __call__(self, k_step_number: list = None, t_duration = None ): - - if mode_evolution_oracle is EvolutionOracleType.text_strings: - if t_duration is None: - return 'D_' + str(k_step_number) - else: - return 'exp( i'+ str(t_duration) +'D_k' - elif mode_evolution_oracle is EvolutionOracleType.numerical: - if t_duration is None: - return d_k_list[k_step_number] - else: - return d_k_list[k_step_number].exp(t_duration) - if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - if t_duration is None: - raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") - else: - return d_k_list[k_step_number.circuit(t_duration) - -class DiagonalAssociationFromOptimization(EvolutionOracle): - - def __init__( - self, - loss_function: None, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings -): - self.loss = loss_function - - def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duration = None ): - if self.mode_evolution_oracle is EvolutionOracleType.text_strings: - if t_duration is None: - return 'Optimize $\mu$ D_' + str(k_step_number) - else: - return 'Optimize $\mu$ exp( i'+ str(t_duration) +'D_k' - elif self.mode_evolution_oracle is EvolutionOracleType.numerical: - if t_duration is None: - raise_error(TypeError, "Not implemented") - return 0 - else: - raise_error(TypeError, "Not implemented") - return 0 - if self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - if t_duration is None: - raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") - else: - raise_error(TypeError, "Not implemented") - return sum Z @ J_input.circuit(t_duration) @Z - - - - -### @TODO discuss with others if its not better to formulate it like this - - - - -class doubleBracketStep: - def __init__( - self, - s_step: double = None, - d_Z: DiagonalAssociation = None, - mode_dbr: DoubleBracketRotationType = DoubleBracketRotationType.single_commutator, - mode_evolutiom_reversal: EvolutionOracleInputHamiltonianReversalType = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings -): - self.s_step = s_step - self.diagonal_association = d_Z - self.mode_dbr = mode_dbr #@TODO: this should allow to request gradient search or other operator optimization - self.mode_gci_reversal = mode_GCI_reversal - self.mode_dbr = mode_dbr - self.mode_evolution_oracle = mode_evolution_oracle - - def loss(self, step: float, look_ahead: int = 1): - """ - Compute loss function distance between `look_ahead` steps. - - Args: - step: iteration step. - look_ahead: number of iteration steps to compute the loss function; - """ - # copy initial hamiltonian - h_copy = deepcopy(self.h) - - for _ in range(look_ahead): - self.__call__(mode=self.mode, step=step) - - # off_diagonal_norm's value after the steps - loss = self.off_diagonal_norm - - # set back the initial configuration - self.h = h_copy - - return loss - - def energy_fluctuation(self, state): - """ - Evaluate energy fluctuation - - .. math:: - \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, - - for a given state :math:`|\\mu\\rangle`. - - Args: - state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. - """ - return self.h.energy_fluctuation(state) - - @property - def backend(self): - """Get Hamiltonian's backend.""" - return self.h0.backend - - def hyperopt_step( - self, - step_min: float = 1e-5, - step_max: float = 1, - max_evals: int = 1000, - space: callable = None, - optimizer: callable = None, - look_ahead: int = 1, - verbose: bool = False, - ): - """ - Optimize iteration step. - - Args: - step_min: lower bound of the search grid; - step_max: upper bound of the search grid; - max_evals: maximum number of iterations done by the hyperoptimizer; - space: see hyperopt.hp possibilities; - optimizer: see hyperopt algorithms; - look_ahead: number of iteration steps to compute the loss function; - verbose: level of verbosity. - - Returns: - (float): optimized best iteration step. - """ - if space is None: - space = hyperopt.hp.uniform - if optimizer is None: - optimizer = hyperopt.tpe - - space = space("step", step_min, step_max) - best = hyperopt.fmin( - fn=partial(self.loss, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, - ) - - return best["step"] - - -class DoubleBracketIterationNumpy(DoubleBracketIteration): - """ - Class implementing the Double Bracket iteration algorithm. - For more details, see https://arxiv.org/pdf/2206.11772.pdf - - Args: - hamiltonian (Hamiltonian): Starting Hamiltonian; - mode (DoubleBracketDiagonalAssociationType): type of generator of the evolution. - - Example: - .. testcode:: - - import numpy as np - from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketDiagonalAssociationType - from qibo.hamiltonians import Hamiltonian - from qibo.quantum_info import random_hermitian - - nqubits = 4 - h0 = random_hermitian(2**nqubits) - dbf = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) - - # diagonalized matrix - dbf.h - """ - - def __init__( - self, - hamiltonian: Hamiltonian, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, - ): - self.h = hamiltonian - self.h0 = deepcopy(self.h) - self.mode = mode - - def __call__( - self, step: float, mode: DoubleBracketDiagonalAssociationType = None, d: np.array = None - ): - if mode is None: - mode = self.mode - - if mode is DoubleBracketDiagonalAssociationType.canonical: - operator = self.backend.calculate_matrix_exp( - 1.0j * step, - self.commutator(self.diagonal_h_matrix, self.h.matrix), - ) - elif mode is DoubleBracketDiagonalAssociationType.single_commutator: - if d is None: - raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") - operator = self.backend.calculate_matrix_exp( - 1.0j * step, - self.commutator(d, self.h.matrix), - ) - elif mode is DoubleBracketDiagonalAssociationType.group_commutator: - if d is None: - raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") - operator = ( - self.h.exp(-step) - @ self.backend.calculate_matrix_exp(-step, d) - @ self.h.exp(step) - @ self.backend.calculate_matrix_exp(step, d) - ) - operator_dagger = self.backend.cast( - np.matrix(self.backend.to_numpy(operator)).getH() - ) - self.h.matrix = operator @ self.h.matrix @ operator_dagger - - @staticmethod - def commutator(a, b): - """Compute commutator between two arrays.""" - return a @ b - b @ a - - @property - def diagonal_h_matrix(self): - """Diagonal H matrix.""" - return self.backend.cast(np.diag(np.diag(self.backend.to_numpy(self.h.matrix)))) - - @property - def off_diag_h(self): - return self.h.matrix - self.diagonal_h_matrix - - @property - def off_diagonal_norm(self): - """Norm of off-diagonal part of H matrix.""" - off_diag_h_dag = self.backend.cast( - np.matrix(self.backend.to_numpy(self.off_diag_h)).getH() - ) - return np.real( - np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h)) - ) - - diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index bc91e1d897..e5d54738b5 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -3,6 +3,7 @@ from qibo.hamiltonians import SymbolicHamiltonian from qibo import symbols from qibo.models.dbi.double_bracket import * +from qibo.models.dbi.double_bracket_evolution_oracles import * from copy import deepcopy from enum import Enum, auto @@ -64,138 +65,96 @@ def __init__( self.mode_gci_inversion = mode_gci_inversion self.mode_double_bracket_rotation = mode_double_bracket_rotation + self.gci_unitary = [] + self.gci_unitary_dagger = [] + self.iterated_hamiltonian_query_list = [ [ self.input_hamiltonian_evolution_oracle] ] + def __call__( self, - step: float, + step_duration: float = None, + diagonal_association: EvolutionOracle = None, mode_double_bracket_rotation: DoubleBracketRotationType = None, - d: np.array = None ) if mode_double_bracket_rotation is None: - mode_double_bracket_rotation= self.mode_double_bracket_rotation - if d is None: - if self.mode is DoubleBracketGeneratorType.canonical: - d = self.diagonal_h_matrix - else: - raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") - - if mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: - - double_bracket_rotation = self.group_commutator_reduced(step, d) - double_bracket_rotation_dagger = double_bracket_rotation.T.conj() - else: - super().__call__(step, d ) - - self.h.matrix = double_bracket_rotation_dagger @ self.h.matrix @ double_bracket_rotation - - - def circuit_sequence(self, k_step_number: int = None): - EvolutionOracleDiagonalInput = EvolutionOracle( - name = "DiagonalInput", - mode_evolution_oracle = self.mode_evolution_oracle) - EvolutionOracleInputHamiltonian = EvolutionOracle( name = "InputHamiltonian" ) - - if mode_dbr = DoubleBracketRotationType.group_commutator_reduced - return [ - EvolutionOracleDiagonalInput(s_step, d), - EvolutionOracleInputHamiltonian(s_step), - EvolutionOracleDiagonalInput(s_step,d) ] - def group_commutator_reduced(self, step, d = None): - if d is None: - if mode is DoubleBracketRotationType.canonical: - d = self.diagonal_h_matrix - else: - raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") - return ( - self.backend.calculate_matrix_exp(-step, d) - @ self.h.exp(step) - @ self.backend.calculate_matrix_exp(step, d) - ) - - + mode_double_bracket_rotation = self.mode_double_bracket_rotation - - def unfold_DBI_circuit_symbolic(self, nmb_DBI_steps = 1, s_list, d_list = None): - if d is None: - if mode is DoubleBracketRotationType.canonical: - d = self.diagonal_h_matrix + if diagonal_association is None: + if self.mode_double_bracket_rotation is DoubleBracketRotationType.canonical: + diagonal_association = EvolutionOracle( self.diagonal_h_matrix ) else: - print( DoubleBracketRotationType.canonical) - raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") - if nmb_DBI_steps == 1: - return [ DBI_step( s_list[0], d_list[0], mode_double_bracket_rotation= DoubleBracketRotationType.group_commutator_reduced).circuit_sequence ] + raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}. Did you want to set to canonical mode?") else: - circuit_sequence_so_far = self.unfold_DBI_circuit_symbolic( nmb_DBI_steps = nmb_DBI_steps - 1, s_list,d_list ) - shift_frame_Hk_H0 = reverse(circuit_sequence_so_far) + [EvolutionOracleInputHamiltonian(s_step[nmb_DBI_steps]) ] + circuit_sequence_so_far - return circuit_sequence_so_far.append(EvolutionOracleDiagonalInput(s_step, d[nmb_DBI_steps])) - + shift_frame_Hk_H0.append(EvolutionOracleDiagonalInput(-s_step, d[nmb_DBI_steps])) - + self.mode_diagonal_association = DoubleBracketDiagonalAssociationType.prescribed - - def group_commutator_reduced_unfold(self, step, d = None): - if d is None: - if mode is DoubleBracketRotationType.canonical: - d = self.diagonal_h_matrix - else: - print( DoubleBracketRotationType.canonical) - raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}") - return ( - self.backend.calculate_matrix_exp(-step, d) - @ self.unfold_DBI_circuit( nmb_dbi_steps = k ).T.conj() - @ self.evolution_oracle_reverse_h(step, self.h0) - @ self.unfold_DBI_circuit( nmb_dbi_steps = k ) - @ self.backend.calculate_matrix_exp(step, d) - ) - - def evolution_oracle_reverse_h(self, step, h): - if self.mode_gci_inversion is None: - raise_error(ValueError, f"You need to specify what is {self.mode_gci_inversion} when running a gci step with the imperfect group commutator") - - if self.mode_gci_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites: - R = self.evolution_oracle_reversal_conjugation_by_flips(step) - elif self.mode_gci_inversion is EvolutionOracleInputHamiltonianReversalType.product_Hadamards: - R = self.evolution_oracle_reversal_conjugation_by_hadamards(step) - elif self.mode_gci_inversion is EvolutionOracleInputHamiltonianReversalType.flip_odd_sites_and_NN_Ising_correction: - R = self.evolution_oracle_reversal_conjugation_by_flips(step) - Z = self.evolution_oracle_reversal_conjugation_by_unitary_diagonal_correction(R, step, h) - return R.matrix @ h.exp(step) @ R.matrix @ Z.matrix + if self.mode_dbr is DoubleBracketRotationType.single_commutator: + raise_error(NotImplementedError, "Keeping track of single commutator DBRs not implemented") + double_bracket_rotation_step = self.single_commutator_query_list(step, diagonal_association) else: - raise_error(TypeError, "Not implemented") - return R.matrix @ h.exp(step) @ R.matrix + #This will run the appropriate group commutator step + double_bracket_rotation_step = self.group_commutator_query_list(step, diagonal_association) + + if self.mode_evolution_oracle is EvolutionOracleType.numerical: + #then dbr step output is a matrix + ddouble_bracket_rotation_matrix = 0 * self.h.matrix + double_bracket_rotation_dagger_matrix = 0 * self.h.matrix + for m in double_bracket_rotation_matrix: + double_bracket_rotation_matrix = double_bracket_rotation_matrix * m + for m in double_bracket_rotation_dagger_matrix: + double_bracket_rotation_dagger_matrix = double_bracket_rotation_dagger_matrix * m + self.h.matrix = double_bracket_rotation_dagger_matrix @ self.h.matrix @ double_bracket_rotation_matrix + + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation + or self.mode_evolution_oracle is EvolutionOracleType.text_strings: + #then dbr step output is a query list + self.gci_unitary.append(double_bracket_rotation_step[forwards]) + self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) + + self.iterated_hamiltonian_evolution_oracle.append( + double_bracket_rotation_step[backwards] + + self.iterated_hamiltonian_evolution_oracle[-1 ] + + double_bracket_rotation_step[forwards]) - def evolution_oracle_reversal_conjugation_by_flips(self,step): + else: + super().__call__(step, d ) + + def group_commutator_query_list(self, + s_step: double, + diagonal_association_evolution_oracle: EvolutionOracle = None, + iterated_hamiltonian_evolution_oracle: EvolutionOracle = None): - R = symbols.I(0) - for qubit_nmb in range(self.h.nqubits): - if np.mod(qubit_nmb,2) == 0: - R *= symbols.X(qubit_nmb) - - return SymbolicHamiltonian(R, nqubits = self.h.nqubits) - - def evolution_oracle_reversal_conjugation_by_hadamards(self,step): - - R = symbols.I(0) - for qubit_nmb in range(self.h.nqubits): - if np.mod(qubit_nmb,2) == 0: - R *= ( symbols.X(qubit_nmb)+symbols.Z(qubit_nmb))/np.sqrt(2) - - return SymbolicHamiltonian(R, nqubits = self.nqubits) - - def evolution_oracle_reversal_conjugation_by_unitary_diagonal_correction(self,R, step, h, how = 'default'): - """This function takes an input reversal unitary and searches for the correction of diagonal terms variationally""" - @TODO use hyperopt to find d - if how is 'hyperopt': - def loss( d, s): - np.linalg.norm( R.matrix @ h.exp(s) @ R.matrix @ d @ h.exp(s) - h.exp(0) ) - raise_error(TypeError, "Not implemented") + if iterated_hamiltonian_evolution_oracle is None: + iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle[-1] + + if self.mode_dbr is DoubleBracketRotationType.group_commutator + return {forwards: [ + iterated_hamiltonian_evolution_oracle.circuit(-s_step), + diagonal_association_evolution_oracle.circuit(s_step), + iterated_hamiltonian_evolution_oracle.circuit(s_step), + diagonal_association_evolution_oracle.circuit(-s_step) + ] , + backwards: [ #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step), + iterated_hamiltonian_evolution_oracle.circuit(-s_step), + diagonal_association_evolution_oracle.circuit(-s_step), + iterated_hamiltonian_evolution_oracle.circuit(s_step) + ] } + elif self.mode_dbr is DoubleBracketRotationType.group_commutator_reduced + return {forwards: [ + diagonal_association_evolution_oracle.circuit(s_step), + iterated_hamiltonian_evolution_oracle.circuit(s_step), + diagonal_association_evolution_oracle.circuit(-s_step) + ] , + backwards: [ + diagonal_association_evolution_oracle.circuit(s_step), + iterated_hamiltonian_evolution_oracle.circuit(-s_step), + diagonal_association_evolution_oracle.circuit(-s_step) + ] } + else: + if self.mode_dbr is DoubleBracketRotationType.single_commutator: + raise_error(ValueError, "You are in the group commutator query list but your dbr mode is a perfect bracket and not an approximation by means of a group commutator!") else: - d0 = np.inv( R.matrix @ h.exp(s) @ R.matrix @ h.exp(s) ) - d1 = self.backend.cast(np.diag(np.diag(self.backend.to_numpy( d0 )))) - from import scipy.linalg import polar - return polar(d1)[0] - def evolution_oracle_input_hamiltonian(self,step, diagonal_correction): - raise_error(TypeError, "Not implemented") - - return None - #Questions + raise_error(ValueError, "You are in the group commutator query list but your dbr mode is not recognized") + + From 4690220d52ce590bbfca1d663575d1c4f23538d8 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 6 Feb 2024 04:44:38 +0100 Subject: [PATCH 013/116] stuff runs but next need to create a mutable EvolutionOracles allowing for frame shifting --- .../dbi/double_bracket_evolution_oracles.py | 43 ++++++++++-------- .../group_commutator_iteration_transpiler.py | 44 ++++++++++--------- .../models/dbi/test_dbi_evolution_oracles.py | 30 +++++++++++++ 3 files changed, 77 insertions(+), 40 deletions(-) create mode 100644 src/qibo/models/dbi/test_dbi_evolution_oracles.py diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 18941c8a4a..9e299a9538 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -6,7 +6,7 @@ import numpy as np from qibo.config import raise_error -from qibo.hamiltonians import Hamiltonian +from qibo.hamiltonians import AbstractHamiltonian, SymbolicHamiltonian @@ -23,26 +23,27 @@ class EvolutionOracleType(Enum): class EvolutionOracle: - def __init__( h_generator: AbstractHamiltonian = None, - name = None, + def __init__( self, + h_generator: AbstractHamiltonian, + name, mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): - if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation and if type(h_generator) is not SymbolicHamiltonian: + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation and type(h_generator) is not SymbolicHamiltonian: raise_error(TypeError, "If the evolution oracle mode will be to make Trotter-Suzuki decompositions then you must use the SymbolicHamiltonian generator") if h_generator is None and name is None: raise_error(NotImplementedError, "You have to specify either a matrix and then work in the numerical mode, or SymbolicHamiltonian and work in hamiltonian_simulation mode or at least a name and work with text_strings to list DBI query lists") self.h = h_generator - self.mode_evolution_oracle = mode_evolution_oracle self.name = name + self.mode_evolution_oracle = mode_evolution_oracle - def __call__(self, t_duration: double = None): + def __call__(self, t_duration: float = None): """ Returns either the name or the circuit """ if t_duration is None: return self.name else: return self.circuit( t_duration = t_duration ) - def circuit(self, t_duration: double = None): + def circuit(self, t_duration: float = None): if self.mode_evolution_oracle is EvolutionOracleType.text_strings: return self.name + str(t_duration) @@ -54,7 +55,7 @@ def circuit(self, t_duration: double = None): raise_error(ValueError, f"You are using an EvolutionOracle type which is not yet supported.") @property - def name(self): + def print(self): return self.name class DoubleBracketDiagonalAssociationType(Enum): @@ -75,13 +76,17 @@ class DoubleBracketDiagonalAssociationType(Enum): class DiagonalAssociationDephasing(EvolutionOracle): - def __init__( - self, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings - ): - super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.dephasing, mode_evolution_oracle = mode_evolution_oracle) + def __init__( + self, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings +): + super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.dephasing, mode_evolution_oracle = mode_evolution_oracle) + + + + - def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_duration = None ): + def __call__(self, J_input: EvolutionOracle, k_step_number: list = None, t_duration = None ): if mode_evolution_oracle is EvolutionOracleType.text_strings: if t_duration is None: #iterate over all Z ops @@ -96,9 +101,9 @@ def __call__(self, J_input: EvolutionHamiltonian, k_step_number: list = None, t_ if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if t_duration is None: #iterate over all Z ops - return sum Z @ J_input @ Z + return sum(Z @ J_input @ Z) else: - return sum Z @ J_input.circuit(t_duration) @Z + return sum( Z @ J_input.circuit(t_duration) @Z) class DiagonalAssociationFromList(EvolutionOracle): @@ -126,14 +131,14 @@ def __call__(self, k_step_number: list = None, t_duration = None ): if t_duration is None: raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") else: - return d_k_list[k_step_number.circuit(t_duration) + return d_k_list[k_step_number.circuit(t_duration)] class DiagonalAssociationFromOptimization(EvolutionOracle): def __init__( self, loss_function: None, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.canonical, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): self.loss = loss_function @@ -156,7 +161,7 @@ def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duratio raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") else: raise_error(TypeError, "Not implemented") - return sum Z @ J_input.circuit(t_duration) @Z + return None diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index e5d54738b5..a91d22d4a2 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -54,15 +54,15 @@ def __init__( mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.numerical, mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing ): - if mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator + if mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: mode_double_bracket_rotation_old = DoubleBracketGeneratorType.single_commutator - + else: + mode_double_bracket_rotation_old = DoubleBracketGeneratorType.group_commutator super().__init__( input_hamiltonian_evolution_oracle.h, mode_double_bracket_rotation_old ) self.input_hamiltonian_evolution_oracle = input_hamiltonian_evolution_oracle self.mode_diagonal_association = mode_diagonal_association - self.mode_gci_inversion = mode_gci_inversion self.mode_double_bracket_rotation = mode_double_bracket_rotation self.gci_unitary = [] @@ -74,29 +74,31 @@ def __call__( step_duration: float = None, diagonal_association: EvolutionOracle = None, mode_double_bracket_rotation: DoubleBracketRotationType = None, - ) + ): if mode_double_bracket_rotation is None: mode_double_bracket_rotation = self.mode_double_bracket_rotation if diagonal_association is None: - if self.mode_double_bracket_rotation is DoubleBracketRotationType.canonical: - diagonal_association = EvolutionOracle( self.diagonal_h_matrix ) + if self.mode_diagonal_association is DoubleBracketDiagonalAssociationType.dephasing: + raise_error(NotImplementedError, "diagonal_h_matrix is np.array but need to cast to SymbolicHamiltonian") + diagonal_association = EvolutionOracle( self.diagonal_h_matrix, 'Dephasing', + mode_evolution_oracle = self.input_hamiltonian_evolution_oracle.mode_evolution_oracle) else: raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}. Did you want to set to canonical mode?") else: self.mode_diagonal_association = DoubleBracketDiagonalAssociationType.prescribed - if self.mode_dbr is DoubleBracketRotationType.single_commutator: + if self.mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: raise_error(NotImplementedError, "Keeping track of single commutator DBRs not implemented") double_bracket_rotation_step = self.single_commutator_query_list(step, diagonal_association) else: #This will run the appropriate group commutator step - double_bracket_rotation_step = self.group_commutator_query_list(step, diagonal_association) + double_bracket_rotation_step = self.group_commutator_query_list(step_duration, diagonal_association) if self.mode_evolution_oracle is EvolutionOracleType.numerical: #then dbr step output is a matrix - ddouble_bracket_rotation_matrix = 0 * self.h.matrix + double_bracket_rotation_matrix = 0 * self.h.matrix double_bracket_rotation_dagger_matrix = 0 * self.h.matrix for m in double_bracket_rotation_matrix: double_bracket_rotation_matrix = double_bracket_rotation_matrix * m @@ -104,54 +106,54 @@ def __call__( double_bracket_rotation_dagger_matrix = double_bracket_rotation_dagger_matrix * m self.h.matrix = double_bracket_rotation_dagger_matrix @ self.h.matrix @ double_bracket_rotation_matrix - elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation - or self.mode_evolution_oracle is EvolutionOracleType.text_strings: + elif (self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation + or self.mode_evolution_oracle is EvolutionOracleType.text_strings): #then dbr step output is a query list self.gci_unitary.append(double_bracket_rotation_step[forwards]) self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) self.iterated_hamiltonian_evolution_oracle.append( double_bracket_rotation_step[backwards] - + self.iterated_hamiltonian_evolution_oracle[-1 ] + + self.iterated_hamiltonian_query_list[-1 ] + double_bracket_rotation_step[forwards]) else: super().__call__(step, d ) def group_commutator_query_list(self, - s_step: double, + s_step: float, diagonal_association_evolution_oracle: EvolutionOracle = None, iterated_hamiltonian_evolution_oracle: EvolutionOracle = None): if iterated_hamiltonian_evolution_oracle is None: - iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle[-1] + iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_query_list[-1] - if self.mode_dbr is DoubleBracketRotationType.group_commutator - return {forwards: [ + if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: + return {'forwards': [ iterated_hamiltonian_evolution_oracle.circuit(-s_step), diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(s_step), diagonal_association_evolution_oracle.circuit(-s_step) ] , - backwards: [ #in general an evolution oracle might have imperfect time reversal + 'backwards': [ #in general an evolution oracle might have imperfect time reversal diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(-s_step), diagonal_association_evolution_oracle.circuit(-s_step), iterated_hamiltonian_evolution_oracle.circuit(s_step) ] } - elif self.mode_dbr is DoubleBracketRotationType.group_commutator_reduced - return {forwards: [ + elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: + return {'forwards': [ diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(s_step), diagonal_association_evolution_oracle.circuit(-s_step) ] , - backwards: [ + 'backwards': [ diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(-s_step), diagonal_association_evolution_oracle.circuit(-s_step) ] } else: - if self.mode_dbr is DoubleBracketRotationType.single_commutator: + if self.mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: raise_error(ValueError, "You are in the group commutator query list but your dbr mode is a perfect bracket and not an approximation by means of a group commutator!") else: raise_error(ValueError, "You are in the group commutator query list but your dbr mode is not recognized") diff --git a/src/qibo/models/dbi/test_dbi_evolution_oracles.py b/src/qibo/models/dbi/test_dbi_evolution_oracles.py new file mode 100644 index 0000000000..d771342c7d --- /dev/null +++ b/src/qibo/models/dbi/test_dbi_evolution_oracles.py @@ -0,0 +1,30 @@ +from qibo.hamiltonians import SymbolicHamiltonian +from qibo import symbols +from double_bracket_evolution_oracles import * +from group_commutator_iteration_transpiler import * + + + +def test_evolution_oracle_gci_classes(): + return 0 + + +"""Test create evolution oracle""" + +h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2), nqubits = 3 ) + +#By default this initializes with text_strings oracle type +input_hamiltonian_evolution_oracle = EvolutionOracle(h_input, "ZX") + +c1 = input_hamiltonian_evolution_oracle.circuit(0.1) +assert isinstance( c1, str), "Should be a string here" +print( c1 ) + +input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation +c2 =input_hamiltonian_evolution_oracle.circuit(0.2) +assert isinstance( c2, type(h_input.circuit(0.1)) ), "Should be a qibo.Circuit here" +c2.draw() +d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits = 3 ) +gci = GroupCommutatorIterationWithEvolutionOracles( input_hamiltonian_evolution_oracle ) +#By default this will test the dephasing oracle +gci(0.2, d_0) From 41f0a76abe189f60206c4afb1c70c6351bf5224c Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 6 Feb 2024 05:19:56 +0100 Subject: [PATCH 014/116] defined FrameShifted evolution oracles, it is a recursive class on top of evolution oracle --- .../group_commutator_iteration_transpiler.py | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index a91d22d4a2..a801dd4980 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -106,17 +106,21 @@ def __call__( double_bracket_rotation_dagger_matrix = double_bracket_rotation_dagger_matrix * m self.h.matrix = double_bracket_rotation_dagger_matrix @ self.h.matrix @ double_bracket_rotation_matrix - elif (self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation - or self.mode_evolution_oracle is EvolutionOracleType.text_strings): + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: #then dbr step output is a query list self.gci_unitary.append(double_bracket_rotation_step[forwards]) self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) - self.iterated_hamiltonian_evolution_oracle.append( - double_bracket_rotation_step[backwards] - + self.iterated_hamiltonian_query_list[-1 ] - + double_bracket_rotation_step[forwards]) + self.iterated_hamiltonian_evolution_oracle = + FrameShiftedEvolutionOracle( + self.iterated_hamiltonian_evolution_oracle, + name = str(step_duration), + double_bracket_rotation_step[backwards], + double_bracket_rotation_step[forwards]) + + elif self.mode_evolution_oracle is EvolutionOracleType.text_strings): + raise_error(NotImplementedError) else: super().__call__(step, d ) @@ -126,7 +130,7 @@ def group_commutator_query_list(self, iterated_hamiltonian_evolution_oracle: EvolutionOracle = None): if iterated_hamiltonian_evolution_oracle is None: - iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_query_list[-1] + iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: return {'forwards': [ From 308b3abdd5baea0391f308eade7cf259f7600174 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 6 Feb 2024 05:20:39 +0100 Subject: [PATCH 015/116] defined FrameShifted evolution oracles, it is a recursive class on top of evolution oracle --- .../dbi/double_bracket_evolution_oracles.py | 48 +++++++++++++++++-- 1 file changed, 45 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 9e299a9538..176357102a 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -54,9 +54,51 @@ def circuit(self, t_duration: float = None): else: raise_error(ValueError, f"You are using an EvolutionOracle type which is not yet supported.") - @property - def print(self): - return self.name + + def add_static_dynamic(self, other_oracle: EvolutionOracle): + raise_error(NotImplementedError, "Stopped because maybe overengineering plus not sure which composition is really needed") + assert self.mode_evolution_oracle is other_oracle.mode_evolution_oracle + added_oracles = EvolutionOracle(h_generator = {self.name: self.h, other_oracle.name: other_oracle.h}, name = self.name + '*' +other_oracle.name, mode_evolution_oracle = self.mode_evolution_oracle) + def new_cicuit( self, t_duration ): + if self.mode_evolution_oracle is EvolutionOracleType.text_strings: + return self.name + str(t_duration) + elif self.mode_evolution_oracle is EvolutionOracleType.numerical: + return self.h.exp(t_duration) + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + return self.h.circuit(t_duration) + else: + raise_error(ValueError, + f"You are using an EvolutionOracle type which is not yet supported.") + import types + added_oracles.circuit = types.MethodType( new_cicuit, added_oracles ) + +class FrameShiftedEvolutionOracle(EvolutionOracle): + def __init__( self, + base_evolution_oracle: EvolutionOracle, + name, + before_circuit, after_circuit ): + assert isinstance(before_circuit, type(after_circuit) ) + + if base_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation : + assert type(before_circuit) is qibo.Circuit: + + self.h = base_evolution_oracle.h + self.name = name + '(' + base_evolution_oracle.name + ')' + self.mode_evolution_oracle = base_evolution_oracle.mode_evolution_oracle + self.before_circuit = before_circuit + self.after_circuit = after_circuit + + def circuit(self, t_duration: float = None): + + if self.mode_evolution_oracle is EvolutionOracleType.text_strings: + return self.name + '(' + str(t_duration) + ')' + elif self.mode_evolution_oracle is EvolutionOracleType.numerical: + return self.before_circuit @ self.h.exp(t_duration) @ self.after_circuit + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + return self.before_circuit @ self.h.circuit(t_duration) @ self.after_circuit + else: + raise_error(ValueError, + f"You are using an EvolutionOracle type which is not yet supported.") class DoubleBracketDiagonalAssociationType(Enum): """Define the evolution generator of a variant of the double-bracket iterations.""" From 6f9745f137d03f2674838e5d4bf52c4e920b2b14 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 6 Feb 2024 06:14:08 +0100 Subject: [PATCH 016/116] it's running through, there might be bugs but overall code structure seems ok! --- .../dbi/double_bracket_evolution_oracles.py | 29 ++++------------- .../group_commutator_iteration_transpiler.py | 32 +++++++++++-------- .../models/dbi/test_dbi_evolution_oracles.py | 13 ++++++++ 3 files changed, 38 insertions(+), 36 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 176357102a..6d81521f4a 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -7,7 +7,7 @@ from qibo.config import raise_error from qibo.hamiltonians import AbstractHamiltonian, SymbolicHamiltonian - +from qibo import Circuit @@ -55,32 +55,17 @@ def circuit(self, t_duration: float = None): raise_error(ValueError, f"You are using an EvolutionOracle type which is not yet supported.") - def add_static_dynamic(self, other_oracle: EvolutionOracle): - raise_error(NotImplementedError, "Stopped because maybe overengineering plus not sure which composition is really needed") - assert self.mode_evolution_oracle is other_oracle.mode_evolution_oracle - added_oracles = EvolutionOracle(h_generator = {self.name: self.h, other_oracle.name: other_oracle.h}, name = self.name + '*' +other_oracle.name, mode_evolution_oracle = self.mode_evolution_oracle) - def new_cicuit( self, t_duration ): - if self.mode_evolution_oracle is EvolutionOracleType.text_strings: - return self.name + str(t_duration) - elif self.mode_evolution_oracle is EvolutionOracleType.numerical: - return self.h.exp(t_duration) - elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.h.circuit(t_duration) - else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") - import types - added_oracles.circuit = types.MethodType( new_cicuit, added_oracles ) - class FrameShiftedEvolutionOracle(EvolutionOracle): def __init__( self, base_evolution_oracle: EvolutionOracle, name, - before_circuit, after_circuit ): + before_circuit, + after_circuit ): + assert isinstance(before_circuit, type(after_circuit) ) - if base_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation : - assert type(before_circuit) is qibo.Circuit: +# if base_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation : +# assert type(before_circuit) is Circuit, str(type(before_circuit)) self.h = base_evolution_oracle.h self.name = name + '(' + base_evolution_oracle.name + ')' @@ -95,7 +80,7 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.before_circuit @ self.h.exp(t_duration) @ self.after_circuit elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.before_circuit @ self.h.circuit(t_duration) @ self.after_circuit + return self.before_circuit + self.h.circuit(t_duration) + self.after_circuit else: raise_error(ValueError, f"You are using an EvolutionOracle type which is not yet supported.") diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index a801dd4980..898bd4e67b 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -67,7 +67,7 @@ def __init__( self.gci_unitary = [] self.gci_unitary_dagger = [] - self.iterated_hamiltonian_query_list = [ [ self.input_hamiltonian_evolution_oracle] ] + self.iterated_hamiltonian_evolution_oracle = self.input_hamiltonian_evolution_oracle def __call__( self, @@ -96,30 +96,34 @@ def __call__( #This will run the appropriate group commutator step double_bracket_rotation_step = self.group_commutator_query_list(step_duration, diagonal_association) - if self.mode_evolution_oracle is EvolutionOracleType.numerical: + if self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: #then dbr step output is a matrix double_bracket_rotation_matrix = 0 * self.h.matrix double_bracket_rotation_dagger_matrix = 0 * self.h.matrix for m in double_bracket_rotation_matrix: - double_bracket_rotation_matrix = double_bracket_rotation_matrix * m + double_bracket_rotation_matrix = double_bracket_rotation_matrix @ m for m in double_bracket_rotation_dagger_matrix: - double_bracket_rotation_dagger_matrix = double_bracket_rotation_dagger_matrix * m + double_bracket_rotation_dagger_matrix = double_bracket_rotation_dagger_matrix @ m self.h.matrix = double_bracket_rotation_dagger_matrix @ self.h.matrix @ double_bracket_rotation_matrix - elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: #then dbr step output is a query list - self.gci_unitary.append(double_bracket_rotation_step[forwards]) - self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) - - self.iterated_hamiltonian_evolution_oracle = - FrameShiftedEvolutionOracle( + #self.gci_unitary.append(double_bracket_rotation_step[forwards]) + #self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) + print (double_bracket_rotation_step) + from functools import reduce + #composition of circuits should be __matmul__ not __add__ in qibo.Circuit.... + before_circuit = reduce(Circuit.__add__, double_bracket_rotation_step['backwards']) + after_circuit = reduce( Circuit.__add__, double_bracket_rotation_step['forwards']) + self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( self.iterated_hamiltonian_evolution_oracle, - name = str(step_duration), - double_bracket_rotation_step[backwards], - double_bracket_rotation_step[forwards]) + str(step_duration), + before_circuit, + after_circuit + ) - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings): + elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: raise_error(NotImplementedError) else: super().__call__(step, d ) diff --git a/src/qibo/models/dbi/test_dbi_evolution_oracles.py b/src/qibo/models/dbi/test_dbi_evolution_oracles.py index d771342c7d..946c318f3d 100644 --- a/src/qibo/models/dbi/test_dbi_evolution_oracles.py +++ b/src/qibo/models/dbi/test_dbi_evolution_oracles.py @@ -28,3 +28,16 @@ def test_evolution_oracle_gci_classes(): gci = GroupCommutatorIterationWithEvolutionOracles( input_hamiltonian_evolution_oracle ) #By default this will test the dephasing oracle gci(0.2, d_0) + +query_list = gci.group_commutator_query_list( 0.2, d_0, input_hamiltonian_evolution_oracle ) + +from functools import reduce +before_circuit =reduce(Circuit.__add__, query_list['backwards']) +after_circuit = reduce(Circuit.__add__, query_list['forwards']) +frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( + input_hamiltonian_evolution_oracle, 'Step 1', before_circuit, after_circuit) + +print(gci.h.exp(0.3)) +print(frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3)) + + From e2a2ba59955f033bb52d0985bf04b6d86f02a013 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 7 Feb 2024 01:15:11 +0000 Subject: [PATCH 017/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../dbi/double_bracket_evolution_oracles.py | 201 ++++++++------ .../group_commutator_iteration_transpiler.py | 261 +++++++++++------- .../models/dbi/test_dbi_evolution_oracles.py | 46 +-- 3 files changed, 303 insertions(+), 205 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 6d81521f4a..de948acc5e 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -1,17 +1,14 @@ -from copy import deepcopy from enum import Enum, auto -from functools import partial import hyperopt import numpy as np +from qibo import Circuit from qibo.config import raise_error from qibo.hamiltonians import AbstractHamiltonian, SymbolicHamiltonian -from qibo import Circuit - -class EvolutionOracleType(Enum): +class EvolutionOracleType(Enum): text_strings = auto() """If you only want to get a sequence of names of the oracle""" @@ -23,26 +20,37 @@ class EvolutionOracleType(Enum): class EvolutionOracle: - def __init__( self, - h_generator: AbstractHamiltonian, - name, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings ): - if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation and type(h_generator) is not SymbolicHamiltonian: - raise_error(TypeError, "If the evolution oracle mode will be to make Trotter-Suzuki decompositions then you must use the SymbolicHamiltonian generator") - if h_generator is None and name is None: - raise_error(NotImplementedError, "You have to specify either a matrix and then work in the numerical mode, or SymbolicHamiltonian and work in hamiltonian_simulation mode or at least a name and work with text_strings to list DBI query lists") - - self.h = h_generator - self.name = name - self.mode_evolution_oracle = mode_evolution_oracle + def __init__( + self, + h_generator: AbstractHamiltonian, + name, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings, + ): + if ( + mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation + and type(h_generator) is not SymbolicHamiltonian + ): + raise_error( + TypeError, + "If the evolution oracle mode will be to make Trotter-Suzuki decompositions then you must use the SymbolicHamiltonian generator", + ) + if h_generator is None and name is None: + raise_error( + NotImplementedError, + "You have to specify either a matrix and then work in the numerical mode, or SymbolicHamiltonian and work in hamiltonian_simulation mode or at least a name and work with text_strings to list DBI query lists", + ) + + self.h = h_generator + self.name = name + self.mode_evolution_oracle = mode_evolution_oracle def __call__(self, t_duration: float = None): - """ Returns either the name or the circuit """ + """Returns either the name or the circuit""" if t_duration is None: return self.name else: - return self.circuit( t_duration = t_duration ) - + return self.circuit(t_duration=t_duration) + def circuit(self, t_duration: float = None): if self.mode_evolution_oracle is EvolutionOracleType.text_strings: @@ -52,143 +60,162 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: return self.h.circuit(t_duration) else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") + raise_error( + ValueError, + f"You are using an EvolutionOracle type which is not yet supported.", + ) + class FrameShiftedEvolutionOracle(EvolutionOracle): - def __init__( self, - base_evolution_oracle: EvolutionOracle, - name, - before_circuit, - after_circuit ): - - assert isinstance(before_circuit, type(after_circuit) ) - -# if base_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation : -# assert type(before_circuit) is Circuit, str(type(before_circuit)) - - self.h = base_evolution_oracle.h - self.name = name + '(' + base_evolution_oracle.name + ')' - self.mode_evolution_oracle = base_evolution_oracle.mode_evolution_oracle - self.before_circuit = before_circuit - self.after_circuit = after_circuit - + def __init__( + self, + base_evolution_oracle: EvolutionOracle, + name, + before_circuit, + after_circuit, + ): + + assert isinstance(before_circuit, type(after_circuit)) + + # if base_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation : + # assert type(before_circuit) is Circuit, str(type(before_circuit)) + + self.h = base_evolution_oracle.h + self.name = name + "(" + base_evolution_oracle.name + ")" + self.mode_evolution_oracle = base_evolution_oracle.mode_evolution_oracle + self.before_circuit = before_circuit + self.after_circuit = after_circuit + def circuit(self, t_duration: float = None): if self.mode_evolution_oracle is EvolutionOracleType.text_strings: - return self.name + '(' + str(t_duration) + ')' + return self.name + "(" + str(t_duration) + ")" elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.before_circuit @ self.h.exp(t_duration) @ self.after_circuit elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.before_circuit + self.h.circuit(t_duration) + self.after_circuit + return self.before_circuit + self.h.circuit(t_duration) + self.after_circuit else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") + raise_error( + ValueError, + f"You are using an EvolutionOracle type which is not yet supported.", + ) + class DoubleBracketDiagonalAssociationType(Enum): """Define the evolution generator of a variant of the double-bracket iterations.""" - + dephasing = auto() """Use dephasing for a canonical bracket.""" - + prescribed = auto() """Use some input diagonal matrix for each step: general diagonalization DBI""" fixed = auto() - """Use same input diagonal matrix in each step: BHMM DBI""" + """Use same input diagonal matrix in each step: BHMM DBI""" optimization = auto() - """Perform optimization to find best diagonal operator""" + """Perform optimization to find best diagonal operator""" class DiagonalAssociationDephasing(EvolutionOracle): def __init__( - self, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings -): - super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.dephasing, mode_evolution_oracle = mode_evolution_oracle) - - - - - - def __call__(self, J_input: EvolutionOracle, k_step_number: list = None, t_duration = None ): + self, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings, + ): + super().__init__( + mode_diagonal_association=DoubleBracketDiagonalAssociationType.dephasing, + mode_evolution_oracle=mode_evolution_oracle, + ) + + def __call__( + self, J_input: EvolutionOracle, k_step_number: list = None, t_duration=None + ): if mode_evolution_oracle is EvolutionOracleType.text_strings: if t_duration is None: - #iterate over all Z ops - return '\Delta(' + J_input.name + ')' + # iterate over all Z ops + return r"\Delta(" + J_input.name + ")" else: - return 'exp( i'+ str(t_duration) +'\Delta(' + J_input.name + ')' + return "exp( i" + str(t_duration) + r"\Delta(" + J_input.name + ")" elif mode_evolution_oracle is EvolutionOracleType.numerical: if t_duration is None: return J_input.h.diag() else: - return J_input.diag().exp(t_duration) + return J_input.diag().exp(t_duration) if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if t_duration is None: - #iterate over all Z ops + # iterate over all Z ops return sum(Z @ J_input @ Z) else: - return sum( Z @ J_input.circuit(t_duration) @Z) + return sum(Z @ J_input.circuit(t_duration) @ Z) + class DiagonalAssociationFromList(EvolutionOracle): def __init__( - self, - d_k_list: list = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings - ): - super().__init__(mode_diagonal_association = DoubleBracketDiagonalAssociationType.prescribed, mode_evolution_oracle = mode_evolution_oracle) + self, + d_k_list: list = None, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings, + ): + super().__init__( + mode_diagonal_association=DoubleBracketDiagonalAssociationType.prescribed, + mode_evolution_oracle=mode_evolution_oracle, + ) self.d_k_list = d_k_list - def __call__(self, k_step_number: list = None, t_duration = None ): - + def __call__(self, k_step_number: list = None, t_duration=None): + if mode_evolution_oracle is EvolutionOracleType.text_strings: if t_duration is None: - return 'D_' + str(k_step_number) + return "D_" + str(k_step_number) else: - return 'exp( i'+ str(t_duration) +'D_k' + return "exp( i" + str(t_duration) + "D_k" elif mode_evolution_oracle is EvolutionOracleType.numerical: if t_duration is None: return d_k_list[k_step_number] else: - return d_k_list[k_step_number].exp(t_duration) + return d_k_list[k_step_number].exp(t_duration) if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if t_duration is None: - raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") + raise_error( + ValueError, + f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.", + ) else: return d_k_list[k_step_number.circuit(t_duration)] + class DiagonalAssociationFromOptimization(EvolutionOracle): def __init__( - self, - loss_function: None, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings -): + self, + loss_function: None, + mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, + mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings, + ): self.loss = loss_function - def __call__(self, h: AbstractHamiltonian, k_step_number: list = None, t_duration = None ): + def __call__( + self, h: AbstractHamiltonian, k_step_number: list = None, t_duration=None + ): if self.mode_evolution_oracle is EvolutionOracleType.text_strings: if t_duration is None: - return 'Optimize $\mu$ D_' + str(k_step_number) + return r"Optimize $\mu$ D_" + str(k_step_number) else: - return 'Optimize $\mu$ exp( i'+ str(t_duration) +'D_k' + return r"Optimize $\mu$ exp( i" + str(t_duration) + "D_k" elif self.mode_evolution_oracle is EvolutionOracleType.numerical: if t_duration is None: raise_error(TypeError, "Not implemented") - return 0 + return 0 else: raise_error(TypeError, "Not implemented") return 0 if self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if t_duration is None: - raise_error(ValueError, f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.") + raise_error( + ValueError, + f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.", + ) else: raise_error(TypeError, "Not implemented") return None - - - diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 898bd4e67b..c1d0f364dd 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -1,170 +1,235 @@ -from qibo import * -from qibo.models.dbi import * -from qibo.hamiltonians import SymbolicHamiltonian -from qibo import symbols -from qibo.models.dbi.double_bracket import * -from qibo.models.dbi.double_bracket_evolution_oracles import * - -from copy import deepcopy from enum import Enum, auto -from functools import partial import hyperopt import numpy as np +from qibo import * +from qibo import symbols from qibo.config import raise_error -from qibo.hamiltonians import Hamiltonian +from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian +from qibo.models.dbi import * +from qibo.models.dbi.double_bracket import * +from qibo.models.dbi.double_bracket_evolution_oracles import * + + +class DoubleBracketRotationType(Enum): + # The dbr types below need a diagonal input matrix $\hat D_k$ : -class DoubleBracketRotationType(Enum): - #The dbr types below need a diagonal input matrix $\hat D_k$ : - single_commutator = auto() """Use single commutator.""" - + group_commutator = auto() """Use group commutator approximation""" - + group_commutator_reduced = auto() """Use group commutator approximation with a reduction using symmetry - - """ - - ## Reserving for later development + + """ + + ## Reserving for later development group_commutator_imperfect = auto() """Use group commutator approximation""" - + group_commutator_reduced_imperfect = auto() - """Use group commutator approximation: + """Use group commutator approximation: symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries. We extrapolate that symmetry to the imperfect reversal. - Note that while may not be performing a similarity operation on the generator of the double bracket iteration, + Note that while may not be performing a similarity operation on the generator of the double bracket iteration, the unfolded operation applied to a state vector will still be unitary: - + """ - + class GroupCommutatorIterationWithEvolutionOracles(DoubleBracketIteration): """ - Class which will be later merged into the @super somehow """ + Class which will be later merged into the @super somehow""" def __init__( self, input_hamiltonian_evolution_oracle: EvolutionOracle, mode_double_bracket_rotation: DoubleBracketRotationType = DoubleBracketRotationType.group_commutator, mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.numerical, - mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing + mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, ): if mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: - mode_double_bracket_rotation_old = DoubleBracketGeneratorType.single_commutator + mode_double_bracket_rotation_old = ( + DoubleBracketGeneratorType.single_commutator + ) else: - mode_double_bracket_rotation_old = DoubleBracketGeneratorType.group_commutator - super().__init__( input_hamiltonian_evolution_oracle.h, mode_double_bracket_rotation_old ) - - self.input_hamiltonian_evolution_oracle = input_hamiltonian_evolution_oracle + mode_double_bracket_rotation_old = ( + DoubleBracketGeneratorType.group_commutator + ) + super().__init__( + input_hamiltonian_evolution_oracle.h, mode_double_bracket_rotation_old + ) + + self.input_hamiltonian_evolution_oracle = input_hamiltonian_evolution_oracle self.mode_diagonal_association = mode_diagonal_association - self.mode_double_bracket_rotation = mode_double_bracket_rotation + self.mode_double_bracket_rotation = mode_double_bracket_rotation self.gci_unitary = [] self.gci_unitary_dagger = [] - self.iterated_hamiltonian_evolution_oracle = self.input_hamiltonian_evolution_oracle + self.iterated_hamiltonian_evolution_oracle = ( + self.input_hamiltonian_evolution_oracle + ) def __call__( - self, - step_duration: float = None, + self, + step_duration: float = None, diagonal_association: EvolutionOracle = None, mode_double_bracket_rotation: DoubleBracketRotationType = None, - ): - + ): + if mode_double_bracket_rotation is None: mode_double_bracket_rotation = self.mode_double_bracket_rotation if diagonal_association is None: - if self.mode_diagonal_association is DoubleBracketDiagonalAssociationType.dephasing: - raise_error(NotImplementedError, "diagonal_h_matrix is np.array but need to cast to SymbolicHamiltonian") - diagonal_association = EvolutionOracle( self.diagonal_h_matrix, 'Dephasing', - mode_evolution_oracle = self.input_hamiltonian_evolution_oracle.mode_evolution_oracle) + if ( + self.mode_diagonal_association + is DoubleBracketDiagonalAssociationType.dephasing + ): + raise_error( + NotImplementedError, + "diagonal_h_matrix is np.array but need to cast to SymbolicHamiltonian", + ) + diagonal_association = EvolutionOracle( + self.diagonal_h_matrix, + "Dephasing", + mode_evolution_oracle=self.input_hamiltonian_evolution_oracle.mode_evolution_oracle, + ) else: - raise_error(ValueError, f"Cannot use group_commutator without specifying matrix {d}. Did you want to set to canonical mode?") + raise_error( + ValueError, + f"Cannot use group_commutator without specifying matrix {d}. Did you want to set to canonical mode?", + ) else: - self.mode_diagonal_association = DoubleBracketDiagonalAssociationType.prescribed + self.mode_diagonal_association = ( + DoubleBracketDiagonalAssociationType.prescribed + ) - if self.mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: - raise_error(NotImplementedError, "Keeping track of single commutator DBRs not implemented") - double_bracket_rotation_step = self.single_commutator_query_list(step, diagonal_association) + if ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.single_commutator + ): + raise_error( + NotImplementedError, + "Keeping track of single commutator DBRs not implemented", + ) + double_bracket_rotation_step = self.single_commutator_query_list( + step, diagonal_association + ) else: - #This will run the appropriate group commutator step - double_bracket_rotation_step = self.group_commutator_query_list(step_duration, diagonal_association) - - if self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - #then dbr step output is a matrix + # This will run the appropriate group commutator step + double_bracket_rotation_step = self.group_commutator_query_list( + step_duration, diagonal_association + ) + + if ( + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical + ): + # then dbr step output is a matrix double_bracket_rotation_matrix = 0 * self.h.matrix double_bracket_rotation_dagger_matrix = 0 * self.h.matrix for m in double_bracket_rotation_matrix: double_bracket_rotation_matrix = double_bracket_rotation_matrix @ m for m in double_bracket_rotation_dagger_matrix: - double_bracket_rotation_dagger_matrix = double_bracket_rotation_dagger_matrix @ m - self.h.matrix = double_bracket_rotation_dagger_matrix @ self.h.matrix @ double_bracket_rotation_matrix - - elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - #then dbr step output is a query list - #self.gci_unitary.append(double_bracket_rotation_step[forwards]) - #self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) - print (double_bracket_rotation_step) + double_bracket_rotation_dagger_matrix = ( + double_bracket_rotation_dagger_matrix @ m + ) + self.h.matrix = ( + double_bracket_rotation_dagger_matrix + @ self.h.matrix + @ double_bracket_rotation_matrix + ) + + elif ( + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + # then dbr step output is a query list + # self.gci_unitary.append(double_bracket_rotation_step[forwards]) + # self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) + print(double_bracket_rotation_step) from functools import reduce - #composition of circuits should be __matmul__ not __add__ in qibo.Circuit.... - before_circuit = reduce(Circuit.__add__, double_bracket_rotation_step['backwards']) - after_circuit = reduce( Circuit.__add__, double_bracket_rotation_step['forwards']) + + # composition of circuits should be __matmul__ not __add__ in qibo.Circuit.... + before_circuit = reduce( + Circuit.__add__, double_bracket_rotation_step["backwards"] + ) + after_circuit = reduce( + Circuit.__add__, double_bracket_rotation_step["forwards"] + ) self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - self.iterated_hamiltonian_evolution_oracle, - str(step_duration), - before_circuit, - after_circuit - ) - - - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: + self.iterated_hamiltonian_evolution_oracle, + str(step_duration), + before_circuit, + after_circuit, + ) + + elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: raise_error(NotImplementedError) else: - super().__call__(step, d ) - - def group_commutator_query_list(self, - s_step: float, - diagonal_association_evolution_oracle: EvolutionOracle = None, - iterated_hamiltonian_evolution_oracle: EvolutionOracle = None): - + super().__call__(step, d) + + def group_commutator_query_list( + self, + s_step: float, + diagonal_association_evolution_oracle: EvolutionOracle = None, + iterated_hamiltonian_evolution_oracle: EvolutionOracle = None, + ): + if iterated_hamiltonian_evolution_oracle is None: - iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle + iterated_hamiltonian_evolution_oracle = ( + self.iterated_hamiltonian_evolution_oracle + ) - if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: - return {'forwards': [ + if ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.group_commutator + ): + return { + "forwards": [ iterated_hamiltonian_evolution_oracle.circuit(-s_step), diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(s_step), - diagonal_association_evolution_oracle.circuit(-s_step) - ] , - 'backwards': [ #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(-s_step), + ], + "backwards": [ # in general an evolution oracle might have imperfect time reversal diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(-s_step), diagonal_association_evolution_oracle.circuit(-s_step), - iterated_hamiltonian_evolution_oracle.circuit(s_step) - ] } - elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: - return {'forwards': [ + iterated_hamiltonian_evolution_oracle.circuit(s_step), + ], + } + elif ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.group_commutator_reduced + ): + return { + "forwards": [ diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(s_step), - diagonal_association_evolution_oracle.circuit(-s_step) - ] , - 'backwards': [ + diagonal_association_evolution_oracle.circuit(-s_step), + ], + "backwards": [ diagonal_association_evolution_oracle.circuit(s_step), iterated_hamiltonian_evolution_oracle.circuit(-s_step), - diagonal_association_evolution_oracle.circuit(-s_step) - ] } + diagonal_association_evolution_oracle.circuit(-s_step), + ], + } else: - if self.mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: - raise_error(ValueError, "You are in the group commutator query list but your dbr mode is a perfect bracket and not an approximation by means of a group commutator!") + if ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.single_commutator + ): + raise_error( + ValueError, + "You are in the group commutator query list but your dbr mode is a perfect bracket and not an approximation by means of a group commutator!", + ) else: - raise_error(ValueError, "You are in the group commutator query list but your dbr mode is not recognized") - - - + raise_error( + ValueError, + "You are in the group commutator query list but your dbr mode is not recognized", + ) diff --git a/src/qibo/models/dbi/test_dbi_evolution_oracles.py b/src/qibo/models/dbi/test_dbi_evolution_oracles.py index 946c318f3d..930d234184 100644 --- a/src/qibo/models/dbi/test_dbi_evolution_oracles.py +++ b/src/qibo/models/dbi/test_dbi_evolution_oracles.py @@ -1,8 +1,8 @@ -from qibo.hamiltonians import SymbolicHamiltonian -from qibo import symbols from double_bracket_evolution_oracles import * from group_commutator_iteration_transpiler import * +from qibo import symbols +from qibo.hamiltonians import SymbolicHamiltonian def test_evolution_oracle_gci_classes(): @@ -11,33 +11,39 @@ def test_evolution_oracle_gci_classes(): """Test create evolution oracle""" -h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2), nqubits = 3 ) +h_input = SymbolicHamiltonian( + symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2), nqubits=3 +) -#By default this initializes with text_strings oracle type +# By default this initializes with text_strings oracle type input_hamiltonian_evolution_oracle = EvolutionOracle(h_input, "ZX") c1 = input_hamiltonian_evolution_oracle.circuit(0.1) -assert isinstance( c1, str), "Should be a string here" -print( c1 ) - -input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation -c2 =input_hamiltonian_evolution_oracle.circuit(0.2) -assert isinstance( c2, type(h_input.circuit(0.1)) ), "Should be a qibo.Circuit here" +assert isinstance(c1, str), "Should be a string here" +print(c1) + +input_hamiltonian_evolution_oracle.mode_evolution_oracle = ( + EvolutionOracleType.hamiltonian_simulation +) +c2 = input_hamiltonian_evolution_oracle.circuit(0.2) +assert isinstance(c2, type(h_input.circuit(0.1))), "Should be a qibo.Circuit here" c2.draw() -d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits = 3 ) -gci = GroupCommutatorIterationWithEvolutionOracles( input_hamiltonian_evolution_oracle ) -#By default this will test the dephasing oracle +d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits=3) +gci = GroupCommutatorIterationWithEvolutionOracles(input_hamiltonian_evolution_oracle) +# By default this will test the dephasing oracle gci(0.2, d_0) -query_list = gci.group_commutator_query_list( 0.2, d_0, input_hamiltonian_evolution_oracle ) +query_list = gci.group_commutator_query_list( + 0.2, d_0, input_hamiltonian_evolution_oracle +) from functools import reduce -before_circuit =reduce(Circuit.__add__, query_list['backwards']) -after_circuit = reduce(Circuit.__add__, query_list['forwards']) -frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - input_hamiltonian_evolution_oracle, 'Step 1', before_circuit, after_circuit) + +before_circuit = reduce(Circuit.__add__, query_list["backwards"]) +after_circuit = reduce(Circuit.__add__, query_list["forwards"]) +frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( + input_hamiltonian_evolution_oracle, "Step 1", before_circuit, after_circuit +) print(gci.h.exp(0.3)) print(frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3)) - - From 31c9ac8ab4eab22995f1ea4461221281d87c0e39 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Thu, 8 Feb 2024 07:08:35 +0100 Subject: [PATCH 018/116] there was a deepcopy issue for passing several circuits, now fixed it seems, see the test notebook gci canonical --- ...th evolution oracles vs existing dbi.ipynb | 154 ++++++++ ...rrect number of Trotter-Suzuki steps.ipynb | 355 ++++++++++++++++++ ...es vs existing dbi in canonical mode.ipynb | 248 ++++++++++++ .../dbi/double_bracket_evolution_oracles.py | 28 +- .../group_commutator_iteration_transpiler.py | 9 +- .../models/dbi/test_dbi_evolution_oracles.py | 75 ++-- 6 files changed, 836 insertions(+), 33 deletions(-) create mode 100644 src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb create mode 100644 src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb create mode 100644 src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb diff --git a/src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb b/src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb new file mode 100644 index 0000000000..de08ac445d --- /dev/null +++ b/src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb @@ -0,0 +1,154 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "4ed280d7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-02-08 04:41:24]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "from qibo.hamiltonians import SymbolicHamiltonian\n", + "from qibo import symbols\n", + "from double_bracket_evolution_oracles import *\n", + "from group_commutator_iteration_transpiler import *\n", + "\n", + "\"\"\"Test create evolution oracle\"\"\"\n", + "\n", + "h_input = SymbolicHamiltonian( symbols.Z(0)+symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + "\n", + "# Initialize with EvolutionOracleType hamiltonian_simulation\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8a03c568", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-08 04:41:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "from double_bracket import *\n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.group_commutator" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e31a8298", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "32.0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dbi.off_diagonal_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fe1e3816", + "metadata": {}, + "outputs": [], + "source": [ + "d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2)+symbols.Z(0), nqubits = 3 )" + ] + }, + { + "cell_type": "markdown", + "id": "ba28a352", + "metadata": {}, + "source": [ + "## The following cell crashes" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f973a06c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-08 04:41:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "ename": "TypeError", + "evalue": "Hamiltonian.exp() missing 1 required positional argument: 'a'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_122196/1963945966.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.51\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/double_bracket.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 79\u001b[0m operator = (\n\u001b[1;32m 80\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 82\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibo/backends/numpy.py\u001b[0m in \u001b[0;36mcalculate_matrix_exp\u001b[0;34m(self, a, matrix, eigenvectors, eigenvalues)\u001b[0m\n\u001b[1;32m 737\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 739\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 740\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 741\u001b[0m \u001b[0mexpd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiag\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0meigenvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/scipy/linalg/_matfuncs.py\u001b[0m in \u001b[0;36mexpm\u001b[0;34m(A)\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 283\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: Hamiltonian.exp() missing 1 required positional argument: 'a'" + ] + } + ], + "source": [ + "dbi(0.51, d = d_0.dense)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "024e0a4a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb b/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb new file mode 100644 index 0000000000..91862c135a --- /dev/null +++ b/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb @@ -0,0 +1,355 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c4be28eb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-02-08 04:16:31]: Using qibojit (numba) backend on /CPU:0\n", + "[Qibo 0.2.5|WARNING|2024-02-08 04:16:31]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ZX0.1\n", + "3 0.5264075362294286\n", + "6 0.12267264894892986\n", + "12 0.03018952498939946\n", + "\n", + "q0: ───U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U ...\n", + "q1: ─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U ...\n", + "q2: ─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U──── ...\n", + "\n", + "q0: ... ─────U─U─────U─U─────U─U───\n", + "q1: ... ─U─U─U─U─U─U─U─U─U─U─U─U─U─\n", + "q2: ... ─U─U─────U─U─────U─U─────U─\n", + "3.651778047740365\n", + "3.651778047740365\n" + ] + } + ], + "source": [ + "run -i 'test_dbi_evolution_oracles.py'" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "4ed280d7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-08 04:26:52]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ZX0.1\n", + "3 0.43947054352187015\n", + "6 0.10267893936993515\n", + "12 0.025341696660493532\n", + "0.02534169666049345\n" + ] + } + ], + "source": [ + "from qibo.hamiltonians import SymbolicHamiltonian\n", + "from qibo import symbols\n", + "from double_bracket_evolution_oracles import *\n", + "from group_commutator_iteration_transpiler import *\n", + "\n", + "\"\"\"Test create evolution oracle\"\"\"\n", + "\n", + "h_input = SymbolicHamiltonian( symbols.Z(0)+symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + "\n", + "## Test initialization of evolution oracles\n", + "#By default EvolutionOracle initializes with text_strings oracle type\n", + "input_hamiltonian_evolution_oracle_text_strings = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.text_strings)\n", + "\n", + "c1 = input_hamiltonian_evolution_oracle_text_strings.circuit(0.1)\n", + "if input_hamiltonian_evolution_oracle_text_strings.mode_evolution_oracle is EvolutionOracleType.text_strings:\n", + " assert isinstance( c1, str), \"Should be a string here\"\n", + "print( c1 )\n", + "\n", + "# Initialize with EvolutionOracleType hamiltonian_simulation\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = True\n", + "c2 = input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2)\n", + "assert np.linalg.norm( c2.unitary() - input_hamiltonian_evolution_oracle_hamiltonian_simulation.h.exp(2) ) < 1\n", + "\n", + "##For some reason running this makes the norm check below blow up to large value\n", + "# if input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:\n", + "# print(type(c2))\n", + "# assert isinstance( c2, type(h_input.circuit(0.1)) ), \"Should be a qibo.Circuit here\"\n", + "# print(c2.draw())\n", + "\n", + "\n", + "# Initialize with EvolutionOracleType numerical\n", + "input_hamiltonian_evolution_oracle_numerical = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical )\n", + "\n", + "c3 = input_hamiltonian_evolution_oracle_numerical.circuit(2)\n", + "if input_hamiltonian_evolution_oracle_numerical.mode_evolution_oracle is EvolutionOracleType.numerical:\n", + " assert isinstance( c3, type(h_input.exp(0.1)) ), \"Should be a np.array here\"\n", + "print(np.linalg.norm( c2.unitary() - c3 ))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "8a03c568", + "metadata": {}, + "outputs": [], + "source": [ + "from double_bracket import *\n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.group_commutator" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "e31a8298", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "32.0" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dbi.off_diagonal_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "fe1e3816", + "metadata": {}, + "outputs": [], + "source": [ + "d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2)+symbols.Z(0), nqubits = 3 )" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "61699387", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-08 04:32:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "ename": "TypeError", + "evalue": "Hamiltonian.exp() missing 1 required positional argument: 'a'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/test_dbi_evolution_oracles.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.51\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moff_diagonal_norm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/double_bracket.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 79\u001b[0m operator = (\n\u001b[1;32m 80\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 82\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibo/backends/numpy.py\u001b[0m in \u001b[0;36mcalculate_matrix_exp\u001b[0;34m(self, a, matrix, eigenvectors, eigenvalues)\u001b[0m\n\u001b[1;32m 737\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 739\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 740\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 741\u001b[0m \u001b[0mexpd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiag\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0meigenvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/scipy/linalg/_matfuncs.py\u001b[0m in \u001b[0;36mexpm\u001b[0;34m(A)\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 283\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: Hamiltonian.exp() missing 1 required positional argument: 'a'" + ] + } + ], + "source": [ + "dbi(0.51, d = d_0.dense)\n", + "dbi.off_diagonal_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "d648a983", + "metadata": {}, + "outputs": [], + "source": [ + "## Test more fancy functionalities\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", + "\n", + "\n", + "query_list = gci.group_commutator_query_list( 0.2, d_0, input_hamiltonian_evolution_oracle_hamiltonian_simulation )\n", + "gci(0.51, d_0)\n", + "u_dagger = gci.iterated_hamiltonian_evolution_oracle.before_circuit.unitary()\n", + "\n", + "dbi_from_gci = u_dagger @ h_input.matrix @ u_dagger.T.conj()" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "84427469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[ 0.37873495-7.23646444e-17j, -0.61455831+6.61914883e-01j,\n", + " 1.65379471-4.82329292e-01j, -1.96431484+8.48346097e-01j,\n", + " -0.66648988-6.34914954e-01j, 0.72872705+1.92520016e-01j,\n", + " 0.46450583-3.48735459e-01j, -0.34937171+7.29602858e-01j],\n", + " [-0.61455831-6.61914883e-01j, 1.3880865 +1.65819142e-16j,\n", + " 1.7100767 -2.63880526e-01j, 1.22172438-4.00032815e-01j,\n", + " -1.71509717-2.99995268e-01j, 0.06517562-7.21879491e-02j,\n", + " 0.05236784-8.00791699e-01j, 0.37782571+6.27793798e-02j],\n", + " [ 1.65379471+4.82329292e-01j, 1.7100767 +2.63880526e-01j,\n", + " 0.9379625 -9.61058031e-17j, -0.31832345+1.01913826e+00j,\n", + " 0.50572804-3.07643806e-01j, -0.60181522-3.91004322e-02j,\n", + " 0.33658616+6.18667086e-01j, -0.44629897+6.13539951e-02j],\n", + " [-1.96431484-8.48346097e-01j, 1.22172438+4.00032815e-01j,\n", + " -0.31832345-1.01913826e+00j, 3.00438693-1.10863074e-16j,\n", + " -0.45113968-1.38908374e+00j, 0.32741828+2.43527104e-02j,\n", + " 0.67878057+8.08157792e-01j, 0.9625186 -2.19948229e-01j],\n", + " [-0.66648988+6.34914954e-01j, -1.71509717+2.99995268e-01j,\n", + " 0.50572804+3.07643806e-01j, -0.45113968+1.38908374e+00j,\n", + " -1.8665001 -8.51001034e-17j, -0.22381594+7.50684558e-01j,\n", + " -1.63817676-3.86048532e-01j, -1.70605432-4.35426293e-01j],\n", + " [ 0.72872705-1.92520016e-01j, 0.06517562+7.21879491e-02j,\n", + " -0.60181522+3.91004322e-02j, 0.32741828-2.43527104e-02j,\n", + " -0.22381594-7.50684558e-01j, 0.05587245-2.20303099e-17j,\n", + " 1.90215343+7.12211017e-01j, -1.21518609-4.71886551e-01j],\n", + " [ 0.46450583+3.48735459e-01j, 0.05236784+8.00791699e-01j,\n", + " 0.33658616-6.18667086e-01j, 0.67878057-8.08157792e-01j,\n", + " -1.63817676+3.86048532e-01j, 1.90215343-7.12211017e-01j,\n", + " -2.46589296+6.93276168e-17j, -0.39503053+4.25721571e-01j],\n", + " [-0.34937171-7.29602858e-01j, 0.37782571-6.27793798e-02j,\n", + " -0.44629897-6.13539951e-02j, 0.9625186 +2.19948229e-01j,\n", + " -1.70605432+4.35426293e-01j, -1.21518609+4.71886551e-01j,\n", + " -0.39503053-4.25721571e-01j, -1.43265026+2.31760624e-17j]])" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dbi_from_gci - dbi.h.matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "776341ed", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-08 04:27:03]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "data": { + "text/plain": [ + "3.626108312062859" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dbi(0.2, d = d_0.dense)\n", + "np.linalg.norm(dbi.h.matrix - h_input.dense.matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "90a8b161", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─U─────U───U─U─────U─U─────U─U───U─────U───U─U─────U─U─────U─U───\n", + "q1: ─U─────U─U─U─U─U─U─U─U─U─U─U─U─U─U─────U─U─U─U─U─U─U─U─U─U─U─U─U─\n", + "q2: ───U─U───U─────U─U─────U─U─────U───U─U───U─────U─U─────U─U─────U─\n", + "q0: ───U─U─────U─U─────U─U───U─────U───U─U─────U─U─────U─U───U─────U─\n", + "q1: ─U─U─U─U─U─U─U─U─U─U─U─U─U─────U─U─U─U─U─U─U─U─U─U─U─U─U─U─────U─\n", + "q2: ─U─────U─U─────U─U─────U───U─U───U─────U─U─────U─U─────U───U─U───\n", + "9.519346834291838\n", + "4.144980851654998\n" + ] + } + ], + "source": [ + "from functools import reduce\n", + "before_circuit = reduce(Circuit.__add__, query_list['backwards'])\n", + "after_circuit = reduce(Circuit.__add__, query_list['forwards'])\n", + "print( before_circuit.draw() )\n", + "print( after_circuit.draw() )\n", + "\n", + "u_before = before_circuit.unitary()\n", + "u_after = after_circuit.unitary()\n", + "\n", + "print( np.linalg.norm( u_before @ input_hamiltonian_evolution_oracle_hamiltonian_simulation.h.matrix@ u_after -gci.h.matrix ))\n", + "frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( \n", + " input_hamiltonian_evolution_oracle_hamiltonian_simulation, 'Step 1', before_circuit, after_circuit)\n", + "\n", + "print( np.linalg.norm( gci.h.exp(0.3) - frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3).unitary()))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "024e0a4a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb new file mode 100644 index 0000000000..0db78d51f6 --- /dev/null +++ b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb @@ -0,0 +1,248 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "id": "4ed280d7", + "metadata": {}, + "outputs": [], + "source": [ + "from qibo.hamiltonians import SymbolicHamiltonian\n", + "from qibo import symbols\n", + "from double_bracket_evolution_oracles import *\n", + "from group_commutator_iteration_transpiler import *\n", + "from numpy.linalg import norm\n", + "\"\"\"Test create evolution oracle\"\"\"\n", + "\n", + "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + "# Initialize with EvolutionOracleType hamiltonian_simulation so that d_0 is Delta\n", + "h_input = h_x + d_0\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8a03c568", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-08 07:00:12]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "from double_bracket import *\n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2791ac7a", + "metadata": {}, + "outputs": [], + "source": [ + "t_step = 0.051#0.98#dbi.hyperopt_step()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "61699387", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "28.82580567725418" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dbi(t_step)\n", + "dbi.off_diagonal_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2c922275", + "metadata": {}, + "outputs": [], + "source": [ + "## Test more fancy functionalities\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e5ef8593", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.136025650750149e-16" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", + "u2 = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", + "norm(u-u2.T.conj())" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "69e80221", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'ZX-0.22583179581272428D00.22583179581272428ZX0.22583179581272428D0-0.22583179581272428'" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d_0.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + "query_list = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\"))\n", + "\n", + "\n", + "query_list['forwards']" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8e865288", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-08 07:00:13]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-08 07:00:13]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "data": { + "text/plain": [ + "7.193109780637881e-16" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + "query_list = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))\n", + "\n", + "\n", + "norm(query_list['forwards'] -query_list['backwards'].T.conj())\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "6e5b8f90", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.561656035791626e-16" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Test more fancy functionalities\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", + "d_ev = EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "\n", + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + "query_list = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle= d_ev )\n", + "\n", + "norm(query_list['forwards'].unitary() -query_list['backwards'].unitary().conj().T)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ecb116a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8976eb8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 6d81521f4a..6c20546029 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -35,7 +35,9 @@ def __init__( self, self.h = h_generator self.name = name self.mode_evolution_oracle = mode_evolution_oracle - + self.mode_find_number_of_trottersuzuki_steps = True + self.eps_trottersuzuki = 0.1 + self.please_be_verbose = False def __call__(self, t_duration: float = None): """ Returns either the name or the circuit """ if t_duration is None: @@ -50,10 +52,29 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.h.exp(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.h.circuit(t_duration) + return self.discretized_evolution_circuit( t_duration, eps = self.eps_trottersuzuki ) else: raise_error(ValueError, f"You are using an EvolutionOracle type which is not yet supported.") + def discretized_evolution_circuit( self, t_duration, eps = 0.05 ): + nmb_trottersuzuki_steps = 3 + target_unitary = self.h.exp(t_duration) + proposed_circuit_unitary = np.linalg.matrix_power(self.h.circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) + norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) + if self.please_be_verbose: + print(nmb_trottersuzuki_steps, norm_difference) + while norm_difference > eps: + nmb_trottersuzuki_steps = nmb_trottersuzuki_steps * 2 + proposed_circuit_unitary = np.linalg.matrix_power(self.h.circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) + norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) + if self.please_be_verbose: + print(nmb_trottersuzuki_steps, norm_difference ) + from functools import reduce + combined_circuit = reduce(Circuit.__add__, [self.h.circuit(t_duration/nmb_trottersuzuki_steps)]*nmb_trottersuzuki_steps) + assert np.linalg.norm( combined_circuit.unitary() - target_unitary ) < eps + return combined_circuit + + class FrameShiftedEvolutionOracle(EvolutionOracle): def __init__( self, @@ -68,6 +89,7 @@ def __init__( self, # assert type(before_circuit) is Circuit, str(type(before_circuit)) self.h = base_evolution_oracle.h + self.base_evolution_oracle = base_evolution_oracle self.name = name + '(' + base_evolution_oracle.name + ')' self.mode_evolution_oracle = base_evolution_oracle.mode_evolution_oracle self.before_circuit = before_circuit @@ -80,7 +102,7 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.before_circuit @ self.h.exp(t_duration) @ self.after_circuit elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.before_circuit + self.h.circuit(t_duration) + self.after_circuit + return self.before_circuit + self.base_evolution_oracle.circuit(t_duration) + self.after_circuit else: raise_error(ValueError, f"You are using an EvolutionOracle type which is not yet supported.") diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 898bd4e67b..22edb41fa9 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -98,8 +98,9 @@ def __call__( if self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: #then dbr step output is a matrix - double_bracket_rotation_matrix = 0 * self.h.matrix - double_bracket_rotation_dagger_matrix = 0 * self.h.matrix + double_bracket_rotation_matrix = np.eye( 2**self.h.nqubits ) + double_bracket_rotation_dagger_matrix = np.eye( 2**self.h.nqubits ) + for m in double_bracket_rotation_matrix: double_bracket_rotation_matrix = double_bracket_rotation_matrix @ m for m in double_bracket_rotation_dagger_matrix: @@ -107,10 +108,6 @@ def __call__( self.h.matrix = double_bracket_rotation_dagger_matrix @ self.h.matrix @ double_bracket_rotation_matrix elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - #then dbr step output is a query list - #self.gci_unitary.append(double_bracket_rotation_step[forwards]) - #self.gci_unitary_dagger.append(double_bracket_rotation_step[backwards]) - print (double_bracket_rotation_step) from functools import reduce #composition of circuits should be __matmul__ not __add__ in qibo.Circuit.... before_circuit = reduce(Circuit.__add__, double_bracket_rotation_step['backwards']) diff --git a/src/qibo/models/dbi/test_dbi_evolution_oracles.py b/src/qibo/models/dbi/test_dbi_evolution_oracles.py index 946c318f3d..dccbde1aa4 100644 --- a/src/qibo/models/dbi/test_dbi_evolution_oracles.py +++ b/src/qibo/models/dbi/test_dbi_evolution_oracles.py @@ -11,33 +11,60 @@ def test_evolution_oracle_gci_classes(): """Test create evolution oracle""" -h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2), nqubits = 3 ) +h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 ) -#By default this initializes with text_strings oracle type -input_hamiltonian_evolution_oracle = EvolutionOracle(h_input, "ZX") +## Test initialization of evolution oracles +#By default EvolutionOracle initializes with text_strings oracle type +input_hamiltonian_evolution_oracle_text_strings = EvolutionOracle(h_input, "ZX", mode_evolution_oracle = EvolutionOracleType.text_strings) -c1 = input_hamiltonian_evolution_oracle.circuit(0.1) -assert isinstance( c1, str), "Should be a string here" +c1 = input_hamiltonian_evolution_oracle_text_strings.circuit(0.1) +if input_hamiltonian_evolution_oracle_text_strings.mode_evolution_oracle is EvolutionOracleType.text_strings: + assert isinstance( c1, str), "Should be a string here" print( c1 ) -input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation -c2 =input_hamiltonian_evolution_oracle.circuit(0.2) -assert isinstance( c2, type(h_input.circuit(0.1)) ), "Should be a qibo.Circuit here" -c2.draw() -d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits = 3 ) -gci = GroupCommutatorIterationWithEvolutionOracles( input_hamiltonian_evolution_oracle ) -#By default this will test the dephasing oracle -gci(0.2, d_0) - -query_list = gci.group_commutator_query_list( 0.2, d_0, input_hamiltonian_evolution_oracle ) - -from functools import reduce -before_circuit =reduce(Circuit.__add__, query_list['backwards']) -after_circuit = reduce(Circuit.__add__, query_list['forwards']) -frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - input_hamiltonian_evolution_oracle, 'Step 1', before_circuit, after_circuit) - -print(gci.h.exp(0.3)) -print(frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3)) +# Initialize with EvolutionOracleType hamiltonian_simulation +input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(h_input, "ZX", + mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) +input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = True +c2 = input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2) +if input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + print(type(c2)) + assert isinstance( c2, type(h_input.circuit(0.1)) ), "Should be a qibo.Circuit here" +print(c2.draw()) + +# Initialize with EvolutionOracleType numerical +input_hamiltonian_evolution_oracle_numerical = EvolutionOracle(h_input, "ZX", + mode_evolution_oracle = EvolutionOracleType.numerical ) + +c3 = input_hamiltonian_evolution_oracle_numerical.circuit(2) +if input_hamiltonian_evolution_oracle_numerical.mode_evolution_oracle is EvolutionOracleType.numerical: + assert isinstance( c3, type(h_input.exp(0.1)) ), "Should be a np.array here" +print(np.linalg.norm( c2.unitary() - c3 )) +U2 = c2.unitary() +input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle = EvolutionOracleType.numerical +print(np.linalg.norm( U2 - input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2))) + +if 0: + + ## Test more fancy functionalities + + gci = GroupCommutatorIterationWithEvolutionOracles( input_hamiltonian_evolution_oracle_hamiltonian_simulation ) + d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits = 3 ) + + query_list = gci.group_commutator_query_list( 0.2, d_0, input_hamiltonian_evolution_oracle_hamiltonian_simulation ) + gci(0.2, d_0) + + + from functools import reduce + before_circuit = reduce(Circuit.__add__, query_list['backwards']) + after_circuit = reduce(Circuit.__add__, query_list['forwards']) + print( before_circuit.draw() ) + print( after_circuit.draw() ) + + + frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( + input_hamiltonian_evolution_oracle_hamiltonian_simulation, 'Step 1', before_circuit, after_circuit) + + print( np.linalg.norm( gci.h.exp(0.3) - frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3).unitary())) From d49748354c9af39ab514903cc5051d3682f55b36 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Thu, 8 Feb 2024 07:34:10 +0100 Subject: [PATCH 019/116] pulling from the remote branch after fixing the deepcopy issue --- .../dbi/double_bracket_evolution_oracles.py | 6 +- .../group_commutator_iteration_transpiler.py | 127 +++++++++++------- 2 files changed, 78 insertions(+), 55 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 6c20546029..2ea60d6670 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -59,18 +59,18 @@ def circuit(self, t_duration: float = None): def discretized_evolution_circuit( self, t_duration, eps = 0.05 ): nmb_trottersuzuki_steps = 3 target_unitary = self.h.exp(t_duration) - proposed_circuit_unitary = np.linalg.matrix_power(self.h.circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) + proposed_circuit_unitary = np.linalg.matrix_power(deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) if self.please_be_verbose: print(nmb_trottersuzuki_steps, norm_difference) while norm_difference > eps: nmb_trottersuzuki_steps = nmb_trottersuzuki_steps * 2 - proposed_circuit_unitary = np.linalg.matrix_power(self.h.circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) + proposed_circuit_unitary = np.linalg.matrix_power(deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) if self.please_be_verbose: print(nmb_trottersuzuki_steps, norm_difference ) from functools import reduce - combined_circuit = reduce(Circuit.__add__, [self.h.circuit(t_duration/nmb_trottersuzuki_steps)]*nmb_trottersuzuki_steps) + combined_circuit = reduce(Circuit.__add__, [deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps)]*nmb_trottersuzuki_steps) assert np.linalg.norm( combined_circuit.unitary() - target_unitary ) < eps return combined_circuit diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 22edb41fa9..448a3fc93f 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -96,67 +96,90 @@ def __call__( #This will run the appropriate group commutator step double_bracket_rotation_step = self.group_commutator_query_list(step_duration, diagonal_association) - if self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - #then dbr step output is a matrix - double_bracket_rotation_matrix = np.eye( 2**self.h.nqubits ) - double_bracket_rotation_dagger_matrix = np.eye( 2**self.h.nqubits ) - - for m in double_bracket_rotation_matrix: - double_bracket_rotation_matrix = double_bracket_rotation_matrix @ m - for m in double_bracket_rotation_dagger_matrix: - double_bracket_rotation_dagger_matrix = double_bracket_rotation_dagger_matrix @ m - self.h.matrix = double_bracket_rotation_dagger_matrix @ self.h.matrix @ double_bracket_rotation_matrix - - elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - from functools import reduce - #composition of circuits should be __matmul__ not __add__ in qibo.Circuit.... - before_circuit = reduce(Circuit.__add__, double_bracket_rotation_step['backwards']) - after_circuit = reduce( Circuit.__add__, double_bracket_rotation_step['forwards']) - self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - self.iterated_hamiltonian_evolution_oracle, - str(step_duration), - before_circuit, - after_circuit - ) - - - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: - raise_error(NotImplementedError) - else: - super().__call__(step, d ) - - def group_commutator_query_list(self, - s_step: float, - diagonal_association_evolution_oracle: EvolutionOracle = None, - iterated_hamiltonian_evolution_oracle: EvolutionOracle = None): - + if self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: + before_circuit = double_bracket_rotation_step['backwards'] + after_circuit = double_bracket_rotation_step['forwards'] + self.h.matrix = before_circuit @ self.h.matrix @ after_circuit + + elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + before_circuit = double_bracket_rotation_step['backwards'] + after_circuit = double_bracket_rotation_step['forwards'] + self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( + deepcopy(self.iterated_hamiltonian_evolution_oracle), + str(step_duration), + before_circuit, + after_circuit + ) + + + elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: + raise_error(NotImplementedError) + else: + super().__call__(step, d ) + return before_circuit + + def group_commutator(self, + s_step: float, + diagonal_association_evolution_oracle: EvolutionOracle = None, + iterated_hamiltonian_evolution_oracle: EvolutionOracle = None): + if iterated_hamiltonian_evolution_oracle is None: iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: - return {'forwards': [ - iterated_hamiltonian_evolution_oracle.circuit(-s_step), - diagonal_association_evolution_oracle.circuit(s_step), - iterated_hamiltonian_evolution_oracle.circuit(s_step), + assert diagonal_association_evolution_oracle.mode_evolution_oracle is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle + + if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or + diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): + return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ + diagonal_association_evolution_oracle.circuit(s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(s_step)+ + diagonal_association_evolution_oracle.circuit(-s_step) + ) , + 'backwards': ( #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ + diagonal_association_evolution_oracle.circuit(-s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(s_step) + ) } + elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: + return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ + diagonal_association_evolution_oracle.circuit(s_step)@ + iterated_hamiltonian_evolution_oracle.circuit(s_step)@ diagonal_association_evolution_oracle.circuit(-s_step) - ] , - 'backwards': [ #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step), - iterated_hamiltonian_evolution_oracle.circuit(-s_step), - diagonal_association_evolution_oracle.circuit(-s_step), + ) , + 'backwards': ( #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step)@ + iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ + diagonal_association_evolution_oracle.circuit(-s_step)@ iterated_hamiltonian_evolution_oracle.circuit(s_step) - ] } + ) } + elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: - return {'forwards': [ - diagonal_association_evolution_oracle.circuit(s_step), - iterated_hamiltonian_evolution_oracle.circuit(s_step), + if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or + diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): + return {'forwards': ( + diagonal_association_evolution_oracle.circuit(s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(s_step)+ diagonal_association_evolution_oracle.circuit(-s_step) - ] , - 'backwards': [ - diagonal_association_evolution_oracle.circuit(s_step), - iterated_hamiltonian_evolution_oracle.circuit(-s_step), + ) , + 'backwards': ( #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ + diagonal_association_evolution_oracle.circuit(-s_step) + ) } + elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: + return {'forwards': ( + diagonal_association_evolution_oracle.circuit(s_step)@ + iterated_hamiltonian_evolution_oracle.circuit(s_step)@ diagonal_association_evolution_oracle.circuit(-s_step) - ] } + ) , + 'backwards': ( #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step)@ + iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ + diagonal_association_evolution_oracle.circuit(-s_step) + ) } + else: if self.mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: raise_error(ValueError, "You are in the group commutator query list but your dbr mode is a perfect bracket and not an approximation by means of a group commutator!") From 8ff096c3c405e2c98e2ad706e10cfe1c7f27cf58 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 8 Feb 2024 06:40:28 +0000 Subject: [PATCH 020/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../dbi/double_bracket_evolution_oracles.py | 48 +++-- .../group_commutator_iteration_transpiler.py | 192 +++++++++++------- .../models/dbi/test_dbi_evolution_oracles.py | 99 ++++++--- 3 files changed, 220 insertions(+), 119 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index edb4c177c3..a5c16f1b44 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -46,6 +46,7 @@ def __init__( self.mode_find_number_of_trottersuzuki_steps = True self.eps_trottersuzuki = 0.1 self.please_be_verbose = False + def __call__(self, t_duration: float = None): """Returns either the name or the circuit""" if t_duration is None: @@ -60,26 +61,44 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.h.exp(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.discretized_evolution_circuit( t_duration, eps = self.eps_trottersuzuki ) + return self.discretized_evolution_circuit( + t_duration, eps=self.eps_trottersuzuki + ) else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") - def discretized_evolution_circuit( self, t_duration, eps = 0.05 ): + raise_error( + ValueError, + f"You are using an EvolutionOracle type which is not yet supported.", + ) + + def discretized_evolution_circuit(self, t_duration, eps=0.05): nmb_trottersuzuki_steps = 3 target_unitary = self.h.exp(t_duration) - proposed_circuit_unitary = np.linalg.matrix_power(deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) - norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) + proposed_circuit_unitary = np.linalg.matrix_power( + deepcopy(self.h).circuit(t_duration / nmb_trottersuzuki_steps).unitary(), + nmb_trottersuzuki_steps, + ) + norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) if self.please_be_verbose: print(nmb_trottersuzuki_steps, norm_difference) while norm_difference > eps: nmb_trottersuzuki_steps = nmb_trottersuzuki_steps * 2 - proposed_circuit_unitary = np.linalg.matrix_power(deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) - norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) + proposed_circuit_unitary = np.linalg.matrix_power( + deepcopy(self.h) + .circuit(t_duration / nmb_trottersuzuki_steps) + .unitary(), + nmb_trottersuzuki_steps, + ) + norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) if self.please_be_verbose: - print(nmb_trottersuzuki_steps, norm_difference ) + print(nmb_trottersuzuki_steps, norm_difference) from functools import reduce - combined_circuit = reduce(Circuit.__add__, [deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps)]*nmb_trottersuzuki_steps) - assert np.linalg.norm( combined_circuit.unitary() - target_unitary ) < eps + + combined_circuit = reduce( + Circuit.__add__, + [deepcopy(self.h).circuit(t_duration / nmb_trottersuzuki_steps)] + * nmb_trottersuzuki_steps, + ) + assert np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps return combined_circuit @@ -103,7 +122,6 @@ def __init__( self.before_circuit = before_circuit self.after_circuit = after_circuit - def circuit(self, t_duration: float = None): if self.mode_evolution_oracle is EvolutionOracleType.text_strings: @@ -111,7 +129,11 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.before_circuit @ self.h.exp(t_duration) @ self.after_circuit elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - return self.before_circuit + self.base_evolution_oracle.circuit(t_duration) + self.after_circuit + return ( + self.before_circuit + + self.base_evolution_oracle.circuit(t_duration) + + self.after_circuit + ) else: raise_error( ValueError, diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index e795709a7b..410e75c05f 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -125,89 +125,133 @@ def __call__( step_duration, diagonal_association ) - if self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - before_circuit = double_bracket_rotation_step['backwards'] - after_circuit = double_bracket_rotation_step['forwards'] + if ( + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical + ): + before_circuit = double_bracket_rotation_step["backwards"] + after_circuit = double_bracket_rotation_step["forwards"] self.h.matrix = before_circuit @ self.h.matrix @ after_circuit - elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - before_circuit = double_bracket_rotation_step['backwards'] - after_circuit = double_bracket_rotation_step['forwards'] - self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - deepcopy(self.iterated_hamiltonian_evolution_oracle), - str(step_duration), - before_circuit, - after_circuit - ) - - - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: + elif ( + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + before_circuit = double_bracket_rotation_step["backwards"] + after_circuit = double_bracket_rotation_step["forwards"] + self.iterated_hamiltonian_evolution_oracle = ( + FrameShiftedEvolutionOracle( + deepcopy(self.iterated_hamiltonian_evolution_oracle), + str(step_duration), + before_circuit, + after_circuit, + ) + ) + + elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: raise_error(NotImplementedError) else: - super().__call__(step, d ) + super().__call__(step, d) return before_circuit - def group_commutator(self, + def group_commutator( + self, s_step: float, diagonal_association_evolution_oracle: EvolutionOracle = None, - iterated_hamiltonian_evolution_oracle: EvolutionOracle = None): - + iterated_hamiltonian_evolution_oracle: EvolutionOracle = None, + ): + if iterated_hamiltonian_evolution_oracle is None: - iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle - - if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: - assert diagonal_association_evolution_oracle.mode_evolution_oracle is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle - - if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or - diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): - return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step) - ) } - elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step) - ) } - - elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: - if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or - diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): - return {'forwards': ( - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step) - ) } - elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - return {'forwards': ( - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step) - ) } + iterated_hamiltonian_evolution_oracle = ( + self.iterated_hamiltonian_evolution_oracle + ) + + if ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.group_commutator + ): + assert ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle + ) + + if ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.text_strings + or diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + return { + "forwards": ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + ), + } + elif ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical + ): + return { + "forwards": ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + ), + } + + elif ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.group_commutator_reduced + ): + if ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.text_strings + or diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + return { + "forwards": ( + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + ), + } + elif ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical + ): + return { + "forwards": ( + diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + ), + } else: if ( diff --git a/src/qibo/models/dbi/test_dbi_evolution_oracles.py b/src/qibo/models/dbi/test_dbi_evolution_oracles.py index c4a5830f61..86b3cd52b9 100644 --- a/src/qibo/models/dbi/test_dbi_evolution_oracles.py +++ b/src/qibo/models/dbi/test_dbi_evolution_oracles.py @@ -11,60 +11,95 @@ def test_evolution_oracle_gci_classes(): """Test create evolution oracle""" -h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 ) +h_input = SymbolicHamiltonian( + symbols.X(0) + + symbols.Z(0) * symbols.X(1) + + symbols.Y(2) + + symbols.Y(1) * symbols.Y(2), + nqubits=3, +) ## Test initialization of evolution oracles -#By default EvolutionOracle initializes with text_strings oracle type -input_hamiltonian_evolution_oracle_text_strings = EvolutionOracle(h_input, "ZX", mode_evolution_oracle = EvolutionOracleType.text_strings) +# By default EvolutionOracle initializes with text_strings oracle type +input_hamiltonian_evolution_oracle_text_strings = EvolutionOracle( + h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.text_strings +) c1 = input_hamiltonian_evolution_oracle_text_strings.circuit(0.1) -if input_hamiltonian_evolution_oracle_text_strings.mode_evolution_oracle is EvolutionOracleType.text_strings: - assert isinstance( c1, str), "Should be a string here" -print( c1 ) +if ( + input_hamiltonian_evolution_oracle_text_strings.mode_evolution_oracle + is EvolutionOracleType.text_strings +): + assert isinstance(c1, str), "Should be a string here" +print(c1) # Initialize with EvolutionOracleType hamiltonian_simulation -input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(h_input, "ZX", - mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) +input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle( + h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation +) input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = True c2 = input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2) -if input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: +if ( + input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation +): print(type(c2)) - assert isinstance( c2, type(h_input.circuit(0.1)) ), "Should be a qibo.Circuit here" + assert isinstance(c2, type(h_input.circuit(0.1))), "Should be a qibo.Circuit here" print(c2.draw()) # Initialize with EvolutionOracleType numerical -input_hamiltonian_evolution_oracle_numerical = EvolutionOracle(h_input, "ZX", - mode_evolution_oracle = EvolutionOracleType.numerical ) +input_hamiltonian_evolution_oracle_numerical = EvolutionOracle( + h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.numerical +) c3 = input_hamiltonian_evolution_oracle_numerical.circuit(2) -if input_hamiltonian_evolution_oracle_numerical.mode_evolution_oracle is EvolutionOracleType.numerical: - assert isinstance( c3, type(h_input.exp(0.1)) ), "Should be a np.array here" -print(np.linalg.norm( c2.unitary() - c3 )) +if ( + input_hamiltonian_evolution_oracle_numerical.mode_evolution_oracle + is EvolutionOracleType.numerical +): + assert isinstance(c3, type(h_input.exp(0.1))), "Should be a np.array here" +print(np.linalg.norm(c2.unitary() - c3)) U2 = c2.unitary() -input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle = EvolutionOracleType.numerical -print(np.linalg.norm( U2 - input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2))) +input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle = ( + EvolutionOracleType.numerical +) +print( + np.linalg.norm( + U2 - input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2) + ) +) if 0: ## Test more fancy functionalities - gci = GroupCommutatorIterationWithEvolutionOracles( input_hamiltonian_evolution_oracle_hamiltonian_simulation ) - d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits = 3 ) + gci = GroupCommutatorIterationWithEvolutionOracles( + input_hamiltonian_evolution_oracle_hamiltonian_simulation + ) + d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits=3) - query_list = gci.group_commutator_query_list( 0.2, d_0, input_hamiltonian_evolution_oracle_hamiltonian_simulation ) + query_list = gci.group_commutator_query_list( + 0.2, d_0, input_hamiltonian_evolution_oracle_hamiltonian_simulation + ) gci(0.2, d_0) - from functools import reduce - before_circuit = reduce(Circuit.__add__, query_list['backwards']) - after_circuit = reduce(Circuit.__add__, query_list['forwards']) - print( before_circuit.draw() ) - print( after_circuit.draw() ) - - - frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - input_hamiltonian_evolution_oracle_hamiltonian_simulation, 'Step 1', before_circuit, after_circuit) - - print( np.linalg.norm( gci.h.exp(0.3) - frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3).unitary())) - + before_circuit = reduce(Circuit.__add__, query_list["backwards"]) + after_circuit = reduce(Circuit.__add__, query_list["forwards"]) + print(before_circuit.draw()) + print(after_circuit.draw()) + + frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( + input_hamiltonian_evolution_oracle_hamiltonian_simulation, + "Step 1", + before_circuit, + after_circuit, + ) + + print( + np.linalg.norm( + gci.h.exp(0.3) + - frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3).unitary() + ) + ) From 2754cd22ebe08ad3c261d6a00387fde63bc95c81 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 13 Feb 2024 08:06:30 +0800 Subject: [PATCH 021/116] New branch for implementing magnetic field strategy for double bracket iterations --- ...strategy_Pauli-Z_products.ipynb => dbi_strategy_Pauli-Z.ipynb} | 0 examples/dbi/dbi_strategy_magnetic_field.ipynb | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename examples/dbi/{DBI_strategy_Pauli-Z_products.ipynb => dbi_strategy_Pauli-Z.ipynb} (100%) create mode 100644 examples/dbi/dbi_strategy_magnetic_field.ipynb diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/dbi_strategy_Pauli-Z.ipynb similarity index 100% rename from examples/dbi/DBI_strategy_Pauli-Z_products.ipynb rename to examples/dbi/dbi_strategy_Pauli-Z.ipynb diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb new file mode 100644 index 0000000000..e69de29bb2 From 588a02ae89162aadb7cbe7a22bcbaa6b28ebe325 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 15 Feb 2024 01:11:01 +0000 Subject: [PATCH 022/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- tests/test_models_dbi_utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index 1c7f825c01..89e2ce9b0d 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -1,4 +1,5 @@ """"Testing utils for DoubleBracketIteration model""" + import numpy as np import pytest From 9d663cbb21a32802174b4b9fdc745ce9705a0e41 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 15 Feb 2024 13:54:12 +0800 Subject: [PATCH 023/116] Fix test random hamiltonian seed for test coverage stability --- tests/test_models_dbi.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 6ee130f71e..3d1a72e57d 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -11,12 +11,13 @@ from qibo.quantum_info import random_hermitian NSTEPS = 1 +seed = 10 """Number of steps for evolution.""" @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_canonical(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.canonical, @@ -30,7 +31,7 @@ def test_double_bracket_iteration_canonical(backend, nqubits): @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_group_commutator(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -49,7 +50,7 @@ def test_double_bracket_iteration_group_commutator(backend, nqubits): @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_single_commutator(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -66,7 +67,7 @@ def test_double_bracket_iteration_single_commutator(backend, nqubits): @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_hyperopt_step(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) @@ -115,7 +116,7 @@ def test_energy_fluctuations(backend): def test_double_bracket_iteration_scheduling_grid_hyperopt( backend, nqubits, scheduling ): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -125,12 +126,12 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( for _ in range(NSTEPS): step1 = dbi.choose_step(d=d, scheduling=scheduling) dbi(d=d, step=step1) - step2 = dbi.choose_step(scheduling=scheduling) + step2 = dbi.choose_step() dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm -@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("nqubits", [3, 4, 6]) @pytest.mark.parametrize("n", [2, 3]) @pytest.mark.parametrize( "backup_scheduling", [None, DoubleBracketScheduling.use_polynomial_approximation] @@ -138,7 +139,7 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( def test_double_bracket_iteration_scheduling_polynomial( backend, nqubits, n, backup_scheduling ): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -149,6 +150,8 @@ def test_double_bracket_iteration_scheduling_polynomial( for _ in range(NSTEPS): step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) dbi(d=d, step=step1) - step2 = dbi.polynomial_step(n=n) + step2 = dbi.choose_step( + scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=n + ) dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 892fda40814fa65dcacebf34e479a01e89d2b89e Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 22 Feb 2024 15:08:28 +0800 Subject: [PATCH 024/116] Added functions for running gradient descent --- .../dbi/dbi_strategy_magnetic_field.ipynb | 242 ++++++++++++++++++ src/qibo/models/dbi/utils.py | 208 +++++++++++++-- 2 files changed, 429 insertions(+), 21 deletions(-) diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index e69de29bb2..6f9d7cb8f8 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -0,0 +1,242 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-Bracket Iteration Strategy: magnetic field (onsite Z)\n", + "This notebook shows the diagonalization process of DBI using the magnetic field strategy, which varies the diagonal operator $D$ by gradient descent. To find the gradient with respect to $D$, parameterization of $D$ is required. For the purpose of this notebook, we represent it by onsite Pauli-Z operators, i.e.\n", + "\n", + "$$ D = \\sum \\alpha_i Z_i $$\n", + "\n", + "Note that it is also possible to have higher-order terms, such as $ D = \\sum \\alpha_i Z_i + \\sum \\beta_{i,j}Z_iZ_j+...$\n", + "\n", + "The gradients are calculated under the premise that the diagonalization gain curve can be fitted by a polynomial, and that the iteration step duration is taken at the first dip of the curve." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.quantum_info import random_hermitian\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", + "from qibo.models.dbi.utils import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test on random Hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", + "[Qibo 0.2.5|INFO|2024-02-22 08:22:59]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 31.576176740060667\n" + ] + } + ], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", \"numba\")\n", + "# initialize dbi object\n", + "nqubits = 5\n", + "h0 = random_hermitian(2**nqubits, seed=2)\n", + "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j)]\n", + "Gradient: [ 482.57311611 272.8003344 -526.64628147 420.97083752 47.09691378]\n", + "s: 0.06953854599881942\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" + ] + } + ], + "source": [ + "# generate the onsite Z operators\n", + "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", + "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", + "grad, s = gradient_onsite_Z(dbi,d,3, onsite_Z_ops)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:106: RuntimeWarning: overflow encountered in matmul\n", + " return a @ b - b @ a\n", + "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:106: RuntimeWarning: invalid value encountered in matmul\n", + " return a @ b - b @ a\n" + ] + } + ], + "source": [ + "iters = 30\n", + "off_diagonal_norm_tot = [dbi.off_diagonal_norm]\n", + "num_iters = []\n", + "s_step = [0]\n", + "for i in range(iters):\n", + " s, d_coef, d, off_diagonal_norm_history = gradient_descent_onsite_Z(dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " off_diagonal_norm_tot.append(off_diagonal_norm_history[-1])\n", + " num_iters.append(len(off_diagonal_norm_history))\n", + " s_step.append(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", + "plt.plot(off_diagonal_norm_tot)\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "h_input = SymbolicHamiltonian( symbols.Z(0)+symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-22 08:38:54]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "dbi(step=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DBF_qibo", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 75e1fa6de7..5ba8af5e67 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -2,8 +2,8 @@ from itertools import product from typing import Optional +import hyperopt import numpy as np -from hyperopt import hp, tpe from qibo import symbols from qibo.config import raise_error @@ -78,26 +78,16 @@ def select_best_dbr_generator( ): """Selects the best double bracket rotation generator from a list and runs the - Args: - dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. - d_list (list): list of diagonal operators (np.array) to run from. - step (float): fixed iteration duration. - Defaults to ``None``, uses hyperopt. - <<<<<<< HEAD - step_min (float): Minimally allowed iteration duration. - step_max (float): Maximally allowed iteration duration. - max_evals (int): Maximally allowed number of evaluation in hyperopt. - compare_canonical (bool): If `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - ======= - step_min (float): minimally allowed iteration duration. - step_max (float): maximally allowed iteration duration. - max_evals (int): maximally allowed number of evaluation in hyperopt. - compare_canonical (bool): if `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - mode (`DoubleBracketGeneratorType`): DBI generator type used for the selection. - >>>>>>> 056830fff9eedef0da2003a638ce4dbd30b6e3b8 - - Returns: - The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. + Args: + dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. + d_list (list): list of diagonal operators (np.array) to run from. + step (float): fixed iteration duration. + Defaults to ``None``, uses hyperopt. + compare_canonical (boolean): include the canonical bracket into the comparison. + scheduling: choose the method of finding optimal step. + + Returns: + The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. """ if scheduling is None: scheduling = dbi_object.scheduling @@ -160,3 +150,179 @@ def cs_angle_sgn(dbi_object, d): ) ) return np.sign(norm) + + +def dGamma_di_onsite_Z( + dbi_object: DoubleBracketIteration, n: int, i: int, d: np.array, onsite_Z_ops=None +): + """Computes the derivatives $\frac{\\partial \\Gamma_n}{\\partial \alpha_i}$ where the diagonal operator $D=\\sum \alpha_i Z_i$. + + Args: + dbi_object (DoubleBracketIteration): the target dbi object + n (int): the number of nested commutators in `Gamma` + i (int): the index of onsite-Z coefficient + d (np.array): the diagonal operator + + Returns: + (list): [dGamma_0_di, dGamma_1_di, ..., dGamma_n_di] + """ + nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) + if onsite_Z_ops is None: + Z_i_str = "I" * (i) + "Z" + "I" * (nqubits - i - 1) + Z_i = SymbolicHamiltonian(str_to_symbolic(Z_i_str)).dense.matrix + else: + Z_i = onsite_Z_ops[i] + dGamma_di = [np.zeros((2**nqubits, 2**nqubits))] * (n + 1) + W = dbi_object.commutator(d, dbi_object.h.matrix) + dW_di = dbi_object.commutator(Z_i, dbi_object.h.matrix) + for k in range(n + 1): + if k == 0: + continue + elif k == 1: + dGamma_di[k] = dW_di + else: + dGamma_di[k] = dbi_object.commutator( + dW_di, dbi_object.Gamma(k - 1, d) + ) + dbi_object.commutator(W, dGamma_di[k - 1]) + return dGamma_di + + +def ds_di_onsite_Z( + dbi_object: DoubleBracketIteration, + d: np.array, + i: int, + taylor_coef=None, + onsite_Z_ops=None, +): + """Return the derivatives of the first 3 polynomial coefficients with respect to onsite Pauli-Z coefficients""" + # generate the list of derivatives w.r.t ith Z operator coefficient + nqubits = int(np.log2(d.shape[0])) + if onsite_Z_ops is None: + onsite_Z_ops = generate_onsite_Z_ops(nqubits) + dGamma_di = dGamma_di_onsite_Z(dbi_object, 3, i, d, onsite_Z_ops=onsite_Z_ops) + + def derivative_product(k1, k2): + r"""Calculate the derivative of a product $\sigma(\Gamma(n1,i))@\sigma(\Gamma(n2,i))""" + return dbi_object.sigma(dGamma_di[k1]) @ dbi_object.sigma( + dbi_object.Gamma(k2, d) + ) + dbi_object.sigma( + dbi_object.sigma(dbi_object.Gamma(k1, d)) + ) @ dbi_object.sigma( + dGamma_di[k2] + ) + + # calculate the derivatives of s polynomial coefficients + da = np.trace(3 * derivative_product(1, 2) + 3 * derivative_product(3, 0)) + db = np.trace(2 * derivative_product(1, 1) + 2 * derivative_product(0, 2)) + dc = np.trace(2 * derivative_product(1, 0)) + + ds = 0 + if taylor_coef != None: + a, b, c = taylor_coef[len(taylor_coef) - 3 :] + delta = b**2 - 4 * a * c + ddelta = 2 * (b * db - 2 * (a * dc + da * c)) + + ds = (-db + 0.5 * ddelta / np.sqrt(delta)) * a - (-b + np.sqrt(delta)) * da + ds /= 2 * a**2 + + return da, db, dc, ds + + +def gradient_onsite_Z( + dbi_object: DoubleBracketIteration, d: np.array, n_taylor=3, onsite_Z_ops=None +): + """Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients""" + # n is the highest order for calculating s + + # initialize gradient + nqubits = int(np.log2(d.shape[0])) + if onsite_Z_ops is None: + onsite_Z_ops = generate_onsite_Z_ops(nqubits) + grad = np.zeros(nqubits) + s, coef = dbi_object.polynomial_step( + n=n_taylor, + backup_scheduling=DoubleBracketScheduling.use_polynomial_approximation, + ) + a, b, c = coef[len(coef) - 3 :] + for i in range(nqubits): + da, db, dc, ds = ds_di_onsite_Z(dbi_object, d, i, [a, b, c], onsite_Z_ops) + grad[i] = ( + s**3 / 3 * da + + s**2 / 2 * db + + 2 * s * dc + + s**2 * ds * a + + s * ds * b + + 2 * ds * c + ) + return grad, s + + +def onsite_Z_decomposition(h_matrix: np.array, onsite_Z_ops=None): + nqubits = int(np.log2(h_matrix.shape[0])) + if onsite_Z_ops is None: + onsite_Z_ops = generate_onsite_Z_ops(nqubits) + decomposition = [] + for Z_i in onsite_Z_ops: + expect = np.trace(h_matrix @ Z_i) / 2**nqubits + decomposition.append(expect) + return decomposition + + +def generate_onsite_Z_ops(nqubits): + onsite_Z_str = ["I" * (i) + "Z" + "I" * (nqubits - i - 1) for i in range(nqubits)] + onsite_Z_ops = [ + SymbolicHamiltonian(str_to_symbolic(Z_i_str)).dense.matrix + for Z_i_str in onsite_Z_str + ] + return onsite_Z_ops + + +def gradient_descent_onsite_Z( + dbi_object: DoubleBracketIteration, + d_coef: list, + d: np.array = None, + n_taylor: int = 3, + onsite_Z_ops=None, + grad_tol: float = 1e-2, + lr_min: float = 1e-5, + lr_max: float = 1, + max_evals: int = 100, + space: callable = None, + optimizer: callable = None, + look_ahead: int = 1, + verbose: bool = False, +): + nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) + if onsite_Z_ops is None: + onsite_Z_ops = generate_onsite_Z_ops(nqubits) + off_diagonal_norm_history = [dbi_object.off_diagonal_norm] + if d is None: + d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) + grad, s = gradient_onsite_Z( + dbi_object, d, n_taylor=n_taylor, onsite_Z_ops=onsite_Z_ops + ) + off_diagonal_norm_history.append(dbi_object.loss(s, d)) + # optimize gradient descent step with hyperopt + if space is None: + space = hyperopt.hp.loguniform("lr", np.log(lr_min), np.log(lr_max)) + if optimizer is None: + optimizer = hyperopt.tpe + + def func_loss_to_lr(lr): + d_coef_eval = [d_coef[j] - grad[j] * lr for j in range(nqubits)] + d_eval = sum([d_coef_eval[i] * onsite_Z_ops[i] for i in range(nqubits)]) + return dbi_object.loss(step=s, d=d_eval) + + best = hyperopt.fmin( + fn=func_loss_to_lr, + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + lr = best["lr"] + + d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)] + d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) + dbi_object(step=s, d=d) + return s, d_coef, d, off_diagonal_norm_history From 0eb2add79684b74f0ac1a276bc0d7dcd37f6cc63 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 22 Feb 2024 16:27:32 +0800 Subject: [PATCH 025/116] Run magnetic field strategy on TFIM --- .../dbi/dbi_strategy_magnetic_field.ipynb | 224 ++++++++++++++++-- 1 file changed, 207 insertions(+), 17 deletions(-) diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index 6f9d7cb8f8..ea0dbb3ad2 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -26,11 +26,29 @@ "import matplotlib.pyplot as plt\n", "\n", "from qibo import hamiltonians, set_backend\n", + "from qibo.hamiltonians import SymbolicHamiltonian\n", "from qibo.quantum_info import random_hermitian\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", "from qibo.models.dbi.utils import *" ] }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_matrix(matrix, title=\"\"):\n", + " \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n", + " fig, ax = plt.subplots(figsize=(5,5))\n", + " ax.set_title(title)\n", + " try:\n", + " im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n", + " except TypeError:\n", + " im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n", + " fig.colorbar(im, ax=ax)\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -40,15 +58,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", - "[Qibo 0.2.5|INFO|2024-02-22 08:22:59]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.5|INFO|2024-02-22 16:06:03]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -57,6 +74,16 @@ "text": [ "Initial off diagonal norm 31.576176740060667\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -66,7 +93,8 @@ "nqubits = 5\n", "h0 = random_hermitian(2**nqubits, seed=2)\n", "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))\n", - "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", + "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" ] }, { @@ -175,47 +203,209 @@ "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test on TFIM\n", + "Here we choose to customize our TFIM in the X axis using `SymbolicHamiltonian`. It is also possible to use Hadamard gate to rotate the TFIM inbuilt in `qibo`.\n", + "\n", + "$$ H = -(\\sum X_i X_{i+1} + \\sum hZ_i)" + ] + }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-22 16:08:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "h_input = SymbolicHamiltonian( symbols.Z(0)+symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 )" + "# generate the Hamiltonian\n", + "nqubits = 5\n", + "h = 1\n", + "H_TFIM = SymbolicHamiltonian( - h*symbols.Z(nqubits-1), nqubits=nqubits)\n", + "# add linear interaction terms\n", + "for i in range(nqubits-1):\n", + " H_TFIM -= SymbolicHamiltonian(symbols.X(i)*symbols.X(i+1) + h*symbols.Z(i), nqubits=nqubits)\n", + "H_TFIM = H_TFIM.dense\n", + "visualize_matrix(H_TFIM.matrix, title=f'TFIM with L={nqubits} h={h}')" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-02-22 08:38:54]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|INFO|2024-02-22 16:13:45]: Using qibojit (numba) backend on /CPU:0\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n" ] } ], "source": [ - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))" + "# backend\n", + "set_backend(\"qibojit\", \"numba\")\n", + "# initialize dbi object\n", + "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM))\n", + "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix)\n", + "print(d_coef)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n", + "Gradient: [ -7.8132536 -17.94433184 -20.56560814 -17.94433184 -7.8132536 ]\n", + "s: 0.047896529653867745\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" + ] + } + ], "source": [ - "dbi(step=0.1)" + "# generate the onsite Z operators\n", + "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", + "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix, onsite_Z_ops)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", + "grad, s = gradient_onsite_Z(dbi_TFIM,d,3, onsite_Z_ops)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" + ] + } + ], + "source": [ + "iters = 30\n", + "off_diagonal_norm_tot = [dbi_TFIM.off_diagonal_norm]\n", + "num_iters = []\n", + "s_step = [0]\n", + "for i in range(iters):\n", + " s, d_coef, d, off_diagonal_norm_history = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " off_diagonal_norm_tot.append(off_diagonal_norm_history[-1])\n", + " num_iters.append(len(off_diagonal_norm_history))\n", + " s_step.append(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", + "plt.plot(off_diagonal_norm_tot)\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# the final matrix\n", + "visualize_matrix(dbi_TFIM.h.matrix)" + ] } ], "metadata": { From 08fb83727bafafb83b679adbcf9456f3a51f3435 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 22 Feb 2024 22:27:40 +0800 Subject: [PATCH 026/116] Complete dbi_strategies_compare notebook --- examples/dbi/dbi_strategies_compare.ipynb | 254 ++++++++++++++++ .../dbi/dbi_strategy_magnetic_field.ipynb | 272 +++--------------- src/qibo/models/dbi/double_bracket.py | 48 ++-- src/qibo/models/dbi/utils.py | 6 +- 4 files changed, 327 insertions(+), 253 deletions(-) create mode 100644 examples/dbi/dbi_strategies_compare.ipynb diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb new file mode 100644 index 0000000000..0afd3a9841 --- /dev/null +++ b/examples/dbi/dbi_strategies_compare.ipynb @@ -0,0 +1,254 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DBI strategies comparison\n", + "\n", + "This notebook is a comparison of the so-far developed diagonalization strategies for DBI, including the canonical, Pauli-Z, and magnetic field strategies. On top of these, we also show case the use of invariant DBI generators such as 'BHMM'." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", + "from qibo.quantum_info import random_hermitian\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", + "from qibo.models.dbi.utils import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_matrix(matrix, title=\"\"):\n", + " \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n", + " fig, ax = plt.subplots(figsize=(5,5))\n", + " ax.set_title(title)\n", + " try:\n", + " im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n", + " except TypeError:\n", + " im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n", + " fig.colorbar(im, ax=ax)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test on random Hamiltonian\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", \"numba\")\n", + "# initialize dbi object\n", + "nqubits = 5\n", + "h0 = random_hermitian(2**nqubits, seed=2)\n", + "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", + "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# iterations steps\n", + "NSTEPS = 15\n", + "# choose polynomial scheduling\n", + "scheduling = DoubleBracketScheduling.use_hyperopt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Canonical" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize DBI class for the canonical case\n", + "dbi_canonical = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.canonical, scheduling=scheduling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Canonical\n", + "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n", + "steps_canonical_plot = [0]\n", + "for s in range(NSTEPS):\n", + " # same settings as iteration from list\n", + " step = dbi_canonical.choose_step(d=dbi.diagonal_h_matrix, max_evals=50)\n", + " dbi_canonical(step=step)\n", + " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", + " off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n", + " steps_canonical_plot.append(steps_canonical_plot[-1]+step)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pauli-Z" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize DBI class for the Pauli-Z strategy\n", + "dbi_pauli = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "generate_local_Z = generate_Z_operators(nqubits)\n", + "Z_ops = list(generate_local_Z.values())\n", + "Z_names = list(generate_local_Z.keys())\n", + "Z_optimal = []\n", + "# add in initial values for plotting\n", + "off_diagonal_norm_history_pauli = [dbi_pauli.off_diagonal_norm]\n", + "steps_pauli_plot = [0]\n", + "scheduling = DoubleBracketScheduling.use_hyperopt\n", + "for _ in range(NSTEPS):\n", + " dbi_pauli, idx, step, flip_sign = select_best_dbr_generator(dbi_pauli, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=50)\n", + " off_diagonal_norm_history_pauli.append(dbi_pauli.off_diagonal_norm)\n", + " steps_pauli_plot.append(steps_pauli_plot[-1]+step)\n", + " if flip_sign < 0:\n", + " Z_optimal.append('-' + Z_names[idx])\n", + " else:\n", + " Z_optimal.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi_pauli.off_diagonal_norm}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Magnetic field" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize DBI class for the canonical case\n", + "dbi_gradient = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", + "d_coef = onsite_Z_decomposition(dbi_gradient.h.matrix, onsite_Z_ops)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "off_diagonal_norm_history_gradient = [dbi_gradient.off_diagonal_norm]\n", + "steps_gradient_plot= [0]\n", + "for _ in range(NSTEPS):\n", + " step, d_coef, d = gradient_descent_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=50, n_taylor=5)\n", + " off_diagonal_norm_history_gradient.append(dbi_gradient.off_diagonal_norm)\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n", + " steps_gradient_plot.append(steps_gradient_plot[-1]+step)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n", + "plt.plot(off_diagonal_norm_history_canonical, label='canonical')\n", + "plt.plot(off_diagonal_norm_history_pauli, label='Pauli-Z')\n", + "plt.plot(off_diagonal_norm_history_gradient, label='gradient')\n", + "plt.legend()\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n", + "plt.plot(steps_canonical_plot, off_diagonal_norm_history_canonical, marker='o', label='canonical')\n", + "plt.plot(steps_pauli_plot, off_diagonal_norm_history_pauli, marker='o', label='Pauli-Z')\n", + "plt.plot(steps_gradient_plot,off_diagonal_norm_history_gradient, marker='o', label='gradient')\n", + "plt.legend()\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DBF_qibo", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index ea0dbb3ad2..d324efdb38 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -26,7 +26,7 @@ "import matplotlib.pyplot as plt\n", "\n", "from qibo import hamiltonians, set_backend\n", - "from qibo.hamiltonians import SymbolicHamiltonian\n", + "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", "from qibo.quantum_info import random_hermitian\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", "from qibo.models.dbi.utils import *" @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -58,34 +58,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-02-22 16:06:03]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 31.576176740060667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# backend\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -99,38 +74,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j)]\n", - "Gradient: [ 482.57311611 272.8003344 -526.64628147 420.97083752 47.09691378]\n", - "s: 0.06953854599881942\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" - ] - } - ], + "outputs": [], "source": [ "# generate the onsite Z operators\n", "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", @@ -144,58 +90,24 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:106: RuntimeWarning: overflow encountered in matmul\n", - " return a @ b - b @ a\n", - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:106: RuntimeWarning: invalid value encountered in matmul\n", - " return a @ b - b @ a\n" - ] - } - ], + "outputs": [], "source": [ "iters = 30\n", "off_diagonal_norm_tot = [dbi.off_diagonal_norm]\n", - "num_iters = []\n", "s_step = [0]\n", "for i in range(iters):\n", - " s, d_coef, d, off_diagonal_norm_history = gradient_descent_onsite_Z(dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " off_diagonal_norm_tot.append(off_diagonal_norm_history[-1])\n", - " num_iters.append(len(off_diagonal_norm_history))\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " off_diagonal_norm_tot.append(dbi.off_diagonal_norm)\n", " s_step.append(s)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", "plt.plot(off_diagonal_norm_tot)\n", @@ -215,27 +127,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-22 16:08:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# generate the Hamiltonian\n", "nqubits = 5\n", @@ -250,78 +144,28 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-02-22 16:13:45]: Using qibojit (numba) backend on /CPU:0\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n" - ] - } - ], + "outputs": [], "source": [ "# backend\n", "set_backend(\"qibojit\", \"numba\")\n", "# initialize dbi object\n", - "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM))\n", - "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix)\n", - "print(d_coef)" + "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM))" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n", - "Gradient: [ -7.8132536 -17.94433184 -20.56560814 -17.94433184 -7.8132536 ]\n", - "s: 0.047896529653867745\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" - ] - } - ], + "outputs": [], "source": [ "# generate the onsite Z operators\n", "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", "grad, s = gradient_onsite_Z(dbi_TFIM,d,3, onsite_Z_ops)\n", + "print('Initial off-diagonal norm:', dbi.off_diagonal_norm)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", "print('s:', s)" @@ -329,56 +173,25 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" - ] - } - ], + "outputs": [], "source": [ - "iters = 30\n", + "NSTEPS = 30\n", "off_diagonal_norm_tot = [dbi_TFIM.off_diagonal_norm]\n", - "num_iters = []\n", "s_step = [0]\n", - "for i in range(iters):\n", - " s, d_coef, d, off_diagonal_norm_history = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " off_diagonal_norm_tot.append(off_diagonal_norm_history[-1])\n", - " num_iters.append(len(off_diagonal_norm_history))\n", - " s_step.append(s)" + "for _ in range(NSTEPS):\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " off_diagonal_norm_tot.append(dbi_TFIM.off_diagonal_norm)\n", + " s_step.append(s)\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM.off_diagonal_norm}\")" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", "plt.plot(off_diagonal_norm_tot)\n", @@ -388,24 +201,21 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# the final matrix\n", "visualize_matrix(dbi_TFIM.h.matrix)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Different initial `d`\n", + "Next, we show the effect of different choices of the initial direction of the gradient descent method." + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 13fbfff622..8ae4429c4a 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -225,22 +225,10 @@ def polynomial_step( if backup_scheduling is None: backup_scheduling = DoubleBracketScheduling.use_grid_search - def sigma(h: np.array): - return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) - - def Gamma(k: int): - r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" - if k == 0: - return self.h.matrix - else: - W = self.commutator(d, sigma(self.h.matrix)) - result = self.h.matrix - for _ in range(k): - result = self.commutator(W, result) - return result - # list starting from s^n highest order to s^0 - sigma_gamma_list = np.array([sigma(Gamma(k)) for k in range(n + 2)]) + sigma_gamma_list = np.array( + [self.sigma(self.Gamma(k, d)) for k in range(n + 2)] + ) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients for rotation with [W,H] and H c1 = [ @@ -258,7 +246,8 @@ def Gamma(k: int): power = k + j product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) - roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + taylor_coefficients = list(reversed(trace_coefficients[:n])) + roots = np.roots(taylor_coefficients) error = 1e-3 real_positive_roots = [ np.real(root) @@ -267,7 +256,7 @@ def Gamma(k: int): ] # solution exists, return minimum s if len(real_positive_roots) > 0: - return min(real_positive_roots) + return min(real_positive_roots), taylor_coefficients # solution does not exist, resort to backup scheduling elif ( backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation @@ -277,7 +266,12 @@ def Gamma(k: int): n=n + 1, d=d, backup_scheduling=backup_scheduling ) else: - return self.choose_step(d=d, scheduling=backup_scheduling) + print( + f"Unable to find roots with current order, resorting to {backup_scheduling}" + ) + return self.choose_step(d=d, scheduling=backup_scheduling), list( + reversed(trace_coefficients[: n + 1]) + ) def choose_step( self, @@ -292,7 +286,9 @@ def choose_step( if scheduling is DoubleBracketScheduling.use_hyperopt: return self.hyperopt_step(d=d, **kwargs) if scheduling is DoubleBracketScheduling.use_polynomial_approximation: - return self.polynomial_step(d=d, **kwargs) + # omit taylor coefficients + step, _ = self.polynomial_step(d=d, **kwargs) + return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ @@ -330,3 +326,17 @@ def energy_fluctuation(self, state): state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ return self.h.energy_fluctuation(state) + + def sigma(self, h: np.array): + return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) + + def Gamma(self, k: int, d: np.array): + r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" + if k == 0: + return self.h.matrix + else: + W = self.commutator(d, self.sigma(self.h.matrix)) + result = self.h.matrix + for _ in range(k): + result = self.commutator(W, result) + return result diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 9a311adcf8..b0a89c116a 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -250,6 +250,8 @@ def gradient_onsite_Z( + s * ds * b + 2 * ds * c ) + grad = np.array(grad) + grad = grad / np.linalg.norm(grad) return grad, s @@ -291,13 +293,11 @@ def gradient_descent_onsite_Z( nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) if onsite_Z_ops is None: onsite_Z_ops = generate_onsite_Z_ops(nqubits) - off_diagonal_norm_history = [dbi_object.off_diagonal_norm] if d is None: d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) grad, s = gradient_onsite_Z( dbi_object, d, n_taylor=n_taylor, onsite_Z_ops=onsite_Z_ops ) - off_diagonal_norm_history.append(dbi_object.loss(s, d)) # optimize gradient descent step with hyperopt if space is None: space = hyperopt.hp.loguniform("lr", np.log(lr_min), np.log(lr_max)) @@ -321,4 +321,4 @@ def func_loss_to_lr(lr): d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)] d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) dbi_object(step=s, d=d) - return s, d_coef, d, off_diagonal_norm_history + return s, d_coef, d From 3cd9338f7acc876786150305633c7d3f45f1d8b1 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 23 Feb 2024 17:49:47 +0800 Subject: [PATCH 027/116] Fix error: missing argument d in gradient_onsite_Z --- examples/dbi/dbi_strategies_compare.ipynb | 8 + examples/dbi/dbi_strategy_Pauli-Z 2.ipynb | 514 ++++++++++++++++++ .../dbi/dbi_strategy_magnetic_field.ipynb | 112 +++- src/qibo/models/dbi/utils.py | 21 +- tests/test_models_dbi_utils 2.py | 50 ++ 5 files changed, 687 insertions(+), 18 deletions(-) create mode 100644 examples/dbi/dbi_strategy_Pauli-Z 2.ipynb create mode 100644 tests/test_models_dbi_utils 2.py diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb index 0afd3a9841..0bb5642abf 100644 --- a/examples/dbi/dbi_strategies_compare.ipynb +++ b/examples/dbi/dbi_strategies_compare.ipynb @@ -194,6 +194,7 @@ "steps_gradient_plot= [0]\n", "for _ in range(NSTEPS):\n", " step, d_coef, d = gradient_descent_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=50, n_taylor=5)\n", + " dbi_gradient(d=d,step=step)\n", " off_diagonal_norm_history_gradient.append(dbi_gradient.off_diagonal_norm)\n", " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n", " steps_gradient_plot.append(steps_gradient_plot[-1]+step)" @@ -228,6 +229,13 @@ "plt.xlabel('Iteration')\n", "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/examples/dbi/dbi_strategy_Pauli-Z 2.ipynb b/examples/dbi/dbi_strategy_Pauli-Z 2.ipynb new file mode 100644 index 0000000000..5f563a172a --- /dev/null +++ b/examples/dbi/dbi_strategy_Pauli-Z 2.ipynb @@ -0,0 +1,514 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-Bracket Iteration Strategy: Pauli-Z products\n", + "\n", + "In this example, we demonstrate the usage of a DBI strategy, where the diagonal operators for double bracket iterations are variationally chosen from all possible local Pauli-Z operators." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initial setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python -m pip install hyperopt # required to optimize the DBF step" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import copy, deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", + "from qibo.models.dbi.utils import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below are some useful functions to visualize the diagonalization process." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_matrix(matrix, title=\"\"):\n", + " \"\"\"Visualize absolute values of a matrix in a heatmap form.\"\"\"\n", + " fig, ax = plt.subplots(figsize=(5, 5))\n", + " ax.set_title(title)\n", + " try:\n", + " im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n", + " except TypeError:\n", + " im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n", + " fig.colorbar(im, ax=ax)\n", + "\n", + "\n", + "def visualize_drift(h0, h):\n", + " \"\"\"Visualize drift of the evolved hamiltonian w.r.t. h0.\"\"\"\n", + " fig, ax = plt.subplots(figsize=(5, 5))\n", + " ax.set_title(r\"Drift: $|\\hat{H}_0 - \\hat{H}_{1}|$\")\n", + " try:\n", + " im = ax.imshow(np.absolute(h0 - h), cmap=\"inferno\")\n", + " except TypeError:\n", + " im = ax.imshow(np.absolute((h0 - h).get()), cmap=\"inferno\")\n", + "\n", + " fig.colorbar(im, ax=ax)\n", + "\n", + "\n", + "def plot_histories(loss_histories: list, steps: list, labels: list = None):\n", + " \"\"\"Plot off-diagonal norm histories over a sequential evolution.\"\"\"\n", + " plt.figure(figsize=(5, 5 * 6 / 8))\n", + " if len(steps) == 1:\n", + " # fixed_step\n", + " x_axis = [i * steps[0] for i in range(len(loss_histories))]\n", + " else:\n", + " x_axis = [sum(steps[:k]) for k in range(1, len(steps) + 1)]\n", + " plt.plot(x_axis, loss_histories, \"-o\")\n", + "\n", + " x_labels_rounded = [round(x, 2) for x in x_axis]\n", + " x_labels_rounded = [0] + x_labels_rounded[0:5] + [max(x_labels_rounded)]\n", + " x_labels_rounded.pop(3)\n", + " plt.xticks(x_labels_rounded)\n", + "\n", + " y_labels_rounded = [round(y, 1) for y in loss_histories]\n", + " y_labels_rounded = y_labels_rounded[0:5] + [min(y_labels_rounded)]\n", + " plt.yticks(y_labels_rounded)\n", + "\n", + " if labels is not None:\n", + " labels_copy = copy(labels)\n", + " labels_copy.insert(0, \"Initial\")\n", + " for i, label in enumerate(labels_copy):\n", + " plt.text(x_axis[i], loss_histories[i], label)\n", + "\n", + " plt.grid()\n", + " plt.xlabel(r\"Flow duration $s$\")\n", + " plt.title(\"Loss function histories\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example: TFIM\n", + "\n", + "As an example, we consider the Transverse Field Ising Model (TFIM):\n", + "$$ H_{\\rm TFIM} = - \\sum_{i=1}^{N}\\bigl( Z_i Z_{i+1} + h X_i \\bigr),$$\n", + "which is already implemented in `Qibo`. For this tutorial we set $N=5$ and $h=3$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# set the qibo backend (we suggest qibojit if N >= 20)\n", + "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# initialize class\n", + "# Note: use deepcopy to prevent h being edited\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(H_TFIM.matrix)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate local Pauli-Z operators" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "generate_local_Z = generate_Z_operators(nqubits)\n", + "Z_ops = list(generate_local_Z.values())\n", + "Z_names = list(generate_local_Z.keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Iteration from a list of operators\n", + "The idea of this strategy is to chose the Z operator that reduces the off-diagonal norm of the hamiltonian most efficiently. Given a list of operators (np.array), the function `select_best_dbr_generator_and_run` searches for the maximum decrease in off-diagonal norm for each operator and runs one double bracket rotation using the optimal operator from the list.\n", + "\n", + "Note that the hyperopt settings can be set as positional arguments." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NSTEPS = 15\n", + "max_evals = 100\n", + "step_max = 1\n", + "Z_optimal = []\n", + "# add in initial values for plotting\n", + "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", + "steps = [0]\n", + "scheduling = DoubleBracketScheduling.use_hyperopt\n", + "for _ in range(NSTEPS):\n", + " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", + " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", + " steps.append(steps[-1]+step)\n", + " if flip_sign < 0:\n", + " Z_optimal.append('-' + Z_names[idx])\n", + " else:\n", + " Z_optimal.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi.off_diagonal_norm}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_histories(off_diagonal_norm_history, steps, Z_optimal)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is worth noting that due to the nature of `hyperopt`, the iterations may be unstable and multiple runs may be required for the optimal result (alternatively, we can perform a grid search on the optimal step). Hence, it is sometimes needed to adjust its parameters including the following:\n", + "\n", + "- step_min\n", + "- step_max\n", + "- max_evals" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compare with canonical\n", + "\n", + "We compare the effectiveness at diagonalzation between the Pauli-Z operators and the canonical generator:\n", + "\n", + "$$ d = [H,\\sigma(H)]$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# set the qibo backend (we suggest qibojit if N >= 20)\n", + "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "\n", + "# initialize class|\n", + "# Note: use deepcopy to prevent h being edited\n", + "dbi_canonical = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "print(\"Initial off diagonal norm\", dbi_canonical.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n", + "steps_canonical = [0]\n", + "steps_canonical_plot = [0]\n", + "for s in range(NSTEPS):\n", + " # same settings as iteration from list\n", + " step = dbi_canonical.hyperopt_step(\n", + " step_min = 1e-5,\n", + " step_max = 1,\n", + " space = hp.uniform,\n", + " optimizer = tpe,\n", + " )\n", + " dbi_canonical(step=step)\n", + " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", + " off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n", + " steps_canonical.append(step)\n", + " steps_canonical_plot.append(steps_canonical_plot[-1]+step)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", + "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n", + "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n", + "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Norm off-diagonal restriction\")\n", + "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(off_diagonal_norm_history)\n", + "print(off_diagonal_norm_history_canonical)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we make 2 observations:\n", + "\n", + "1. The canonical strategy has a steeper decrease at the beginning than Pauli-Z operators.\n", + "2. However, the canonical strategy is also prone to getting stuck at a local minimum and hence resultting in a lesser degree of diagonalization.\n", + "\n", + "Therefore, we explore the possibility of mixing the two strategies by including the canonical generator in the list." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mixed strategy: optimal at each step" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dbi_mixed = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", + "print(\"Initial off diagonal norm\", dbi_mixed.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dbi_eval = deepcopy(dbi_mixed)\n", + "dbi_eval.mode = DoubleBracketGeneratorType.canonical\n", + "if step is None:\n", + " step = dbi_eval.hyperopt_step(\n", + " step_max=step_max,\n", + " space=hp.uniform,\n", + " optimizer=tpe,\n", + " max_evals=max_evals,\n", + " )\n", + "dbi_eval(step=step)\n", + "print('canonical norm', dbi_eval.off_diagonal_norm, 'step', step)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Z_optimal_mixed = []\n", + "# add in initial values for plotting\n", + "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", + "steps = [0]\n", + "for _ in range(NSTEPS):\n", + " dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, scheduling=scheduling, compare_canonical=True, max_evals=max_evals, step_max=step_max)\n", + " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", + " steps.append(steps[-1]+step)\n", + " if idx == len(Z_ops):\n", + " Z_optimal_mixed.append('Canonical')\n", + " elif flip_sign < 0:\n", + " Z_optimal_mixed.append('-' + Z_names[idx])\n", + " else:\n", + " Z_optimal_mixed.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal_mixed[-1]}, loss {dbi_mixed.off_diagonal_norm}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", + "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n", + "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n", + "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n", + "plt.plot(off_diagonal_norm_history_mixed, label=\"Mixed\")\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Norm off-diagonal restriction\")\n", + "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After a few tests, we realize that the mixed strategy does not always outperform just using Pauli-Z operators. This could be caused by 2 reasons: \n", + "\n", + "1. Unstability of hyperopt\n", + "2. Tendency of canonical operator to get stuck at a near local minimum" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mixed strategy: initial canonical\n", + "\n", + "Since the canonical double bracket iteration performs better at the initial steps, we attempt to combine the two strategies: iterate a few steps using the canonical bracket before switching to the variational Z-operators." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dbi_mixed_can= DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "print(\"Initial off diagonal norm\", dbi_mixed_can.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the initial iterations using canonical iterations\n", + "off_diagonal_norm_history_mixed_can = [dbi_mixed_can.off_diagonal_norm]\n", + "steps_mixed_can = [0]\n", + "cannonical_NSTEPS = 2\n", + "for i in range(cannonical_NSTEPS):\n", + " step = steps_canonical[i+1]\n", + " dbi_mixed_can(step=step)\n", + " off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n", + " steps_mixed_can.append(step)\n", + " \n", + "print(\"After 2 steps, off diagonal norm:\", dbi_mixed_can.off_diagonal_norm)\n", + "print(\"By comparison, the Pauli-Z:\", off_diagonal_norm_history[2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Continue the remaining steps with Pauli-Z operators\n", + "Z_optimal_mixed_can = [\"Cannonical\" for _ in range(cannonical_NSTEPS)]\n", + "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", + "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n", + "for _ in range(remaining_NSTEPS):\n", + " dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", + " off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n", + " steps_mixed_can.append(step)\n", + " if idx == len(Z_ops):\n", + " Z_optimal_mixed.append('Canonical')\n", + " elif flip_sign < 0:\n", + " Z_optimal_mixed.append('-' + Z_names[idx])\n", + " else:\n", + " Z_optimal_mixed.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_+1}/{remaining_NSTEPS}: {step} with operator {Z_optimal_mixed_can[-1]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", + "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n", + "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n", + "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n", + "plt.plot(off_diagonal_norm_history_mixed, label=\"Mixed: optimal steps\")\n", + "plt.plot(off_diagonal_norm_history_mixed_can, label=\"Mixed: initial canonical\")\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Norm off-diagonal restriction\")\n", + "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example also shows that the canonical generator is more likely to drive the model into a local minimum than variationally assigned diagonal operator, and that it is hard to get it unstuck even with the Pauli-Z operators." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index d324efdb38..cb65b76541 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -67,7 +67,10 @@ "# initialize dbi object\n", "nqubits = 5\n", "h0 = random_hermitian(2**nqubits, seed=2)\n", - "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))\n", + "scheduling = DoubleBracketScheduling.use_hyperopt\n", + "mode = DoubleBracketGeneratorType.single_commutator\n", + "n_taylor = 5\n", + "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" ] @@ -82,7 +85,7 @@ "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi,d,3, onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi,d,5, onsite_Z_ops)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", "print('s:', s)" @@ -95,11 +98,12 @@ "outputs": [], "source": [ "iters = 30\n", - "off_diagonal_norm_tot = [dbi.off_diagonal_norm]\n", + "off_diagonal_norm = [dbi.off_diagonal_norm]\n", "s_step = [0]\n", "for i in range(iters):\n", " s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " off_diagonal_norm_tot.append(dbi.off_diagonal_norm)\n", + " dbi(step=s, d=d)\n", + " off_diagonal_norm.append(dbi.off_diagonal_norm)\n", " s_step.append(s)" ] }, @@ -110,7 +114,7 @@ "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", - "plt.plot(off_diagonal_norm_tot)\n", + "plt.plot(off_diagonal_norm)\n", "plt.xlabel('Iteration')\n", "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" ] @@ -151,7 +155,7 @@ "# backend\n", "set_backend(\"qibojit\", \"numba\")\n", "# initialize dbi object\n", - "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM))" + "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" ] }, { @@ -164,7 +168,7 @@ "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi_TFIM,d,3, onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi_TFIM,d,5, onsite_Z_ops)\n", "print('Initial off-diagonal norm:', dbi.off_diagonal_norm)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", @@ -177,13 +181,14 @@ "metadata": {}, "outputs": [], "source": [ - "NSTEPS = 30\n", - "off_diagonal_norm_tot = [dbi_TFIM.off_diagonal_norm]\n", - "s_step = [0]\n", + "NSTEPS = 15\n", + "off_diagonal_norm_delta = [dbi_TFIM.off_diagonal_norm]\n", + "s_step_delta = [0]\n", "for _ in range(NSTEPS):\n", - " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " off_diagonal_norm_tot.append(dbi_TFIM.off_diagonal_norm)\n", - " s_step.append(s)\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100, n_taylor=5, use_ds=True)\n", + " dbi_TFIM(step=s, d=d)\n", + " off_diagonal_norm_delta.append(dbi_TFIM.off_diagonal_norm)\n", + " s_step_delta.append(s)\n", " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM.off_diagonal_norm}\")" ] }, @@ -194,7 +199,7 @@ "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", - "plt.plot(off_diagonal_norm_tot)\n", + "plt.plot(off_diagonal_norm_delta)\n", "plt.xlabel('Iteration')\n", "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" ] @@ -216,6 +221,85 @@ "## Different initial `d`\n", "Next, we show the effect of different choices of the initial direction of the gradient descent method." ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "H = H_TFIM.matrix\n", + "L = int(np.log2(H.shape[0]))\n", + "N = np.diag(np.linspace(np.min(np.diag(H)),np.max(np.diag(H)),2**L))\n", + "d_coef = onsite_Z_decomposition(N, onsite_Z_ops)\n", + "print(d_coef)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "visualize_matrix(H, 'Initial hamiltonian')\n", + "visualize_matrix(N, 'Min-max diagonal matrix')\n", + "visualize_matrix(d, 'Min-max projection onsite-Z')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we see that the min-max diagonal operator can be correctly decomposed into onsite-Z operators. Then we generate the diagonalization curve and compare with other initializations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", \"numba\")\n", + "# initialize dbi object\n", + "dbi_TFIM_MMH = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NSTEPS = 15\n", + "off_diagonal_norm_MMH = [dbi_TFIM_MMH.off_diagonal_norm]\n", + "s_step_MMH = [0]\n", + "# d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", + "# d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", + "for _ in range(NSTEPS):\n", + " d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", + " d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM_MMH, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " dbi_TFIM_MMH(d=d, step=s)\n", + " off_diagonal_norm_MMH.append(dbi_TFIM_MMH.off_diagonal_norm)\n", + " s_step_MMH.append(s)\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM_MMH.off_diagonal_norm}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", + "plt.plot(off_diagonal_norm_MMH, label='MMH')\n", + "plt.plot(off_diagonal_norm_delta, label='delta')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')\n", + "plt.legend()" + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index b0a89c116a..f42ab174d3 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -225,7 +225,11 @@ def derivative_product(k1, k2): def gradient_onsite_Z( - dbi_object: DoubleBracketIteration, d: np.array, n_taylor=3, onsite_Z_ops=None + dbi_object: DoubleBracketIteration, + d: np.array, + n_taylor=3, + onsite_Z_ops=None, + use_ds=False, ): """Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients""" # n is the highest order for calculating s @@ -236,12 +240,15 @@ def gradient_onsite_Z( onsite_Z_ops = generate_onsite_Z_ops(nqubits) grad = np.zeros(nqubits) s, coef = dbi_object.polynomial_step( + d=d, n=n_taylor, backup_scheduling=DoubleBracketScheduling.use_polynomial_approximation, ) a, b, c = coef[len(coef) - 3 :] for i in range(nqubits): da, db, dc, ds = ds_di_onsite_Z(dbi_object, d, i, [a, b, c], onsite_Z_ops) + if use_ds is True: + ds = 0 grad[i] = ( s**3 / 3 * da + s**2 / 2 * db @@ -281,7 +288,6 @@ def gradient_descent_onsite_Z( d: np.array = None, n_taylor: int = 3, onsite_Z_ops=None, - grad_tol: float = 1e-2, lr_min: float = 1e-5, lr_max: float = 1, max_evals: int = 100, @@ -289,6 +295,7 @@ def gradient_descent_onsite_Z( optimizer: callable = None, look_ahead: int = 1, verbose: bool = False, + use_ds: bool = True, ): nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) if onsite_Z_ops is None: @@ -296,7 +303,7 @@ def gradient_descent_onsite_Z( if d is None: d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) grad, s = gradient_onsite_Z( - dbi_object, d, n_taylor=n_taylor, onsite_Z_ops=onsite_Z_ops + dbi_object, d, n_taylor=n_taylor, onsite_Z_ops=onsite_Z_ops, use_ds=use_ds ) # optimize gradient descent step with hyperopt if space is None: @@ -320,5 +327,11 @@ def func_loss_to_lr(lr): d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)] d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) - dbi_object(step=s, d=d) return s, d_coef, d + + +def diagonal_min_max(matrix: np.array): + L = int(np.log2(matrix.shape[0])) + D = np.linspace(np.min(np.diag(matrix)), np.max(np.diag(matrix)), 2**L) + D = np.diag(D) + return D diff --git a/tests/test_models_dbi_utils 2.py b/tests/test_models_dbi_utils 2.py new file mode 100644 index 0000000000..cd9f74e9de --- /dev/null +++ b/tests/test_models_dbi_utils 2.py @@ -0,0 +1,50 @@ +""""Testing utils for DoubleBracketIteration model""" + +import numpy as np +import pytest + +from qibo import set_backend +from qibo.hamiltonians import Hamiltonian +from qibo.models.dbi.double_bracket import ( + DoubleBracketGeneratorType, + DoubleBracketIteration, +) +from qibo.models.dbi.utils import * +from qibo.quantum_info import random_hermitian + +NSTEPS = 5 +"""Number of steps for evolution.""" + + +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +def test_generate_Z_operators(backend, nqubits): + h0 = random_hermitian(2**nqubits) + dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) + generate_Z = generate_Z_operators(nqubits) + Z_ops = list(generate_Z.values()) + + delta_h0 = dbi.diagonal_h_matrix + dephasing_channel = (sum([Z_op @ h0 @ Z_op for Z_op in Z_ops]) + h0) / 2**nqubits + norm_diff = np.linalg.norm(delta_h0 - dephasing_channel) + + assert norm_diff < 1e-3 + + +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("step", [0.1, None]) +def test_select_best_dbr_generator(backend, nqubits, step): + h0 = random_hermitian(2**nqubits, seed=1, backend=backend) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + ) + generate_Z = generate_Z_operators(nqubits) + Z_ops = list(generate_Z.values()) + initial_off_diagonal_norm = dbi.off_diagonal_norm + + for _ in range(NSTEPS): + dbi, idx, step_optimize, flip = select_best_dbr_generator( + dbi, Z_ops, step=step, compare_canonical=True + ) + + assert initial_off_diagonal_norm > dbi.off_diagonal_norm From d01632bbf186b83fde31585c864ea7002b49c926 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Wed, 28 Feb 2024 07:27:36 +0100 Subject: [PATCH 028/116] added other reordering of GC; test notebook improved; there was no bug: should use d.dense.matrix --- ...th evolution oracles vs existing dbi.ipynb | 154 ----- ...rrect number of Trotter-Suzuki steps.ipynb | 2 +- ...h evolution oracles vs existing dbi .ipynb | 526 ++++++++++++++++++ ...es vs existing dbi in canonical mode.ipynb | 248 --------- .../group_commutator_iteration_transpiler.py | 34 +- 5 files changed, 560 insertions(+), 404 deletions(-) delete mode 100644 src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb create mode 100644 src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb delete mode 100644 src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb diff --git a/src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb b/src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb deleted file mode 100644 index de08ac445d..0000000000 --- a/src/qibo/models/dbi/Bug detected Test gci with evolution oracles vs existing dbi.ipynb +++ /dev/null @@ -1,154 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "4ed280d7", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-02-08 04:41:24]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], - "source": [ - "from qibo.hamiltonians import SymbolicHamiltonian\n", - "from qibo import symbols\n", - "from double_bracket_evolution_oracles import *\n", - "from group_commutator_iteration_transpiler import *\n", - "\n", - "\"\"\"Test create evolution oracle\"\"\"\n", - "\n", - "h_input = SymbolicHamiltonian( symbols.Z(0)+symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - "\n", - "# Initialize with EvolutionOracleType hamiltonian_simulation\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "8a03c568", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-08 04:41:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], - "source": [ - "from double_bracket import *\n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.group_commutator" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "e31a8298", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "32.0" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dbi.off_diagonal_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "fe1e3816", - "metadata": {}, - "outputs": [], - "source": [ - "d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2)+symbols.Z(0), nqubits = 3 )" - ] - }, - { - "cell_type": "markdown", - "id": "ba28a352", - "metadata": {}, - "source": [ - "## The following cell crashes" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f973a06c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-08 04:41:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "ename": "TypeError", - "evalue": "Hamiltonian.exp() missing 1 required positional argument: 'a'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_122196/1963945966.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.51\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/double_bracket.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 79\u001b[0m operator = (\n\u001b[1;32m 80\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 82\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibo/backends/numpy.py\u001b[0m in \u001b[0;36mcalculate_matrix_exp\u001b[0;34m(self, a, matrix, eigenvectors, eigenvalues)\u001b[0m\n\u001b[1;32m 737\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 739\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 740\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 741\u001b[0m \u001b[0mexpd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiag\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0meigenvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/scipy/linalg/_matfuncs.py\u001b[0m in \u001b[0;36mexpm\u001b[0;34m(A)\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 283\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: Hamiltonian.exp() missing 1 required positional argument: 'a'" - ] - } - ], - "source": [ - "dbi(0.51, d = d_0.dense)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "024e0a4a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb b/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb index 91862c135a..f60fca73dc 100644 --- a/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb +++ b/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb @@ -85,7 +85,7 @@ "\n", "# Initialize with EvolutionOracleType hamiltonian_simulation\n", "input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = True\n", "c2 = input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2)\n", "assert np.linalg.norm( c2.unitary() - input_hamiltonian_evolution_oracle_hamiltonian_simulation.h.exp(2) ) < 1\n", diff --git a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb new file mode 100644 index 0000000000..624dd622a3 --- /dev/null +++ b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb @@ -0,0 +1,526 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e88ec634", + "metadata": {}, + "source": [ + "## This compares to DoubleBracketIteration whenever possible" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4ed280d7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-02-28 07:12:02]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "from qibo.hamiltonians import SymbolicHamiltonian\n", + "from qibo import symbols\n", + "from double_bracket_evolution_oracles import *\n", + "from group_commutator_iteration_transpiler import *\n", + "from numpy.linalg import norm\n", + "\"\"\"Test create evolution oracle\"\"\"\n", + "\n", + "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + "# Initialize with EvolutionOracleType hamiltonian_simulation so that d_0 is Delta\n", + "h_input = h_x + d_0\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "adb26c5e", + "metadata": {}, + "outputs": [], + "source": [ + "t_step = 0.0051#0.98#dbi.hyperopt_step()" + ] + }, + { + "cell_type": "markdown", + "id": "7e7e0a4f", + "metadata": {}, + "source": [ + "#### 1. DoubleBracketIteration and group commutator" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8a03c568", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-28 07:12:02]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "from double_bracket import *\n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.group_commutator" + ] + }, + { + "cell_type": "markdown", + "id": "a136181b", + "metadata": {}, + "source": [ + "DoubleBracketIteration only rotates the hamiltonian h, and currently doesn't give access to the unitary" + ] + }, + { + "cell_type": "markdown", + "id": "f8fe0eee", + "metadata": {}, + "source": [ + "Instead, we can wrap around the code executed in __call__" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "56ccf62a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-02-28 07:12:02]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "def wrapper_gc(self,step, d):\n", + " return (\n", + " self.h.exp(-step)\n", + " @ self.backend.calculate_matrix_exp(-step, d)\n", + " @ self.h.exp(step)\n", + " @ self.backend.calculate_matrix_exp(step, d)\n", + " )\n", + "unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),d_0.dense.matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "61699387", + "metadata": {}, + "outputs": [], + "source": [ + "dbi(t_step, d = d_0.dense.matrix)\n" + ] + }, + { + "cell_type": "markdown", + "id": "1e0884ba", + "metadata": {}, + "source": [ + "#### 2. Evolution oracle hamiltonian simulation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c9a9b4ef", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "78e4188a", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "72bdc7a7", + "metadata": {}, + "outputs": [], + "source": [ + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "98d982bc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.007067863925084279" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(unitary_gc_from_oracles['forwards'].unitary() - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8993f422", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.057067374464121946" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(unitary_gc_from_oracles['backwards'].unitary() - unitary_gc_existing)" + ] + }, + { + "cell_type": "markdown", + "id": "72010706", + "metadata": {}, + "source": [ + "#### 3. Evolution oracle numpy\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "762e0860", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_numerical = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_numerical ))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9bf85f00", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.numerical)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "14081ca6", + "metadata": {}, + "outputs": [], + "source": [ + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" + ] + }, + { + "cell_type": "markdown", + "id": "df014d55", + "metadata": {}, + "source": [ + "Compared to the group commutator using Hamiltonian simulation there will be small deviations that arise from Trotter-Suzuki decomposition" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5f5547de", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0040927048339044324" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(unitary_gc_from_oracles['backwards'] - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8e277576", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.057357576681930346" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" + ] + }, + { + "cell_type": "markdown", + "id": "c6066566", + "metadata": {}, + "source": [ + "We may check by switching the group commutator flag that the difference comes from ordering and inversions" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "38557c87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", + "\n", + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b976dfb7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d9a1a9f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31bd4a9e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7236de2a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e22d7b2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "791378c7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b282521c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8005bf94", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'GroupCommutatorIterationWithEvolutionOracles' object has no attribute 'group_commutator_query_list'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_187837/1460049839.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mused_circuit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step_duration, diagonal_association, mode_double_bracket_rotation)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 125\u001b[0m \u001b[0;31m# This will run the appropriate group commutator step\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 126\u001b[0;31m double_bracket_rotation_step = self.group_commutator_query_list(\n\u001b[0m\u001b[1;32m 127\u001b[0m \u001b[0mstep_duration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 128\u001b[0m )\n", + "\u001b[0;31mAttributeError\u001b[0m: 'GroupCommutatorIterationWithEvolutionOracles' object has no attribute 'group_commutator_query_list'" + ] + } + ], + "source": [ + "used_circuit = gci(t_step, diagonal_association= evolution_oracle_diagonal_target)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6af8fd94", + "metadata": {}, + "outputs": [], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + "gc_numpy = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4f78e3a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4d23962", + "metadata": {}, + "outputs": [], + "source": [ + "## Test more fancy functionalities\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", + "d_ev = EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "\n", + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + "query_list = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle= d_ev )\n", + "\n", + "norm(query_list['forwards'].unitary() -query_list['backwards'].unitary().conj().T)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e69dc0b", + "metadata": {}, + "outputs": [], + "source": [ + "norm(query_list['forwards'] -query_list['backwards'].T.conj())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfee7994", + "metadata": {}, + "outputs": [], + "source": [ + "#Test file entry\n", + "u = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", + "u2 = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", + "norm(u-u2.T.conj())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "527bb789", + "metadata": {}, + "outputs": [], + "source": [ + "d_0.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + "query_list = gci.group_commutator( np.sqrt(t_step*2),\n", + " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\"))\n", + "\n", + "\n", + "query_list['forwards']" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb deleted file mode 100644 index 0db78d51f6..0000000000 --- a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi in canonical mode.ipynb +++ /dev/null @@ -1,248 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 13, - "id": "4ed280d7", - "metadata": {}, - "outputs": [], - "source": [ - "from qibo.hamiltonians import SymbolicHamiltonian\n", - "from qibo import symbols\n", - "from double_bracket_evolution_oracles import *\n", - "from group_commutator_iteration_transpiler import *\n", - "from numpy.linalg import norm\n", - "\"\"\"Test create evolution oracle\"\"\"\n", - "\n", - "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - "# Initialize with EvolutionOracleType hamiltonian_simulation so that d_0 is Delta\n", - "h_input = h_x + d_0\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "8a03c568", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-08 07:00:12]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], - "source": [ - "from double_bracket import *\n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "2791ac7a", - "metadata": {}, - "outputs": [], - "source": [ - "t_step = 0.051#0.98#dbi.hyperopt_step()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "61699387", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "28.82580567725418" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dbi(t_step)\n", - "dbi.off_diagonal_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "2c922275", - "metadata": {}, - "outputs": [], - "source": [ - "## Test more fancy functionalities\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e5ef8593", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5.136025650750149e-16" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "u = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", - "u2 = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", - "norm(u-u2.T.conj())" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "69e80221", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'ZX-0.22583179581272428D00.22583179581272428ZX0.22583179581272428D0-0.22583179581272428'" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d_0.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - "query_list = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\"))\n", - "\n", - "\n", - "query_list['forwards']" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "8e865288", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-08 07:00:13]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-08 07:00:13]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "data": { - "text/plain": [ - "7.193109780637881e-16" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - "query_list = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))\n", - "\n", - "\n", - "norm(query_list['forwards'] -query_list['backwards'].T.conj())\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "6e5b8f90", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6.561656035791626e-16" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## Test more fancy functionalities\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", - "d_ev = EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "\n", - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - "query_list = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle= d_ev )\n", - "\n", - "norm(query_list['forwards'].unitary() -query_list['backwards'].unitary().conj().T)\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5ecb116a", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e8976eb8", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index e795709a7b..eb5e93b7d3 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -20,6 +20,8 @@ class DoubleBracketRotationType(Enum): group_commutator = auto() """Use group commutator approximation""" + group_commutator_other_sorting = auto() + """Use group commutator approximation""" group_commutator_reduced = auto() """Use group commutator approximation with a reduction using symmetry @@ -160,7 +162,8 @@ def group_commutator(self, if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): - return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ + return {'forwards': ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ diagonal_association_evolution_oracle.circuit(s_step)+ iterated_hamiltonian_evolution_oracle.circuit(s_step)+ diagonal_association_evolution_oracle.circuit(-s_step) @@ -183,7 +186,36 @@ def group_commutator(self, diagonal_association_evolution_oracle.circuit(-s_step)@ iterated_hamiltonian_evolution_oracle.circuit(s_step) ) } + elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_other_sorting: + assert diagonal_association_evolution_oracle.mode_evolution_oracle is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle + if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or + diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): + return {'forwards': ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ + diagonal_association_evolution_oracle.circuit(-s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(s_step)+ + diagonal_association_evolution_oracle.circuit(s_step) + ) , + 'backwards': ( #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(-s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ + diagonal_association_evolution_oracle.circuit(s_step)+ + iterated_hamiltonian_evolution_oracle.circuit(s_step) + ) } + elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: + return {'forwards': ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ + diagonal_association_evolution_oracle.circuit(-s_step)@ + iterated_hamiltonian_evolution_oracle.circuit(s_step)@ + diagonal_association_evolution_oracle.circuit(s_step) + ) , + 'backwards': ( #in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(-s_step)@ + iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ + diagonal_association_evolution_oracle.circuit(s_step)@ + iterated_hamiltonian_evolution_oracle.circuit(s_step) + ) } elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): From bfec99629bfa29d434aedbd284597bdb1f999db8 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 15:09:23 +0800 Subject: [PATCH 029/116] Complete the merge in docstring --- src/qibo/models/dbi/utils.py | 30 ++++++++++-------------------- 1 file changed, 10 insertions(+), 20 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 75e1fa6de7..52f8a33294 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -78,26 +78,16 @@ def select_best_dbr_generator( ): """Selects the best double bracket rotation generator from a list and runs the - Args: - dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. - d_list (list): list of diagonal operators (np.array) to run from. - step (float): fixed iteration duration. - Defaults to ``None``, uses hyperopt. - <<<<<<< HEAD - step_min (float): Minimally allowed iteration duration. - step_max (float): Maximally allowed iteration duration. - max_evals (int): Maximally allowed number of evaluation in hyperopt. - compare_canonical (bool): If `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - ======= - step_min (float): minimally allowed iteration duration. - step_max (float): maximally allowed iteration duration. - max_evals (int): maximally allowed number of evaluation in hyperopt. - compare_canonical (bool): if `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - mode (`DoubleBracketGeneratorType`): DBI generator type used for the selection. - >>>>>>> 056830fff9eedef0da2003a638ce4dbd30b6e3b8 - - Returns: - The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. + Args: + dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. + d_list (list): list of diagonal operators (np.array) to run from. + step (float): fixed iteration duration. + Defaults to ``None``, optimize with `scheduling` method and `choose_step` function. + compare_canonical (boolean): if `True`, the diagonalization effect with operators from `d_list` is compared with the canonical bracket. + scheduling (`DoubleBracketScheduling`): scheduling method for finding the optimal step. + + Returns: + The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. """ if scheduling is None: scheduling = dbi_object.scheduling From 54ced5bd2525c5322c305a7807ea50c414be9f7c Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 15:20:41 +0800 Subject: [PATCH 030/116] Remove `use` in scheduling names --- examples/dbi/dbi_scheduling.ipynb | 35 ++++++++++++++++++--------- src/qibo/models/dbi/double_bracket.py | 18 +++++++------- tests/test_models_dbi.py | 8 +++--- 3 files changed, 36 insertions(+), 25 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 275d2dea73..1f53822023 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -87,7 +87,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The default scheduling strategy is grid search: `DoubleBracketScheduling.use_grid_serach`. This strategy specifies a list of step durations to test one by one and finds the one that maximizes the cost function (off-digonal norm of Hamiltonian)" + "The default scheduling strategy is grid search: `DoubleBracketScheduling.\n", + "grid_serach`. This strategy specifies a list of step durations to test one by one and finds the one that maximizes the cost function (off-digonal norm of Hamiltonian)" ] }, { @@ -97,16 +98,26 @@ "outputs": [], "source": [ "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search)\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", "print('grid_search step:', step_grid)\n", "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, max_evals=100, step_max=0.6)\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, max_evals=100, step_max=0.6)\n", "print('hyperopt_search step:', step_hyperopt)\n", "# polynomial expansion\n", - "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=5)\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, n=5)\n", "print('polynomial_approximation step:', step_poly)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "step_poly = dbi.polynomial_step(n=5)\n", + "print(step_poly)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -169,15 +180,15 @@ "outputs": [], "source": [ "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_max=0.6, d=d)\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", "grid_min = dbi.loss(step=step_grid, d=d)-dbi.off_diagonal_norm\n", "print('grid_search step:', step_grid, 'loss', grid_min)\n", "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, d=d, max_evals=100, step_max=0.6)\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, d=d, max_evals=100, step_max=0.6)\n", "hyperopt_min = dbi.loss(step=step_hyperopt, d=d)-dbi.off_diagonal_norm\n", "print('hyperopt_search step:', step_hyperopt, 'loss', hyperopt_min)\n", "# polynomial expansion\n", - "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, d=d, n=5)\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=5)\n", "poly_min = dbi.loss(step=step_poly, d=d)-dbi.off_diagonal_norm\n", "print('polynomial_approximation step:', step_poly, 'loss', poly_min)" ] @@ -230,10 +241,10 @@ " step_min = step_poly - search_range/2\n", " step_max = step_poly + search_range/2\n", "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_min=step_min, step_max=step_max, d=d)\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_min=step_min, step_max=step_max, d=d)\n", "print('grid_search step:', step_grid)\n", "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, step_min=step_min, step_max=step_max, max_evals=100, d=d,)\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, step_min=step_min, step_max=step_max, max_evals=100, d=d,)\n", "print('hyperopt_search step:', step_hyperopt)" ] }, @@ -313,9 +324,9 @@ "outputs": [], "source": [ "NSTEPS = 8\n", - "scheduling_list = [DoubleBracketScheduling.use_grid_search,\n", - " DoubleBracketScheduling.use_hyperopt,\n", - " DoubleBracketScheduling.use_polynomial_approximation,]\n", + "scheduling_list = [DoubleBracketScheduling.grid_search,\n", + " DoubleBracketScheduling.hyperopt,\n", + " DoubleBracketScheduling.polynomial_approximation,]\n", "scheduling_labels = ['grid search',\n", " 'hyperopt',\n", " 'polynomial',]\n", diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 1d1d48d6c9..1dbfc50b56 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -25,11 +25,11 @@ class DoubleBracketGeneratorType(Enum): class DoubleBracketScheduling(Enum): """Define the DBI scheduling strategies.""" - use_hyperopt = auto() + hyperopt = auto() """Use hyperopt package.""" - use_grid_search = auto() + grid_search = auto() """Use greedy grid search.""" - use_polynomial_approximation = auto() + polynomial_approximation = auto() """Use polynomial expansion (analytical) of the loss function.""" @@ -61,7 +61,7 @@ def __init__( self, hamiltonian: Hamiltonian, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, - scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, + scheduling: DoubleBracketScheduling = DoubleBracketScheduling.grid_search, ): self.h = hamiltonian self.h0 = deepcopy(self.h) @@ -223,7 +223,7 @@ def polynomial_step( d = self.diagonal_h_matrix if backup_scheduling is None: - backup_scheduling = DoubleBracketScheduling.use_grid_search + backup_scheduling = DoubleBracketScheduling.grid_search def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) @@ -270,7 +270,7 @@ def Gamma(k: int): return min(real_positive_roots) # solution does not exist, resort to backup scheduling elif ( - backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation + backup_scheduling == DoubleBracketScheduling.polynomial_approximation and n < n_max + 1 ): return self.polynomial_step( @@ -287,11 +287,11 @@ def choose_step( ): if scheduling is None: scheduling = self.scheduling - if scheduling is DoubleBracketScheduling.use_grid_search: + if scheduling is DoubleBracketScheduling.grid_search: return self.grid_search_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.use_hyperopt: + if scheduling is DoubleBracketScheduling.hyperopt: return self.hyperopt_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.use_polynomial_approximation: + if scheduling is DoubleBracketScheduling.polynomial_approximation: return self.polynomial_step(d=d, **kwargs) def loss(self, step: float, d: np.array = None, look_ahead: int = 1): diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 07904c551e..a573c32088 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -112,7 +112,7 @@ def test_energy_fluctuations(backend): @pytest.mark.parametrize( "scheduling", - [DoubleBracketScheduling.use_grid_search, DoubleBracketScheduling.use_hyperopt], + [DoubleBracketScheduling.grid_search, DoubleBracketScheduling.hyperopt], ) @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_scheduling_grid_hyperopt( @@ -136,7 +136,7 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( @pytest.mark.parametrize("nqubits", [3, 4, 6]) @pytest.mark.parametrize("n", [2, 3]) @pytest.mark.parametrize( - "backup_scheduling", [None, DoubleBracketScheduling.use_polynomial_approximation] + "backup_scheduling", [None, DoubleBracketScheduling.polynomial_approximation] ) def test_double_bracket_iteration_scheduling_polynomial( backend, nqubits, n, backup_scheduling @@ -146,14 +146,14 @@ def test_double_bracket_iteration_scheduling_polynomial( dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, - scheduling=DoubleBracketScheduling.use_polynomial_approximation, + scheduling=DoubleBracketScheduling.polynomial_approximation, ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) dbi(d=d, step=step1) step2 = dbi.choose_step( - scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=n + scheduling=DoubleBracketScheduling.polynomial_approximation, n=n ) dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 4b9dc91c3acc7ca1aa9524e81341579cfc0ae105 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 15:31:04 +0800 Subject: [PATCH 031/116] Complete docstring; set default polynomial order to even number 4. --- src/qibo/models/dbi/double_bracket.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 1dbfc50b56..d017b32d7f 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -205,7 +205,7 @@ def hyperopt_step( def polynomial_step( self, - n: int = 3, + n: int = 4, n_max: int = 5, d: np.array = None, backup_scheduling: DoubleBracketScheduling = None, @@ -214,9 +214,10 @@ def polynomial_step( Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) Args: - n (int, optional): The order to which the loss function is expanded. Defaults to 3. - n_max (int, optional): The maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. - d (np.array, optional): The diagonal operator, default as $\delta(H)$. + n (int, optional): the order to which the loss function is expanded. Defaults to 4. + n_max (int, optional): maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. + d (np.array, optional): diagonal operator, default as $\delta(H)$. + backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. """ if d is None: @@ -259,6 +260,7 @@ def Gamma(k: int): product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + print(list(reversed(trace_coefficients[: n + 1]))) error = 1e-3 real_positive_roots = [ np.real(root) From 0c7199d6149fa4330008ace138fba132f3df2379 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Wed, 28 Feb 2024 08:40:14 +0100 Subject: [PATCH 032/116] for some reason the discretization eps doesn't imporve gc --- ...h evolution oracles vs existing dbi .ipynb | 209 ++++++++++++------ .../dbi/double_bracket_evolution_oracles.py | 12 +- .../group_commutator_iteration_transpiler.py | 16 +- 3 files changed, 164 insertions(+), 73 deletions(-) diff --git a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb index 624dd622a3..56eb407502 100644 --- a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb +++ b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "e88ec634", + "id": "3a0428df", "metadata": {}, "source": [ "## This compares to DoubleBracketIteration whenever possible" @@ -18,7 +18,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-02-28 07:12:02]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.5|INFO|2024-02-28 08:17:20]: Using qibojit (numba) backend on /CPU:0\n" ] } ], @@ -50,7 +50,7 @@ }, { "cell_type": "markdown", - "id": "7e7e0a4f", + "id": "fa707dfd", "metadata": {}, "source": [ "#### 1. DoubleBracketIteration and group commutator" @@ -66,7 +66,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 07:12:02]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-02-28 08:17:20]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -79,7 +79,7 @@ }, { "cell_type": "markdown", - "id": "a136181b", + "id": "5181f671", "metadata": {}, "source": [ "DoubleBracketIteration only rotates the hamiltonian h, and currently doesn't give access to the unitary" @@ -87,7 +87,7 @@ }, { "cell_type": "markdown", - "id": "f8fe0eee", + "id": "c6cd7c30", "metadata": {}, "source": [ "Instead, we can wrap around the code executed in __call__" @@ -96,14 +96,14 @@ { "cell_type": "code", "execution_count": 4, - "id": "56ccf62a", + "id": "f204bed7", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 07:12:02]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-02-28 08:17:20]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -130,7 +130,7 @@ }, { "cell_type": "markdown", - "id": "1e0884ba", + "id": "1649c99c", "metadata": {}, "source": [ "#### 2. Evolution oracle hamiltonian simulation\n" @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 30, "id": "c9a9b4ef", "metadata": {}, "outputs": [], @@ -151,8 +151,8 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "78e4188a", + "execution_count": 31, + "id": "3b757553", "metadata": {}, "outputs": [], "source": [ @@ -163,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 32, "id": "72bdc7a7", "metadata": {}, "outputs": [], @@ -174,17 +174,17 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "98d982bc", + "execution_count": 33, + "id": "1e75a4bf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.007067863925084279" + "0.007068588046085704" ] }, - "execution_count": 9, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -195,17 +195,17 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "8993f422", + "execution_count": 34, + "id": "84853d7a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.057067374464121946" + "0.05706730540522153" ] }, - "execution_count": 10, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -216,7 +216,103 @@ }, { "cell_type": "markdown", - "id": "72010706", + "id": "e4202b2c", + "metadata": {}, + "source": [ + "We may improve the discrepancy by setting smaller eps" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "275e2b48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "running discretization adjustment\n", + "3 5.703698185439878e-05\n", + "6 1.425710829003397e-05\n", + "12 3.5641435459211722e-06\n", + "24 8.910275418042565e-07\n", + "48 2.2275636394665562e-07\n", + "96 5.568905837658941e-08\n", + "running discretization adjustment\n", + "3 5.703698185442657e-05\n", + "6 1.4257108290027298e-05\n", + "12 3.5641435458984836e-06\n", + "24 8.910275417724017e-07\n", + "48 2.2275636393673975e-07\n", + "96 5.568905839345736e-08\n", + "running discretization adjustment\n", + "3 5.703698185439878e-05\n", + "6 1.425710829003397e-05\n", + "12 3.5641435459211722e-06\n", + "24 8.910275418042565e-07\n", + "48 2.2275636394665562e-07\n", + "96 5.568905837658941e-08\n", + "running discretization adjustment\n", + "3 5.703698185442657e-05\n", + "6 1.4257108290027298e-05\n", + "12 3.5641435458984836e-06\n", + "24 8.910275417724017e-07\n", + "48 2.2275636393673975e-07\n", + "96 5.568905839345736e-08\n" + ] + }, + { + "data": { + "text/plain": [ + "0.00706869515351788" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = 0.0000001\n", + "evolution_oracle_diagonal_target.eps_trottersuzuki = 0.00000001\n", + "gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = True\n", + "evolution_oracle_diagonal_target.please_be_verbose = False\n", + "\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "norm(unitary_gc_from_oracles['forwards'].unitary() - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "15be2e17", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.009965571871141131" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "norm(unitary_gc_from_oracles['backwards'].unitary() - unitary_gc_existing)" + ] + }, + { + "cell_type": "markdown", + "id": "24432d44", "metadata": {}, "source": [ "#### 3. Evolution oracle numpy\n" @@ -224,8 +320,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "762e0860", + "execution_count": 23, + "id": "cf131743", "metadata": {}, "outputs": [], "source": [ @@ -237,8 +333,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "9bf85f00", + "execution_count": 24, + "id": "f56c5eac", "metadata": {}, "outputs": [], "source": [ @@ -248,8 +344,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "14081ca6", + "execution_count": 25, + "id": "f8b0df99", "metadata": {}, "outputs": [], "source": [ @@ -259,7 +355,7 @@ }, { "cell_type": "markdown", - "id": "df014d55", + "id": "8108c4fd", "metadata": {}, "source": [ "Compared to the group commutator using Hamiltonian simulation there will be small deviations that arise from Trotter-Suzuki decomposition" @@ -267,8 +363,8 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "5f5547de", + "execution_count": 26, + "id": "efbf6f4a", "metadata": { "scrolled": true }, @@ -279,7 +375,7 @@ "0.0040927048339044324" ] }, - "execution_count": 15, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -290,8 +386,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "8e277576", + "execution_count": 27, + "id": "a470eee4", "metadata": {}, "outputs": [ { @@ -300,7 +396,7 @@ "0.057357576681930346" ] }, - "execution_count": 14, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -311,7 +407,7 @@ }, { "cell_type": "markdown", - "id": "c6066566", + "id": "a0e838f2", "metadata": {}, "source": [ "We may check by switching the group commutator flag that the difference comes from ordering and inversions" @@ -319,8 +415,8 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "38557c87", + "execution_count": 28, + "id": "5d188cc0", "metadata": {}, "outputs": [ { @@ -329,7 +425,7 @@ "0.0" ] }, - "execution_count": 23, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -345,7 +441,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b976dfb7", + "id": "da275227", "metadata": {}, "outputs": [], "source": [] @@ -353,7 +449,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9d9a1a9f", + "id": "4b17028f", "metadata": {}, "outputs": [], "source": [] @@ -361,7 +457,7 @@ { "cell_type": "code", "execution_count": null, - "id": "31bd4a9e", + "id": "6c24c01c", "metadata": {}, "outputs": [], "source": [] @@ -369,7 +465,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7236de2a", + "id": "c2298051", "metadata": {}, "outputs": [], "source": [] @@ -377,7 +473,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1e22d7b2", + "id": "9f8f03f4", "metadata": {}, "outputs": [], "source": [] @@ -385,7 +481,7 @@ { "cell_type": "code", "execution_count": null, - "id": "791378c7", + "id": "25279269", "metadata": {}, "outputs": [], "source": [] @@ -393,30 +489,17 @@ { "cell_type": "code", "execution_count": null, - "id": "b282521c", + "id": "5be7b4a3", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": 16, - "id": "8005bf94", + "execution_count": null, + "id": "ef1e0b8a", "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'GroupCommutatorIterationWithEvolutionOracles' object has no attribute 'group_commutator_query_list'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_187837/1460049839.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mused_circuit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step_duration, diagonal_association, mode_double_bracket_rotation)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 125\u001b[0m \u001b[0;31m# This will run the appropriate group commutator step\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 126\u001b[0;31m double_bracket_rotation_step = self.group_commutator_query_list(\n\u001b[0m\u001b[1;32m 127\u001b[0m \u001b[0mstep_duration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 128\u001b[0m )\n", - "\u001b[0;31mAttributeError\u001b[0m: 'GroupCommutatorIterationWithEvolutionOracles' object has no attribute 'group_commutator_query_list'" - ] - } - ], + "outputs": [], "source": [ "used_circuit = gci(t_step, diagonal_association= evolution_oracle_diagonal_target)" ] @@ -424,7 +507,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6af8fd94", + "id": "d669f931", "metadata": {}, "outputs": [], "source": [ diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index edb4c177c3..ca106fc666 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -60,13 +60,18 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.h.exp(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + if self.please_be_verbose: + print("Calling circuit in Hamiltonian simulation mode for time t=" +str(t_duration) +" and next running discretization adjustment to reach precision eps = " +str(self.eps_trottersuzuki)) return self.discretized_evolution_circuit( t_duration, eps = self.eps_trottersuzuki ) else: raise_error(ValueError, f"You are using an EvolutionOracle type which is not yet supported.") - def discretized_evolution_circuit( self, t_duration, eps = 0.05 ): + def discretized_evolution_circuit( self, t_duration, eps = None): nmb_trottersuzuki_steps = 3 + if eps is None: + eps = self.eps_trottersuzuki target_unitary = self.h.exp(t_duration) + from copy import deepcopy proposed_circuit_unitary = np.linalg.matrix_power(deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps).unitary(), nmb_trottersuzuki_steps) norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) if self.please_be_verbose: @@ -78,7 +83,8 @@ def discretized_evolution_circuit( self, t_duration, eps = 0.05 ): if self.please_be_verbose: print(nmb_trottersuzuki_steps, norm_difference ) from functools import reduce - combined_circuit = reduce(Circuit.__add__, [deepcopy(self.h).circuit(t_duration/nmb_trottersuzuki_steps)]*nmb_trottersuzuki_steps) + circuit_1_step = deepcopy(self.h.circuit(t_duration/nmb_trottersuzuki_steps)) + combined_circuit = reduce(Circuit.__add__, [circuit_1_step]*nmb_trottersuzuki_steps) assert np.linalg.norm( combined_circuit.unitary() - target_unitary ) < eps return combined_circuit @@ -135,7 +141,7 @@ class DoubleBracketDiagonalAssociationType(Enum): """Perform optimization to find best diagonal operator""" -class DiagonalAssociationDephasing(EvolutionOracle): +class DiagonalAssociationDephasingChannel(EvolutionOracle): def __init__( self, diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index eb5e93b7d3..a7f7bf7d2b 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -83,9 +83,11 @@ def __call__( mode_double_bracket_rotation: DoubleBracketRotationType = None, ): + #Set rotation type if mode_double_bracket_rotation is None: mode_double_bracket_rotation = self.mode_double_bracket_rotation - + + #Setup diagonal association if diagonal_association is None: if ( self.mode_diagonal_association @@ -93,23 +95,25 @@ def __call__( ): raise_error( NotImplementedError, - "diagonal_h_matrix is np.array but need to cast to SymbolicHamiltonian", + "diagonal_h_matrix is np.array but need to cast to SymbolicHamiltonian; need to find a way to take the diagonal of the internal matrix self. h and create a SymbolicHamiltonian out of that", ) diagonal_association = EvolutionOracle( - self.diagonal_h_matrix, + SymbolicHamiltonian( self.diagonal_h_matrix ), "Dephasing", mode_evolution_oracle=self.input_hamiltonian_evolution_oracle.mode_evolution_oracle, ) else: raise_error( ValueError, - f"Cannot use group_commutator without specifying matrix {d}. Did you want to set to canonical mode?", + f"Cannot use group_commutator without specifying the diagonal association. Did you want to set to canonical mode?", ) + else: self.mode_diagonal_association = ( DoubleBracketDiagonalAssociationType.prescribed ) + # Perform the rotation if ( self.mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator @@ -123,7 +127,7 @@ def __call__( ) else: # This will run the appropriate group commutator step - double_bracket_rotation_step = self.group_commutator_query_list( + double_bracket_rotation_step = self.group_commutator( step_duration, diagonal_association ) @@ -141,13 +145,11 @@ def __call__( before_circuit, after_circuit ) - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: raise_error(NotImplementedError) else: super().__call__(step, d ) - return before_circuit def group_commutator(self, s_step: float, From a2455cd5c28a7c708d5fb6eac150403a503a50cd Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Wed, 28 Feb 2024 08:49:12 +0100 Subject: [PATCH 033/116] for some reason the discretization eps doesn't imporve gc; fix bug on enum comparing line 164 --- ...h evolution oracles vs existing dbi .ipynb | 194 ++++++++++++------ .../group_commutator_iteration_transpiler.py | 2 +- 2 files changed, 135 insertions(+), 61 deletions(-) diff --git a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb index 56eb407502..b90754c1c5 100644 --- a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb +++ b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "3a0428df", + "id": "165fb962", "metadata": {}, "source": [ "## This compares to DoubleBracketIteration whenever possible" @@ -18,7 +18,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-02-28 08:17:20]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.5|INFO|2024-02-28 08:38:48]: Using qibojit (numba) backend on /CPU:0\n" ] } ], @@ -50,7 +50,7 @@ }, { "cell_type": "markdown", - "id": "fa707dfd", + "id": "5566710b", "metadata": {}, "source": [ "#### 1. DoubleBracketIteration and group commutator" @@ -66,7 +66,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 08:17:20]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-02-28 08:38:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -79,7 +79,7 @@ }, { "cell_type": "markdown", - "id": "5181f671", + "id": "6528f1df", "metadata": {}, "source": [ "DoubleBracketIteration only rotates the hamiltonian h, and currently doesn't give access to the unitary" @@ -87,7 +87,7 @@ }, { "cell_type": "markdown", - "id": "c6cd7c30", + "id": "656f7226", "metadata": {}, "source": [ "Instead, we can wrap around the code executed in __call__" @@ -96,14 +96,14 @@ { "cell_type": "code", "execution_count": 4, - "id": "f204bed7", + "id": "8000ad94", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 08:17:20]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-02-28 08:38:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -130,7 +130,7 @@ }, { "cell_type": "markdown", - "id": "1649c99c", + "id": "eaae3f92", "metadata": {}, "source": [ "#### 2. Evolution oracle hamiltonian simulation\n" @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 6, "id": "c9a9b4ef", "metadata": {}, "outputs": [], @@ -151,8 +151,8 @@ }, { "cell_type": "code", - "execution_count": 31, - "id": "3b757553", + "execution_count": 7, + "id": "251a9aaa", "metadata": {}, "outputs": [], "source": [ @@ -163,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 8, "id": "72bdc7a7", "metadata": {}, "outputs": [], @@ -174,8 +174,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "1e75a4bf", + "execution_count": 9, + "id": "1b867ee3", "metadata": {}, "outputs": [ { @@ -184,7 +184,7 @@ "0.007068588046085704" ] }, - "execution_count": 33, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -195,8 +195,8 @@ }, { "cell_type": "code", - "execution_count": 34, - "id": "84853d7a", + "execution_count": 10, + "id": "4249320a", "metadata": {}, "outputs": [ { @@ -205,7 +205,7 @@ "0.05706730540522153" ] }, - "execution_count": 34, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -216,7 +216,7 @@ }, { "cell_type": "markdown", - "id": "e4202b2c", + "id": "d19c7b59", "metadata": {}, "source": [ "We may improve the discrepancy by setting smaller eps" @@ -224,36 +224,36 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "275e2b48", + "execution_count": 11, + "id": "60191dd2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "running discretization adjustment\n", + "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", "3 5.703698185439878e-05\n", "6 1.425710829003397e-05\n", "12 3.5641435459211722e-06\n", "24 8.910275418042565e-07\n", "48 2.2275636394665562e-07\n", "96 5.568905837658941e-08\n", - "running discretization adjustment\n", + "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", "3 5.703698185442657e-05\n", "6 1.4257108290027298e-05\n", "12 3.5641435458984836e-06\n", "24 8.910275417724017e-07\n", "48 2.2275636393673975e-07\n", "96 5.568905839345736e-08\n", - "running discretization adjustment\n", + "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", "3 5.703698185439878e-05\n", "6 1.425710829003397e-05\n", "12 3.5641435459211722e-06\n", "24 8.910275418042565e-07\n", "48 2.2275636394665562e-07\n", "96 5.568905837658941e-08\n", - "running discretization adjustment\n", + "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", "3 5.703698185442657e-05\n", "6 1.4257108290027298e-05\n", "12 3.5641435458984836e-06\n", @@ -268,7 +268,7 @@ "0.00706869515351788" ] }, - "execution_count": 42, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -287,17 +287,51 @@ }, { "cell_type": "code", - "execution_count": 41, - "id": "15be2e17", + "execution_count": 12, + "id": "6cd42839", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", + "3 5.703698185439878e-05\n", + "6 1.425710829003397e-05\n", + "12 3.5641435459211722e-06\n", + "24 8.910275418042565e-07\n", + "48 2.2275636394665562e-07\n", + "96 5.568905837658941e-08\n", + "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", + "3 5.703698185442657e-05\n", + "6 1.4257108290027298e-05\n", + "12 3.5641435458984836e-06\n", + "24 8.910275417724017e-07\n", + "48 2.2275636393673975e-07\n", + "96 5.568905839345736e-08\n", + "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", + "3 5.703698185439878e-05\n", + "6 1.425710829003397e-05\n", + "12 3.5641435459211722e-06\n", + "24 8.910275418042565e-07\n", + "48 2.2275636394665562e-07\n", + "96 5.568905837658941e-08\n", + "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", + "3 5.703698185442657e-05\n", + "6 1.4257108290027298e-05\n", + "12 3.5641435458984836e-06\n", + "24 8.910275417724017e-07\n", + "48 2.2275636393673975e-07\n", + "96 5.568905839345736e-08\n" + ] + }, { "data": { "text/plain": [ "0.009965571871141131" ] }, - "execution_count": 41, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -312,7 +346,7 @@ }, { "cell_type": "markdown", - "id": "24432d44", + "id": "3a432c29", "metadata": {}, "source": [ "#### 3. Evolution oracle numpy\n" @@ -320,8 +354,8 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "cf131743", + "execution_count": 13, + "id": "d74c7f45", "metadata": {}, "outputs": [], "source": [ @@ -333,8 +367,8 @@ }, { "cell_type": "code", - "execution_count": 24, - "id": "f56c5eac", + "execution_count": 14, + "id": "687be448", "metadata": {}, "outputs": [], "source": [ @@ -344,8 +378,8 @@ }, { "cell_type": "code", - "execution_count": 25, - "id": "f8b0df99", + "execution_count": 15, + "id": "9e4dce92", "metadata": {}, "outputs": [], "source": [ @@ -355,7 +389,7 @@ }, { "cell_type": "markdown", - "id": "8108c4fd", + "id": "1bda6a3b", "metadata": {}, "source": [ "Compared to the group commutator using Hamiltonian simulation there will be small deviations that arise from Trotter-Suzuki decomposition" @@ -363,8 +397,8 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "efbf6f4a", + "execution_count": 16, + "id": "406b3e0c", "metadata": { "scrolled": true }, @@ -375,7 +409,7 @@ "0.0040927048339044324" ] }, - "execution_count": 26, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -386,8 +420,8 @@ }, { "cell_type": "code", - "execution_count": 27, - "id": "a470eee4", + "execution_count": 17, + "id": "e05a5407", "metadata": {}, "outputs": [ { @@ -396,7 +430,7 @@ "0.057357576681930346" ] }, - "execution_count": 27, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -407,7 +441,7 @@ }, { "cell_type": "markdown", - "id": "a0e838f2", + "id": "89ca2378", "metadata": {}, "source": [ "We may check by switching the group commutator flag that the difference comes from ordering and inversions" @@ -415,8 +449,8 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "5d188cc0", + "execution_count": 18, + "id": "dafb7da0", "metadata": {}, "outputs": [ { @@ -425,7 +459,7 @@ "0.0" ] }, - "execution_count": 28, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -441,7 +475,7 @@ { "cell_type": "code", "execution_count": null, - "id": "da275227", + "id": "06178c1e", "metadata": {}, "outputs": [], "source": [] @@ -449,7 +483,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4b17028f", + "id": "1648f1fe", "metadata": {}, "outputs": [], "source": [] @@ -457,7 +491,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6c24c01c", + "id": "df8bdfc3", "metadata": {}, "outputs": [], "source": [] @@ -465,7 +499,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c2298051", + "id": "91d84c18", "metadata": {}, "outputs": [], "source": [] @@ -473,7 +507,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9f8f03f4", + "id": "0a0d15ce", "metadata": {}, "outputs": [], "source": [] @@ -481,25 +515,65 @@ { "cell_type": "code", "execution_count": null, - "id": "25279269", + "id": "c7291936", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": null, - "id": "5be7b4a3", + "execution_count": 20, + "id": "1845d734", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.numerical)\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" + ] }, { "cell_type": "code", - "execution_count": null, - "id": "ef1e0b8a", + "execution_count": 25, + "id": "cdc92ec2", + "metadata": {}, + "outputs": [], + "source": [ + "assert evolution_oracle_hamiltonian_simulation.mode_evolution_oracle.value == 3" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "a6a3602e", "metadata": {}, "outputs": [], + "source": [ + "assert evolution_oracle_diagonal_target.mode_evolution_oracle.value == 2" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ba00110a", + "metadata": {}, + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_202260/1460049839.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mused_circuit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step_duration, diagonal_association, mode_double_bracket_rotation)\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[0;31m# This will run the appropriate group commutator step\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 130\u001b[0;31m double_bracket_rotation_step = self.group_commutator(\n\u001b[0m\u001b[1;32m 131\u001b[0m \u001b[0mstep_duration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 132\u001b[0m )\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36mgroup_commutator\u001b[0;34m(self, s_step, diagonal_association_evolution_oracle, iterated_hamiltonian_evolution_oracle)\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 163\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 165\u001b[0m if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], "source": [ "used_circuit = gci(t_step, diagonal_association= evolution_oracle_diagonal_target)" ] @@ -507,7 +581,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d669f931", + "id": "85492abe", "metadata": {}, "outputs": [], "source": [ diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index a7f7bf7d2b..e1d1f8ed3b 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -160,7 +160,7 @@ def group_commutator(self, iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: - assert diagonal_association_evolution_oracle.mode_evolution_oracle is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle + assert diagonal_association_evolution_oracle.mode_evolution_oracle.value is EvolutionOracleType. iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): From a84ba9a714224ec32b93ce81c2263ab9860d9eee Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Wed, 28 Feb 2024 09:11:48 +0100 Subject: [PATCH 034/116] iterating the oracle gci works (slowly because repetitions kick in) --- ...h evolution oracles vs existing dbi .ipynb | 339 +++++++++++++----- .../dbi/double_bracket_evolution_oracles.py | 3 +- .../group_commutator_iteration_transpiler.py | 2 +- 3 files changed, 261 insertions(+), 83 deletions(-) diff --git a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb index b90754c1c5..10f3e44093 100644 --- a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb +++ b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "165fb962", + "id": "238be0ba", "metadata": {}, "source": [ "## This compares to DoubleBracketIteration whenever possible" @@ -18,7 +18,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-02-28 08:38:48]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.5|INFO|2024-02-28 09:05:06]: Using qibojit (numba) backend on /CPU:0\n" ] } ], @@ -50,7 +50,7 @@ }, { "cell_type": "markdown", - "id": "5566710b", + "id": "1fda11ae", "metadata": {}, "source": [ "#### 1. DoubleBracketIteration and group commutator" @@ -66,7 +66,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 08:38:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-02-28 09:05:06]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -79,7 +79,7 @@ }, { "cell_type": "markdown", - "id": "6528f1df", + "id": "9b120dcf", "metadata": {}, "source": [ "DoubleBracketIteration only rotates the hamiltonian h, and currently doesn't give access to the unitary" @@ -87,7 +87,7 @@ }, { "cell_type": "markdown", - "id": "656f7226", + "id": "fe8d0ee3", "metadata": {}, "source": [ "Instead, we can wrap around the code executed in __call__" @@ -96,14 +96,14 @@ { "cell_type": "code", "execution_count": 4, - "id": "8000ad94", + "id": "2b85bdfa", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 08:38:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-02-28 09:05:06]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -130,7 +130,7 @@ }, { "cell_type": "markdown", - "id": "eaae3f92", + "id": "b3b2d4bd", "metadata": {}, "source": [ "#### 2. Evolution oracle hamiltonian simulation\n" @@ -152,7 +152,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "251a9aaa", + "id": "76844c6d", "metadata": {}, "outputs": [], "source": [ @@ -164,6 +164,18 @@ { "cell_type": "code", "execution_count": 8, + "id": "edc1fc41", + "metadata": {}, + "outputs": [], + "source": [ + "assert evolution_oracle_diagonal_target.mode_evolution_oracle.value is gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "id": "72bdc7a7", "metadata": {}, "outputs": [], @@ -174,8 +186,8 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "1b867ee3", + "execution_count": 10, + "id": "4dc00e21", "metadata": {}, "outputs": [ { @@ -184,7 +196,7 @@ "0.007068588046085704" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -195,8 +207,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "4249320a", + "execution_count": 11, + "id": "46c4b173", "metadata": {}, "outputs": [ { @@ -205,7 +217,7 @@ "0.05706730540522153" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -216,7 +228,7 @@ }, { "cell_type": "markdown", - "id": "d19c7b59", + "id": "e6bc1b3d", "metadata": {}, "source": [ "We may improve the discrepancy by setting smaller eps" @@ -224,8 +236,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "60191dd2", + "execution_count": 12, + "id": "c65c042b", "metadata": {}, "outputs": [ { @@ -268,7 +280,7 @@ "0.00706869515351788" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -287,8 +299,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "6cd42839", + "execution_count": 13, + "id": "067d7288", "metadata": {}, "outputs": [ { @@ -331,7 +343,7 @@ "0.009965571871141131" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -346,7 +358,7 @@ }, { "cell_type": "markdown", - "id": "3a432c29", + "id": "fe089127", "metadata": {}, "source": [ "#### 3. Evolution oracle numpy\n" @@ -354,8 +366,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "d74c7f45", + "execution_count": 14, + "id": "5d92342a", "metadata": {}, "outputs": [], "source": [ @@ -367,8 +379,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "687be448", + "execution_count": 15, + "id": "c7dfce82", "metadata": {}, "outputs": [], "source": [ @@ -378,8 +390,8 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "9e4dce92", + "execution_count": 16, + "id": "1c7abdf1", "metadata": {}, "outputs": [], "source": [ @@ -389,7 +401,7 @@ }, { "cell_type": "markdown", - "id": "1bda6a3b", + "id": "994704b9", "metadata": {}, "source": [ "Compared to the group commutator using Hamiltonian simulation there will be small deviations that arise from Trotter-Suzuki decomposition" @@ -397,8 +409,8 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "406b3e0c", + "execution_count": 17, + "id": "7a289f6b", "metadata": { "scrolled": true }, @@ -409,7 +421,7 @@ "0.0040927048339044324" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -420,8 +432,8 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "e05a5407", + "execution_count": 18, + "id": "b51b35e0", "metadata": {}, "outputs": [ { @@ -430,7 +442,7 @@ "0.057357576681930346" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -441,7 +453,7 @@ }, { "cell_type": "markdown", - "id": "89ca2378", + "id": "254a2d48", "metadata": {}, "source": [ "We may check by switching the group commutator flag that the difference comes from ordering and inversions" @@ -449,8 +461,8 @@ }, { "cell_type": "code", - "execution_count": 18, - "id": "dafb7da0", + "execution_count": 19, + "id": "c95fe6a2", "metadata": {}, "outputs": [ { @@ -459,7 +471,7 @@ "0.0" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -472,92 +484,216 @@ "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" ] }, + { + "cell_type": "markdown", + "id": "32ae7052", + "metadata": {}, + "source": [ + "#### 4. Check gci rotation" + ] + }, { "cell_type": "code", - "execution_count": null, - "id": "06178c1e", + "execution_count": 20, + "id": "11b5bcd2", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" + ] }, { "cell_type": "code", - "execution_count": null, - "id": "1648f1fe", + "execution_count": 21, + "id": "cc65f36b", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "qibo.models.dbi.double_bracket_evolution_oracles.EvolutionOracle" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(gci.iterated_hamiltonian_evolution_oracle)" + ] }, { "cell_type": "code", - "execution_count": null, - "id": "df8bdfc3", + "execution_count": 22, + "id": "ed9fc128", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" + ] }, { "cell_type": "code", - "execution_count": null, - "id": "91d84c18", + "execution_count": 23, + "id": "d096b97f", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "qibo.models.dbi.double_bracket_evolution_oracles.FrameShiftedEvolutionOracle" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(gci.iterated_hamiltonian_evolution_oracle)" + ] }, { "cell_type": "code", - "execution_count": null, - "id": "0a0d15ce", + "execution_count": 24, + "id": "24d7c169", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle" + ] }, { "cell_type": "code", - "execution_count": null, - "id": "c7291936", + "execution_count": 25, + "id": "2977472f", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()" + ] }, { "cell_type": "code", - "execution_count": 20, - "id": "1845d734", + "execution_count": 26, + "id": "ee01d03d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.599372836877071e-06" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( dbi.h.exp(t_step) - u_frame_shifted)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "eb70162a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "a3a57fbe", "metadata": {}, "outputs": [], "source": [ - "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.numerical)\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" + "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" ] }, { "cell_type": "code", - "execution_count": 25, - "id": "cdc92ec2", + "execution_count": 29, + "id": "1dba0755", "metadata": {}, "outputs": [], "source": [ - "assert evolution_oracle_hamiltonian_simulation.mode_evolution_oracle.value == 3" + "dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)" ] }, { "cell_type": "code", - "execution_count": 27, - "id": "a6a3602e", + "execution_count": 30, + "id": "a22a77e0", "metadata": {}, "outputs": [], "source": [ - "assert evolution_oracle_diagonal_target.mode_evolution_oracle.value == 2" + "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()\n" ] }, { "cell_type": "code", - "execution_count": 21, - "id": "ba00110a", + "execution_count": 32, + "id": "6d8b5fe7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.6001822532601247e-06" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( dbi.h.exp(t_step) - u_frame_shifted)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56b3e69c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "a1e61678", "metadata": {}, "outputs": [ { @@ -567,23 +703,64 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_202260/1460049839.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mused_circuit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_207231/3626348486.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mu_frame_shifted\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step_duration, diagonal_association, mode_double_bracket_rotation)\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[0;31m# This will run the appropriate group commutator step\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 130\u001b[0;31m double_bracket_rotation_step = self.group_commutator(\n\u001b[0m\u001b[1;32m 131\u001b[0m \u001b[0mstep_duration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 132\u001b[0m )\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36mgroup_commutator\u001b[0;34m(self, s_step, diagonal_association_evolution_oracle, iterated_hamiltonian_evolution_oracle)\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 163\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 165\u001b[0m if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36mgroup_commutator\u001b[0;34m(self, s_step, diagonal_association_evolution_oracle, iterated_hamiltonian_evolution_oracle)\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 163\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 165\u001b[0m if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or\n", "\u001b[0;31mAssertionError\u001b[0m: " ] } ], "source": [ - "used_circuit = gci(t_step, diagonal_association= evolution_oracle_diagonal_target)" + "for k in range(3):\n", + " gci(t_step, diagonal_association=evolution_oracle_diagonal_target)\n", + " dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)\n", + " norm( dbi.h.exp(t_step) - u_frame_shifted)" ] }, { "cell_type": "code", "execution_count": null, - "id": "85492abe", + "id": "4ca65c6d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c20a4c48", "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d722192", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "389d7bbe", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "matmul: Input operand 0 does not have enough dimensions (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_207231/916023419.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m gc_numpy = gci.group_commutator( np.sqrt(t_step),\n\u001b[0m\u001b[1;32m 3\u001b[0m diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36mgroup_commutator\u001b[0;34m(self, s_step, diagonal_association_evolution_oracle, iterated_hamiltonian_evolution_oracle)\u001b[0m\n\u001b[1;32m 178\u001b[0m ) }\n\u001b[1;32m 179\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)@\n\u001b[0m\u001b[1;32m 181\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m@\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m@\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibo/models/dbi/double_bracket_evolution_oracles.py\u001b[0m in \u001b[0;36mcircuit\u001b[0;34m(self, t_duration)\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"(\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_duration\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\")\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbefore_circuit\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_duration\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mafter_circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 120\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhamiltonian_simulation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbefore_circuit\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbase_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_duration\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mafter_circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: matmul: Input operand 0 does not have enough dimensions (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)" + ] + } + ], "source": [ "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", "gc_numpy = gci.group_commutator( np.sqrt(t_step),\n", diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index ca106fc666..d01084e4f4 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -17,7 +17,7 @@ class EvolutionOracleType(Enum): hamiltonian_simulation = auto() """If you will use SymbolicHamiltonian""" - + class EvolutionOracle: def __init__( @@ -104,6 +104,7 @@ def __init__( # assert type(before_circuit) is Circuit, str(type(before_circuit)) self.h = base_evolution_oracle.h + self.base_evolution_oracle = base_evolution_oracle self.name = name + "(" + base_evolution_oracle.name + ")" self.mode_evolution_oracle = base_evolution_oracle.mode_evolution_oracle self.before_circuit = before_circuit diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index e1d1f8ed3b..663d4583b2 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -160,7 +160,7 @@ def group_commutator(self, iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: - assert diagonal_association_evolution_oracle.mode_evolution_oracle.value is EvolutionOracleType. iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value + assert diagonal_association_evolution_oracle.mode_evolution_oracle.value is self.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): From 745d407e54114c44cea0826e9adb57b14a3c4124 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 28 Feb 2024 08:20:59 +0000 Subject: [PATCH 035/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../dbi/double_bracket_evolution_oracles.py | 38 ++- .../group_commutator_iteration_transpiler.py | 258 +++++++++++------- 2 files changed, 182 insertions(+), 114 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index a2242e53e0..b3fb420901 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -17,7 +17,7 @@ class EvolutionOracleType(Enum): hamiltonian_simulation = auto() """If you will use SymbolicHamiltonian""" - + class EvolutionOracle: def __init__( @@ -63,12 +63,22 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: if self.please_be_verbose: - print("Calling circuit in Hamiltonian simulation mode for time t=" +str(t_duration) +" and next running discretization adjustment to reach precision eps = " +str(self.eps_trottersuzuki)) - return self.discretized_evolution_circuit( t_duration, eps = self.eps_trottersuzuki ) + print( + "Calling circuit in Hamiltonian simulation mode for time t=" + + str(t_duration) + + " and next running discretization adjustment to reach precision eps = " + + str(self.eps_trottersuzuki) + ) + return self.discretized_evolution_circuit( + t_duration, eps=self.eps_trottersuzuki + ) else: - raise_error(ValueError, - f"You are using an EvolutionOracle type which is not yet supported.") - def discretized_evolution_circuit( self, t_duration, eps = None): + raise_error( + ValueError, + f"You are using an EvolutionOracle type which is not yet supported.", + ) + + def discretized_evolution_circuit(self, t_duration, eps=None): nmb_trottersuzuki_steps = 3 if eps is None: @@ -76,8 +86,12 @@ def discretized_evolution_circuit( self, t_duration, eps = None): target_unitary = self.h.exp(t_duration) from copy import deepcopy - proposed_circuit_unitary = np.linalg.matrix_power(deepcopy(self.h.circuit(t_duration/nmb_trottersuzuki_steps)).unitary(), nmb_trottersuzuki_steps) - norm_difference = np.linalg.norm( target_unitary - proposed_circuit_unitary) + + proposed_circuit_unitary = np.linalg.matrix_power( + deepcopy(self.h.circuit(t_duration / nmb_trottersuzuki_steps)).unitary(), + nmb_trottersuzuki_steps, + ) + norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) if self.please_be_verbose: print(nmb_trottersuzuki_steps, norm_difference) @@ -94,9 +108,11 @@ def discretized_evolution_circuit( self, t_duration, eps = None): print(nmb_trottersuzuki_steps, norm_difference) from functools import reduce - circuit_1_step = deepcopy(self.h.circuit(t_duration/nmb_trottersuzuki_steps)) - combined_circuit = reduce(Circuit.__add__, [circuit_1_step]*nmb_trottersuzuki_steps) - assert np.linalg.norm( combined_circuit.unitary() - target_unitary ) < eps + circuit_1_step = deepcopy(self.h.circuit(t_duration / nmb_trottersuzuki_steps)) + combined_circuit = reduce( + Circuit.__add__, [circuit_1_step] * nmb_trottersuzuki_steps + ) + assert np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps return combined_circuit diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 3ec75e83ae..815f93ea02 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -83,11 +83,11 @@ def __call__( mode_double_bracket_rotation: DoubleBracketRotationType = None, ): - #Set rotation type + # Set rotation type if mode_double_bracket_rotation is None: mode_double_bracket_rotation = self.mode_double_bracket_rotation - - #Setup diagonal association + + # Setup diagonal association if diagonal_association is None: if ( self.mode_diagonal_association @@ -98,7 +98,7 @@ def __call__( "diagonal_h_matrix is np.array but need to cast to SymbolicHamiltonian; need to find a way to take the diagonal of the internal matrix self. h and create a SymbolicHamiltonian out of that", ) diagonal_association = EvolutionOracle( - SymbolicHamiltonian( self.diagonal_h_matrix ), + SymbolicHamiltonian(self.diagonal_h_matrix), "Dephasing", mode_evolution_oracle=self.input_hamiltonian_evolution_oracle.mode_evolution_oracle, ) @@ -139,23 +139,25 @@ def __call__( after_circuit = double_bracket_rotation_step["forwards"] self.h.matrix = before_circuit @ self.h.matrix @ after_circuit + elif ( + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + before_circuit = double_bracket_rotation_step["backwards"] + after_circuit = double_bracket_rotation_step["forwards"] + self.iterated_hamiltonian_evolution_oracle = ( + FrameShiftedEvolutionOracle( + deepcopy(self.iterated_hamiltonian_evolution_oracle), + str(step_duration), + before_circuit, + after_circuit, + ) + ) - elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - before_circuit = double_bracket_rotation_step['backwards'] - after_circuit = double_bracket_rotation_step['forwards'] - self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - deepcopy(self.iterated_hamiltonian_evolution_oracle), - str(step_duration), - before_circuit, - after_circuit - ) - - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: + elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: raise_error(NotImplementedError) else: - super().__call__(step, d ) - - + super().__call__(step, d) def group_commutator( self, @@ -166,92 +168,142 @@ def group_commutator( if iterated_hamiltonian_evolution_oracle is None: - iterated_hamiltonian_evolution_oracle = self.iterated_hamiltonian_evolution_oracle - - if self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator: - assert diagonal_association_evolution_oracle.mode_evolution_oracle.value is self.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value - - if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or - diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): - return {'forwards': ( - iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step) - ) } - elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step) - ) } - elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_other_sorting: - assert diagonal_association_evolution_oracle.mode_evolution_oracle is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle - - if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or - diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): - return {'forwards': ( - iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step)+ - diagonal_association_evolution_oracle.circuit(s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(-s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step) - ) } - elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - return {'forwards': ( - iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step)@ - diagonal_association_evolution_oracle.circuit(s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(-s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step) - ) } - elif self.mode_double_bracket_rotation is DoubleBracketRotationType.group_commutator_reduced: - if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or - diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation): - return {'forwards': ( - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)+ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)+ - diagonal_association_evolution_oracle.circuit(-s_step) - ) } - elif diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical: - return {'forwards': ( - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step) - ) , - 'backwards': ( #in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step)@ - iterated_hamiltonian_evolution_oracle.circuit(-s_step)@ - diagonal_association_evolution_oracle.circuit(-s_step) - ) } + iterated_hamiltonian_evolution_oracle = ( + self.iterated_hamiltonian_evolution_oracle + ) + + if ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.group_commutator + ): + assert ( + diagonal_association_evolution_oracle.mode_evolution_oracle.value + is self.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value + ) + if ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.text_strings + or diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + return { + "forwards": ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + ), + } + elif ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical + ): + return { + "forwards": ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + ), + } + elif ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.group_commutator_other_sorting + ): + assert ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle + ) + + if ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.text_strings + or diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + return { + "forwards": ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + + diagonal_association_evolution_oracle.circuit(s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(-s_step) + + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + ), + } + elif ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical + ): + return { + "forwards": ( + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + @ diagonal_association_evolution_oracle.circuit(s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(-s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + ), + } + elif ( + self.mode_double_bracket_rotation + is DoubleBracketRotationType.group_commutator_reduced + ): + if ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.text_strings + or diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + return { + "forwards": ( + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + + iterated_hamiltonian_evolution_oracle.circuit(-s_step) + + diagonal_association_evolution_oracle.circuit(-s_step) + ), + } + elif ( + diagonal_association_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical + ): + return { + "forwards": ( + diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + ), + "backwards": ( # in general an evolution oracle might have imperfect time reversal + diagonal_association_evolution_oracle.circuit(s_step) + @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) + @ diagonal_association_evolution_oracle.circuit(-s_step) + ), + } else: if ( From 412451987f2f1e80fa7cbed08406a1b1ab9bad8f Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 17:15:09 +0800 Subject: [PATCH 036/116] Added documentation + test of effect of n_taylor --- .../dbi/dbi_strategy_magnetic_field.ipynb | 83 +++++++++++++++++++ src/qibo/models/dbi/double_bracket.py | 3 + src/qibo/models/dbi/utils.py | 56 +++++++++++-- 3 files changed, 133 insertions(+), 9 deletions(-) diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index 40e46f422a..8ab8207500 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -300,6 +300,89 @@ "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')\n", "plt.legend()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Effect of `n_taylor`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", \"numba\")\n", + "# initialize dbi object\n", + "nqubits = 5\n", + "h0 = random_hermitian(2**nqubits, seed=2)\n", + "scheduling = DoubleBracketScheduling.hyperopt\n", + "mode = DoubleBracketGeneratorType.single_commutator\n", + "n_1 = 5\n", + "n_2 = 2\n", + "dbi_1 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", + "dbi_2 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", + "print(\"Initial off diagonal norm\", dbi_1.off_diagonal_norm)\n", + "visualize_matrix(dbi_1.h.matrix, title=f'Random hamiltonian with L={nqubits}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate the onsite Z operators\n", + "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", + "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", + "grad, s = gradient_onsite_Z(dbi,d,5, onsite_Z_ops)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "iters = 30\n", + "d_coef_1, d_1 = d_coef, d\n", + "d_coef_2, d_2 = d_coef, d\n", + "\n", + "off_diagonal_norm_1 = [dbi_1.off_diagonal_norm]\n", + "off_diagonal_norm_2 = [dbi_2.off_diagonal_norm]\n", + "s_step_1 = [0]\n", + "s_step_2 = [0]\n", + "for i in range(iters):\n", + " s_1, d_coef_1, d_1 = gradient_descent_onsite_Z(dbi_1, d_coef_1, d_1, onsite_Z_ops=onsite_Z_ops, n_taylor=n_1, max_evals=100)\n", + " s_2, d_coef_2, d_2 = gradient_descent_onsite_Z(dbi_2, d_coef_2, d_2, onsite_Z_ops=onsite_Z_ops, n_taylor=n_2, max_evals=100)\n", + " dbi_1(step=s_1, d=d_1)\n", + " dbi_2(step=s_2, d=d_2)\n", + " off_diagonal_norm_1.append(dbi_1.off_diagonal_norm)\n", + " off_diagonal_norm_2.append(dbi_2.off_diagonal_norm)\n", + " s_step_1.append(s_1)\n", + " s_step_2.append(s_2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", + "plt.plot(off_diagonal_norm_1, label=f'n_taylor={n_1}')\n", + "plt.plot(off_diagonal_norm_2, label=f'n_taylor={n_2}')\n", + "plt.legend()\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index e75fa16a21..46b8112712 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -280,6 +280,9 @@ def choose_step( scheduling: Optional[DoubleBracketScheduling] = None, **kwargs, ): + """ + Calculate the optimal step using respective `scheduling` methods. + """ if scheduling is None: scheduling = self.scheduling if scheduling is DoubleBracketScheduling.grid_search: diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 3ac26d0225..d179d45a4d 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -187,10 +187,19 @@ def ds_di_onsite_Z( dbi_object: DoubleBracketIteration, d: np.array, i: int, - taylor_coef=None, - onsite_Z_ops=None, + taylor_coef: Optional[list] = None, + onsite_Z_ops: Optional[list] = None, ): - """Return the derivatives of the first 3 polynomial coefficients with respect to onsite Pauli-Z coefficients""" + r"""Return the derivatives of the first 3 polynomial coefficients with respect to onsite Pauli-Z coefficients\ + Args: + dbi_object (DoubleBracketIteration): the target dbi object + d (np.array): the diagonal operator + i (int): the index of onsite-Z coefficient + taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}`, from the highest order to the lowest. + onsite_Z_ops (list): onsite Z operators of `dbi_object.h` + Returns: + floats da, db, dc, ds + """ # generate the list of derivatives w.r.t ith Z operator coefficient nqubits = int(np.log2(d.shape[0])) if onsite_Z_ops is None: @@ -227,11 +236,18 @@ def derivative_product(k1, k2): def gradient_onsite_Z( dbi_object: DoubleBracketIteration, d: np.array, - n_taylor=3, + n_taylor=2, onsite_Z_ops=None, use_ds=False, ): - """Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients""" + r"""Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients + Args: + dbi_object (DoubleBracketIteration): the target dbi object + d (np.array): the diagonal operator + n_taylor (int): the highest order of the taylore expansion of w.r.t `s` + taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}` + use_ds (boolean): if False, ds is set to 0 + """ # n is the highest order for calculating s # initialize gradient @@ -244,6 +260,7 @@ def gradient_onsite_Z( n=n_taylor, backup_scheduling=DoubleBracketScheduling.polynomial_approximation, ) + a, b, c = coef[len(coef) - 3 :] for i in range(nqubits): da, db, dc, ds = ds_di_onsite_Z(dbi_object, d, i, [a, b, c], onsite_Z_ops) @@ -263,6 +280,7 @@ def gradient_onsite_Z( def onsite_Z_decomposition(h_matrix: np.array, onsite_Z_ops=None): + """finds the decomposition of hamiltonian `h_matrix` into Pauli-Z operators""" nqubits = int(np.log2(h_matrix.shape[0])) if onsite_Z_ops is None: onsite_Z_ops = generate_onsite_Z_ops(nqubits) @@ -274,6 +292,7 @@ def onsite_Z_decomposition(h_matrix: np.array, onsite_Z_ops=None): def generate_onsite_Z_ops(nqubits): + """generate the list of Pauli-Z operators of an `nqubit` system in the form of np.array""" onsite_Z_str = ["I" * (i) + "Z" + "I" * (nqubits - i - 1) for i in range(nqubits)] onsite_Z_ops = [ SymbolicHamiltonian(str_to_symbolic(Z_i_str)).dense.matrix @@ -285,18 +304,37 @@ def generate_onsite_Z_ops(nqubits): def gradient_descent_onsite_Z( dbi_object: DoubleBracketIteration, d_coef: list, - d: np.array = None, - n_taylor: int = 3, - onsite_Z_ops=None, + d: Optional[np.array] = None, + n_taylor: int = 2, + onsite_Z_ops: Optional[list] = None, lr_min: float = 1e-5, lr_max: float = 1, max_evals: int = 100, space: callable = None, optimizer: callable = None, - look_ahead: int = 1, verbose: bool = False, use_ds: bool = True, ): + """calculate the elements of one gradient descent step on `dbi_object`. + + Args: + dbi_object (DoubleBracketIteration): the target dbi object + d_coef (list): the initial decomposition of `d` into Pauli-Z operators + d (np.array, optional): the initial diagonal operator. Defaults to None. + n_taylor (int, optional): the highest order to expand the loss function derivative. Defaults to 2. + onsite_Z_ops (list, optional): list of onsite-Z operators. Defaults to None. + lr_min (float, optional): the minimal gradient step. Defaults to 1e-5. + lr_max (float, optional): the maximal gradient step. Defaults to 1. + max_evals (int, optional): the max number of evaluations for `hyperopt` to find the optimal gradient step `lr`. Defaults to 100. + space (callable, optional): the search space for `hyperopt`. Defaults to None. + optimizer (callable, optional): optimizer for `hyperopt`. Defaults to None. + verbose (bool, optional): option to print out the 'hyperopt' progress. Defaults to False. + use_ds (bool, optional): if False, ds is set to 0. Defaults to True. + + Returns: + the optimal step found, coeffcients of `d` in Pauli-Z basis, matrix of `d` + + """ nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) if onsite_Z_ops is None: onsite_Z_ops = generate_onsite_Z_ops(nqubits) From c5ab13e2f5e8c5f011686d925f091213dc4f53e4 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 18:16:14 +0800 Subject: [PATCH 037/116] Remove print line --- src/qibo/models/dbi/double_bracket.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index d017b32d7f..2c160ea525 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -260,7 +260,6 @@ def Gamma(k: int): product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) - print(list(reversed(trace_coefficients[: n + 1]))) error = 1e-3 real_positive_roots = [ np.real(root) From 3bdee0f67597f82c3023804d0ae8b5077511fd14 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 19:25:47 +0800 Subject: [PATCH 038/116] Test coverage for the branch --- src/qibo/models/dbi/utils.py | 3 +- tests/test_models_dbi_utils 2.py | 50 -------------------------------- tests/test_models_dbi_utils.py | 49 ++++++++++++++++++++++++++++++- 3 files changed, 50 insertions(+), 52 deletions(-) delete mode 100644 tests/test_models_dbi_utils 2.py diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index d179d45a4d..8a185dfe06 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -236,8 +236,8 @@ def derivative_product(k1, k2): def gradient_onsite_Z( dbi_object: DoubleBracketIteration, d: np.array, + onsite_Z_ops, n_taylor=2, - onsite_Z_ops=None, use_ds=False, ): r"""Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients @@ -245,6 +245,7 @@ def gradient_onsite_Z( dbi_object (DoubleBracketIteration): the target dbi object d (np.array): the diagonal operator n_taylor (int): the highest order of the taylore expansion of w.r.t `s` + onsite_Z_ops (list): list of Pauli-Z operators taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}` use_ds (boolean): if False, ds is set to 0 """ diff --git a/tests/test_models_dbi_utils 2.py b/tests/test_models_dbi_utils 2.py deleted file mode 100644 index cd9f74e9de..0000000000 --- a/tests/test_models_dbi_utils 2.py +++ /dev/null @@ -1,50 +0,0 @@ -""""Testing utils for DoubleBracketIteration model""" - -import numpy as np -import pytest - -from qibo import set_backend -from qibo.hamiltonians import Hamiltonian -from qibo.models.dbi.double_bracket import ( - DoubleBracketGeneratorType, - DoubleBracketIteration, -) -from qibo.models.dbi.utils import * -from qibo.quantum_info import random_hermitian - -NSTEPS = 5 -"""Number of steps for evolution.""" - - -@pytest.mark.parametrize("nqubits", [3, 4, 5]) -def test_generate_Z_operators(backend, nqubits): - h0 = random_hermitian(2**nqubits) - dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) - generate_Z = generate_Z_operators(nqubits) - Z_ops = list(generate_Z.values()) - - delta_h0 = dbi.diagonal_h_matrix - dephasing_channel = (sum([Z_op @ h0 @ Z_op for Z_op in Z_ops]) + h0) / 2**nqubits - norm_diff = np.linalg.norm(delta_h0 - dephasing_channel) - - assert norm_diff < 1e-3 - - -@pytest.mark.parametrize("nqubits", [3, 4, 5]) -@pytest.mark.parametrize("step", [0.1, None]) -def test_select_best_dbr_generator(backend, nqubits, step): - h0 = random_hermitian(2**nqubits, seed=1, backend=backend) - dbi = DoubleBracketIteration( - Hamiltonian(nqubits, h0, backend=backend), - mode=DoubleBracketGeneratorType.single_commutator, - ) - generate_Z = generate_Z_operators(nqubits) - Z_ops = list(generate_Z.values()) - initial_off_diagonal_norm = dbi.off_diagonal_norm - - for _ in range(NSTEPS): - dbi, idx, step_optimize, flip = select_best_dbr_generator( - dbi, Z_ops, step=step, compare_canonical=True - ) - - assert initial_off_diagonal_norm > dbi.off_diagonal_norm diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index a05266e1de..fe202ee877 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -16,7 +16,7 @@ @pytest.mark.parametrize("nqubits", [2, 3]) -def test_generate_Z_operators(backend, nqubits): +def test_generate_Z_operators(nqubits): h0 = random_hermitian(2**nqubits) dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) generate_Z = generate_Z_operators(nqubits) @@ -47,3 +47,50 @@ def test_select_best_dbr_generator(backend, nqubits, step): ) assert initial_off_diagonal_norm > dbi.off_diagonal_norm + + +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("d_option", ["delta_H", "min_max"]) +def test_gradient_descent_onsite_Z(backend, nqubits, d_option): + h0 = random_hermitian(2**nqubits, seed=1, backend=backend) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + ) + initial_off_diagonal_norm = dbi.off_diagonal_norm + onsite_Z_ops = generate_onsite_Z_ops(nqubits) + if d_option == "delta_H": + d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops) + if d_option == "min_max": + d_min_max = diagonal_min_max(dbi.h.matrix) + d_coef = onsite_Z_decomposition(d_min_max, onsite_Z_ops) + d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) + iters = 15 + for _ in range(iters): + # calculate elements of gradient descent + s, d_coef, d = gradient_descent_onsite_Z( + dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100 + ) + # double bracket rotation with the results + dbi(step=s, d=d) + # when onsite_Z_ops not given + s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef, max_evals=100) + dbi(step=s, d=d) + assert initial_off_diagonal_norm > dbi.off_diagonal_norm + + +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +def test_dGamma_di_onsite_Z(nqubits): + h0 = random_hermitian(2**nqubits, seed=1) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0), + mode=DoubleBracketGeneratorType.single_commutator, + ) + onsite_Z_ops = generate_onsite_Z_ops(nqubits) + d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops) + d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) + # provide onsite_Z_ops or not gives the same result + dGamma_di_onsite_Z_with_Z_ops = dGamma_di_onsite_Z(dbi, 3, 1, d, onsite_Z_ops) + assert ( + dGamma_di_onsite_Z_with_Z_ops[-1] == dGamma_di_onsite_Z(dbi, 3, 1, d)[-1] + ).all() From f35a58d1cc530e25dde60a644561655a16026bb5 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 12:45:43 +0800 Subject: [PATCH 039/116] Fix error in notebook call (key arguments exchanged) --- examples/dbi/dbi_strategy_magnetic_field.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index 8ab8207500..1455a1daca 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -85,7 +85,7 @@ "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi,d,5, onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi, d, n_taylor=5, onsite_Z_ops=onsite_Z_ops)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", "print('s:', s)" @@ -113,7 +113,7 @@ "metadata": {}, "outputs": [], "source": [ - "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", + "plt.title(str(nqubits) + ' spins random hamiltonian')\n", "plt.plot(off_diagonal_norm)\n", "plt.xlabel('Iteration')\n", "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" @@ -168,7 +168,7 @@ "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi_TFIM,d,5, onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi_TFIM, d, n_taylor=5, onsite_Z_ops=onsite_Z_ops)\n", "print('Initial off-diagonal norm:', dbi.off_diagonal_norm)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", @@ -322,7 +322,7 @@ "scheduling = DoubleBracketScheduling.hyperopt\n", "mode = DoubleBracketGeneratorType.single_commutator\n", "n_1 = 5\n", - "n_2 = 2\n", + "n_2 = 3\n", "dbi_1 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", "dbi_2 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", "print(\"Initial off diagonal norm\", dbi_1.off_diagonal_norm)\n", @@ -339,7 +339,7 @@ "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi,d,5, onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi,d,n_taylor=5, onsite_Z_ops=onsite_Z_ops)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", "print('s:', s)" From 80d2604d6362151c7a2a50b5a7b623a462622618 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 14:28:50 +0800 Subject: [PATCH 040/116] Backup scheduling moved to `choose_step` --- examples/dbi/dbi_scheduling.ipynb | 382 +++++++++++++++++++++++--- src/qibo/models/dbi/double_bracket.py | 60 +++- 2 files changed, 383 insertions(+), 59 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 1f53822023..686156fa4c 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -42,9 +42,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-01 14:04:46]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -70,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -93,9 +108,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.030312727272727272\n", + "hyperopt_search step: 0.029554880094525483\n", + "polynomial_approximation step: 0.032960905003724034\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -103,26 +128,33 @@ "# hyperopt\n", "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, max_evals=100, step_max=0.6)\n", "print('hyperopt_search step:', step_hyperopt)\n", - "# polynomial expansion\n", "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, n=5)\n", "print('polynomial_approximation step:', step_poly)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "step_poly = dbi.polynomial_step(n=5)\n", - "print(step_poly)" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.030312727272727272\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -131,7 +163,7 @@ "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", - "plt.title('hyperopt first step')\n", + "plt.title('First DBI step')\n", "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] @@ -147,23 +179,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "# Generate the digaonal operators\n", - "Z_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*nqubits)).dense.matrix\n", - "ZI_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*(nqubits-1)+\"I\")).dense.matrix" + "Z_str = \"Z\"*nqubits\n", + "ZI_str = \"Z\"*(nqubits-1)+\"I\"\n", + "Z_op = SymbolicHamiltonian(str_to_symbolic(Z_str)).dense.matrix\n", + "ZI_op = SymbolicHamiltonian(str_to_symbolic(ZI_str)).dense.matrix\n", + "op_dict = {Z_str:Z_op, ZI_str: ZI_op}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", - "d = ZI_op\n", + "d_str = ZI_str\n", + "d = op_dict[d_str]\n", "# generate data for plotting sigma decrease of the first step\n", "s_space = np.linspace(1e-5, 0.6, 100)\n", "off_diagonal_norm_diff = []\n", @@ -175,9 +220,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", + "hyperopt_search step: 0.565048795659714 loss -6.166892748979453\n", + "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -195,9 +250,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.30303525252525254\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -208,7 +281,7 @@ "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", - "plt.title('hyperopt first step')\n", + "plt.title(f'First DBI step with D={d_str}')\n", "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] @@ -229,9 +302,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.04141414141414142\n", + "hyperopt_search step: 0.04175237619889543\n" + ] + } + ], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -250,9 +332,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.30303525252525254\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAHHCAYAAABdm0mZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACiEklEQVR4nO2dd5wU5f3HP7P9dq837jgO7oCjV+kKAgqKJXaMXSwkRFEUY+FnIpAYTQTUWFCjAiYGoygajcZYQUQBKSKdAykHx/W+e9uf3x97M7sH13Z3Zqfs9/163eu1tzc7+8zczDOf51s5xhgDQRAEQRCExtDJPQCCIAiCIAgpIJFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEARBEIQmIZFDEBGwatUqcBwn/BgMBuTm5uK6665DcXGxZN/73XffYdGiRairqwt7rEePHpX8u2LJ6cfV0XgXLVoEjuNQVVUV20G2Q6T/E6USzfFo7VwQyoJEDkFEwcqVK/H999/jiy++wNy5c/Hhhx9i4sSJqK2tleT7vvvuOyxevDgs4XHJJZfg+++/R25uruTfFUtOPy6lj1fLRHqNEYTUGOQeAEGomSFDhmD06NEAgClTpsDn82HhwoX44IMPcNttt8k8OsDhcCArKwtZWVlyD0V0tHpcaoT+F4RSIUsOQYgIL3jKy8tbvV9cXIwbbrgB2dnZMJvNGDhwIF588cVW21RWVuJXv/oV8vPzYTabkZWVhXPOOQdffPEFgIDL5cEHHwQAFBYWCq6ydevWCX/nOA7bt2/HNddcg7S0NPTp06ddd8D+/ftx/fXXo1u3bjCbzejZsyduueUWuFyuTr+rPfbv34+bb74ZBQUFMJvN6NatGy644AIcOHCgze337NkDjuOwZs0a4b1t27aB4zgMHjy41baXXXYZRo0aJfweelxdHW95eTmuv/56pKSkoFu3brj99ttRX1/f4TEBwXO7Y8cOXHXVVUhOTkZKSgpuuukmVFZWttr222+/xfnnn4+kpCRYrVacffbZ+Pjjjzvc/4YNG8BxHN56660z/vb3v/8dHMfhhx9+aDWWPXv2dHosXR0Lv8+ffvoJM2fOREpKCtLT0zF//nx4vV4cOHAAM2bMQFJSEgoKCvDUU0+1+nxb19ihQ4dw2223oaioCFarFXl5efjFL36BXbt2dXguCEJMSOQQhIgcOXIEANCvXz/hvb1792LMmDHYvXs3li1bhv/85z+45JJLcO+992Lx4sXCdjfffDM++OADPPbYY/jss8/w2muvYdq0aaiurgYA3HnnnbjnnnsAAGvXrsX333+P77//HmeddVarMVx11VXo27cv1qxZg5dffrnNce7cuRNjxozBpk2b8Ic//AH//e9/8eSTT8LlcsHtdnf5u0IpLi7GmDFjUF9fj6effhqff/45/vrXvyI3Nxc2m63NzwwePBi5ubmCkAOAL774AgkJCdi7dy9KS0sBAF6vF+vXr8e0adPa3E9Xx3v11VejX79+eO+99/DII49g9erVuP/++9s9ptO58sor0bdvX7z77rtYtGgRPvjgA1x44YXweDwAgPXr1+O8885DfX09Xn/9dbz11ltISkrCL37xC7z99tvt7nfSpEkYOXLkGcIXAF544QWMGTMGY8aMCetYIhnLtddei+HDh+O9997D7Nmz8cwzz+D+++/HFVdcgUsuuQTvv/8+zjvvPDz88MNYu3Zth+eqtLQUGRkZ+POf/4xPP/0UL774IgwGA8aNG9eu6CUI0WEEQYTNypUrGQC2adMm5vF4WGNjI/v0009ZTk4OO/fcc5nH4xG2vfDCC1mPHj1YfX19q33MnTuXWSwWVlNTwxhjLDExkd13330dfu+SJUsYAHbkyJEz/rZw4UIGgD322GNtjjX0M+eddx5LTU1lFRUVEX1XWyxcuJBZrVbm8/m6tD3PTTfdxHr37i38Pm3aNDZ79myWlpbG3njjDcYYYxs3bmQA2GeffdbucXXl3Dz11FOt3r/rrruYxWJhfr+/02MDwO6///5W7//zn/9kANibb77JGGNs/PjxLDs7mzU2NgrbeL1eNmTIENajRw/he9r6n/Dv7dixQ3hvy5YtDIBwHsI5lq6OJXSfy5Yta7XPESNGMABs7dq1wnsej4dlZWWxq6666oyxd3SteL1e5na7WVFRUavz2JXPEkSkkCWHIKJg/PjxMBqNSEpKwowZM5CWloZ///vfMBgC4W5OpxNffvklrrzySlitVni9XuHn4osvhtPpxKZNmwAAY8eOxapVq/D4449j06ZNgnUgXK6++uoO/+5wOLB+/Xpce+21osZRZGZmwuFw4LbbbsPGjRvh8/m69Lnzzz8fP//8M44cOQKn04lvv/0WM2bMwNSpU/H5558DCFh3zGYzJk6cGNUYL7vssla/Dxs2DE6nExUVFV36/I033tjq92uvvRYGgwFff/017HY7Nm/ejGuuuQaJiYnCNnq9HjfffDNOnDjRoQXj+uuvR3Z2ditrzvPPP4+srCz88pe/DOtYIh3LpZde2ur3gQMHguM4XHTRRcJ7BoMBffv2xbFjx9o9FiBgfXviiScwaNAgmEwmGAwGmEwmFBcXY9++fR1+liDEgkQOQUTB3//+d/zwww/46quv8Otf/xr79u3D9ddfL/y9uroaXq8Xzz//PIxGY6ufiy++GACEtOa3334bt956K1577TVMmDAB6enpuOWWW1BWVhbWmDrLcKmtrYXP50OPHj3CPNqOmTNnDv785z9jy5YtmDhxInJzczFv3jw0NDR0+DneBfXFF1/g22+/hcfjwXnnnYdp06bhyy+/FP52zjnnICEhIaoxZmRktPrdbDYDAJqbm7v0+ZycnFa/GwwGZGRkoLq6GrW1tWCMtXn+u3fvDgCC67EtzGYzfv3rX2P16tWoq6tDZWUl3nnnHdx5553COLt6LJGOJT09vdXvJpMJVqsVFovljPedTme7xwIA8+fPx+9//3tcccUV+Oijj7B582b88MMPGD58eJfPN0FEC2VXEUQUDBw4UAg2njp1Knw+H1577TW8++67QvAvv3q+++6729xHYWEhgIAl5Nlnn8Wzzz6L48eP48MPP8QjjzyCiooKfPrpp10eE8dxHf49PT0der0eJ06c6PI+u4LBYMDDDz+Mhx9+GCdOnMDf/vY3/PGPf4TFYsFf/vKXdj/Xo0cP9OvXD1988QUKCgowevRopKam4vzzz8ddd92FzZs3Y9OmTa3il+SirKwMeXl5wu9erxfV1dXIyMhAWloadDodTp06dcbn+NiizMzMDvf/m9/8Bn/+85+xYsUKOJ1OeL1ezJkzJ+xxijGWaHnzzTdxyy234Iknnmj1flVVFVJTUyX9boLgIUsOQYjIU089hbS0NDz22GPw+/2wWq2YOnUqduzYgWHDhmH06NFn/Jy+IgeAnj17Yu7cuZg+fTq2b98uvB+u5aEtEhISMHnyZKxZs6bD4njRfFePHj3w6KOPIiEhAV6vt9Ptp02bhq+++gqff/45pk+fDiAQvN2zZ0889thj8Hg87QYdizHervLPf/6z1e/vvPMOvF4vpkyZApvNhnHjxmHt2rWtxuD3+/Hmm28KYq4jcnNzMXPmTCxfvhwvv/wyfvGLX6Bnz55hj1OMsUQLx3FnWKA+/vhjnDx5UtLvJYhQyJJDECKSlpaGBQsW4KGHHsLq1atx00034a9//SsmTpyISZMm4Te/+Q0KCgrQ2NiIQ4cO4aOPPsJXX32F+vp6TJ06FTfccAMGDBiApKQk/PDDD/j0009x1VVXCfsfOnQoAOCvf/0rbr31VhiNRvTv3x9JSUlhjfPpp5/GxIkTMW7cODzyyCPo27cvysvL8eGHH+KVV15BUlJSWN81d+5c1NfXY/r06ejZsycqKyvxwgsvwGQy4de//nWn4zn//POxfPlyVFVV4dlnn231/sqVK5GWltYqfbwtxDo3HbF27VoYDAZMnz4de/bswe9//3sMHz4c1157LQDgySefxPTp0zF16lT89re/hclkwvLly7F792689dZbnVrZAGDevHkYN24cgECxyUgRYyzRcOmll2LVqlUYMGAAhg0bhm3btmHJkiWiu0kJokPkjnwmCDXCZ4T88MMPZ/ytubmZ9ezZkxUVFTGv18sYY+zIkSPs9ttvZ3l5ecxoNLKsrCx29tlns8cff5wxxpjT6WRz5sxhw4YNY8nJySwhIYH179+fLVy4kNnt9lb7X7BgAevevTvT6XQMAPv6668ZY8EMmcrKyjbHenr2yt69e9nMmTNZRkYGM5lMrGfPnmzWrFnM6XR2+l2n8/zzz7NJkyax7OxsZjabWWFhIbv99tvZ4cOHu3Q+a2trmU6nYzabjbndbuF9PnspNJOno+MS69ycDv/5bdu2sV/84hcsMTGRJSUlseuvv56Vl5e32nbDhg3svPPOYzabjSUkJLDx48ezjz76KKzvLSgoYAMHDuxwLF05lq6MpaN93nrrrcxms52x/eTJk9ngwYM7/O7a2lp2xx13sOzsbGa1WtnEiRPZhg0b2OTJk9nkyZO7fC4IIho4xhiLubIiCIJQEYsWLcLixYtRWVkpeSzLTz/9hOHDh+PFF1/EXXfdJel3EYTWIXcVQRCEAjh8+DCOHTuG//u//0Nubi5mzZol95AIQvVQ4DFBEIQC+OMf/4jp06ejqakJa9asgdVqlXtIBKF6yF1FEARBEIQmIUsOQRAEQRCahEQOQRAEQRCahEQOQRAEQRCaJK6zq/x+P0pLS5GUlCR5YSyCIAiCIMSBMYbGxkZ0794dOl379pq4FjmlpaXIz8+XexgEQRAEQURASUlJh1W041rk8OXeS0pKkJycLPNoCIIQHbsdaOm6jdJSwGaTdzwEITN2tx3dlwXuidIHSmEzqfOeaGhoQH5+fqdtW+Ja5PAuquTkZBI5BKFF9Prg6+RkEjlE3KN36wFL4HVycrJqRQ5PZ6EmFHisIXxOH/bM3IM9M/fA5/TJPRyCIAiCkBUSOVrCB1S+W4nKdysB0jgEQRBEnBPX7iqCIAiCiCcMOgNuHX6r8FrraP8ICYIgCFXi8/ng8XjkHobmeHnGywAA5mVwep0yj6ZtjEYj9KExdRFCIocgCIJQFIwxlJWVoa6uTu6hEDKSmpqKnJycqOrYkcghCIIgFAUvcLKzs2G1WqlYq4gwxuBnfgCAjtMp8twyxuBwOFBRUQEAyM3NjXhfJHIIgiAIxeDz+QSBk5GRIfdwNIfP78OOsh0AgJE5I6HXRe8SkoKEhAQAQEVFBbKzsyN2XVF2FUEQBKEY+Bgcq9Uq80gIueGvgWjiskjkEARBEIpDiW4UIraIcQ2QyCEIgiAIQpOQyCEIgiAIGTl69Cg4jsOPP/7Y7jbr1q0Dx3GqzjjjOA4ffPBBTL+TAo8JgiAIQkby8/Nx6tQpZGZmyj0UzaFaS86TTz6JMWPGICkpCdnZ2bjiiitw4MABuYdFKACnx4dauxs1djeqmlyoaHSiotEJp4d6XRDxh9/P4PT40OD0oLrJhfIGJ0rrmlHf7IHPz+QeXtzjdruh1+uRk5MDg0G9dgelFm1U7Rldv3497r77bowZMwZerxePPvooLrjgAuzduxe2eO00rAeyrskSXmsVv5/hWI0De0sbsKe0HocqmlDV5EK13Y3qJjeaXN52P2s26JBqNSI1wYTsZDP6ZieiKDsJRd0SUZSdiFSrKYZHQhDi4PX5sb+sETtK6nCwrBHlDU6UN7pQXu9EZZOrQzFjNemRaDYgK8mMgkwbCjKsKMiwoXeWDUPzUmEyqHYtLAuNjY2YM2cOPvjgAyQnJ+Ohhx7Cv//9b4wYMQLPPvssCgoKcOedd+LQoUN4//33ccUVV2Dx4sUoLCzEjh07MGLECADAJ598gvvuuw8lJSUYP348br311i6P4dixY5g7dy6+/fZbuN1uFBQUYMmSJbj44ovBcRyqjlbhzwv/jK3fb4XNZsMFF1yAZ555RrAkffrpp3j88cexe/du6PV6TJgwAX/961/Rp08fAAH3WmFhId5++20sX74cmzZtwksvvYTbbrsNK1aswLJly3Do0CGkp6fj6quvxgsvvCCMraqqCldeeSX+97//IS8vD8uWLcNll10m3j/gNDjGmCakfGVlJbKzs7F+/Xqce+65XfpMQ0MDUlJSUF9fj+TkZIlHSERDs9uH/+4+hbXbT2LH8VrY3V23yvAB+l250ofkJeOSod1xydBc9MygFFbVY7cDiYmB101NgIYWQMerHfjXD8ex9WgtfjpZB6fH36XP6XUcdBzg8XV+Q9hMekwsysTU/tmY0j8bOSmWaIfdKU6nE0eOHEFhYSEslpbvYwxwOCT/7jaxWoOTSBeYPXs2Pv/8c7z++uvo1q0bHnvsMXzxxRe4/fbbBZFTW1uL3//+97jiiisAAAaDoZXIKSkpQVFREebMmYPf/OY32Lp1Kx544AGUl5ejtrYWqampHY7h0ksvhdvtxrJly2Cz2bB3714kJyfj3HPPxalTpzBs2DDMnj0bt9xyC5qbm/Hwww/D6/Xiq6++AgC899574DgOQ4cOhd1ux2OPPYajR4/ixx9/hE6nE0ROQUEBli1bhpEjR8JsNuPf//435s+fjz//+c+46KKLUF9fj40bN+K+++4DEIjJ6dGjB5566imMGTMGzz//PFasWIFjx44hPT39jONo81pooavPb9Vack6nvr4eANo8UTwulwsul0v4vaGhQfJxEZHDGMPOE/V4Z2sJPvqxFI0hFhqzQYcBOUkY1D0Z/bslISfFgoxEMzJsJmQkmmE16aHnOHBc4MZijKHJ5UWdw4P6Zg/qHB6crHOguLwJxRVNOFTRhJN1zdh9sgG7TzbgL5/ux9C8FFwxMg83j+9Fq1lCETDGsO1YLV7bcAT/21vWSrgnWQwYkZ+KIXkp6J5iQbfkwE92shlJFiOMeg5GnQ46XeCB7fL6YHf50OT0osHpQVm9E0er7YGfKgf2lzWgqsmN/+0px//2lAMARvdKw+8vHYTh+amxPXCHIyhWY00Y4rixsRFvvPEGVq9ejfPPPx8AsHLlSnTv3r3Vdueddx5++9vfCr8fPXq01d9feukl9O7dG8888ww4jkP//v2xa9cu/OUvf+nSOI4fP46rr74aQ4cOBQD07t271b7POussPPHEE8J7K1asQH5+Pg4ePIh+/frh6quvbrW/119/HdnZ2di7dy+GDBkivH/ffffhqquuEn5//PHH8cADD2DevHnCe2PGjGm1r1mzZuH6668HADzxxBN4/vnnsWXLFsyYMaNLxxYumhA5jDHMnz8fEydObPUPOJ0nn3wSixcvjuHIiEhpcHow/+2d+GJfufBefnoCrh2VjwsG56BPlg0GfdeFB8dxSLIYkWQxIr+dbaqbXPjfnnJ8vKsU3x+uxq6T9dh1sh7v7ziBZ385An2zk6I8KoKInA3FlVj62UHsLKkT3pvcLwuXDMvFWT3T0DvTJgiYrmA26GE26JFuC7hoh+SltPq738+w91QDvtpfga8PVODHkjpsPVaLK5ZvxPVje+LBC/ojzUbu3VB+/vlneDwejB07VngvJSUF/fv3b7Xd6NGjO9zPvn37MH78+FZ1YiZMmNDlcdx77734zW9+g88++wzTpk3D1VdfjWHDhgEAtm3bhq+//hqJbYjGw4cPo1+/fjh8+DB+//vfY9OmTaiqqoLfH7ASHj9+vNUzNvQ4KioqUFpaKoi79uDHAQA2mw1JSUlC+wYp0ITImTt3Ln766Sd8++23HW63YMECzJ8/X/i9oaEB+fntPfLUh8/uw4bEDQCASU2ToLepMzDnUEUjfvX3bfi5yg6TXoeLh+bg2jH5GF+YEdYkHi4ZiWbcMK4nbhjXE1VNLnyy6xSe/vwgdp9swCXPfYtHLhqAWycUSDoGgmiLd34owSNrf4KfASaDDleflYfbzylEUTfphLdOx2FIXgqG5KXg3vOLUN7gxF/+ux9rd5zE6s3H8d9dp/DwjAG4dnS+9PeE1RqwqMhBGJWX+eiP04vYnR4V0lncaLRRJHfeeScuvPBCfPzxx/jss8/w5JNPYtmyZbjnnnvg8/kwcfpE3PN/92BQ1qBWbR34HlG/+MUvkJ+fj1dffRXdu3eH3+/HkCFD4Ha72z0Ovg1DZxiNxla/cxwniCgpUL3Iueeee/Dhhx/im2++QY8ePTrc1mw2w2w2x2hkRCR8vrcc97/9I5pcXnRPseCVm0djaI+Uzj8oMpmJZtwyoQAXDs7Bg+/+hG8OVmLxR3vx1f4KLJ05HN2SpY9NIAgA+Ns3h/HEJ/sBAFef1QMLLh6AzMTYz2Pdki14+pcj8Msx+fj9v3fjYHkTHlm7C9uP1+IvVw+TtkIxx6kinqpPnz4wGo3YsmWLsIBuaGhAcXExJk+e3OX9DBo06Ix6Mps2bQprLPn5+ZgzZw7mzJmDBQsW4NVXX8U999yDkWeNxFvvvIXc/Fz07dH3jN5V1dXV2LdvH1555RVMmjQJADo1IABAUlISCgoK8OWXX2Lq1KlhjVVKVBtowBjD3LlzsXbtWnz11VcoLCyUe0iyo7PqcHbF2Ti74mzorOr61zLG8NcvijH771vR5PJibGE6PrxnoiwCJ5RuyRa8cdsY/OHywbAYddhQXIUbX9uM5jACnwkiEhhjeOrT/YLA+fXk3lg6c5gsAieUcb0z8PG9k/DoxQOh44B3tp7Aqu+OyjompZCUlIRbb70VDz74IL7++mvs2bMHt99+O3S68Lp9z5kzB4cPH8b8+fNx4MABrF69GqtWrery5++77z7873//w5EjR7B9+3Z89dVXGDhwIADgrrvuQkNdA3531++wZcsW/Pzzz/jss89w++23w+fzIS0tDRkZGfjb3/6GQ4cO4auvvmrlAemIRYsWYdmyZXjuuedQXFyM7du34/nnn+/yuKVAXU/CEO6++268+eabWL16NZKSklBWVoaysjI0NzfLPTTZ4DgOpiwTTFkm1fV9eWdrCZ754iAA4NYJvfDPO8fJPpnzcByHWyYU4D/3TEJ2khmHKprw5H/3yT0sQsP4/AyPfrAby9cdBgA8PGMAFlw0UDH3tVGvw+xze+P/Lg48OB//eB++O1Ql86iUwdNPP40JEybg0ksvxbRp03DOOedg4MCBZ2QHdUTPnj3x3nvv4aOPPsLw4cPx8ssvtwoU7gyfz4e7774bAwcOxIwZM9C/f38sX74cANC9e3e89sFr8Pl9uPiiizFkyBDMmzcPKSkp0Ol00Ol0+Ne//oVt27ZhyJAhuP/++7FkyZIufe+tt96KZ599FsuXL8fgwYNx6aWXori4uMvjlgLVppC3d7OvXLkSs2bN6tI+KIVcGVQ1uXD+svWob/bggen9cM/5RXIPqV2+OViJW1ZsAQCsnDUGUwdkyzwiokNUmkL+yvrDePK/+6HjgD9dORTXj+0p95DahDGGB97ZibU7TiLNasSHcyciPz260gsdpQ2rEbvdLtSDueOOO+QeDnx+H3aU7QAAjMwZeYa7SkmIkUKuWksOY6zNn64KHC3id/lx8O6DOHj3Qfhd0gVyic0TH+9DfbMHg3KT8ZspfeQeToec2y8Lt58TcI0++O5OVDW5OvkEQYRHjd2NF746BAD4w+VDFCtwgMBi84mrhmJYjxTUOjyY/fetcLjbL8YZD+zYsQNvvfUWDh8+jO3bt+PGG28EAFx++eUyjyw+Ua3IIc6EeRlKl5eidHkpmFcdBrqNh6qwdsdJcBzwxFVDw0oLl4uHZvTHgJwkVDW58dC7P0WdCUEQoTz/VTEaXV4MzE3GDQoWODwWox6v3DwKmYlm7C9rxINr6J5YunQphg8fjmnTpsFut2PDhg2i9qW66KKLkJiY2OZPOG6teED12VWEenF6fPjdB7sBADeP74URsS4wFiEWox7PXjcCl72wEV/tr8Cbm4/j5vG95B4WoQGOVdvx5qZjAID/u3iAasoV5KYk4OWbzsL1r27Cx7tO4ZfF+Ti3X5bcw5KFkSNHYtu2bZJ+x2uvvdZu/GlHBXGBgPUtxZwivNY6JHII2Vi+7jCOVNmRnWTGby/s3/kHFMSAnGQ8PGMA/vifvfjTx3txblEmemWoI96DUC5P/e8APD6Gc/tlYVKRukTC6IJ03DiuF1Z9dxRvfHc0bkVOLMjLy4v4szpOh6IM5cY9io3yfQOEJjlU0YSXWzJHFv5iMJItxk4+oTxuO7sA43unw+nx4x/fH5N7OITK2XG8Fh//dAocByy4aIDcw4mIWyYELJpfHajAsWq7zKMhCBI5hEz88T974fb5MbV/Fi4emiP3cCJCp+Nw58RAT5j3d5yEx6eeYG9CWTDG8GRIwb+BuerM9uydlYgp/bPAGPB3Ev6EAiCRQ8ScsnonvimuBBCw4qjZLzylfxYyE82otrvx1X7p+q8Q2uaLfRXYcrQGZoMOD1zQT+7hRMWtZxcACLSisLviO9NKifj8Pmw/tR3bT22Hz6/9oqYkcoiY8/GuU2AMGNUrDQWZ6o5jMegDfYQAYM3WEzKPhlAjfGVjALhjYiFyU7rWA0ipTC7KQmGmDY0uL9buOCn3cIg28DM//Cw+LM8kcoiY85+fSgEAvxiWK/NIxGHm6EDPtK8PVKCi0SnzaAi1sae0AcUVTUgw6jFH4XWiuoJOxwmxOW98dzTu08kJeSGRQ8SUkhoHdhyvA8cBFw/Vhsjpm52EkT1T4fMzvL+dVq5EeHy+txwAMKkoU5UB+G1xzagesJn0OFTRhI2HquUeTsyYMmUK7rvvPrmHQYRAIoeIKR/vOgUAGF+YgWwNdfK+dnSg4/CabSdo5UqEBS9ypg/qJvNIxCPJYsQ1owIWTmreqR0WLVqEESNGyD2MsCCRQ8SUj3a2uKqGd5d5JOJy6bBcWIw6HKpowo6SOrmHQ6iEE7UO7D3VAB0HnKexPmi3tAQgf7m/HMerHfIOJo7x+Xzw++Mj/qYtSOQQMePnyibsKW2AXsdhxhB1po23R5LFiIuHBNxva7aWyDwaQi18uS+QkTeqVxoyEs0yj0Zc+mQlYlJRJhgD/rHpqNzDiRl+vx8PPfQQ0tPTkZOTg0WLFgEAbr/9dlx66aWttvV6vcjJycGKFSsABNxdc+fOxdy5c5GamoqMjAz87ne/a2UddrvdeOihh5CXlwebzYZx48Zh3bp1wt9XrVqF1NRU/Oc//8GgQYNgNptx7Ngx1NbW4pZbbkFmRiYm9pmIe2+6t1WHcP5zH3zwAfr16weLxYLp06ejpKRE+PvixYuxc+dOcBwHjuOwatUqaU6iiJDI0RI6IGVyClImpyjyP/ufnwKuqol9M5FuM8k8GvGZ2eKy+mjnKTS7tZ+aSUSPFl1Vodw4LhCA/FnLcUaL3W1v98fpdXZ522ZPc5e2jYQ33ngDNpsNmzdvxlNPPYU//OEP+Pzzz3HnnXfi008/xalTp4RtP/nkEzQ1NeHaa69t9XmDwYDNmzfjueeewzPPPIPXXntN+Pttt92GjRs34l//+hd++uknzJw5EzNmzGglWBwOB5588km89tpr2LNnD7KzszFr1ixs3boVH3zwAd7+79vQQ49fXPoLeDyeVp/705/+hDfeeAMbN25EQ0MDrrvuOgDAL3/5SzzwwAMYPHgwTp06hVOnTuGXv/xlROcollBbBw2hT9Bj5LqRcg+jXXhX1aUayao6nXGF6chPT0BJTTP+u/sUrjqrh9xDIhRMfbMHm34OBOVOH6QtyybP2X0zoOOAY9UOlNY1o3tqdOnxiU8mtvu3i4suxsc3fCz8nr00Gw5P226yyb0mY92sdcLvBX8tQJWj6ozt2MLw4+uGDRuGhQsXAgCKiorwwgsv4Msvv8Sf//xn9O/fH//4xz/w0EMPAQBWrlyJmTNnIjExeFz5+fl45plnwHEc+vfvj127duGZZ57B7NmzcfjwYbz11ls4ceIEuncPuPx/+9vf4tNPP8XKlSuF5pwejwfLly/H8OHDAQDFxcX48MMPsXHjRpx99tkAgIlDJyI/Px8ffPABZs6cKXzuhRdewLhx4wAEBNfAgQOxZcsWjB07FomJiTAYDMjJUc/1qsD1PqFFDpQ1oriiCSa9DhcMVs8NEg46HYeZo1oCkKlmDtEJ6w5UwOtn6JudiEKV14tqj2SLEUPyAs0gNx+JjyyrYcOGtfo9NzcXFRUBt+Sdd96JlStXAgAqKirw8ccf4/bbb2+1/fjx41sVSJ0wYQKKi4vh8/mwfft2MMbQr1+/Vp3H169fj8OHDwufMZlMrcaxb98+GAwGQbwAQEZGBvr37499+/YJ7xkMBowePVr4fcCAAUhNTW21jdogSw4RE3grzuT+WUhJ0EaabFtcPqI7nv78IH44WgOnxweLUS/3kAiFonVXFc+E3hn46UQ9Nh2uwZUjo7NuNi1oavdvel3re63it+1XINdxrdf3R+cdjWpcoRiNrec3juOEwN9bbrkFjzzyCL7//nt8//33KCgowKRJk7q8b7/fD71ej23btkGvb328odaghISEVkKpvYxPxtgZFefbqkCv5qr0JHI0hM/uw6aCTQCA8UfHQ29TxgOWMSYUANSqq4qnZ7oV3ZLNKG9wYWdJHcb1zpB7SIQCcXv9WH8g0Npk2kBti5zxvTPwyjc/Y5MIlhybqesWL6m2jYaMjAxcccUVWLlyJb7//nvcdtttZ2yzadOmM34vKiqCXq/HyJEj4fP5UFFREZY4GjRoELxeLzZv3oxx48dhV8Uu1NXU4eDBgxg4cKCwndfrxdatWzF27FgAwIEDB1BXV4cBAwINY00mE3w+dcUbkrtKY3iqPPBUeTrfMIbsPtmAo9UOWIw6zU/oHMdhVK80AMC247Uyj4ZQKpuPVKPR5UVmohkj81PlHo6kjC5IaxWXE+/ceeedeOONN7Bv3z7ceuutZ/y9pKQE8+fPx4EDB/DWW2/h+eefx7x58wAA/fr1w4033ohbbrkFa9euxZEjR/DDDz/gL3/5Cz755JN2v7OoqAiXX345Zs+ejW+//RZ7d+3F/839P+Tl5eHyyy8XtjMajbjnnnuwefNmbN++HbfddhvGjx8viJ6CggIcOXIEP/74I6qqquByuUQ+O+JDIkdD6BJ0GLN7DMbsHgNdgnL+tXwzzsn9smAza994OKpXOgBg21ESOUTb8K6qaQOzodOp1xXQFZIsRgyNs7icjpg2bRpyc3Nx4YUXCsHDodxyyy1obm7G2LFjcffdd+Oee+7Br371K+HvK1euxC233IIHHngA/fv3x2WXXYbNmzcjPz+/w+9duXIlRo0ahcsvuxy3X3Y7GGP46D8ftXKvWa1WPPzww7jhhhswYcIEJCQk4F//+pfw96uvvhozZszA1KlTkZWVhbfeekuEMyIt2n/ixBGcjoNtsPICGH86UQcAGFOQLu9AYkSoJactnzcR3zDG8EWcxOPwjO+dgZ0ixeUomdB6NTwffPBBq9+bm5tRV1eHO+64o819GI1GPPvss3jppZfa/fvixYuxePHiNv8+a9YszJo164z309LS8Pe//x0+vw87ynYAAIpyis7Y7qqrrsJVV13V5r7NZjPefffdNv+mVJSz3Cc0y86SegDAsB6p8g4kRgzKTYbZoEOdw4PDlZHV2iC0y57SBpTWO5Fg1OOcvplyDycmjG+JTRMjLket+P1+lJaW4ve//z1SUlJw2WWXyT2kuIBEjobwu/04sugIjiw6Ar9bGWW8yxucKGtwQscBQ/KS5R5OTDAZdBjeEmex/Ri5rIjW8FWOz+2XGTfZdxSXAxw/fhx5eXl45513sGLFChgM5EiJBSRyNATzMBxbfAzHFh8D8yijSeTOlj5O/bolwWqKn5uad1ltPVYj80gIpbGzxX07IY4y70LjcvgCiPFGQUEBGGMoKSnB+eef3+Y269atw7PPPhvbgbUwa9Ys1NXVyfLdUkIih5AUfkIfHieuKp7RfFwOWXKI09hTGnDf8kXy4gXBZRWnIkcpcOBgNVphNVrBQfvxgiRyCEn56URLPE5+fE3oI3sGRM7hSjtq7W6ZR0MohaomF8obXOA4YGBufLhvecb34UUOWTflRKfTYVDWIAzKGgSdTvsSQPtHSMgGY0xwV8WbJSfdZkLvrECm23aql0O0sKe0AQBQmGGLi3IKoYzulQa9jsPxGgdOxmlcDhF7SOQQknG02oEGpxdmgw79c5LkHk7MIZcVcTq8q2pwnLmqgEBcjtDHilxWRIwgkUNIBm/FGdw9GUZ9/F1qweBjEjlEgD0nA5acwd3jy1XFM753oFYWxeXIh8/vw0/lP+Gn8p/g86urRUMkxN+Th4gZfNBxvNTHOR2+8vHOkjp4fMpI6SfkRbDkxK3IobgcJeD2ueH2xUesIIkcQjJ4S84IjffmaY/emTakWo1wef1CLAYRvzQ6PTha7QAADO4ef+4qgOJyOmPVqlVITU2VexhdYtGiRRgxYkRYn+E47owK0FJDIoeQBI8v+GAfHqciR6fjcFZPisshAuw71QgAyE2xIN1mknk08pBkMQpWrB0UkK9qfvvb3+LLL7+UexidQiKHkIQDZY1wef1IthhQkGGVeziyIfSxoqKAcU/QVRWfVhye/t0CSQiHKppkHgkRDYmJicjIUH5BSxI5hCTw9XGG56fGdYPKUSEZVowpowo1IQ+8ZTNe43F4irolAgCKNShypkyZgrlz52Lu3LlITU1FRkYGfve73wn3fm1tLW655RakpaXBarXioosuQnFxcZv7Onr0KHQ6HbZu3drq/eeffx69evUCYwzr1q0Dx3H48ssvMXr0aFitVpx99tk4cOBAq8+89NJL6NOnD0wmEwYNHIRP3v2k1d85jsMrr7yCSy+9FFarFQMHDsT333+PQ4cOYcqUKbDZbJgwYQIOHz4sfOZ0d9UPP/yA6dOnIzMzEykpKZg8eTK2b98ezekUBRI5hCTw8TjDesT3qnV4j1QYdBzKG1w4UUsxCPHM7pPxHXTMU5TdYskpD1/k+Oy+sH/83mDQv9/rD7zf7OvSfiPhjTfegMFgwObNm/Hcc8/hmWeewWuvvQYg0Dph69at+PDDD/H999+DMYaLL74YHo/njP0UFBRg2rRpWLlyZav3V65ciVmzZrVaPD766KNYtmwZtm7dCoPBgNtvv1342/vvv4958+bhgQcewO7duzH7V7Pxh/l/wNaNrcXTH//4R9xyyy348ccfMWDAANxwww349a9/jQULFghCa+7cue0ed2NjI2699VZs2LABmzZtQlFRES6++GI0NjaGfxJFJL6qUWkdDrAOsgqv5SRe2zmcToJJj8Hdk7HzRD22HatFfnr8uu7iGZfXJ7hn4rFGTih9swOWnCNVdnh9fhjCKC+xIXFD2N836J1ByJ6ZDQCoer8Ke6/di5TJKRi5bqSwzaaCTfBUnSk0prApYX9ffn4+nnnmGXAch/79+2PXrl145plnMGXKFHz44YfYuHEjzj77bADAP//5T+Tn5+ODDz7AzJkzz9jXnXfeiTlz5uDpp5+G2WzGzp078eOPP2Lt2rWttvvTn/6EyZMnAwAeeeQRXHLJJXA6nbBYLFi6dClmzZqFu+66CwBw//334/NvPsfqv63G7KtnC/u47bbbcO211wIAHn74YUyYMAG///3vceGFFwIA5s2bh9tuu63d4z7vvPNa/f7KK68gLS0N69evx6WXXhruaRQNsuRoCL1Vj7F7xmLsnrHQW+Xrbuxwe3GwPKDe4zXoOBQ+hX5/mbwrGkI+DpY1wetnSLUa0T3FIvdwZCUvNQEJRj3cPj+O1zjkHo7ojB8/vpWVZcKECSguLsbevXthMBgwbtw44W8ZGRno378/9u3b1+a+rrjiChgMBrz//vsAgBUrVmDq1KkoKChotd2wYcOE17m5uQCAiopAt/t9+/bhnHPOEf6u1+lx8XkX48ThE9Dr9G3uo1u3bgCAoUOHtnrP6XSioaHtTNGKigrMmTMH/fr1Q0pKClJSUtDU1ITjx4+3uX2sIEsOITq7TzbAz4CcZAu6Jcf3hA5AaO/wc6X2YhCIriE05eyeEtcxakAg67BPtg27TzaguKIJvbMSu/zZSU2Twv4+zhw835lXZgb2cdryfvzR8WHvVywYY+1eEyaTCTfffDNWrlyJq666CqtXr26zS7nRaBRe8/vy+/1nvNfRd7a1j872G8qsWbNQWVmJZ599Fr169YLZbMaECRPgdstbj4csOYTo/CQUAYxvszwPP4n/XGWXeSSEXFDQcWuEuJwwg4/1Nn3YPzpD8DGnM+gC7yfou7TfSNi0adMZvxcVFWHQoEHwer3YvHmz8Lfq6mocPHgQAwcObHd/d955J7744gssX74cHo8HV111VVjjGThwIL799ttW73333XcdfmckbNiwAffeey8uvvhiDB48GGazGVVVVaJ+RySQyNEQPocPWwZvwZbBW+BzyFeu+0e+KSe5qgAEigICwLHqQAwCEX/wlpxBJHIABONyisu158ItKSnB/PnzceDAAbz11lt4/vnnMW/ePBQVFeHyyy/H7Nmz8e2332Lnzp246aabkJeXh8svv7zd/Q0cOBDjx4/Hww8/jOuvvx4JCQlhjefBBx/EqlWr8PLLL6O4uBhLly3F2rVrcfUdV4va1qFv3774xz/+gX379mHz5s248cYbwx6rFJDI0RIMcOx1wLHXAciYrcynj8drpePTyUtNgMmgg8fHKMMqDvH5mVAIMN5r5PAUtYicQxp04d5yyy1obm7G2LFjcffdd+Oee+7Br371KwCBzKhRo0bh0ksvxYQJE8AYwyeffNLKLdQWd9xxB9xud6usqa5yxRVX4K9//SuWLFmCwYMH49W/vYrHnn4MQ8cN7fzDYbBixQrU1tZi5MiRuPnmm3HvvfciOztb1O+IBI7FcfGOhoYGpKSkoL6+HsnJ6l9hMR9D3YY6AEDqpFRw+tj7/pvdPgx87FMAwI7fT0danFZ2PZ0Ln/kGB8obsXLWGEwdIP+NHzfY7UBiS8xHUxNgs8V8CIcqGjHt6W+QYNRj9+ILodfFd0wOEMismrp0HSxGHfYungFdyDlxOp04cuQICgsLYbGoK6ZvypQpGDFiRJtxM9Hwpz/9Cf/617+wa9euqPfl8/uwo2wHAGBkzshWwcdKo6NroavPb7LkaAhOzyFtShrSpqTJInAACNkSKQlGEjgh8MHHhzW4ciU6ho/HGdQ9mQROC/lpCTDpdXB6/NTDqgOamprwww8/4Pnnn8e9994r93BUCYkcQlSOVgeCa+O5lUNbCBlWFHwcd1DQ8ZkY9Drhniiu0F5cjljMnTsXEydOxOTJkyNyVRGUQq4p/B4/Tv3tFAAg91e50Bljr2GPtjzEe2XE3i2gZHpntmRYkSUn7gj2rCKRE0rf7ETsL2tEcXkTzhvQTe7hiMK6detE3d+qVauwatUqUfcZb5DI0RDMzVA8N9AHJWdWDtBxLJskHK0OuKsKMknkhBKslUOWnHiCMRZiyaGg41ACaeSnqFEnISnkriJE5Ri5q9qEr5VT0ehCo/PM8vGENilvcKHO4YFBxwmNKYkAnTXqjOOcGMkx6U0w6ZUfMynGNUAihxAVcle1TUqCEZmJgUnlaJX2StkTbcOL/h5pCTAblJvFIgdCGnlFU6uHGZ9O7XDQfSIFep0ew7oNw7BuwxSdWQUEr4HOUuw7gtxVhGg4PT6U1jsBAIXkrjqD3pmJqGqqwc9VTRhK1aDjAj7bkBqznkmvDBv0Og5NLi/KGpzITQkUjtPr9UhNTRV6L1mt1rhvhRFvMMbgcDhQUVGB1NRU6PWRizESOYRolLRM6EkWA9KsMgQEKZzCTBu2HK3BYYrLiRv4e6IniZwzMBl0KMiw4nClHcXlTYLIAYCcnBwAwSaTRHySmpoqXAuRQiKHEI0jVXw8jo1WXm1AjTrjj+MkcjqkKDsJhyvtOFTRhHP7ZQnvcxyH3NxcZGdnw+OhGDYxcXqcuOn9mwAAb175JixGZRZcNBqNUVlweEjkEKJxjDKrOkRo1EmWnLjhGImcDinqlohP97QffKzX60V50BFBfDofPj7yMQDAaDbCYlKmyBELCjwmRIMKAXYMb8k5UmWH30+ZI/FACcXkdEhfIfiYCgIS0kAihxANXuRQZlXb9Ey3wqDj0OzxoazBKfdwCImxu7yoanIDAHqS8G8TXuQcLG+ilHFCEkjkEKLBp0YXZtKE3hZGvU5wWxyh9g6ap6Q2cD+kWo1ItlAgflv0yUoExwH1zR5BEBKEmJDIIUQhkD4eaLRHlpz2oeDj+OF4NcXjdIbFqBfOD1U+JqSARA4hCidqHWAMSDQbkEHdx9uFDz6mNHLtQzVyukYRxeUQEkIiR2MYM40wZsbeNM67qgoyqXBXR/BFEqkbufahGjldo292EoD2M6wI8cm0ZiLTmin3MGICpZBrCL1Nj3Mqz5HluynouGv0ziR3VbxANXK6Bh98XFxO90QssJlsqHywUu5hxAyy5BCiQOnjXYN3V52sa4bT45N5NISUkMjpGn1CSisQhNiQyCFEQSgESJacDslMNCHJYgBjQWFIaA+/n6GkNhCITyKnY/LSAu0cKhqd8Pj8Mo+G0BokcjSEr9mHHVN2YMeUHfA1x9ZKILR0oGrHHcJxnGDNOULBx5qlotEFt9cPvY5Dboq2K8pGS6bNDJNeBz8Dyql+lOQ0e5oxZdUUTFk1Bc2eZrmHIzkUk6Ml/ED9+nrhdaxweX0orePTx2nV2hl9Mm3YWVJHwccahndV5aUmwKCntWRH6HQcuqdacLTagZO1zeiRRnOIlPiZH+uPrRdeax0SORqCM3MY9M4g4XWsOFHbDD8DbCY9shLNMftetcLXyjlMwceahRc5JPq7RvfUBBytdgi1tghCLEjkaAidQYfsmdkx/96jVcHMKkof7xxq1Kl9qEZOeHRPDcTllNaRu4oQF7KjElFztDpYI4fonMKQNHLq16NNjrcElVPQcdfgRc7JOrLkEOJCIkdD+L1+VKypQMWaCvi9sfO1HhPSxynouCvw56nB6UWD0yvzaAgpoPTx8MhLDQRnl5LIIUSGRI6GYC6Gvdfuxd5r94K5YmchEDKrSOR0iQSTHqnWQFXqsnoyz2uR4zWUPh4OQXcViRxCXEjkEFHD18ihIMuuk5PcsnKlQEvN4XB7UdXkAkAxOV0lj3dX1TaTCzcGWI1WWI3xcW1S4DERFW6vHydqAyKnkGrkdJnuqQnYX9ZIlhwNUtJixUlJMCIlIfZ95NQIb8mxu31oaPYixUrnTSpsJhvs/xc/SQ9kySGi4kStA34GJBj1yEqi9PGuwheIO0Xmec1B8TjhYzHqkWEzAaDgY0JcSOQQURHqqqL08a7Di5xSsuRoDhI5kUFxOYQUqF7kLF++HIWFhbBYLBg1ahQ2bNgg95DiCr7/ErmqwiM3JTChk7tKe5RQjZyI6J5KcWqxwOl14pLVl+CS1ZfA6dX+/KNqkfP222/jvvvuw6OPPoodO3Zg0qRJuOiii3D8+HG5hxY3nGhpQkgTenjk0oSuWciSExlUKyc2+Pw+fFL8CT4p/gQ+f2x7HMqBqkXO008/jTvuuAN33nknBg4ciGeffRb5+fl46aWXZB2X0+PDxz+dgjuGtWrkgrdE8NlCRNfgLTmn6pyUTaIxSORERh5VPSYkQLUix+12Y9u2bbjgggtavX/BBRfgu+++a/MzLpcLDQ0NrX7EhjGGS57bgLtXb8e6AxWi719plLV0Dc6hTsthwcfkNHsC2SRa5t8/nsTij/bA6dH+qtHvZ4K7ikROeATTyB0yj4TQEqoVOVVVVfD5fOjWrVur97t164aysrI2P/Pkk08iJSVF+MnPzxd9XBzH4bwBgf5R720/Ifr+lQZvyelGlpywsBj1SGtJk9Wyy8rr8+N37+/Gyo1HsXzdYbmHIzmVTS64vH7odZzgkiS6Rrz0ryqtaxaEMCE9qhU5PKdn9DDG2s3yWbBgAerr64WfkpISScZ09ageAICv9leg1u6W5DuUgN/PUNEYmJByyZITNvEQfLzzRB0aXQFL1cvrDgvVsbUK76rqnmqBUa/66TWm8CKnvNEJj0+brn63149Ln/8Wk5d8jQVrd6G6pWgkIR2qvQszMzOh1+vPsNpUVFScYd3hMZvNSE5ObvUjBQNykjG4ezI8PoYPd5ZK8h1KoNruhsfHwHGgGjkREA/ZJBuKq4TXbp8fj/17t6ZjkI5Xk6sqUjJsJpgMOjCmXeG/v6wBNXY3/Ax4a8txTFmyDq9+83NcxG/KhWpFjslkwqhRo/D555+3ev/zzz/H2WefLdOoglx9VsCao2WXVXlLPE5moplWrRGQIxQE1OaEDgDftoicX0/uDZNBhw3FVfhkV9vuZC1wjOJxIkan49Cdrx+l0QyrnSV1AIABOUkYkpeMRpcXf/pkHy589hscrmySd3AaRdVPpvnz5+O1117DihUrsG/fPtx///04fvw45syZI/fQcPmI7jDoOPx0oh7F5Y0x+U69TY8pbAqmsCnQ2/SSfx9lVkWHkGGl0VVro9ODHS2T+k3jeuGuKX0AAH/4zx40ubQZbM3HWvRII5ETCXlpLXE5GrVu/lhSDwC4YFA3/PvuiXjq6mHITDThSJUdz31ZHJMx2Ew2sIUMbCGDzaT9+maqFjm//OUv8eyzz+IPf/gDRowYgW+++QaffPIJevXqJffQkJFoxpT+gQDkdzVqzTlFmVVRIbR20OiEvunnGvj8DAUZVuSnWzFnch/0yrCivMGFZz4/KPfwJIEX/nymEBEe3VOCjTq1yM4TdQCAET1ToddxuHZMPp66ZhgAYP+p2CyG4w1VixwAuOuuu3D06FG4XC5s27YN5557rtxDErhmVB4A4IMdJ+Hzay8OoZwsOVGh9cDjb4srAQATizIBBDLKFl82GACw6ruj2FsqfgkHuSlvpGzDaAgWBNTePdHg9AguqWE9UoX3++cEYkMPVzZRbI4EqF7kKJmpA7KRajWivMGFDS0TvpT4nD7smbkHe2bugc8pfU0SqpETHaGBx1oMxt1wKBCPM7FvlvDelP7ZuHhoDnx+hqc1aM2paAhky3RLpkD8SMjTcP+qXSfqwRjQIy0BmYnB66N7igVJZgO8fhaT7EOn14mZa2Zi5pqZ1NaBiA6zQY/Lh3cHALy3/aT0X+gDKt+tROW7lUAM6q7xgcdkyYkMfrXv9PhR5/DIPBpxKa1rxs+Vdug4YEKfjFZ/u2NiIQBgT2m9HEOTjCaXV4g1yqZ7IiK03KTzx5b4tBH5qa3e5zgO/XKSAASyr6TG5/fh3b3v4t2971JbByJ6+Jo5n+0pQ4NT2gcZZ+JQ9EIRil4oAmeSviM4HzBLlpzIsBj1yLCZAGgv+JjPqhqen4qUBGOrv/XOTAQQOGaHWzsByBUtoj/RbECi2SDzaNSJYN2s0551c2c7IgcA+nULiJyDMUpSiSdI5EjM0LwUFGUnwuX14+OfTkn6XTqjDnl35yHv7jzojNL/a8up2nHU5Gg0+Jh3VU3qm3nG39JsJqS2VHs+WqWdyq/lLa6qbHJVRQxvybG7tdXuhDEmWHKGtyFyBrRYcg6UURq52JDIkRiO4wRrzloNZVk1ubxCJVuy5EQOH3xcqiFLjt/PsJGPxynKanOb3pmB1FUtVUDmq393S6L7IVIsRj0yEwPWTS11Iy9rcKKi0QW9jsOQ7iln/J235Bwo11Yw/o7jtdhxvBaNEnsxOoJETgyYMTgHALCzpB5+CbOsmI+hdl0tatfVgvmkNfXyGUFJZJqPCt48X6YhS87eU4GqrjaTHiN7pra5TWGLy+pnDRVA42PUKOg4OoIZVtq5J3hXVf9uSUgwnVnDrH+LJaekphl2DdWQWvThHly5/Dt8f7hatjGQyIkBPdISYNBxcPv8QoqpFPidfuycuhM7p+6E3yltKqIwoZMVJyq0WPX42xYrzvjeGe1Wwu6dpT1LTrmQWUX3RDTwtXK0FHzMFwFsy1UFAOk2k9Aap7hCO8K/opF34cp3T5DIiQEGvU6o5Mn3tlE7VO1YHLprsOoxH3TM18dpi8IWd9XPmhI5gf8hZVZFhxYzrH4sqQUAjMg/01XF0593WcUgwyoW+P0MlbzIkbG3IYmcGJHfUuad71KsdsoaKOhYDLRW9djp8WHL0RoAwKSuiJzKJs1k0ZC7Shx4F65W3FU+P8OuEwFLzoj8tHa36x+j4GOr0YqmBU1oWtAEq1G69iO1Dje8LeEZoXWBYg2JnBiR39Kwr0Qj5cp5S04uuauiIrR/lRYe9j8crYHb60dOsgV9shLb3a4gIyByGpxe1GqkRhC5q8RBawUBD1c2we72wWrSo292+/dE/xgFH3McB5vJBpvJBo6TrtQI76pKb+kuLxckcmIE35W4RGuWHBI5UdEtJbDCcXn9mnjY7zoZWLGOLUzvcAJNMOmFh5kWgo8ZY0FLDmVXRYXQpFMjcWp86vjQvBTode3fE/00lkZeoQBXFUAiJ2bwIkcr7iqqdiwOZkMwZVYLK1e+sSJ/vXeEluJyGpq9cLX0HaI6OdHBx+SUNzo10cupvUrHp9OvW8DKU9XkQnWTS7LxuLwuzPpgFmZ9MAsur3TfwxfHzCKREx/kp7cEHmtE5JyiwGPRyNVQ8DEv1PjVeEcUaqhWDp81mWo1wmI8M0WY6DoZLe4NxoKLKTXTUaXjUKwmg7A4OCBh5WOv34s3dr6BN3a+Aa9funT1oCVH3mcEiZwYwV+8lY0uNLvV3S/E4/OjqmWlQYUAo4ePa9JCrRzexcCvxjtCEDmVGhA55KoSDY7jBFem2oOPnR4f9pcFBEt76eOhCO0dytTf3kHIrJLZskkiJ0akJBiRZAkUzTtRq25rTmWjC4wBRj0n9F4iIocXOWqveswYEx5KeV0RORqqlUMtHcRFyLBSeaLGntJ6+PwMWUnmLiVpCO0dNNDDiq8ATjE5cQLHcZqJy+GDjrOTLNB1EEhHdI3cFkFQpnKR0+AMduHmH1Id0ael6vGRaruklcBjQTmVVBCVnOTAPcG7PNTKjuN1AAKuqq5kMgWDjzUgchrIXRV3aKVWThl1HxcVwZKjctM8v+pOt5lgNXXe6iMvLQFGPQe31696t0QF1cgRFT5YtVLlIudQS/Xiwd2Tu7Q9b8k5WK7++lEV5K6KP3pm8Gnk6p7QqdqxuGgl8JgXaV2x4gCAXsehV4Y2XFZUI0dcBJEjYZZRLODv6a64b4FA/SijnkOTy6tq4c8YI3dVPJKvEXcVmebFJRh4rO6CgPykzLeq6ApaybAqbwy6cInoCVpy1C38w7V6mww69G5x4x5UcVxOo8sLp6elpILM9wS1j44hUhcE1Fl1OLvibOG1VAjp4ylkmheDbskWcBzg9vlRbXfLWgI9GsJJH+fprRGRUyFYctT5v1MaWYnacFfx7VrCqQzfPycJB8obcaCsCecN6Cb6mKxGKyp+WyG8lgL+fkgyG9rsuh5LwhI5hYWFEZWBvu+++3DvvfeG/TmtkZ8WrJXDGBO9pDbHcTBlSZ/txAce54SxYifax2TQITPRjMpGF8rqnaoVOeFkVvHw3cjVXBDQ7w+a5sm6KQ5aiMmxu7xocAYC8cOZK/vnJAE7pWvUyXEcsmxZkuybh78fshQg+sMSOatWrYroSwoKCiL6nNbIS0sAxwHNHp+qV+xU7Vh8clMsqGx0obSuGUPy2u9UrGQiETmFLaZ5Nbd2qHW44fEF3IxyV3fVCvx5bHB64fT4VFlgkV8MJpkNSDR3/VHbT+hhpd57Qgndx3nCEjmTJ0+WahxxgdmgR26yBaX1ThyvcYgucvwuPw7NPwQA6Pt0X+jM4rusGGMUeCwBuSkW/HSiXtXBx8HA4/Bjck7WNav+YZaZaIJRT2GOYpBsMcBk0MHtDRQe7ZEmXbdsqYg0C5XPsDpc0QSPzy/6NeXyujD/f/MBAE9f+DTMBvGFiFLSxwEKPI45+RLG5TAvQ+nyUpQuLwXzShPAWufwUI8eCeAzrEpVWvXY7fULKaPhxORkJpqQZDaAMfUG5CtpQtcKHMcJcTlqrZVzKkKRk5eaAKtJD7fPL8k94fV7sXzrcizfulyytg5B9638zwgSOTFGyLCqFv/i5Ywcei3shV4Le4EzSlOkj1+1pttMqlx1KxVeMKo1BiGQGRaILwqnCjbHcULl459V2t6hnGrkSILa43LKIgg6BgCdjhOsoWotEKqUvlUABR7HHCHDSoLWDjqTDoWLCkXfbyhllD4uCbzrsqrJLfNIIuNEXeB6zktNCHuO6J1pw08n6lWbYcXXyKHimOKidpETtOSEn6DRLdmMQxVNqm1Qyo9bCdZ+CjyOMWpv7VAuxOPIf/FqCX5Cr1LphM435gwn6JiHDz4+UqXOQEuqkSMNahc50SRo8I1e1eqq48ethEB8CjyOMcGYHPFjL5ifwbEvIJ6sA63gJOgrFc3qhGgfoS6ISiu8hlvtOBS1u6sqyLopCWq/J/i5Mlx3FQBkt1xLarXkVCooTi2qYoAejwdlZWVwOBzIyspCenq6WOPSLPnpfAn/Zri9fpgM4oVF+Zv9+GHIDwCASU2ToLeJHzND6ePSwLurauxu+P1MdY1P+b5VeanhZ8GovSBgORUClAQtxKkBkbkx+dRrPqhdTTS7fWhsadSrBHdV2E/YpqYmvPLKK5gyZQpSUlJQUFCAgQMHIisrC7169cLs2bPxww8/SDFWTZCVaIbFqIOfqbMhY7AQoPwXr5bISAwE6/r8DLUO9cXl8FlhkVhyClpETrXdjXqHR9RxxQJqcyINaq567GyphQZEZsnppmJLDp9ZZTHqkBRGfSCpCEvkPPPMMygoKMCrr76K8847D2vXrsWPP/6IgwcP4vvvv8fChQvh9Xoxffp0zJgxA8XFxVKNW7VwHKfquBx+dUITurgY9TqkWY0A1GmeFyw5YaSP8ySaDcLK9Ui1uqw5Xl+gjgugjFWrllBzTA5vgbEYdUhJMIb9ed4qKEVMToIxAUfmHcGReUeQYBQ/7CA0s0rsqv6REJbM+u677/D1119j6NChbf597NixuP322/Hyyy/j9ddfx/r161FUVCTKQLVEz3QrDpY3qVPkNPB+ZorJEZvMRDNqHR5UNbqBHLlH03UYYxFVOw6lIMOGikYXjtc4MCI/VcTRSUu13Q0/C3RUz7CRyBGT0E7kUrTBkZJgz6rwsw2B1pYcsY9dx+lQkFog2v5OJ1g3Shn3Q1giZ82aNV3azmw246677opoQPEAX71TijRyKXF6fKhrcSdQTI74ZCWZUVzRJFgG1EKN3S0UiIw0jVqt8Re8OyEr0Qy9yuKolA4fp+b2+tHg9EZkEZGLsihjF3mB5/L60dDsRYpVPcfOu6uUYtkULep15cqVYu1K80jdjVwq+AeQyaBDcoL8vlatEayVo64HPW/FyU4yw2yILNhdra4JCjqWDotRj2RLYJ5R23URabVjHotRL4g6vkSBWLh9bjz42YN48LMH4faJH/+npEKAgIgiZ+3atfj666+F35ubm3HjjTeKtXtNodaYHP7hm5VoVpXpWC1kqjTQMpKeVafDi5wKkSd0qQkWPVPGhK411Cp+o8ms4hHickTOsPL4PFj6/VIs/X4pPD7xA/358SqhRg4gosh588038eijj2L//v0oLi7GpEmTMGXKFLF2ryl6ZkjX2kFKqluq8fKZQIS4hMYgqIkTUQQd8/CrPrU9zCqopYOkqPWeKIuiRg6PWjOsBHeVQkRO1D6H+fPnY8SIERgxYgRWrFiBG264AYwxrFixAiNHjhRjjJqjR8vDoMHpRb3Doxp/K2/JEbt7OhEgs0U8qq21QzTVjnlUu2LnRY5CTPNaI0ul4veUCPXE+HtCbHeV1PD/K6VYN6MWOZMnT8ZPP/2Ejz76CPv370dpaSnGjx+Pzz77DKWlpbjkkkvEGKemsJoMyEw0o6rJhZJaB1KsKXIPqUsERQ5ZcqQgU6UP+pMhfasiJUul8UjBmBxlTOhaQ621cspCsqsihb+m1FYQMBiTo4zFcNQi5/LLL8fll18u/N7c3Izdu3fjp59+whdffEEipx16piegqimQMjskTy0ih3dXKePi1RpqfdDzlhwxYnKq7W54fX4Y9OJVApcSoRAgNeeUBDXGanl8fuFBH1VMjgqP3e31o6alCKJqRU5nOfsJCQkYM2YMxowZE9XAtE5+uhXbj9epKsOK3FXSwk/oNXY3fH6mmpTkaPpW8aTbTNBxgJ8FhI5aLCP8w4xicqRBjW7MykYXGAOMeg4Ztsit3sGYHPUcO/+MMOg4pFmVYfEPW+QkJiZixIgRGDVqlPAzaNAg6HTqWHkpBcEUqaKbl9xV0pJua93aQQ1istkdLF/fI4K+VTx6HYfMRDMqGl2obHSpQuS4vD5h1UoxOdKgRpFzKqQqfDQ96Pg6M2oKPA7tPq6U/nthi5wlS5Zg+/bt2LBhA15++WX4fD5YLBYMGzZMED1nnXUWhg8fLsV4NUMwyFS8m1eXoMOY3WOE12LDu6vU8PBVI0a9Duk2E2rsblQ1uVRxnvmeVTaTPuraSVlJQZGjBoS6UXodUlWSPKA21OjCFdLHoxTqfMZhRaO4FZ8TjAnY/Zvdwmsx4bMNleKqAiIQOaGVjF0uFxISEnD//fejpqYGW7duxYoVK+ByueDz+UQdqNaQovAbp+NgG2wTbX+nU03uKsnJTGwROSpp7RDasyraSVhtq/bykHogVDdKGtQYq8W3dIgmHgcIWnLcXj/qmz1IFcn9o+N0GJw9WJR9nU7QkqMcy2ZUSy+zOfBPuPbaazFs2DAAgM/nw549e6IfmcYRRE6jOtKFPT4/altaOpC7SjoyE804WN6EyiZ1mKjFKATIw6/a1RJoKYh+Ba1atUZorFaN3a2YtOSOEKNGDgCYDXqkWY2odXhQ3uASTeRIiZBZpaAYNdFlsV6vFwQP0T5SWHL8bj+OLDqCI4uOwO/2i7ZfAELsgY6DKm42tcKvXNUifqNtzBmK2iw5fCxSZhTBpUTH8LFagHriF4W+VSI0MeZdVmLG5bh9bixatwiL1i0Sva1DZaPy6kYp3/anUTKTAhNjjSNghhUD5mE4tvgYji0+BuZhouyThxdj6TZqRCglautfdVJES062yqrbkvs2Nqit6rFYlhwgaBERU+B5fB4sXr8Yi9cvFr2tg9CBXEGWnLDdVbNnz8aoUaMwevRoDB06FADIHx0B6VYTOA5gLCB0xGhmxhk4dL+ru/BaTIJBx7RqlRKhf5VKJnTeXdUjipYOPGqrbltFbU5igtosfNE25wxFba0dlFYIEIhA5Bw4cADvvPMOGhsbYTAEPr548WJMmTIFZ511FkaMGAGrNfJU0njBoNch3WpCdUuQqRgiR2fWod+L/UQY3ZlUNdKqNRaobUIX05KjtmPn3VVUHFNa1FT12O9ngiARw5ITbNKpFpHDZ1cpx10Vtsj55ptvAADFxcXYtm0btm/fjm3btuGxxx5DXV0d9Ho9+vXrR8HHXSAz0RwQOSpYtVfbqUZOLFBT/yrGmKim+WB1W+XfD0Co8Kd7QkrUJH6r7C54/Qw6LijOoiEYk6P8Y/f5mTBvqdpdxVNUVISioiJcd911wntHjhzB1q1bsWPHDlEGp3Uyk0w4UC5e/AVjDJ6qgI/VmGkU1Y1INXJig5pichqavfD4ArFfWSKYp/l9ONw+2F1e2MxRd52RFF74Z9jonpASNcXk8KI/K8ksSrq7YMlRQcZhtd0Fn5+B4xBVpWexCWsWOX78OHr27Nnu3wsLC1FYWIiZM2cCAE6ePIm8vLzoRqhhxH6g+R1+fJf9HQBgUtMk6G16UfYLhKxaFeRr1SJCXZAml+JbO/APnSSLAWZD9NdaotkAq0kPh9uHykaX8kUOxeTEBDVZcoLxOOIU2ctWUWsHPug4wyaOwBOLsEYyZswYzJ49G1u2bGl3m/r6erz66qsYMmQI1q5dG/UAtQwvcqpV4Jqo4uMPFKTQtUi6LRCQ7mdArUPZ14UU2UVqWbX7/Aw1DhI5sUCoeqwCkSO4b0Wq5xNs/+MEY+JmzIpNpQKDjoEwLTn79u3DE088gRkzZsBoNGL06NHo3r07LBYLamtrsXfvXuzZswejR4/GkiVLcNFFF0k1bk2gpkwasuTEBqNehzSrOlo7VEsgfLMSzThW7VD8qr3W4QZjAMcFMiUJ6VBTrJaYmVVAUOB5fAy1Do/Q3y4aLAYLtty5RXgtFvxzTAzXtZiEZclJT0/H0qVLUVpaipdeegn9+vVDVVUViouLAQA33ngjtm3bho0bN5LA6QJqCjLlXWpiBNMRHcNfF0p/0POWHDEtGcIDTeHZJLz1Nc1qUpRpXovw10STywuH2yvzaDpGzMwqADAZdIKwESsuR6/TY0zeGIzJGwO9TryQhmqFxm1G5PS2WCyYNm0arrrqKrHHE1dkJqnDDOv3M6HiMZnmpScrKdDaQenBx8E6MeJNamopCMj/b8h9Kz2JZgMsRh2cHj+qGt3omaHcWC2x+laFkp1kRo3djfIGFwYouJ9d0H2trHsi4iVIWloa3nvvPTHHEneopcNufbMHXn/AH0yZJNKjlr5mQlkBMd1VKgkyrZLAikW0DcdxIbFayrbwBUsqiNfdW+yCgG6fG0s2LsGSjUtEbevAu6/FcKmJScQihzGGl156CePGjcP48eMxd+5cbN68WcyxaR4h8Njuht+v3KAyfkJPSTDCZCDTvNSoJVarWgJLjlpEjhTHTrSPGgoCMsaCMTkiNhLNFtmF6/F58NAXD+GhLx4Sta2DUotjRvXE2rlzJ8aOHYspU6bgwIEDmDx5Mu6//36xxqZ5+FWgz89Q1yxuDxExofL1sSVLJW5MKXzwagkylcKKRbSPGsRvncMDlzfQh1DMYnjBDCvlHjsgTYyeGETl3Fy9ejWmT58u/L5r1y5cccUV6NGjBx544IGoB6d1jHodUq1G1Dk8qGpyKc7Mx1NFjQhjilosOVV2CQKPE9XRv0qpQZZaRQ0ihxchqVYjLEbxAnr5goBK718l3BMKC2mI2JKTkZGB/Pz8Vu8NHToUzz33HF5++eWoBxYvZKqgBgRlVsUWtWTdSdHWgF8BV9vd8CnahatM07xW4dsbKFn4Bytgi7tYVUNBQMaYcPzpCrPkRCxyhg8fjtdff/2M9/v27YuSkpKoBhVPCOnCSr55yV0VU9SwanV7/WhwBtJ5xQxG54sh+vxM0cUQKfA4tqjhnpAqTitbBcfe6Aq2eFFaxmHE7qrHH38cU6dOxcmTJ3HXXXdh2LBhaG5uxhNPPIHCwkIxx6hpgq0dlD+hk2k+NvAWsxq7cls78CUF9DoOKQlG0fZr1OuQbjWh2u5GZaNyiyFSw9rYoobA4xqJqsKHVj32+xl0CpwPeIEXSPcXz1UnBhGLnPHjx2PTpk2YN28epkyZIpSctlgsWLNmjWgD1DpqaMhIIie2nN7aQYnnnb8m0m0m0SfdrCQzqu1uVDS6MDBX1F2LhrBqV1j8gVZRhSVHohRq/tgDVY/dinSRKjXoGIgy8Hj48OFYt24dKioqsG3bNvj9fowbNw6ZmZlijU/ziJlJo7PoMPzr4cJrsQh2IFfeBaxFDCqwZkjR0oEnK8mM/WWNin2gOdxeONw+AMqc1LVIZkiRSMYYOE6J1gz+QS/u/WrU65CZaEJVU6AgYLT7txgs+PrWr4XXYsA/I5SYPCNK6cjs7Gxq4xAhwSDT6Cd0Ts8hbUpa1Ps5nSqJbl6ifTITA9YMpVr4pGjOyaP0VTtvxTEZdEhUeKd0rcCLaY+PodHlRbJFPBepWEjlrgKArCQLqprcqGh0YhCSo9qXXqfHlIIp4gysheCxK+8ZQZXdZEbpMTmMMcqukoHMJPHErxRIGYyueJHTMqFnJZoVaVHQIhajHjZTINajWqFzZbWErW/4NPIKhWZYKbWlA0AiR3bEjMnxe/w4+eJJnHzxJPwef9T7AwCH2wdny774By8hPUoPtBRq5EiwcstSeJ0g3rVMrqrYkhESkK9EqkPi1MSmW5J4rR08Pg9e3PIiXtzyomgVj5Xa0gEQSeRs374dbrcy1bXS4X3N1U1uIXg7UpiboXhuMYrnFoO5xakxwouvBKMeVhOZ5mOF0i18QuEvCYSv0juRS1UPhegY/gGq1HtCSpeNUBBQhE7kbp8bc/87F3P/O1e03lVKDmkQReSMGTMGR48eFWNXcQc/Ubp9fjQ0e6PbmR7IuiYLWddkASJl8QmZVWTFiSlK71AvmKelsOQovBM5FQKUB36u5MWEkvD6/Kh1BKwikrhwFV4QkP+fKNFdJcrSPFoLRDxjMeqRZDGg0elFZZMLKdbIA+r0Fj0Grxks4uiAykYqXy8HinfZSBiTI1S3VazAo+KYcsCfbyWKHF7gcByQZpVA5PDNnBU6Hyi5pIIqY3KOHj2KO+64A4WFhUhISECfPn2wcOFC1brMshRcK6dawtgLon0ylR58K6F5mrfkNDq9cHp8ou8/WoLNOemeiCXpNuXOk7zwSrOaJCnema5gKxYQvCeUGJOjyiCL/fv3w+/345VXXkHfvn2xe/duzJ49G3a7HUuXLpV7eGGTmWjGz1V2Rd68VS2WnCxyV8UUJfevYoyhSsJ02WSLASaDDm6vH5WNLuSnW0X/jmiQMh6JaJ9MBVtypAw6Dt1vtQKP3e9n2ndXxZoZM2ZgxowZwu+9e/fGgQMH8NJLL6lT5PDpwlGu2n12HzYkbgAATGqaBL0t+sAcqnYsD7w1Q4mtHZpcXri9gYw7KVw2HMchK9GMk3XNqFCgyBGCLMmSE1OEB70Chb/U2UX8YqLRGbj3TAblOGHqmj3ge+mmKdCSo5wzFSX19fVIT0+XexgRoeRMGsokkYd0a7C1g9JWrvxDxmqSLuNOybVypIxHItpHydYMqS0ZKQlGYaGjtMa1vBUr1WqEUa88SaFKS87pHD58GM8//zyWLVvW4XYulwsuV3DSbGhokHpoXULJ/at4dxUfI0LEBoNehzSrCTV2N2rsbuGhrwQE4SvhQz5boRlWAdM8WTflIFPBdXKkdlfpdBzSrEZUNblR3eQWmnZGgtlgxn+u/4/wOlqU3NIBUJglZ9GiReA4rsOfrVu3tvpMaWkpZsyYgZkzZ+LOO+/scP9PPvkkUlJShJ/8/HwpD6fLKFrkkLtKNoLmeWVdF1UxyKRQqiWnlWlegiwaon1Cg2+VltFbHYO2BvzxR2vJMegMuKTfJbik3yUw6KK3cwhWLIW6b0Wx5CxcuFCUppxz587Fdddd1+E2BQUFwuvS0lJMnToVEyZMwN/+9rdO979gwQLMnz9f+L2hoUERQoc3cVYq0F1VpeBy3VpHqeb56hg0bA2KHGUVBOQFZ0qCUVFxEfFAekj/qganFykJyulfFYuyAoqdD2Jg2Y0G0USOGGRmZnZZLJ08eRJTp07FqFGjsHLlSuh0nU84ZrMZZrPy1KZSC7+5vD40OAMFCsmSE3uUWvxMyuacPEq15FTFQOARbWMx6pFoNqDJ5UV1k0tRIqcmBm0NBEtWlJZdj8+Df+76JwDgxqE3wqiP7jwqPUZNlTE5paWlmDJlCnr27ImlS5eisrJS+FtOTo6MI4uM0Do5jDHFNP3jVydGPaeoCSVe4CcN5a3cpJ/UlNq7S8nl6+OBdJsJTS4vauxu9M6SezRBYlFPTKxaOW6fG7f9+zYAwMxBM6MWOcF4JGXeE6oUOZ999hkOHTqEQ4cOoUePHq3+pjRfbVfgV8Qurx9NLi+SLMoQFKFVLJUivOIJftJQWkxOZQxSqJVqyVFyt+V4ICPRhOM1jrgU/sJ8oLBjV3KNHEBhgcddZdasWWCMtfmjRhJMethMgZo2SkojD65alXnxah2lu6ukvC54AVWjtHTZGASYEu2TocBaOV6fH3V83yoJ3VXKnQ+UfU+oUuRoESEuR0Gr9krKrJIVxQYaCnEpEprmWwSU0+OHwx1l41oRUXr8gdYRxK+C0sh5Ic5xQKqEGXdKbe1QpfDAYxI5CkFII1eQeT4WDzOifZTakDAWpnmbSQ9TS2ExJa3apezZRXROugLbnUjdt4pHqZacGsG6qUyRE1ZMTmFhYUSxGffddx/uvffesD8XTwR7FSlH5FD6uLwEV63KmdS8Pr9Qp0NK8zTHcUi3mVDW4EStw62Y1g7VQk0QuifkQIkP+pqm2Dzk0xW46PGEuuoUKvzDEjmrVq2K6EtCa9sQbcNbS5RUKycWsRdE+4QW/1JK/6pahweMBUzzaVZpA+TTWkSOktx1gvBXUAXqeEKJ1s2qGKSPA4FWL0BgPvD7GXRKmA9ajl3HAakKzcANS+RMnjxZqnHEPWJUPebMHAa9M0h4HS0UZCkvvIhgLDCxKcFtyKfKpllNMEjcp4ZfGdcq6IFWHaNVO9E2fIaRkizeNTGKXeSbX/pZoPJ2pKLKbDDjnWveEV5HQ2hLByWIrrZQZQq5FhGjIKDOoEP2zGyxhiRM6OlkyZEFg16HVKsRdQ4PauwKETkxfMgrLdDS6fGhyRUIglaqaV7rKNJdFSNLjlGvQ7LFgAanFzV2V8TfZ9AZMHPwTFHGVKOChTDF5CiELAXG5Cg9oCweyLCZUOfwBMRFN7lHE9teZkoTObxl06jnkGyh9aEchLqrlFI4NVbuKiAgrhucXlQ3udFXvPVsxCi9pQNAMTmKIeiuinxC93v9qHq/KrC/KzOhi6K3DmMsZisUon0ybGYcrrQr5kEfyxRqxYmckCKISni4xiP8NeH1MzQ0e5EicVxYV6iJYauPdJsJR6rsUTXp9Pq9eH/f+wCAKwdeGVWTzuB8oBFLDsXkSIcYMTnMxbD32r0AgElNk6JyRja5vHD7/ACUbYrUOsFaOcqw8MWibxVPmuJEDtXIkRuzQY8kswGNLi+q7S5FiBz+3oxFWwMxame5vC5c++61AICmBU0wmCJ/UASFv3LvCaqToxD4mByH2xd58TMdkDI5BSmTU6L+z/IPlgSjHgkt1ZiJ2MPHQymlVkwsY3KUFn9BxTGVQbrCerrFom4Uj3BPKGQ+UENIQ1SOZY/Hg7KyMjgcDmRlZSE9PV2sccUdNpMeJoMObq8fNXY3rBGoa32CHiPXjRRlPLG8cYn2UdqDPuiDj4ElpyVlVimtHciSowwybCYcq3YoRvjH8kGfJoIlR0zU4K4Ke73f1NSEV155BVOmTEFKSgoKCgowaNAgZGVloVevXpg9ezZ++OEHKcaqaTiOC9ZBsHtkHk3sClwRHaM0kRPLmByl1USJpauOaJ9go0r5XbihxfBiEnissPlADYHHYYmcZ555BgUFBXj11Vdx3nnnYe3atfjxxx9x4MABfP/991i4cCG8Xi+mT5+OGTNmoLi4WKpxaxIlxV9Q0LEySE9UzoQOBMcRiyBL3pJT5/DA2xIfJifVKjDNxwP8tacElw0fAKyTuG8Vj/KC8ZV/T4TlE/nuu+/w9ddfY+jQoW3+fezYsbj99tvx0ksvYcWKFVi/fj2KiopEGWg8EFrhNhJ8dh82FWwCAIw/Oh56W+SxNFUxDKYj2kdpXZdj2XE4tKJyXbNHdgtKFfWtUgRKalzL3w9S963iUdKxAyGuOgXfE2GJnDVr1nRpO4vFgrvuuiuiAcUzwWySyN1VnipxXF01FH+gCJS0cnO4vXC4fQBic10Y9DqkJBhR36yMYohqWLXGA0p60Mfa4s0vLpRQBbx1cUzl3hOiVLSqq6vD//73P5w8eRIcxyE3NxcXXngh0tLSxNh93BD0t8rvmiB3lTLICLHuyd2vhn/Imww6JJpjUwwvw2YSRI7c1FAwviLgxa4S5slYJ2iki1AM0aQ3YeXlK4XXkcIfu0mvQ1KM5oNIiDqF/PXXX8fYsWOxadMm+P1++Hw+bNq0CePHj8frr78uxhjjBiGbRAGBx9UkchTB6f1q5IS/JrISY1cMTymWLMZYSD0UuifkJF1BLtzQApGxgE9Ocfv8ghUlXIx6I2aNmIVZI2bBqI+8zlBNSN8qJRfHjFp+PfXUU9i+fTsSExNbvf/HP/4Ro0aNwh133BHtV8QNQZUu/wpFDfUP4gFjK5dN5P1qxIDvqxZLS4ZSCgI2urzw+BgAKo4pNxkKqpMTa+tegkmPBKMezR4fauxuJFnkK4ZYpYLMKkAESw7HcWhqajrj/aamJkWrOyWiqBRyFQSUxQu80Iym5YcYCOmiMRRaSkmZ5VetVBxTfkLjUvx+JutY5LB4RxuT5PV78fHBj/HxwY/h9UdYeBahdaOU/YyI2pKzdOlSTJ48GUOGDEFeXh4A4MSJE9izZw+WLVsW9QDjCcE0r4DiZ3I80Ii2SbeZ8HOV/P2r5Cj8pRRLDrlvlUOaLWC98PoZGpyemKRut4ccbQ0yEk04WdcccQq9y+vCpW9dCiC6tg5C3SiF3xNRi5xLL70UF110EbZs2YLS0lIwxpCXl4exY8dCr6cVTzgoJf7A4fbC6QnUJaFJXX6UYp6XI7tIMZYce+yaMBIdYzbokWQxoNHpRbXdLavIkcPirZTFsFqSU8IWOW1FdOv1ekyYMEG0QcUr/AqlzuGGz89iUnehLfiHmdmgg5VM87LD1yqSu/gZX78plpMaH4wfTddlMaihoGNFkWEzBUROkxt9suQbR3WTfO4quYW/Glo6ABGInMTERIwYMQKjRo0SfgYNGgSdjnp9Rgs/ofsZUN/skW1CDa3sSnFV8iMUBJQ5IJ2fVNNiOaErpEFplfAwU/aEHi9kJJpxtNohe5JGtQwWPqVYN9XQ0gGIQOQsWbIE27dvx4YNG/Dyyy/D5/PBYrFg2LBhgug566yzMHz4cCnGq2mMeh2SLQY0OL2osbtlEznCqlXhF2+8oJTiZ3Jk3KVblTGhU40cZaGEe8Lj86O+me9bFUt3VUurF7kTEVRSHDNskRNaydjlciEhIQH3338/ampqsHXrVqxYsQIulws+n0/UgcYLGYlmQeTIRTWtWhVFhkJ69chiyQmJP4i0+JkYqCX+IF5QQrsTvuqwjgNSE2KXyp3eEtYgtxVLLRm4UQUem82Bg7v22msxbNgwAIDP58OePXuiH1mckmY14gjkXblSjRxlwafMKsaaIYPIcXv9sLt9Mau0fDqUXaUslNChPvSaiGUl8nQFzAeMsWAvN4XfE6LPGHq9XhA8RPhE06STM3EoeqFIeB0pJHKUhRJM881uH5o9AetsLC05VpMeZoMOLq8ftXa3bCKnJobd14nO4R/0/INWDuSy7kU7H5j0Jrxw0QvC60hwuH1weQMZuEp34Sq34UScEk3kvM6oQ97deVGPQVihKPzijRf4SUTO/lW86DbquZj2qeE4Dhk2E0rrnai2u5Gfbo3Zd4dSQy5cRZGpAEtOVYxbOvAI/ewiPHaj3oi7x94d1Rh4N6HFqIM1wjo7sSLslKjZs2fj5ZdfxtatW+FyBf7JlIEjHkoofkaWHGXBZ935/EwIdIw1QjyONfYZd2lRTurRwhhDFd0TikIJadQ1Mi0G+e+zu31weuSJfQ0Wi1W+6A9bgh04cADvvPMOGhsbYTAEPr548WJMmTIFZ511FkaMGAGrVZ7VlhaIJj2Q+RjqNtQBAFInpYLTR/Yw4itZ0qpVGZgMulbFz2LpLuKRM/BWbned3e2D20vFMZUE/3+Qs9WJXNlFSWYDjHoOHh9Djd2N7qkJYX3e5/dhw/ENAIBJPSdBrwu/Fpqasg3DFjnffPMNAKC4uBjbtm3D9u3bsW3bNjz22GOoq6uDXq9Hv379KPg4QtKiSJn1O/3YOXUnAGBS0yTobZEV8qMgS+WRmWhGo4xZd0oQOXJZcmqoOKbiyGzJ6JHThRusJxbbxSDHcUi3mVDe4IpI5Di9Tkx9YyqAQFsHm8kW9hjkKIIYKRE704qKilBUVITrrrtOeO/IkSPYunUrduzYIcrg4pFoAo/BAdZBVuF1pJC7Snmk20w4UmWXLW1UjvRxHrktOaF93Mg1rwxOd+HKY92Ur55YmjUgcuS7JzQqco4fP46ePXu2+/fCwkIUFhZi5syZAICTJ08KTTuJriFM6BGYYfVWPcbuGRvV9zs9PjjcAT8vBR4rB7nN83IKX74goGyWHJXUA4knTIZg4VS5Xbhy3BPBFHq5Fj18tqHy74mwAo/HjBmD2bNnY8uWLe1uU19fj1dffRVDhgzB2rVrox5gvBGVJUcEeIUe6ywaomPkLuXONwNMk6EZYrrMDUrVtGqNJ3jRKdc9Ied1IXfVY826q/bt24cnnngCM2bMgNFoxOjRo9G9e3dYLBbU1tZi79692LNnD0aPHo0lS5bgoosukmrcmoW/aBwtkfMWY2xjAGqagn5mMs0rB7mzSWplDDQMtnaQ11VH7ltlwbtwq2WqlVMro8jJUMhiWA0iJyxLTnp6OpYuXYrS0lK89NJL6NevH6qqqlBcXAwAuPHGG7Ft2zZs3LiRBE6EJLZEzgPhP9B8Dh+2DN6CLYO3wOeILLWwmrotKxJ+1Sq3NUMWS44wocuTPh/MNqR7QklkyBir5fMz1Al9q+S7J+RORFBDccyI/BEWiwXTpk3DVVddJfZ44h6O45BmNaGiMYLIeQY49jqE15EgpEWq4OKNJ4LuKnlXrXLGH8i1YqfimMokQ8YO9bUON1jLHBvLvlU80cRuikEw21JjMTmhpKWl4b333hNzLEQLcqp0akSoTJQyqckR4MlbjxqcXnh8/ph/P7mrlEmwp1vsxS8v+lOtRhj0ET9GIyaaGD2j3oinpj2Fp6Y9BaM+fIGmpr5VQBQp5IwxvPTSS3jqqafAcRxGjx6Nm2++GePGjRNzfHGJnMHHavK1xhNyplH7/Uy4FuW4LlKtJnAcwFjgnshOssT0+9W0ao0neEtOlQz3hNzzZDSV8U16Ex4858GIv1tNfauAKCw5ALBz506MHTsWU6ZMwYEDBzB58mTcf//9Yo0tbpFz1V5jV49CjyeE4md2NxiL0BcZIfXNHvhbvlKOmBy9jhNcArX22MflkAtXmQgWb1nmyRaRI8P9AMgbj8Qfuxr6VgFRNuhcvXo1pk+fLvy+a9cuXHHFFejRowceeOCBqAcXr8hpyaFVqzJJswUe8l4/Q0OzFynW2MUB8OnjSWYDTIbYm+aBwD1R6/C0BMYnxfS7yV2lTDKFYPzYu6vkduvz31vf7IHH54cxDJeZz+/D9lPbAQBn5Z4VdlsHuRqTRkrEM1ZGRgby8/NbvTd06FA899xzePnll6MeWDwjZ0yOUKqcVq2KwmzQC3WLYj2p1yog8DbY2iG2lhyH24vmliaI5MJVFvJavOWdJ3kXLgDUhZl16PQ6Mfa1sRj72lg4vc6wv1vuYw+XiEXO8OHD8frrr5/xft++fVFSUhLVoOIdJQQe06pVechVFE/O9HGedJmyy/gHqEmvQyIVx1QU/EO21uGGzx9bF26NzPeEXsdF1ecwGuSORwqXiEXO448/jhdeeAE33HADvv32WzQ0NKC8vBxPPPEECgsLxRxj3CHXxQsE/dtquYDjCblWrnKmj/MERU5sLTmhbgkqjqks+HgYPwPqYuzal9tdFfrdsbbsqqnaMRBFTM748eOxadMmzJs3D1OmTBGCIS0WC9asWSPaAOMRuUr4u7w+NLq8LWNQh781ngimzMpkyVHAhB5rS44SHmZE2xj0OqRajahzeFBtd8e0t5gSXDZyWfzV1LcKiDLwePjw4Vi3bh0qKiqwbds2+P1+jBs3DpmZmWKNLy5JkynwmL9ZDDoOyQlkmlcachUElLN8PQ9v3ZTLVaeW+IN4I8NmCoicJjfQLXbfK7e7CpBvMaw2d5UoT7Ls7Gxq4yAiwb4kHvj9DDpdbMzkvBkyjUzzioSPyYl1J/IaGWvk8ITGX8QSKqmgbDISzThcaY+5yyYYuyifNUMu97Xa3FXy5IMSHZLasjrw+RkanLGLQaCgY2Uj18pN7poggHxdl4MTujpM8/FGhgwPesZYSAXw2Ld04JF7PlDLcyIsS05hYWFEK/z77rsP9957b9ifi1dMBh2SzAY0uryosbsF0dMZnJFDr4W9hNfhQvEHyoa3ZsR6UlOCu4oXWLG25JC7StlkyJBxaHf74G5pL6IES06484FRb8TCyQuF1+ESjEdSh/APS+SsWrUqoi8pKCiI6HPxTHqiSRA5vbO69hmdSYfCRZFntlWr7OKNN/gJtSrGjSoVEXgcIvAYYzFzp5LwVzYZgoUvdvcEn4GaYNQjwRReIT0xSY+wGKJJb8KiKYsi+k619a0CwhQ5kydPlmocxGmkWU04Vu2I6aqd4g+UDZ/NEOuYHEWkkLdYcjw+hiaXF0mW2LgJ1BZkGW/IYd3kRYXc14Qc7qrQvlVyH39XoZgchRLJBcz8DPY9dtj32MEiKI5Fq1ZlkylM6C74Y1T8zOnxwe4OVPyV05KTYNIjwRhYNcsh/DPJXaVIMmSI1ZKzWW0okQYe+5kfeyr2YE/FHviZP6zPtu5bJZ8VKxwoJkehCF1mw4hB8Df78cOQHwAAk5omQW8LtyeJMm5eom34a8LPgLpmT0z+T/yEbtBxSLbIW1Yg3WbCybpm1Njd6JVhi8l31lDgsaLh74GqGGZXKSW7KJiF6w4rC7fZ04whLw0BADQtaILN1PV7KbRvlVoycCkmR6EEe/WEGVSWGbkZX21R8/GGMbT4WZMrJpNsTUg8jtyTWqjIiQWhViy5H2hE22TK4K5SiiVHjkWPGq39FJOjUIIlu7t+8+ptepxTeU7E36nGCzje4IufVTW5URSD4mdKSB/nSYtxDAJ/7xn18luxiLbhkyTqHOF3444UpcRpGfU6JFsMaHB6UWOPzaJHjdmGFJOjUISU2VgG1PGmSBVdwPFGRoQZFZGiJOGbEYHwjwbeVZVmld+KRbRNaoIRvJcmVnOlkvr7CfNBjGKSlOKqCwcSOQol1n1JPD4/Gpzelu+m+AOlwpvnYzWpKVHkxM6So4wsGqJ9dDouIqt3NCjFXRU6hljdE2rMwCWRo1AiCTz2NfuwY8oO7JiyA75mX1jfx6+CdFxgdUQok1jXBVFCIUCejMTY1glSQhNGonNinWGlFHdV6BhiJfDUWEuNHM0KRYict4fR1sEP1K+vF16HQ+iNG6teWUT48A/cqhhPanKmj/PE2pKjhP5EROcEH/Tx68KN9T2hhGPvKiRyFAr/UGlyeeHy+mA2SFuTIDQ1kFAugjWjMUaWHIdyMu4yYuyqU9KKnWifWF8XSnrQR+KuMuqN+O2E3wqvw4E/x0qYD7oKiRyFkmwxwKDj4PUz1No9yEmJjcjJTFLPxRuPZMW4V0+Nkiw5ibF11VWrrHx9vJIZw2B8t9ePxpbYRSVcF5G4q0x6E5ZcsCSi71Nb3yqAYnIUC8dxwoMlFjdvVWPg4s1U0cUbj8T6Qa+kFPLQ7CrGpK/4LBw7xeQomkgr/0YCb9nU6zgkx6i1SEdkhFRBlxrGmPAsUoLA6yokchRMMI08jLicCKkSyteTyFEyGTGc0AGgpuXaU4Jpnp/QXV6/UKRPSoQgSwUcO9E+sexELlg2rUZFxC5GEnTtZ34crTuKo3VHw2rr4HD74PSoq28VQCJH0aRHkGEVKbwlhzJJlA1vyWl0eeH0SPug9/uZotJlrSZDsH9VDEReMPaChL+SCQp/6a0ZSorHASKLyWn2NKPwr4Uo/Gshmj3NXf4c/x1mg3r6VgEkchSNcAHH4OYVYnLIkqNoki0GGPWBFaTUGRWNTi98LY1A02zym+aB2PYq4oUUCX9lwwv/WGQYBS05yrgm+Guz1iG9C5e3lGUmqqdvFUAiR9HwD5YaRwzcVS0iJ4tEjqLhOC5mdUF4C2Ki2SB5dl9XiVUxRJfXh0aXcgJMifaJpQtXabWTeNHv8TGhmKtU8JYypVixugqJHAWTHsPCb9W0alUNwVo50l4XNQqs+BtctUt97MoKMCXahxf9jS3lNqSkWmGWHLNBj0RzIElaakuWWksqkMhRMLHqsBsaNU/uKuUTq341fNCxEtLHeQR3lcTHXh3St0oJAaZE+yQnBMptANLPlbUKDEZPj1FMktKsWF2FRI6CyYxRGfv6Zg88voA/V20XcDySKTzoY2TJsSrHkhGrwm81CnyYEW3DcVzMrwslWTNi1dpBrXWjSOQomFj5mvmHZbJFObEXRPsEJ3SpRQ6fPq4c616mLTbuKqEeCIl+VcBfo1ILf/66UJJ1M1atHapVmm1IFY8VTGZS4GKq7OKNyxk4dL+ru/C6q/Cmf3JVqYPYuav4mBzlWHJitWrlSypkJdE9oQZi5drna5Ypqf1NuGnkBp0Bd42+S3jdVdTqrlK9yHG5XBg3bhx27tyJHTt2YMSIEXIPSTT4VWujs2v9q3RmHfq92C/s76H0cXUhuDElntCVaMkRgq4lFniVdE+oilhZvZUYfJsepqvObDDjxUteDPt71Ni3CtCAu+qhhx5C9+7d5R6GJCQnBGuiSHnz8s0eqW+VOoiVuypYCFA5lpzMGGVXVbbcE2TJUQeCu0rC60JpxTF5gu6q2AQeK+nYu4KqRc5///tffPbZZ1i6dKncQ5GEcGuiMMbgrnTDXRleYShyV6mLzBjVyVGiDz60T5GUxc/IuqkuhB5OEt4TSiyOCYSUGumiZZcxhkp7JSrtlV2+h9Scgatad1V5eTlmz56NDz74AFartUufcblccLmCarehoUGq4YlGZpIJZQ3OLgXU+R1+fJf9HQBgUtMk6G1dCyIONl1T18UbrwR79bjAGJOs+mitXXmWHF7keP0MDc1epEiU+UWWHHWREYNYLX6eTFJQcUwg/MBjh8eB7KXZAICmBU2wmWydf0alfasAlVpyGGOYNWsW5syZg9GjR3f5c08++SRSUlKEn/z8fAlHKQ688Ohq8HEkVPIdyMldpQpiVeVUib2bLEY9klqKn1VLaJ6nCuDqIhiML901IbR0UNhDPpL+VeGi1r5VgMJEzqJFi8BxXIc/W7duxfPPP4+GhgYsWLAgrP0vWLAA9fX1wk9JSYlERyIemWFk0uhtekxhUzCFTemyFQcg07zaaPWgl2hSd3l9aGppa5CukOquPOkSd532+vzBPj0k/FVBLDqRKzUmJTTjUCoXrlr7VgEKc1fNnTsX1113XYfbFBQU4PHHH8emTZtgNrd+KI8ePRo33ngj3njjjTY/azabz/iM0skUskmkX7Vmqiw1MJ7JSDSh0eVFVZMbvbPE3z+fKmvQcUiyKGqaQIbNhGPVDslikmocbjAG6Dhy4aqFWGRXKVXk8ALP7fXD7vYJbR7ERK19qwCFiZzMzExkZmZ2ut1zzz2Hxx9/XPi9tLQUF154Id5++22MGzdOyiHGnMwYmGGrKfBYdWQkmnG02iHZdcHHpGQkKq+tgeCakMhdxR97us0EvcKOnWgb/ppo9vjgcHthNYn/aKtRYGYVAFhNBliMOjg9ftQ0uaUROQoVeF1BUSKnq/Ts2bPV74mJiQCAPn36oEePHnIMSTLCqQvic/qw/+b9AIAB/xgAvaVzl5Xd5UWzJ9DUjkSOeuBXrlLVyhFiUhQYeCv1qp0XOXQ/qAebSQ+zQQeX14/qJjes6RKIHAXXicmwmXGyrhnVdhd6ZnQtEScc1NzmRFExOcSZhNW/ygdUvluJyncrgS424+X3m2DUwybBCoCQBqkDLZX8oM+QuLotv6BQosAj2iZQbkPauBylBh4D0gcfqznbUBNPtYKCAklrZsiJ1BVeeZGjtlLd8U6WxA0JKxWcXZQhcZ8iYUJX4LET7ZORaEZpvVOyonhKdVcB4bU7MegMuHX4rcLrrlBBIoeQiqyQCq9+PxM9PoIKAaqTWMWlKHFSk7rjtJJddUT7SL0gVLLLJhzrptlgxqorVoW1/4oGJwAgO9kS9tjkhtxVCoc3jfpZsMy+mFD6uDqRekJXcu+mDKETOcXkEEHSJY7V4verRHeV1J3I1WzdJJGjcIx6HdJaqrpK4WsOdltW3o1LtE+w3UccW3Li0IpFtI/Ufc34RaYSLTnpYbhwGWOwu+2wu+1dDvPg74nsZPXdEyRyVADvmuAbaYoJtXRQJ5kSFz9TsoUvdNXq94sfi0fuKnUipSXH6fHB4Q5kc6jdkuPwOJD4ZCISn0yEw+PodPtmtw+NLYVBs1V4T5DIUQFCQUApLDlUCFCV8MK3zuGBx+cXff9KtmaEunDrmj2i71/JrjqifaQsq8AvJox6Tqg2riSkzK6qaAzE41iMOklq8EgNiRwVIKUlp0roW0UTuppITTCCj0EXe2JzenxobOmJpUSRY9TrkMq7cEV217m9ftQ5AsJJicdOtI+U7qrakGJ4SmxrkC5hML7gqkqyKPLYO4NEjgrIkjCTRkghJ3eVqtDpuLD88OHA78+k1yFZYS0dePiVq9iB1/w9ptdxSE1QTvd1onOkdFdVKnyelDLwuEIQOco89s4gkaMCBDNso3TuKgo8Vh+ZEq3eQl1VSl25ZUqUYRXMrFJeOwuiY0JLC4hdN62yQdmBt7zAa/b40OzuYiXYLhJMH1fmsXcGiRwVwLuSxLbkuLw+NLS4JSj+QH1IlWUUrJ2kXOEr3bErNxaJ6Bh+DnP7/EKgrFjwcSlKtWYkmg0w6QOPc7HviQoVp48DJHJUAW/JqRTbNN+yP4OOQwqZ5lVHMI1cOkuOUpHKNUE1ctSLxahHUot7taJBmgd9dpIyi+FxHCdZ8HEwfVyZx94ZynS4E60QLDmdxV7ogaxrsoTXnRHa0kGpbgmifYJ9zcSd1NRgzZCq4rPQt4pEjirplmxBo7MJFQ1O9M1OFG2/FQp3VwEB4V/W4Oy0rIRep8c1g64RXneGmls6ACRyVEFmSIApY6xdQaK36DF4zeAu77eaWjqommAMgrgPejVYM6SOR6JsQ3XSLdmMQxVNKGuJIxELpburgJDWDp3cExaDBWtmrunyftUucshdpQIyW4KCnR6/UJBKDKgeiLqRqiCgqtxVYh+7ghuTEp3TrcWdVC6yu4rfX5ZC3VWAdLVyKim7ipAaq8mABGPArChmurCSq9oSnSNVawc1XBdSHbsaBB7RPt1SeJEjniWHMaaKB70Uwt/r8wsuYaXGI3UGiRyVwFtzOoq/8Nl9WMetwzpuHXz2zi0+QiFABWfREO0jVZPOShXE5EhlxapSgauOaJ9uLdcs714Sg/pmD9wtVcWVfE8Ea+V0LPztbju4xRy4xRzsbnuH21bb3WAsUDcqXYHtLLoCiRyVkCFB4TdeodOErk6CgccuUeuCVKkgZZSfcOscHnhFbGuhBoFHtE+3lgygsnrxRA4fk5KSYITF2IWMDplIl6B2FB9wnWEzQa/SulEUeKwS+AdaR4GWOqsOZ1ecLbzuDMEtQYUAVQlvyXF5/bC7faL0lbG7vLC3xH0pOfg21WqCjgv0r6pxuEUxpbdqZ6FggUe0T9BdJd5iUMisUvD9AEjjrqpsUnchQIAsOapBaNLZgSWH4ziYskwwZXUtJZx3Vym1VDnRMaGxWmLFpvDXV4JRD5tJuavWUPO5WBlWrdpZJND6T43wlpyKRqdo1k0hs0rhD3q+an2liD0OgwJPnfE4AIkc1RC05FDgMRGEt+aINbGFWveUXjtJ7GwSNbSzIDqGt8B5fEy060LphQB5BIHXIJ77Wu3VjgESOaqhK0GmfpcfB+8+iIN3H4Tf1XGcgs/PUOPgO5CTu0qt5LaY58WqC1KpoklN7Di10L5VhDoxGXRCAK5YLiu1uKt4Eeb2+UUX/kq3YnUEiRyVEBpk2h7My1C6vBSly0vBvB0r+ZqWqHmOA9KtNKmrlZyUBADiBVqqKYU6Q+SCgEK1YxUcO9E+vEWjXKQMK95dpfTrwmTQCQJdrEWPGoogdgaJHJWQ0YWYnHDg95NmNcGgp8tArfCWnFNiiRwVVcHOkMhdpYZjJ9qnW4vVoVyke6JCRb2bBIHXgcjR6/S4uOhiXFx0cadtHYLVjpV/7O1B0XUqIUvo1SNukCWZ5tVNjsgps+qy5Ijbv0oNPbuIzgk+6MV1Y3ZTwXWRk2zBntIGlNW3f+wWgwUf3/Bxl/anpvmgPWgJrxL4Cb3O4YFHhLog1LdKG/CWnNL6ZlH2p6ZgdLGLIWphQickcFc18NlVyrdm8Cn0ZSLMB4yxkKBr9d4TJHJUQmqCUSjGJIZ5Xk0PM6J9clPjOCZHZHcV3RPaIJhlFP09EVo3Sg0PesGyK8KxNzR74fYqv9JzZ5DIUQm6kLogYqQL85VdM8hdpWp4S05Fo0uUyr+qEjkil1WgasfagI/JEeNBz1sybCY9bCIU25SaHCHbsv17wu62w/aEDbYnbB22deCDjpMtBkVXeu4MEjkqIlPEuJxg3yqa0NVMZqIZeh0Hn59F7bZhjAXjUlRwXWSIXAyQAo+1gZgxOWpyVQFBS05nQdcOjwMOj6PDbSpVFHDdESRyVIRQ9VgESw4FHmsDvY4TAiJPRemHb3R54WoxT6vhQc9bXBpdXjjc3qj2ZXd54WhxS5AlR93wIqeqKXrrZrmKLJtAqCVHPCuWGtx0HUEiR0VkiphNwj8Q+TorhHrh43KiTSPnxXOi2YAEBbd04EmyGJFkCbgQSuuiPHaVtLMgOodvJslY0AUZKYIlRyUPel7g1Td74PT4otqXFmrkACRyVAVvnhfDLXGyNiBy8lJJ5KidHJFq5agpHoene4tIL62LzoqlpnYWRMfodJzwYI7WZVWpkpYOPMmWYD+7aJMR1DgftAWJHBXBd4WOtiBgQ3MwY4BEjvrJTRYnbbRSRfE4PN1TW1LooxQ5ampnQXROV4ridYUKlbU14DhOtEWPWnp2dQaJHBUhliXnRJ1D2J8a3BJEx4g1qfHuKjX1MuveItJLRVq1qiEWiegcoepx1CJHfS6bHLEEXoO6BF57KD8njhDgLTntpszqgJTJKcLr9uDjF7qTFUcT5IrUv0qdlhxx3FWV1LdKU4hmyWlQnzWjs+BjHafD5F6ThdftoZaeXZ1BIkdFZHbSdVmfoMfIdSM73c/J2oAlh1xV2iA3VSxLjvrKCojurlL5hE4EECuNXG3uKiB47O0tehKMCVg3a12n+6mk7Coi1vBuhOomNxjruMt4R5xseSDkpZHI0QJ8QcDyBid8/sivCzUWwxM98FhFAo9oHzEsOU6PD/XNHgDqetDniOCqc3p8aHAGyjKouTknQCJHVfAVj71+Jtx8kcCLHHJXaYOsRDN0XOC6iKb6rxqtGaExOdEIfzUeO9E+YsTk8NeEyaBDSoJRlHHFAjFq5fDHbjbokGxRt8OHRI6KMBv0ws3WlhnWZ/dhY9ZGbMzaCJ+9/RoJJ1ticshdpQ0Mep0QMxCNy0qN1oycFAs4DnB7/VFVAqfAY20hhruqIiTjTk1lBTpzV9nddmQtyULWkqx22zpUhIh+NR17W5DIURk9WlxMJTVtl+T2VHngqerYysPXyOlB7irNEMywisxt4/eHtHRQkTXDqNcJroRIXVYen184b/l0T2gCMYriVfKZVSqKxwGCc0FFo6td93WVowpVjqp291Gpwqyy9iCRozJ6plsBACW1Z4ocXYIOY3aPwZjdY6BLaPtf6/T4hIcZuau0Q/cog4/rmz3w+AITotqatkabYVVa1ww/C5jm1STwiPYJNJUMzIGRuqzU2taAd1/7onBfa6VGDkAiR3Xk8yKn5swJndNxsA22wTbYBk7XtomRfwgmGPVIs6rHz0x0TE5ydGnkvPBNSTDCbFBX7aSgyIns2I+3WEV7pltVb5onAnAcF7XLik8f76ayBpUGfVCsRxqXo5UaOQCJHNXBm9PbsuR0BaGdQ1oCTegaIjfKgoBqDrzNi9KSEypyCO3QLSm6DCs1FgLkyekkLqcztFQBXN1h03FID8GSc6bI8bv9OPbEMQBAr//rBZ3pTA17so5q5GgRIaMi0klNxV3peYFXGmE8Ei9y8knkaIpuKdGJnHIVFgLkCVif6qMXeBqw5JDIURn5aUGRwxhrZY1hHoZjiwMip+eDPYE2nlcnqdqxJon2QR+05KhvQuev5ZMRuqtKyJKjSbolRZdGLmQYqfBBH20auZZickjkqAw+I8ru9qHW4RFq53QVyqzSJrktD/ryBif8fgZdOzFZ7aFmSw5vlTxF7ioihGhjctScYcQfe1vuax2nw+juo4XXbaFm9/XpkMhRGRajHt2SzShvcKGkxhG+yCF3lSbJTjKD4wCPj6Ha7g57clJznZjckJRZl9cXduD08eoWkZNBIkdLROOu8vqCdZfUaM3oqElngjEBP8z+od3P+kLKSahR4J0OBR6rEMFlFUHwMTXn1CZGvU4IEowkLod/0KsxLiXdZoLZ0JIuXB/eqr3e4RHK1/P3FaENonFXVTW5wRig13HICHMhqQRyo4jRO1kbKKlgMuiQocJFz+mQyFEh/IPoeDsFAdvD72dC0TPqW6U9cqMoCHikKlD5tHemTdQxxQKO4wTL5MkwXVb8PZSVZEaCSV2p80THhLqrwm35wQfeZiaawnb9KoGgFSt8V93PVU0AgMIMG/QqPPbTIZGjQoQ08jZq5XRERaMLHh+DXscJqxxCO+S2NKsMN4283uERTPMFKhQ5QNAyGa7Ao3gc7cKLnGaPD40ub1ifrVBxZhUQdFc1ubxoOu3YHR4HCp4tQMGzBXB4zlwo/1zZsuDJUudccDokclQIb8k5Eaa7il/l5iRbYNDTv15r5ERYK+dIdWBSy04yI9GszjA9IbssTEvOsZrAsfcikaM5Ekx6oblkeZj3hFqrHfPYzAYktdzLp7usGGM4Vn8Mx+qPtWnhEiw5Kl3wnA496VRIfge1cjqCFzkUdKxNgn748B70R1tcVWqe1CJNIy+hGjmaJtIMKy3UiekWYVyO4LrOShR9THJAIkeF8BPyybrmdhuwtUVotWNCe0Rqyfm5Sv3m6UirHpO7Stt06yDLqCMqVFw3ikeoehzmsfPuKjUvekIhkaNCcpItMOo5eHwsrAuY0se1TaQxOUc0ZMmJOCaH0sc1SbcIH/TBmBz1WnJyIkihd7i9wvzRR8WLnlBI5KgQvY4TJvVwXFaUPq5tQtNGw8kmOSL44NVrns5t6cJ+sra5y8fu8fmFe4IsOdqkW3JkaeT89qoWORH0r+IXPOk2E1Kt6kudbwsSOSqlZwRxOeSu0jb8qtXt86OmJVuqMxhjOKIB83T3lGAlcL7uTWecqnPC52cwG3SaaERInEmPltpH/MO7K/j9DIcqAsK/T7Z6hX+3CFo7aM1VBVDFY9XSQygIGGKe5wDrIKvwOhTGGAUeaxyTQYfMRDOqmlw4Ve/sUiGvykYX7G4fdJy6rRkJJj3SbSbU2N0orWtGSoKx08+ENuZUYy0UonMG5CYBAA6UNXb5M8drHGj2+GAy6FCQod6HfXtVjzmOw6CsQcLrUNRcL6s9SOSolPz0gFA5EWLJ0Vv1GLtnbJvbNziD9RK6p6o3mI7omNwUC6qaXCird2JIXkqn2/NBxz3SrDAZ1G3Y7Z5qQY3djVP1zRiYm9zp9hR0rH36dQuInIpGF6qbXF0S/gfKA4KoKDtR1cXwctrpX2U1WrHnrj1tfubnyhbXtUbicQByV6kWvgR9V6se866qdJsJVhNpW62SE2bVYy0EHfPwgdddTSMnkaN9Es0G4f/bVWsOv13/nCTJxhULuqUEBF1Vkwsen79LnxEyLVUcn3c6JHJUilArp4sFAclVFR90DzONXEsiJ9w0cqqREx8MaBEr+8MUOQNULnIybWYYdBwYCzbg7YjQ+DytZFYBJHJUC786KW9wwenxAQB8Dh+2DN6CLYO3wOfwtdqen/jJVaVtclqsGV3NqDiigRo5PPy13VWRQ5ac+GBAi+tyf1lDl7bnt+NdXWpFp+PaTKF3eBwYvHwwBi8f3KqtQ2WTC40ubyA+T0MlFchvoVLSrEbYTHrY3T6crGtGn6xEgAGOvS0X7WlZtEFLjnYuXuJM+DTyrjaq1JIlR6iVQ+4qIoRwLDlOjw9Hqx0tn+s8rkvpdEs242Rdc6u2Fowx7K3cK7zm4a04PdKsMBu006yWLDkqheO4M7qR6yw6DP96OIZ/PRw6S+t/LaWPxwd9W1Je955qgL+Tatg+P8Oxau2InGBMTucCr97hQX2zB0AwiJ/QJrzIOVje2GmF+MOVTfD5GVISjEKNHTXDC/jilpT4jvhZQwueUEjkqBg+jZzPsOL0HNKmpCFtSho4feusAIrJiQ8G5CTBYtSh0ekVGu21x8naZnh8DCaDTqgzo2b4a7uswdnpw4yPZctMNFMgvsbplWGDxaiD0+MXRH17hAYdn55erUaG56cCAH4sqet0Wz6zSguu61BI5KgYfgXaqlZOO5DIiQ8Meh2G9UgFAOw4XtfhtkK34QybJurEZCUFAi19fiY0WGyPoKuK7geto9dxQnxNZy4rPn28v8rjcXhG9kwDAOw4XttpJXAt1sgBSOSomtOrHvs9fpx88SROvngSfk8wZdDp8QnR9eSu0j4jW1ZvOzpZvWkpHgcIPMz4FPrSTuJyKB4nvhDick51HHyslfRxnkG5yTAZdKh1eIRYo/bgqx1rpfs4D4kcFZOf1jqNnLkZiucWo3huMZg7qNr5TJsEox5p1s4rwRLqZmTPVACdW3IEkaMh8zTvdussw4pETnzBBxF3asnRSPo4j8mgw9CWoqA7jte2u53H5xfuCXJXEYpBCDzuRKEfa7l4u6daNOFnJjqGN1EfKGuA3dV+HydB5Ki4dP3pdDWNnGrkxBd8e4eORE59s0eoL9VPIyIHCLHstix6OI5Dr5Re6JXSS3gelNQ44PUzJBj16JakrTIjJHJUTI8W11OD0ytkirTFd4erAADDW2I1CG3TLdmC7ikW+Bnw04n6drcTmvFpaOXWq0Ww7S7t2C1Blpz4grfkHK9xCO1tTudgSzxO9xQLki3asXgLcTklAUuO1WjF0fuO4uh9R2E1Bq7/0MacWojPC4VEjoqxmQ3IsJkAdNyNfP2BSgDA5P5ZMRkXIT+nT2yn4/T4UNrS+kErMTkAMKkoEwDwzcFKeNspZe/1+YWSCloqeka0T7rNhOykQEo4L2ZOZ7/G4nF4ePf1vlONcLjbFnhadF3zkMhROby5/UQ77R3K6p3YX9YIjgMmFZHIiRc6i8s5XuMAY0CSJSiUtcDInmlItRpR3+xpN/D6VL0TXj+DSa/TnGmeaB+h8vGptkXOgZZKx/01UAQwlNwUC7olm+HzM+xqx7LLZ1r20dCCh4dEjsoReljVtB2DsP5gBYCAqypdQw8zomN4kfNjSV2bqaNCJkWmTVNxWnodh3NbxPzX+yva3Ia3evZIT9CcaZ5on2Dl47ZdmQfLmlptpxU4jsPIfN6yW4dmTzPGvDoGY14dg2ZP4LlxWKOZVQCJHNWT3xKX01438vUHW1xV/ciKE08M7p4Co55DZaOrzQrAWksfD+W8AdkAgK/aETmHW46d4nHii47aOzDGNNOzqi3O6pUKIJBh5Wd+bC3diq2lW+FnAZeulucDVYucjz/+GOPGjUNCQgIyMzNx1VVXyT2kmMNflFuO1JyxYvf6/NhQHAg6nkLxOHGFxajHwBbzfFsuqyN8IcBM7a3czu2XBY4LPMzK6s8UeB/sOAkAGNUSt0TEB0Ia+amGM+bKsgYnGpxe6HUc+mRr70HPx+htP36mZbfR6RHqqFFMjoJ47733cPPNN+O2227Dzp07sXHjRtxwww1yDyvmXDAoBwlGPQ6UN2LzzzWt/rajpA6NTi/SrEahCi4RP5yeOhqKlgMN020m4djXH6xq9bc9pfXYdqwWBh2HX47Jl2F0hFz0ybbBoOPQ4PQKqeI8fH2c3pk2TTWn5BnSPQUGXcCye6qh9bHzc0FmollTWWU8qhQ5Xq8X8+bNw5IlSzBnzhz069cP/fv3xzXXXCP30GJOitWIa0b1AAD8fdPRVn9bdyBgrp9UlAU9xR7EHR1lWGm1hDvP1P4Bl9U3xZWt3n9z03EAwIWDc5CdTEHH8YTZoBcK3Z0el6O1Ssenk2AKWnZ/PG3RE6x0rM25QJUiZ/v27Th58iR0Oh1GjhyJ3NxcXHTRRdizZ0+Hn3O5XGhoaGj1owVmnVMAAFh3oPWEzsfjkKsqPuGDj/ecbIDL6xPer2/2oKrJDQAo0KrIaYnL2XS4WnivwenBv38MuKpuGt9LlnER8tJe5WNB5GgwHoeHnw92npZ1uK9F8PUhkaMcfv75ZwDAokWL8Lvf/Q7/+c9/kJaWhsmTJ6Ompqbdzz355JNISUkRfvLztWGu7pOViKn9sxDqaq1sdGL3ycDFS6nj8UnPdCvSbSa4fX7sDSmO97dvDgMIpJYmmrXZgXtw92RkJ5nhcAfF3Uc/lsLh9qFvdiLG906XcXSEXAiVj09LI9dqjZxQBJFzsk54b9fJOqzceBQAMKqXNu8JRYmcRYsWgeO4Dn+2bt0Kvz8QEf7oo4/i6quvxqhRo7By5UpwHIc1a9a0u/8FCxagvr5e+CkpKYnVoUnO7RMLAQCNVgZDpgEbDwVWsEPzUpDVUgSLiC8CqaOpAIJxOas3H8eLXwdEzvzp/WQamfRwHCe4rHje2hJwVd08vpem0uaJrtNWGrnX58ehSj59XFs1ckI5q8V9va+0EZnWTGQkZOK+f/0It9ePaQO74aqReTKPUBoUtYybO3currvuug63KSgoQGNjQHUPGjRIeN9sNqN37944fvx4u581m80wm7X5wJ/YNxO9eiTinnua8LtLBmJnSUDkUOp4fDOyZyq+3F+BH0vq8PX+Cvz+37sBAPeeX4SZo7VhyWyPqQOy8OF3xcLvhyvtsCbacOVZ2pzMic7hRczPlXa8/u0RmAw6OFxeuL1+WE16oVWOFuEtuzV24NNrD+DZL4qxobgKBRlWLLt2uGZrRilK5GRmZiIzM7PT7UaNGgWz2YwDBw5g4sSJAACPx4OjR4+iV6/49LVzHIfbJxZiwdpdWLnxKOwt5bspHie+4YOPNxRX4ot95fD5Ga4+qwfun1Yk88ik55y+mTDqW0/cl4/I02QGCdE1clMsSLMaUevw4I//2dvqb/26JWn2QQ8ELbtf7q/Ag2t+ws9VdliMOrx88yikJGj3nlCUyOkqycnJmDNnDhYuXIj8/Hz06tULS5YsAQDMnDlT5tHJx5Uj8/DUp/uF4m/JFgNGtLgriPhkWI8UcBxQ6wg0cJ3YNxNPXjU0Ltw1SRYjRvVqXQvnpvE9ZRoNoQQ4jsPT147Ax7tOwe31w+X1we31w8eAO1pc/lqGt+z+3JJd+eerhmnaRQeoVOQAwJIlS2AwGHDzzTejubkZ48aNw1dffYW0tPgt8GX0AovftaG0zollM52YNDQLBr2iwq6IGJNkMaIoOxEHy5swICcJy286CyZD/FwToe7akT1TMbh7ioyjIZTA1AHZQvZdvDGyZxr8cKHCtBA5KRZcOOQbuYckOaoVOUajEUuXLsXSpUvlHopy8APJuzxIhh4co3gcIsCDFw7ARztLseDiAXHnqgnNLLx+LFlxiPhmVK80DOuRjI+rd+NYE4S2DlpGtSKHOBPOzGHQO4Pw+d5yTOiegIuG5sg9JEIBTB/UDdMHdZN7GLIQWuDsgsHxeQ4Igsdi1OPtX01A4pNyjyR2kMjREDqDDtkzs3EjsnGj3IMhCAUQGnukxXL9BEF0TPw45wmCIAiCiCvIkqMh/F4/qt4PNCTMvDITujgKMCUIgiCI0yGRoyGYi2HvtYHaD5OaJtF/lyAIgohr6DFIEARBEHGE1WiVewgxg0QOQRAEQcQJNpMN9v+zyz2MmEFBGwRBEARBaBISOQRBEARBaBISOQRBEAQRJzi9Tlyy+hJcsvoSOL1OuYcjORSTQxAEQRBxgs/vwyfFnwivtQ5ZcgiCIAiC0CQkcgiCIAiC0CQkcgiCIAiC0CQkcgiCIAiC0CQkcgiCIAiC0CRxnV3FGAMANDQ0yDwScfDZfbAjUMmyoaEBep9e5hERhMzYQyq7NjQAPu1nkxBER9jddqAlc7yhoQE+kzrvCf65zT/H24NjnW2hYU6cOIH8/Hy5h0EQBEEQRASUlJSgR48e7f49rkWO3+9HaWkpkpKSwHGcaPttaGhAfn4+SkpKkJycLNp+tQidq/Cg89V16Fx1HTpXXYfOVdeR8lwxxtDY2Iju3btDp2s/8iau3VU6na5DBRgtycnJdBN0ETpX4UHnq+vQueo6dK66Dp2rriPVuUpJSel0Gwo8JgiCIAhCk5DIIQiCIAhCk5DIkQCz2YyFCxfCbDbLPRTFQ+cqPOh8dR06V12HzlXXoXPVdZRwruI68JggCIIgCO1ClhyCIAiCIDQJiRyCIAiCIDQJiRyCIAiCIDQJiRyCIAiCIDQJiZwIWb58OQoLC2GxWDBq1Chs2LChw+3Xr1+PUaNGwWKxoHfv3nj55ZdjNFL5CedcnTp1CjfccAP69+8PnU6H++67L3YDVQDhnKu1a9di+vTpyMrKQnJyMiZMmID//e9/MRyt/IRzvr799lucc845yMjIQEJCAgYMGIBnnnkmhqOVl3DnLJ6NGzfCYDBgxIgR0g5QQYRzrtatWweO48742b9/fwxHLB/hXlculwuPPvooevXqBbPZjD59+mDFihXSDZARYfOvf/2LGY1G9uqrr7K9e/eyefPmMZvNxo4dO9bm9j///DOzWq1s3rx5bO/evezVV19lRqORvfvuuzEeeewJ91wdOXKE3XvvveyNN95gI0aMYPPmzYvtgGUk3HM1b9489pe//IVt2bKFHTx4kC1YsIAZjUa2ffv2GI9cHsI9X9u3b2erV69mu3fvZkeOHGH/+Mc/mNVqZa+88kqMRx57wj1XPHV1dax3797sggsuYMOHD4/NYGUm3HP19ddfMwDswIED7NSpU8KP1+uN8chjTyTX1WWXXcbGjRvHPv/8c3bkyBG2efNmtnHjRsnGSCInAsaOHcvmzJnT6r0BAwawRx55pM3tH3roITZgwIBW7/36179m48ePl2yMSiHccxXK5MmT40rkRHOueAYNGsQWL14s9tAUiRjn68orr2Q33XST2ENTHJGeq1/+8pfsd7/7HVu4cGHciJxwzxUvcmpra2MwOmUR7rn673//y1JSUlh1dXUshscYY4zcVWHidruxbds2XHDBBa3ev+CCC/Ddd9+1+Znvv//+jO0vvPBCbN26FR6PR7Kxyk0k5ypeEeNc+f1+NDY2Ij09XYohKgoxzteOHTvw3XffYfLkyVIMUTFEeq5WrlyJw4cPY+HChVIPUTFEc12NHDkSubm5OP/88/H1119LOUxFEMm5+vDDDzF69Gg89dRTyMvLQ79+/fDb3/4Wzc3Nko0zrht0RkJVVRV8Ph+6devW6v1u3bqhrKyszc+UlZW1ub3X60VVVRVyc3MlG6+cRHKu4hUxztWyZctgt9tx7bXXSjFERRHN+erRowcqKyvh9XqxaNEi3HnnnVIOVXYiOVfFxcV45JFHsGHDBhgM8fOYiORc5ebm4m9/+xtGjRoFl8uFf/zjHzj//POxbt06nHvuubEYtixEcq5+/vlnfPvtt7BYLHj//fdRVVWFu+66CzU1NZLF5cTP1SsyHMe1+p0xdsZ7nW3f1vtaJNxzFc9Eeq7eeustLFq0CP/+97+RnZ0t1fAURyTna8OGDWhqasKmTZvwyCOPoG/fvrj++uulHKYi6Oq58vl8uOGGG7B48WL069cvVsNTFOFcV/3790f//v2F3ydMmICSkhIsXbpU0yKHJ5xz5ff7wXEc/vnPfwodxJ9++mlcc801ePHFF5GQkCD6+EjkhElmZib0ev0ZSrWiouIMRcuTk5PT5vYGgwEZGRmSjVVuIjlX8Uo05+rtt9/GHXfcgTVr1mDatGlSDlMxRHO+CgsLAQBDhw5FeXk5Fi1apGmRE+65amxsxNatW7Fjxw7MnTsXQODhxBiDwWDAZ599hvPOOy8mY481Ys1Z48ePx5tvvin28BRFJOcqNzcXeXl5gsABgIEDB4IxhhMnTqCoqEj0cVJMTpiYTCaMGjUKn3/+eav3P//8c5x99tltfmbChAlnbP/ZZ59h9OjRMBqNko1VbiI5V/FKpOfqrbfewqxZs7B69WpccsklUg9TMYh1bTHG4HK5xB6eogj3XCUnJ2PXrl348ccfhZ85c+agf//++PHHHzFu3LhYDT3miHVd7dixQ7NhCDyRnKtzzjkHpaWlaGpqEt47ePAgdDodevToIc1AYxbirCH4tLnXX3+d7d27l913333MZrOxo0ePMsYYe+SRR9jNN98sbM+nkN9///1s79697PXXX4+7FPKunivGGNuxYwfbsWMHGzVqFLvhhhvYjh072J49e+QYfkwJ91ytXr2aGQwG9uKLL7ZKXa2rq5PrEGJKuOfrhRdeYB9++CE7ePAgO3jwIFuxYgVLTk5mjz76qFyHEDMiuQ9DiafsqnDP1TPPPMPef/99dvDgQbZ79272yCOPMADsvffek+sQYka456qxsZH16NGDXXPNNWzPnj1s/fr1rKioiN15552SjZFEToS8+OKLrFevXsxkMrGzzjqLrV+/XvjbrbfeyiZPntxq+3Xr1rGRI0cyk8nECgoK2EsvvRTjEctHuOcKwBk/vXr1iu2gZSKcczV58uQ2z9Wtt94a+4HLRDjn67nnnmODBw9mVquVJScns5EjR7Lly5czn88nw8hjT7j3YSjxJHIYC+9c/eUvf2F9+vRhFouFpaWlsYkTJ7KPP/5YhlHLQ7jX1b59+9i0adNYQkIC69GjB5s/fz5zOBySjY9jrCUCliAIgiAIQkNQTA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEARBEJqERA5BEJrj3XffxdChQ5GQkICMjAxMmzYNdrtd7mERBBFjDHIPgCAIQkxOnTqF66+/Hk899RSuvPJKNDY2YsOGDaA2fQQRf1CDToIgNMX27dsxatQoHD16FL169ZJ7OARByAi5qwiC0BTDhw/H+eefj6FDh2LmzJl49dVXUVtbK/ewCIKQAbLkEAShORhj+O677/DZZ5/h/fffR1lZGTZv3ozCwkK5h0YQRAwhkUMQhKbx+Xzo1asX5s+fj/nz58s9HIIgYggFHhMEoSk2b96ML7/8EhdccAGys7OxefNmVFZWYuDAgXIPjSCIGEMihyAITZGcnIxvvvkGzz77LBoaGtCrVy8sW7YMF110kdxDIwgixpC7iiAIgiAITULZVQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaBISOQRBEARBaJL/B4PfGMQWMFHjAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -261,7 +361,7 @@ "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", - "plt.title('hyperopt first step')\n", + "plt.title(r'Restrict $s$ with polynomial')\n", "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] @@ -282,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -292,9 +392,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-01 13:32:30]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 15.16260860504813\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -308,9 +423,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -319,9 +456,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------Scheduling grid search----------\n", + "New optimized step at iteration 1/8: 0.11112 with operator IIZZ, loss 11.680408968308086\n", + "New optimized step at iteration 2/8: 0.08081727272727272 with operator IIZZ, loss 9.142367366920572\n", + "New optimized step at iteration 3/8: 0.1010190909090909 with operator ZZIZ, loss 7.958198114832907\n", + "New optimized step at iteration 4/8: 0.07071636363636363 with operator IIZZ, loss 6.482023887224007\n", + "New optimized step at iteration 5/8: 0.1010190909090909 with operator ZZIZ, loss 5.771042676877126\n", + "New optimized step at iteration 6/8: 0.08081727272727272 with operator IIZZ, loss 5.140994036668525\n", + "New optimized step at iteration 7/8: 0.11112 with operator -ZZII, loss 4.728283208000788\n", + "New optimized step at iteration 8/8: 0.06061545454545455 with operator IIZZ, loss 4.40400614947187\n", + "----------Scheduling hyperopt----------\n", + "New optimized step at iteration 1/8: 0.1088441936662135 with operator IIZZ, loss 11.676654434031814\n", + "New optimized step at iteration 2/8: 0.07922158082178958 with operator IIZZ, loss 9.135794848474623\n", + "New optimized step at iteration 3/8: 0.10296369768833129 with operator ZZIZ, loss 7.935942900247105\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[32], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:105\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m flip_list[i] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m step \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 105\u001b[0m step_best \u001b[38;5;241m=\u001b[39m \u001b[43mdbi_eval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchoose_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\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\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 109\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:301\u001b[0m, in \u001b[0;36mDoubleBracketIteration.choose_step\u001b[0;34m(self, d, scheduling, backup_scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 299\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrid_search_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 300\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mhyperopt:\n\u001b[0;32m--> 301\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[43mhyperopt_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\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 302\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mpolynomial_approximation:\n\u001b[1;32m 303\u001b[0m step, coef \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolynomial_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:197\u001b[0m, in \u001b[0;36mDoubleBracketIteration.hyperopt_step\u001b[0;34m(self, step_min, step_max, max_evals, space, optimizer, look_ahead, verbose, d)\u001b[0m\n\u001b[1;32m 194\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 196\u001b[0m space \u001b[38;5;241m=\u001b[39m space(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m, step_min, step_max)\n\u001b[0;32m--> 197\u001b[0m best \u001b[38;5;241m=\u001b[39m \u001b[43mhyperopt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfmin\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloss\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlook_ahead\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlook_ahead\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mspace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mspace\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 200\u001b[0m \u001b[43m \u001b[49m\u001b[43malgo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuggest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 201\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_evals\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 202\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 203\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m best[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:586\u001b[0m, in \u001b[0;36mfmin\u001b[0;34m(fn, space, algo, max_evals, timeout, loss_threshold, trials, rstate, allow_trials_fmin, pass_expr_memo_ctrl, catch_eval_exceptions, verbose, return_argmin, points_to_evaluate, max_queue_len, show_progressbar, early_stop_fn, trials_save_file)\u001b[0m\n\u001b[1;32m 583\u001b[0m rval\u001b[38;5;241m.\u001b[39mcatch_eval_exceptions \u001b[38;5;241m=\u001b[39m catch_eval_exceptions\n\u001b[1;32m 585\u001b[0m \u001b[38;5;66;03m# next line is where the fmin is actually executed\u001b[39;00m\n\u001b[0;32m--> 586\u001b[0m \u001b[43mrval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexhaust\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 588\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_argmin:\n\u001b[1;32m 589\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(trials\u001b[38;5;241m.\u001b[39mtrials) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:364\u001b[0m, in \u001b[0;36mFMinIter.exhaust\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexhaust\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 363\u001b[0m n_done \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials)\n\u001b[0;32m--> 364\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mn_done\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_until_done\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[43masynchronous\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:278\u001b[0m, in \u001b[0;36mFMinIter.run\u001b[0;34m(self, N, block_until_done)\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 274\u001b[0m \u001b[38;5;66;03m# Based on existing trials and the domain, use `algo` to probe in\u001b[39;00m\n\u001b[1;32m 275\u001b[0m \u001b[38;5;66;03m# new hp points. Save the results of those inspections into\u001b[39;00m\n\u001b[1;32m 276\u001b[0m \u001b[38;5;66;03m# `new_trials`. This is the core of `run`, all the rest is just\u001b[39;00m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;66;03m# processes orchestration\u001b[39;00m\n\u001b[0;32m--> 278\u001b[0m new_trials \u001b[38;5;241m=\u001b[39m \u001b[43malgo\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 279\u001b[0m \u001b[43m \u001b[49m\u001b[43mnew_ids\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[43mdomain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrials\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[43mrstate\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mintegers\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m31\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 280\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_ids) \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(new_trials)\n\u001b[1;32m 283\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_trials):\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:935\u001b[0m, in \u001b[0;36msuggest\u001b[0;34m(new_ids, domain, trials, seed, prior_weight, n_startup_jobs, n_EI_candidates, gamma, verbose)\u001b[0m\n\u001b[1;32m 931\u001b[0m memo[observed[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvals\u001b[39m\u001b[38;5;124m\"\u001b[39m]] \u001b[38;5;241m=\u001b[39m observed_vals_dict\n\u001b[1;32m 933\u001b[0m \u001b[38;5;66;03m# evaluate `n_EI_candidates` pyll nodes in `posterior` using `memo`\u001b[39;00m\n\u001b[1;32m 934\u001b[0m \u001b[38;5;66;03m# TODO: it seems to return idxs, vals, all the same. Is this correct?\u001b[39;00m\n\u001b[0;32m--> 935\u001b[0m idxs, vals \u001b[38;5;241m=\u001b[39m \u001b[43mpyll\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrec_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mposterior\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprint_node_on_error\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 937\u001b[0m \u001b[38;5;66;03m# hack to add offset again for randint params\u001b[39;00m\n\u001b[1;32m 938\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m label, param \u001b[38;5;129;01min\u001b[39;00m domain\u001b[38;5;241m.\u001b[39mparams\u001b[38;5;241m.\u001b[39mitems():\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/pyll/base.py:902\u001b[0m, in \u001b[0;36mrec_eval\u001b[0;34m(expr, deepcopy_inputs, memo, max_program_len, memo_gc, print_trace, print_node_on_error)\u001b[0m\n\u001b[1;32m 899\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m copy\u001b[38;5;241m.\u001b[39mdeepcopy(_kwargs)\n\u001b[1;32m 901\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 902\u001b[0m rval \u001b[38;5;241m=\u001b[39m \u001b[43mscope\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impls\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\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 904\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m print_node_on_error:\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:398\u001b[0m, in \u001b[0;36madaptive_parzen_normal\u001b[0;34m(mus, prior_weight, prior_mu, prior_sigma, LF)\u001b[0m\n\u001b[1;32m 394\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 395\u001b[0m \u001b[38;5;124;03mmus - matrix (N, M) of M, N-dimensional component centers\u001b[39;00m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 397\u001b[0m mus \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(mus)\n\u001b[0;32m--> 398\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(mus\u001b[38;5;241m.\u001b[39mdtype) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobject\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 400\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mus\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 401\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmus must be vector\u001b[39m\u001b[38;5;124m\"\u001b[39m, mus)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:42\u001b[0m, in \u001b[0;36m__str__\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mstr\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:363\u001b[0m, in \u001b[0;36m_name_get\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[38;5;66;03m# append bit counts\u001b[39;00m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _name_includes_bit_suffix(dtype):\n\u001b[0;32m--> 363\u001b[0m name \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mformat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m8\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;66;03m# append metadata to datetimes\u001b[39;00m\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mtype \u001b[38;5;129;01min\u001b[39;00m (np\u001b[38;5;241m.\u001b[39mdatetime64, np\u001b[38;5;241m.\u001b[39mtimedelta64):\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -359,7 +538,28 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for i, scheduling in enumerate(scheduling_labels):\n", @@ -369,6 +569,100 @@ "plt.title(\"Compare Variational Pauli-Z using different scheduling strategies\")\n", "plt.legend()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## When polynomial approximation has no solution\n", + "\n", + "In some cases, the prescribed taylor expansion order `n` may not be sufficient to produce a meaningful step duration (real positive). In these cases, we rely on a backup scheduling method in `choose_step`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-01 14:05:27]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "dbi.scheduling = DoubleBracketScheduling.polynomial_approximation\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For demonstration purposes, we let `n=1` which is a linear fit to the loss function. This results in no valid solutions and function `polynomial_step` returns `None`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None [(-1290240+0j), (-23040+0j)]\n" + ] + } + ], + "source": [ + "step, coef = dbi.polynomial_step(n=1)\n", + "print(step, coef)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "now n=2, step=0.03321888741718203\n", + "No solution found, going to backup DoubleBracketScheduling.grid_search\n", + "No solution found, going to backup DoubleBracketScheduling.hyperopt\n", + "0.03321888741718203 0.030312727272727272 0.029274407933556172\n" + ] + } + ], + "source": [ + "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=1, n_max=5)\n", + "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", + "step_backup_hyper = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.hyperopt, n=1)\n", + "print(step_backup_poly, step_backup_grid, step_backup_hyper)" + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 2c160ea525..5c2e26f81c 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -156,14 +156,14 @@ def grid_search_step( d = self.diagonal_h_matrix loss_list = [self.loss(step, d=d) for step in space] - idx_max_loss = loss_list.index(min(loss_list)) + idx_max_loss = np.argmin(loss_list) return space[idx_max_loss] def hyperopt_step( self, step_min: float = 1e-5, step_max: float = 1, - max_evals: int = 1000, + max_evals: int = 500, space: callable = None, optimizer: callable = None, look_ahead: int = 1, @@ -205,7 +205,7 @@ def hyperopt_step( def polynomial_step( self, - n: int = 4, + n: int = 2, n_max: int = 5, d: np.array = None, backup_scheduling: DoubleBracketScheduling = None, @@ -226,6 +226,11 @@ def polynomial_step( if backup_scheduling is None: backup_scheduling = DoubleBracketScheduling.grid_search + if n > n_max: + raise ValueError( + "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." + ) + def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) @@ -259,7 +264,9 @@ def Gamma(k: int): power = k + j product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) - roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + # coefficients from high to low (n:0) + coef = list(reversed(trace_coefficients[: n + 1])) + roots = np.roots(coef) error = 1e-3 real_positive_roots = [ np.real(root) @@ -268,22 +275,29 @@ def Gamma(k: int): ] # solution exists, return minimum s if len(real_positive_roots) > 0: - return min(real_positive_roots) - # solution does not exist, resort to backup scheduling - elif ( - backup_scheduling == DoubleBracketScheduling.polynomial_approximation - and n < n_max + 1 - ): - return self.polynomial_step( - n=n + 1, d=d, backup_scheduling=backup_scheduling - ) + return min(real_positive_roots), coef + # solution does not exist, return None else: - return self.choose_step(d=d, scheduling=backup_scheduling) + return None, coef + + # # solution does not exist, resort to backup scheduling + # elif ( + # backup_scheduling == DoubleBracketScheduling.polynomial_approximation + # and n < n_max + 1 + # ): + # return self.polynomial_step( + # n=n + 1, d=d, backup_scheduling=backup_scheduling + # ) + # else: + # return self.choose_step(d=d, scheduling=backup_scheduling) def choose_step( self, d: Optional[np.array] = None, scheduling: Optional[DoubleBracketScheduling] = None, + backup_scheduling: Optional[ + DoubleBracketScheduling + ] = DoubleBracketScheduling.hyperopt, **kwargs, ): if scheduling is None: @@ -293,7 +307,23 @@ def choose_step( if scheduling is DoubleBracketScheduling.hyperopt: return self.hyperopt_step(d=d, **kwargs) if scheduling is DoubleBracketScheduling.polynomial_approximation: - return self.polynomial_step(d=d, **kwargs) + step, coef = self.polynomial_step(d=d, **kwargs) + # if no solution + if step is None: + if ( + backup_scheduling + == DoubleBracketScheduling.polynomial_approximation + and coef is not None + ): + # if `n` is not provided, try default value + kwargs["n"] = kwargs.get("n", 2) + kwargs["n"] += 1 + step, coef = self.polynomial_step(d=d, **kwargs) + # if n==n_max, return None + else: + # Issue: cannot pass kwargs + step = self.choose_step(d=d, scheduling=backup_scheduling) + return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ From 54a86a8add3bafedeb0383b92b346296db16aa1b Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi <146689118+Sam-XiaoyueLi@users.noreply.github.com> Date: Fri, 1 Mar 2024 14:30:54 +0800 Subject: [PATCH 041/116] Update src/qibo/models/dbi/double_bracket.py Co-authored-by: Edoardo Pedicillo --- src/qibo/models/dbi/double_bracket.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 5c2e26f81c..2fe515306d 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -223,8 +223,6 @@ def polynomial_step( if d is None: d = self.diagonal_h_matrix - if backup_scheduling is None: - backup_scheduling = DoubleBracketScheduling.grid_search if n > n_max: raise ValueError( From 50554e32a7ce8a6f8264af48aad8e9c2c267b9a2 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 22:43:50 +0800 Subject: [PATCH 042/116] Simplify code structure in `polynomial_step` --- examples/dbi/dbi_scheduling.ipynb | 309 +++----------------------- src/qibo/models/dbi/double_bracket.py | 46 +--- 2 files changed, 46 insertions(+), 309 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 686156fa4c..3958aa2dff 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -42,24 +42,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-01 14:04:46]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -85,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -108,19 +93,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.030312727272727272\n", - "hyperopt_search step: 0.029554880094525483\n", - "polynomial_approximation step: 0.032960905003724034\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -134,27 +109,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.030312727272727272\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -179,18 +136,9 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "# Generate the digaonal operators\n", "Z_str = \"Z\"*nqubits\n", @@ -202,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -220,19 +168,9 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", - "hyperopt_search step: 0.565048795659714 loss -6.166892748979453\n", - "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -250,27 +188,9 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.30303525252525254\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -302,18 +222,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.04141414141414142\n", - "hyperopt_search step: 0.04175237619889543\n" - ] - } - ], + "outputs": [], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -332,27 +243,9 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.30303525252525254\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -382,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -392,24 +285,9 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-01 13:32:30]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 15.16260860504813\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -423,31 +301,9 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -456,51 +312,9 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------Scheduling grid search----------\n", - "New optimized step at iteration 1/8: 0.11112 with operator IIZZ, loss 11.680408968308086\n", - "New optimized step at iteration 2/8: 0.08081727272727272 with operator IIZZ, loss 9.142367366920572\n", - "New optimized step at iteration 3/8: 0.1010190909090909 with operator ZZIZ, loss 7.958198114832907\n", - "New optimized step at iteration 4/8: 0.07071636363636363 with operator IIZZ, loss 6.482023887224007\n", - "New optimized step at iteration 5/8: 0.1010190909090909 with operator ZZIZ, loss 5.771042676877126\n", - "New optimized step at iteration 6/8: 0.08081727272727272 with operator IIZZ, loss 5.140994036668525\n", - "New optimized step at iteration 7/8: 0.11112 with operator -ZZII, loss 4.728283208000788\n", - "New optimized step at iteration 8/8: 0.06061545454545455 with operator IIZZ, loss 4.40400614947187\n", - "----------Scheduling hyperopt----------\n", - "New optimized step at iteration 1/8: 0.1088441936662135 with operator IIZZ, loss 11.676654434031814\n", - "New optimized step at iteration 2/8: 0.07922158082178958 with operator IIZZ, loss 9.135794848474623\n", - "New optimized step at iteration 3/8: 0.10296369768833129 with operator ZZIZ, loss 7.935942900247105\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[32], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:105\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m flip_list[i] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m step \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 105\u001b[0m step_best \u001b[38;5;241m=\u001b[39m \u001b[43mdbi_eval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchoose_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\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\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 109\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:301\u001b[0m, in \u001b[0;36mDoubleBracketIteration.choose_step\u001b[0;34m(self, d, scheduling, backup_scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 299\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrid_search_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 300\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mhyperopt:\n\u001b[0;32m--> 301\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[43mhyperopt_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\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 302\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mpolynomial_approximation:\n\u001b[1;32m 303\u001b[0m step, coef \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolynomial_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:197\u001b[0m, in \u001b[0;36mDoubleBracketIteration.hyperopt_step\u001b[0;34m(self, step_min, step_max, max_evals, space, optimizer, look_ahead, verbose, d)\u001b[0m\n\u001b[1;32m 194\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 196\u001b[0m space \u001b[38;5;241m=\u001b[39m space(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m, step_min, step_max)\n\u001b[0;32m--> 197\u001b[0m best \u001b[38;5;241m=\u001b[39m \u001b[43mhyperopt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfmin\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloss\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlook_ahead\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlook_ahead\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mspace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mspace\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 200\u001b[0m \u001b[43m \u001b[49m\u001b[43malgo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuggest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 201\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_evals\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 202\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 203\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m best[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:586\u001b[0m, in \u001b[0;36mfmin\u001b[0;34m(fn, space, algo, max_evals, timeout, loss_threshold, trials, rstate, allow_trials_fmin, pass_expr_memo_ctrl, catch_eval_exceptions, verbose, return_argmin, points_to_evaluate, max_queue_len, show_progressbar, early_stop_fn, trials_save_file)\u001b[0m\n\u001b[1;32m 583\u001b[0m rval\u001b[38;5;241m.\u001b[39mcatch_eval_exceptions \u001b[38;5;241m=\u001b[39m catch_eval_exceptions\n\u001b[1;32m 585\u001b[0m \u001b[38;5;66;03m# next line is where the fmin is actually executed\u001b[39;00m\n\u001b[0;32m--> 586\u001b[0m \u001b[43mrval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexhaust\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 588\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_argmin:\n\u001b[1;32m 589\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(trials\u001b[38;5;241m.\u001b[39mtrials) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:364\u001b[0m, in \u001b[0;36mFMinIter.exhaust\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexhaust\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 363\u001b[0m n_done \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials)\n\u001b[0;32m--> 364\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mn_done\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_until_done\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[43masynchronous\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:278\u001b[0m, in \u001b[0;36mFMinIter.run\u001b[0;34m(self, N, block_until_done)\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 274\u001b[0m \u001b[38;5;66;03m# Based on existing trials and the domain, use `algo` to probe in\u001b[39;00m\n\u001b[1;32m 275\u001b[0m \u001b[38;5;66;03m# new hp points. Save the results of those inspections into\u001b[39;00m\n\u001b[1;32m 276\u001b[0m \u001b[38;5;66;03m# `new_trials`. This is the core of `run`, all the rest is just\u001b[39;00m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;66;03m# processes orchestration\u001b[39;00m\n\u001b[0;32m--> 278\u001b[0m new_trials \u001b[38;5;241m=\u001b[39m \u001b[43malgo\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 279\u001b[0m \u001b[43m \u001b[49m\u001b[43mnew_ids\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[43mdomain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrials\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[43mrstate\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mintegers\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m31\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 280\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_ids) \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(new_trials)\n\u001b[1;32m 283\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_trials):\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:935\u001b[0m, in \u001b[0;36msuggest\u001b[0;34m(new_ids, domain, trials, seed, prior_weight, n_startup_jobs, n_EI_candidates, gamma, verbose)\u001b[0m\n\u001b[1;32m 931\u001b[0m memo[observed[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvals\u001b[39m\u001b[38;5;124m\"\u001b[39m]] \u001b[38;5;241m=\u001b[39m observed_vals_dict\n\u001b[1;32m 933\u001b[0m \u001b[38;5;66;03m# evaluate `n_EI_candidates` pyll nodes in `posterior` using `memo`\u001b[39;00m\n\u001b[1;32m 934\u001b[0m \u001b[38;5;66;03m# TODO: it seems to return idxs, vals, all the same. Is this correct?\u001b[39;00m\n\u001b[0;32m--> 935\u001b[0m idxs, vals \u001b[38;5;241m=\u001b[39m \u001b[43mpyll\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrec_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mposterior\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprint_node_on_error\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 937\u001b[0m \u001b[38;5;66;03m# hack to add offset again for randint params\u001b[39;00m\n\u001b[1;32m 938\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m label, param \u001b[38;5;129;01min\u001b[39;00m domain\u001b[38;5;241m.\u001b[39mparams\u001b[38;5;241m.\u001b[39mitems():\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/pyll/base.py:902\u001b[0m, in \u001b[0;36mrec_eval\u001b[0;34m(expr, deepcopy_inputs, memo, max_program_len, memo_gc, print_trace, print_node_on_error)\u001b[0m\n\u001b[1;32m 899\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m copy\u001b[38;5;241m.\u001b[39mdeepcopy(_kwargs)\n\u001b[1;32m 901\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 902\u001b[0m rval \u001b[38;5;241m=\u001b[39m \u001b[43mscope\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impls\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\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 904\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m print_node_on_error:\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:398\u001b[0m, in \u001b[0;36madaptive_parzen_normal\u001b[0;34m(mus, prior_weight, prior_mu, prior_sigma, LF)\u001b[0m\n\u001b[1;32m 394\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 395\u001b[0m \u001b[38;5;124;03mmus - matrix (N, M) of M, N-dimensional component centers\u001b[39;00m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 397\u001b[0m mus \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(mus)\n\u001b[0;32m--> 398\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(mus\u001b[38;5;241m.\u001b[39mdtype) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobject\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 400\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mus\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 401\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmus must be vector\u001b[39m\u001b[38;5;124m\"\u001b[39m, mus)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:42\u001b[0m, in \u001b[0;36m__str__\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mstr\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:363\u001b[0m, in \u001b[0;36m_name_get\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[38;5;66;03m# append bit counts\u001b[39;00m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _name_includes_bit_suffix(dtype):\n\u001b[0;32m--> 363\u001b[0m name \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mformat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m8\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;66;03m# append metadata to datetimes\u001b[39;00m\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mtype \u001b[38;5;129;01min\u001b[39;00m (np\u001b[38;5;241m.\u001b[39mdatetime64, np\u001b[38;5;241m.\u001b[39mtimedelta64):\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -538,33 +352,12 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure()\n", "for i, scheduling in enumerate(scheduling_labels):\n", " plt.plot(s_scheduling[i], off_norm_scheduling[i], '-o', label=scheduling)\n", - "plt.xlabel(\"Iterations\")\n", + "plt.xlabel(\"Step durations\")\n", "plt.ylabel(\"Norm off-diagonal restriction\")\n", "plt.title(\"Compare Variational Pauli-Z using different scheduling strategies\")\n", "plt.legend()" @@ -581,24 +374,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-01 14:05:27]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -625,17 +403,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None [(-1290240+0j), (-23040+0j)]\n" - ] - } - ], + "outputs": [], "source": [ "step, coef = dbi.polynomial_step(n=1)\n", "print(step, coef)" @@ -643,20 +413,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now n=2, step=0.03321888741718203\n", - "No solution found, going to backup DoubleBracketScheduling.grid_search\n", - "No solution found, going to backup DoubleBracketScheduling.hyperopt\n", - "0.03321888741718203 0.030312727272727272 0.029274407933556172\n" - ] - } - ], + "outputs": [], "source": [ "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=1, n_max=5)\n", "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 2fe515306d..ddd7e179b9 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -9,6 +9,8 @@ from qibo.hamiltonians import Hamiltonian +error = 1e-3 + class DoubleBracketGeneratorType(Enum): """Define DBF evolution.""" @@ -223,7 +225,6 @@ def polynomial_step( if d is None: d = self.diagonal_h_matrix - if n > n_max: raise ValueError( "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." @@ -232,29 +233,18 @@ def polynomial_step( def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) - def Gamma(k: int): - r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" - if k == 0: - return self.h.matrix - else: - W = self.commutator(d, sigma(self.h.matrix)) - result = self.h.matrix - for _ in range(k): - result = self.commutator(W, result) - return result - - # list starting from s^n highest order to s^0 - sigma_gamma_list = np.array([sigma(Gamma(k)) for k in range(n + 2)]) + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = self.commutator(d, sigma(self.h.matrix)) + Gamma_list = [self.h.matrix] + sigma_Gamma_list = [sigma(Gamma_list[0])] + for _ in range(n + 1): + Gamma_list.append(self.commutator(W, Gamma_list[-1])) + sigma_Gamma_list.append(sigma(Gamma_list[-1])) + sigma_Gamma_list = np.array(sigma_Gamma_list) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients for rotation with [W,H] and H - c1 = [ - exp_coef * delta_gamma - for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[1:]) - ] - c2 = [ - exp_coef * delta_gamma - for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[:-1]) - ] + c1 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[1:] + c2 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[:-1] # product coefficient trace_coefficients = [0] * (2 * n + 1) for k in range(n + 1): @@ -265,7 +255,6 @@ def Gamma(k: int): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) roots = np.roots(coef) - error = 1e-3 real_positive_roots = [ np.real(root) for root in roots @@ -278,17 +267,6 @@ def Gamma(k: int): else: return None, coef - # # solution does not exist, resort to backup scheduling - # elif ( - # backup_scheduling == DoubleBracketScheduling.polynomial_approximation - # and n < n_max + 1 - # ): - # return self.polynomial_step( - # n=n + 1, d=d, backup_scheduling=backup_scheduling - # ) - # else: - # return self.choose_step(d=d, scheduling=backup_scheduling) - def choose_step( self, d: Optional[np.array] = None, From 4fcdf643171760f2f3d4df7794b20992e906bdb1 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 22:49:51 +0800 Subject: [PATCH 043/116] Update `test_models_dbi.py` --- tests/test_models_dbi.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index a573c32088..111079f8a7 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -150,10 +150,10 @@ def test_double_bracket_iteration_scheduling_polynomial( ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) + step1 = dbi.choose_step(n=n, backup_scheduling=backup_scheduling) dbi(d=d, step=step1) - step2 = dbi.choose_step( - scheduling=DoubleBracketScheduling.polynomial_approximation, n=n - ) - dbi(step=step2) + # step2 = dbi.choose_step( + # scheduling=DoubleBracketScheduling.polynomial_approximation, n=n + # ) + # dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 67701e173c03d09df60080948fb6ae4513486c1f Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 23:29:59 +0800 Subject: [PATCH 044/116] Define sigma and Gamma as class function --- src/qibo/models/dbi/double_bracket.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index ddd7e179b9..ffd371110c 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -230,17 +230,10 @@ def polynomial_step( "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." ) - def sigma(h: np.array): - return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = self.commutator(d, sigma(self.h.matrix)) - Gamma_list = [self.h.matrix] - sigma_Gamma_list = [sigma(Gamma_list[0])] - for _ in range(n + 1): - Gamma_list.append(self.commutator(W, Gamma_list[-1])) - sigma_Gamma_list.append(sigma(Gamma_list[-1])) - sigma_Gamma_list = np.array(sigma_Gamma_list) + W = self.commutator(d, self.sigma(self.h.matrix)) + Gamma_list = self.generate_Gamma_list(n + 2, d) + sigma_Gamma_list = list(map(self.sigma, Gamma_list)) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients for rotation with [W,H] and H c1 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[1:] @@ -337,3 +330,14 @@ def energy_fluctuation(self, state): state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ return self.h.energy_fluctuation(state) + + def sigma(self, h: np.array): + return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) + + def generate_Gamma_list(self, n: int, d: np.array): + r"""Computes the n-nested Gamma functions, where $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" + W = self.commutator(d, self.sigma(self.h.matrix)) + Gamma_list = [self.h.matrix] + for _ in range(n - 1): + Gamma_list.append(self.commutator(W, Gamma_list[-1])) + return Gamma_list From ca71ffaa76980a2142c37d3d60c4816a3ae60982 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 5 Mar 2024 15:12:12 +0800 Subject: [PATCH 045/116] Modified structure: moving scheduling strategies in `utils_scheduling.py` --- examples/dbi/dbi_scheduling.ipynb | 303 +++++++++++++++++++++--- src/qibo/models/dbi/double_bracket.py | 185 +++------------ src/qibo/models/dbi/utils.py | 26 +- src/qibo/models/dbi/utils_scheduling.py | 145 ++++++++++++ 4 files changed, 464 insertions(+), 195 deletions(-) create mode 100644 src/qibo/models/dbi/utils_scheduling.py diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 3958aa2dff..34a49760b5 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -29,7 +29,8 @@ "\n", "from qibo import hamiltonians, set_backend\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *" + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *" ] }, { @@ -42,9 +43,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", + "[Qibo 0.2.5|INFO|2024-03-05 15:06:24]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -70,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -93,9 +110,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.030312727272727272\n", + "hyperopt_search step: 0.028991467713834373\n", + "polynomial_approximation step: 0.032960905003724034\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -109,9 +136,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is:" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0.030312727272727272\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAHFCAYAAAAQU+iSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACXWklEQVR4nO3dd3hUZfYH8O+dXpJMekgjCRAg9F5soKIUe8G1rIgFdQUVseHKrrDrytr9WcAK2Cvqura1AQLSQqihQwKB9DpJJpl6f3/M3DsJpEy5d+beyfk8T56HJDOTdyZh5sx5z3sOw7IsC0IIIYSQCKMI9wIIIYQQQsRAQQ4hhBBCIhIFOYQQQgiJSBTkEEIIISQiUZBDCCGEkIhEQQ4hhBBCIhIFOYQQQgiJSBTkEEIIISQiUZBDCCGEkIhEQQ4hPdyqVavAMEyHHw899BCKi4vBMAxWrVol2M9ctmyZX7eXnZ3Nr0mhUMBkMiEvLw+zZs3CTz/91OF1Tr8vRqMReXl5WLJkCZqbm9tddvbs2YiKigrmLvH8vW+EEPGowr0AQog0rFy5EgMHDmz3tbS0NKSkpGDTpk3o27evYD9r2bJlSExMxOzZs32+ztlnn43nnnsOANDU1ISDBw/ik08+wdSpU3HNNdfg448/hlqtbneda6+9Fg8++CB/nXXr1uEf//gHdu/ejdWrVwt2f9oK5L4RQsRBQQ4hBAAwZMgQjBkzpsPvTZgwodvrWywWGAwGoZfFi42NbbeOKVOmYO7cuVi8eDGWLFmCRYsW4emnn253nZSUlDOuc/z4cXz44YdobW2FTqcTbb2EkPCj7SpCSJc62q5avHgxGIZBQUEBrr32WsTFxfGZnmPHjuH6669HWloatFotUlJScOGFF2Lnzp0A3FtPhYWFWLduHb+VlJ2dHfD6Fi9ejMGDB+PVV19Fa2trt5c3mUxgGAZKpdLvnxXsfTObzXjooYeQk5MDjUaD9PR0zJ8//4ztM4ZhMG/ePLzxxhvo378/tFotBg0ahE8++cTvNRPSk1EmhxACAHA6nXA4HO2+plJ1/RRx9dVX4/rrr8fdd9/Nv1DPmDEDTqcTzzzzDHr37o3q6mr88ccfqK+vBwB89dVXuPbaa2EymbBs2TIAgFarDWrtl112Gf79738jPz8f55xzDv91lmX5+8RtV7377ru4/vrrz9ja8kUw981isWDSpEk4efIk/vrXv2LYsGEoLCzE3//+d+zZswe//PILGIbhf9Y333yDNWvW4B//+AeMRiOWLVuGG264ASqVCtdee22gDxUhPQtLCOnRVq5cyQLo8MNut7NFRUUsAHblypX8dZ544gkWAPv3v/+93W1VV1ezANiXXnqpy585ePBgdtKkST6vMSsri73kkks6/f7y5ctZAOynn37Kf62z+zR9+nS2qamp3fVvueUW1mg0drmGYO/b0qVLWYVCwW7btq3d17/44gsWAPv999+3W7ter2fLy8v5rzkcDnbgwIFsv379uvz5hBAvyuQQQgAA7733HvLy8tp9rbtMzjXXXNPu8/j4ePTt2xfPPvssnE4nzj//fAwfPhwKhbg74yzLdvj16667Dg8//DAAoKWlBTt37sQ///lPTJs2Db/88otfGaRg79u3336LIUOGYMSIEe0yZlOnTgXDMFi7di2mT5/Of/3CCy9ESkoK/7lSqcSf/vQnLFmyBCdPnkRGRobPayekp6KaHEIIACAvLw9jxoxp99Gd1NTUdp8zDINff/0VU6dOxTPPPINRo0YhKSkJ9913HxobG8VaOo4fPw7AfRqsraSkJP6+nHvuubj33nvx8ssvY8OGDX4f8w72vlVUVGD37t1Qq9XtPqKjo8GyLKqrq9tdvlevXmfcBve1mpoav9ZOSE9FmRxCSMDa1pBwsrKy8M477wAADh06hM8++wyLFy+GzWbD66+/LvgaWJbFf//7XxiNRp8Cs2HDhgEAdu3a5ffPCua+JSYmQq/XY8WKFZ1+v63y8vIzLsN9LSEhwe+1E9ITUZBDCBFN//79sWjRIqxevRoFBQX817VaLVpaWgT5GUuWLMG+ffvw17/+1acj4dxJqOTk5KB+rr/37dJLL8VTTz2FhIQE5OTkdHv7v/76KyoqKvgtK6fTiU8//RR9+/alrSpCfERBDiFEMLt378a8efMwc+ZM5ObmQqPR4LfffsPu3buxcOFC/nJDhw7FJ598gk8//RR9+vSBTqfD0KFDu7zt+vp6bN68GQDQ3NzMNwNcv349rrvuOixZsuSM61RUVPDXaW1txc6dO/Hkk08iNjYWt956a0jv2/z587F69Wqcd955eOCBBzBs2DC4XC6cOHECP/30Ex588EGMHz+ev53ExERccMEF+Nvf/safrjpw4AAdIyfEDxTkEEIE06tXL/Tt2xfLli1DSUkJGIZBnz598Pzzz+Pee+/lL7dkyRKUlZVhzpw5aGxsRFZWFoqLi7u87Y0bN2LixIn8iIb09HSMGzcOixYtwsUXX9zhdb744gt88cUXAAC1Wo3MzExcfvnlePzxx5GVlRXS+2Y0GrF+/Xr8+9//xptvvomioiLo9Xr07t0bU6ZMOaNX0OWXX47Bgwdj0aJFOHHiBPr27YsPP/wQf/rTn/xaNyE9GcN2diyBEEJIWDAMg7lz5+LVV18N91IIkTU6XUUIIYSQiERBDiGEEEIiEtXkEEKIxFAVASHCoEwOIYQQQiISBTmEEEIIiUgU5BBCCCEkIvXomhyXy4XS0lJER0d32J6eEEIIIdLDsiwaGxuRlpbW5ZDcHh3klJaWIjMzM9zLIIQQQkgASkpKuhxz0qODnOjoaADuBykmJibMq+las60Zac+7JyyXPgcYT5QCRmOYV0UIIYSEntlsRmZmJv863pkeHeRwW1QxMTGSD3KUNiXgmT0YwwDGmBgKcgghhPRo3ZWaUOGxDLlYNQr/fASFMwvhbHWGezmEEEKIJFGQI0MslKj6ug5VX1QBFOMQQgghHaIgRyZUChVuGXwTbtkJqFzhXg0hhBAifT26JkdOtCotVk1/A5j5ISVvCCGEEB9QJocQQgghEYkyOTLBsiwstmZADWjt4V4NIYQQIn2UyZEJi92CqJdTEPU4YKHQlBBCCOkWBTmEEEIIiUgU5BBCCCEkIlGQQwghhJCIREEOIYQQQiKSbIOcpUuXYuzYsYiOjkZycjKuvPJKHDx4MNzLIoQQQohEyDbIWbduHebOnYvNmzfj559/hsPhwMUXX4zm5uZwL42QHsXlYsO9hLCxOVxw9uD7T0KHZVmwrLz+1lpsTuw4URfWNcj2MPKPP/7Y7vOVK1ciOTkZ27dvx3nnnRemVYlHqVDi2v5XAl99DRXrRNKVcYBKBShDtwa704Ub39oMhmHw3m3joFOH8IcL7LvdZdhfZsaY7DiMzY6HUSvt/wosy+KTbSV49bcjiDWoMTY73vMRh+QYXcjXY3O48Pn2EixbcxRKBYNP75qAVJM+5OsIp1P1Lbjk5fUYkxWHt28ZG+7lEBGwLIvShlZsP16HPSfrMT4nAVMGpYR0DXXNNrz822F8vPUE0kx6XDUyHVeOTEdmvCGk6/BXi82JO97bhvziOrx9yxicm5sUlnUwrNxCw04cOXIEubm52LNnD4YMGeLTdcxmM0wmExoaGhATEyPyCgXQ3AxERbn/3dQEGI0h/fG/HajAbavyAQBzz++Lh6cODOnPF8reUw24/NUN4N6AqxQMhmWYcFbfRNx2Tg7ijZrwLvA0zVYHFn29F1/tONXh9wenxeC1G0chO1H8vwebw4XVBSfx6m9HcKq+hf/6iMxYfHrXBGhV8g18/fXCz4fw8q+HAQC/LJiEfslRYV4REUp+cS1WbizG9uN1KDe38l9nGODpa4bhujGZoq/B6nDi/U3H8fKvh2FudZzx/bHZcbh+bG9cPSodDMOIvh5/cAHOxiM1MGqUWHXbOIzNjhf0Z/j6+i3tt68+YlkWCxYswDnnnNNlgGO1WmG1WvnPzWZzKJYXMb7eUcr/+/V1xzBjaCoGp5nCuCL/uVws/v6fvXCxQP+UKFhsTpysa0HBiXoUnKjH+sNV+PKes6FUSONJ43BFI/7yYQGOVDZBqWCw4KL+yEowYFtRLbYW1+FAuRmFpWbMfGMTPrxjPPqnRIu2lh0n6nDvxztwss4d3CRFazH7rGy8+fsx7Cypx+JvCrH06mGi/XwpcblYrN5+kv98dcFJPDpNnkF/Zxpa7LA7XVApGCgUDJQMA4NGKbkXVKE5nC7c+/EOlDW4gxuVgsHgtBjE6NVYf7gaj3yxG3anCzeNzxJtDWsPVuLv/ynEiVoLAGBgr2g8Om0gappt+GrHSfxxtAbbiuuwrbgONc1W3HleX9HW4q9QBDj+iIggZ968edi9ezc2bNjQ5eWWLl2KJUuWhGhVkaXZ6sDP+yoAuDMHhaVmPPLFbvxn7tlQKeVT2vVFwUkUnKiHUaPEe7eNRy+TDiW1Fmw6VoN//ncfdp1swCfbToj6BOarb3eX4uHPd6PF7kRytBav3DAS4/skAAAuHZYGAKgwt+KWFVtxoLwRf3pjE96/fTyGpAsfeJbWt2DOe/mobrIhMUqLv0zui5vG94ZOrcSQdBNmr9yKj7eWYGh6LG4c31vwny81m47VtMtkfVVwCg9dPEAywXGwVm8/iYe+2IXT8/x5qTH4Zt7ZUMvo/7y/ft5XgbKGViQYNXjtplEYnhELvUYJlmWx5L/7sOqPYjz+1V7YHS7MPjtH8J//U2E5/vJhAZwuFknRWjx88QBcMzqD/9u6dnQGyhtasXJjEd74/Rie/vEgRmfFYXRW+AIJjtQCHEDGhcece++9F9988w3WrFmDjIyMLi/72GOPoaGhgf8oKSkJ0SqD12xrBvNcFJjFgFmlw9qobVjLrIWzOTQzyX/eV4EWuxPZCQasvHUsTHo1CkvNeGt9UUh+vhDqLTb8+4cDAID5U/qjl8ldy5IZb8B1YzLxwEX9AQDP/HgQNU3WTm8nFA5VNGL+JzvRYnfi7H4J+P7+c/kAp62UGB0+uXMChmWYUGex44a3NqNA4EK/FpsTd77vDnDyUmOw9uHJuP2cHL4ma1L/JDw8dQAA4Ilv9mL78fAWGobC5/nu546ZozNg0qtRbm7FH0erw7wq4fxYWH5GgAMA+8vMOFjeGPoFhdC7m4oBADeM640JfRKg17j/zhmGwROXDcJd5/UBACz+7z68+ftRQX/2xiPVmPfRDjhdLK4YkYa1D03GdWMzzwiee5l0WDh9IC4bngani8W9H+1AXbNN0LX4q9UuvQAHkHGQw7Is5s2bhy+//BK//fYbcnK6j6i1Wi1iYmLafRDffL3TXQ9yxYh0JEfr8LdLBwEAXvzlEI5VNYVzaT577qeDqG22ITc5CrPPzj7j+7MmZiEvNQYNLXY8/eOB0C/Qg2VZLPp6LxwuFhcMTMZ7t41HYpS208vHGjT44I7xGJsdh8ZWB25+ews2H6sRbC0Lv9yNvafMiDdq8ObNoxHVQZH2Xyb1xYyhvWB3svjLB9tR2aaOIdKYW+34YW85AOCmCVm4bHgqALTbvpK7faXurfyP50zAkX9Nx8Enp2GiJ8jee6ohnEsT1aGKRmw+VgulgukwI8kwDBZOH4h7L+gHAHjq+wN4zxMUBWv78TrMeS8fNqcLUwen4PmZw7s8EMEwDJ66aghyEo0obWjFg5/vCutJxxUbiyQX4AAyDnLmzp2LDz74AB999BGio6NRXl6O8vJytLS0dH9lmVOgFWcVjcBZlWdBYRD/V1jdZMX6w+53qVeMcG+TXDMqHef1T4LN4cLC1Xskf4x4z8kGfLjlBADgH1cM6TDdrlIq8OSVgwEAn+WfxPbjtSFdI2d1wSlsLaqFXq3EP64Y7NMWSIxOjXdvG4dz+iWi2ebEHe/mC/Ji9Obvx/CfnaVQKhi8duOoTk90MAyDZ68djv4pUahstOKZ/0Vuz6pvd5XB6nAhNzkKwzNMuGaUO4P8Y2E5GlvtYV5d8OqabfxW3OD0GKiUCmhVSgzLcG+D7i2N3CCHC1guHpSCtNiOTwsyDIMHLx6A+y7MBQAs/qYQaw5UBvVzC0sbcOvKrbDYnDg3NxEv3zDSpzKAaJ0ar944EhqVAr8dqMRb648FtY5AWWwOvO3J6i+5YohkAhxAxkHO8uXL0dDQgMmTJyM1NZX/+PTTT8O9NNExDKBJUkOTpAlJEeD3e8rgdLEYlmFCn6Qozxrc7yIMGiW2FtfiCwm/i3W5WCz6z16wLHDliDRM7Hvmtg9ndFY8Zo52v2gt+roQDqcrVMsE4H6Beer7/QCA+6fkIiPO92OiBo0Kb98yBhP7JKDJ6sDsldtwosYS8FrWHqzEvz0ZrScuG9Tl4wYARq0Kiy9zB4nrDlXJrqeHrz7f7tmqGpMBhmEwIjMWfZOMaLW78MOe8jCvLnj7ytxZnN7xBsTo1PzXB3tqvfaeiswDG+ZWO74scGesZ03M7vbyD0zJxczRGXCxwLyPCvjsl78OVzRi1jtbYW51YGx2HN64ebRfpxQHp5n4/3fP/O9gWN6cfbTlBGqbbchKMOBKzxthqZBtkMM1Rjr9Y/bs2eFeWsT5eod3q6qtjDgD/jLJXdX/v0LpPrn/Z9cp7CqpR5RWhb/OyOv28gunD0SMToX9ZWa8v/l4CFbo9cz/DqC22Yb+KVG4/Rz/ixp1aiXemDUaeakxqG6yYtaKLagOoL5o98l63PvRDrAscP3YTNw8wbdC7NHZcdCpFahqtOJwpTy2Mf1xpLIJO07UQ6lgcOVI9/8HhmFwjScwlnKw76tCT6ZmcFr77fwhns/3l5lDHvyHwurtJ2GxOdE/JQoT+nSfiWAYBv+6aijO6puAZpsTt63ahvIG/7Zp95xswHVvbEJNsw1D0mPwzuyxMGj8Pw90w7hMXO6pz3nws10h/f202p1443d3BumeyX0ldxBFWqshPnGxahx64DgOzT0El1XcP+YTNRYUnKiHggEuG5Z6xvfPyU0EAOwoqZfsO/dvd5UBAOac28enxnkJUVo87DkO/MJPhwIKEgKx/XgtPt7qzhI8eeXQgE+wxOjUePfWsUiP1aO4xoLbV21Ds/XMPhud2XuqAX9+ewsarQ6My4nHkisG+5wx1KqUfKp645HIKcTlcEHM+QOSkBzt/Vu6amQ6GAbYWlwbVPZMCgo9GYnTg5zsBCOMGiWsDheOVkVWZ3mXi8X7m9xvaG6emO3z37tGpcDyP49Gv+QolJtbcfu7vv9f21pUixvf2ow6ix3DMkx4/7bx7TJn/nAHXEOQYNSguMbCZ6RC4dNtJahqtCI9Vo+rRnZ9+CccKMiRIRZKlL5VidJlpWAd4gYW3+xy/2c5q29ihwHCoLQYaJQK1DbbcFyCT+6tdif+OOouwr14sO+dSm8c1xuD02LQaHXg3T+KRVqdl93pwuNf7QXgPrEzLie4Pe3kGB3eu30c4gxq7DrZgL98WIAWW/cn8faVmvHnd7bA3OrA6Kw4rJg91u8Gf2f1dQe+G48IU/wsFQ6nC18WuIOca0e3bwaXatLjnH7u+726QN7ZHG+Q074VgULB8F+LtOLjDUeqcay6GdFaFa4emd79Fdow6dVYOXssEowaFJaacfu73W8TrzlYiZvfcb+RGJ8Tjw/vGI+4IJuQRuvU+Mtkd2b9/349DKtD/JO3VocTr69znzC7e3JfaFTSCymktyLSIaVCiRk5UzHjEKAMUcKEZVl8vdPdAPCKTvZZtSolhqS73/EJfXRZCPnFdXyfmYG9fG+Up1QwmHu++wTFe5uO+5UJCcQHm4/jQHkjYg1qPObDlpov+iZFYcXssdCrlfj9UBWmvvR7l9mVA+Vm3PT2ZtRb7BiRGYtVt47t8CRVd7gX+y3HaiJqW2P94WpUNloRb9TggoHJZ3yfK0D+csdJyRfid6bF5uRPS56eyQHchchA5BUfcwXH14zOCGjES2a8AW/dMgY6tQKbj9Viyovr8MLPh854Y2FutePDLcdx53v5sDpcuGBgMt69bRyiA8zgnO7PE7KQHK3FqfoWfLZN/BYpq7efQllDK1JitHwto9RQkCMTOpUO312zGt99BOhC0xoH+8rMOFLZBI1KgalDenV6uZG94wAAO07Uh2Zhflh70H3qYVL/JL+LtKcO7oWsBAMaWuz4LF+8J4wWmxOvrXG/G3ro4gGCjpUY2dudjUk16XCi1oKb3t6Chz/fhQaL+xSQy8XiSGUTPttWgpve2oI6ix3DM0x47/bAn3gHpcXApFej0erAngh6x89laK4YkdbhO9apg3shSqtCSW0LthWH52ResPaXm+FigcQobYeZ2yGeTE5hBBUfl9Ra8KvndNTNEwNvAjqqdxy+vfdcnNMvETaHCy//ehhTXliHz7aV4P9+OYxrl/+Bkf/42d1I0MnisuFpeOPm0YLOANSplZjnOd7+6pojaLWL92Jhd7qwbO0RAMBd5/WV7CxDCnJIp77d7a5lmZKX3OVe8ShPkCPFTM66Q1UAgMkDznzn3R2lgsEd57obf729vki0rMQHm4+jusmKjDg9/jRW+Jk4E/sm4KcHzsMszxP459tP4sIX1uHmd7Zg+D9+wpQX1uGR1btR02zD0HQT3rs98NoAwP24cT1VIqkuh9uiuSiv421PvUbJZ3jyZdoQsbN6HA7XTbuwtEG22arTrTlYCZYFJvSJR9+k4OaP9UuOwvu3j8Pym0YhPVaPU/UteGT1brz4yyHkH6+D08WiT5IRCy7qj5f+NEKUztF/GpuJ9Fg9KsxWfCDiwYmvd5zCyboWJEZpcMM46XY5pyCHdOqA5yjpOf26nh47KivWffnyRlhs4m7r+ONUfQsOVzZBwXi3UPw1c3QGEowanKpvwXd7ygReobu/BLenfe8F/URrlx+tU+MfVwzBF3dPRN8kI9/7qLHVAZ1agXHZ8Zh7fl98cPt4mPTBp87P7scFOZFRl+N0sfzMrq4GofZJcn+vpFZ69Wm+2NfJySpO3yQjtCoFmm1OFNdERvExF7wK1duFYRhMH5qKXxZMwr0X9ENuchRmDO2FpVcPxfpHzsdvD07GfRfmijYCRKtS8s0KX193VJStdqeLxfK17uetOef24btCS1FEzK7qCZptzUh+KRn4K1D2DIAQxBIlnif13p00gOOkmvToFaNDubkVu082YEIH4wfCYd1BdxZnZO84mAyBvXDr1ErMmpiNF385hDd/P4bLh6cJ2pvo/U3HUdNsQ+94A64eJf6e9pjseHx//7n4escp2BwujOwdhwG9ogUPrs72BJXbT9Sh1e6UbCrbV6X1LXC4WGiUCqR0cUKP+79yQqZBTmdFxxyVUoG81BjsLKnH3lIz3zdLzri+P0LPfNNrlHjw4gF48OIBgt6uL64ZnYHl647ieI0F724qxj2T+wl6+z8VluNYdTNMejVu8rG9RLhQJkdGLA4LLMKVa3SJZVmcrHM/UWfEddz5sy0umyOlLSuuHmdy/64zUd2ZNTELerUShaVmQTMTzVYH319CzCzO6bQqJf40tjdunpiNIekmUX5uTqIRqSYdbA4X8oul8zcRKC5oyYjXd/kOnAtySurkF+TYnS4c8Myl6iyTA4A/aFAYAcXHrXYnDlW477MYg23DRa1UYP4Ud0fmN9Ydg1nATtwsy2K5J/t8y8SsgA4nhBIFOaRD1U02tNpdYBh02t68rVESKz62OVz80fFJA4ILcuKMGr5W5g0BB/K9t+k4apttyE4w4Co/j61KHcMw/FHyDRFQl8O1R8jqJqvJjb0orW+FXWYny45WNcHmcCFKq+oyextJxceHKhrhcLGIM6iRZuq+h5acXD48Hf2So9DQYudHLghh09Ea7D7ZAJ1agVvOyhbsdsVCQQ7pEPdONDVG51Pvg5G9YwEAO07USaIpYMGJOjRZHUgwavgn5WDcfk4OFIz7GHGg7dvbarI6+AnG916QK7kuoULg6nIiYTo3l8nJSui8HgcAkqK00KoUcLpYlNXLa0gpF7QMSo2BootsFZfx2FvaIIn/68HgTv8NSTeFZEROKCkVDBZc1B8A8M76Y6gRqKkpl8W5bkwmEroYHCwVkffMSgRRwqfnfZudNDjNBLWSQXWTDSW14R+SutZTj3Ne/6Qun7B9lRlvwCXD3L2CuP/kwXj3j2LUWezISTR22oNI7ri6nD2nGvgj63J1otZdZNvZgFKOQsHwl5HblhVXjzOoi60qAMhNiYJayaDeYucHecqVWPU4UjF9SC8MTTeh2ebEsrXBP2/tPdWA9YeroVQwmOM5eSp1FOSQDnEnSTJ9HBCpUysxyJMx2VES/hoM7uj4pCDrcdq6e5L7P/V/d5ViV0l9wLdTb7Hx04Lvu7BfRGZxACAlRod+yVFgWWDTMXmfsvJ1uwqQb/ExV2PT3Qu+VqVE/xR3Y025D+vk77MA2V4pYhgGD091Fz6/v/k4SoMMSrkawkuHpXYb8EtFZD67kqDxmRwfio45ozxbVgVh7hFSYW7F/jIzGAY4Nzewo+MdGZxmwtWj3LUzT363L+BU/dM/HkS9xY7+KVG4fHhk1eKc7uy+8u+Xw7Is36Y/K6H7J/ZMz/8ZOQU5LhfLb8N2VXTM4S4j5+Jjm8OFA2XuouOhEZrJAdzPgRP6xMPmcOH/fjkc8O2cqLHgu93uDvh3nddXqOWJjoIcmVAwCkzKOAeTigEl64LpnGiYJplE+w3ymRw/onVvU8B6MZbkMy6LMyzdJPie8cNTB0CnVmBbcR1+2Ov/5PXtx+vw8dYTANxDOMXqlSEVZ3m2rDbKuC6n3mJHo6fXiC//HzJlmMkpqbOg0eqARqVAv+Tuj4XzdTky7mh9uLIRNqcL0ToVMuN9fzMnN+5sjnvg8BcFJ3HUM7bDX2+uPwoX686Od7elKSUU5MiEXq3H2ut/xNpVgNFpw8gfB2Lk2pFQ6sXpP8LVE2T6kcnhio/3l5l9GgYpFq4/jpBbVZxUk55/F7P0h/1+tU13OF14/Ks9AIBrBRjCKQcT+iRAwQDHqppR3iCvQlzOcU+w0itG51O/H2676qSMghyuHmdAim89k/hBnQIU4YcLV2g9JC3yio5PNzorDlPykuF0sXjh50N+X7+6yYrP891jTe6eJJ8sDkBBDumA08Xye7f+ZHLSY/VIjtbC4WLDNrPI4XRh/WFPkBPAKAdf3DWpD1JitCipbfFrQvmqP4q9QzinDxRlbVJj0qv5+o19ZfJ813/c09m3u6aYHDlmcgq76XR8urzUaCgYoKrRikqzPINX7jlqaEbkblW19dDUAWAY4LvdZX5n4J7+4QCsDhdGZMZiQh95vTmjIIecodzcCruThVrJdNnd9XQMw7TplxOeupxDFU0wtzoQpVVhuEhPXgaNik//vvrbEVT7cDSztL6Ffwe1cNpAWRy9FAo3D+hYlTzHAHD1OL19qMcBvEFOncWORgGbsImpu5lVpzNoVPzvVa4Tyff6GdjJ3cBeMbhiuPsk59If9vs8e+w/O0/h8+0noWCAv87Ik13Wi4IcmWi2NSPptSwkPQyYVTpszNqBjUkb4WwWfluIKzpOi+26u2tHuC2rcHU+3n2yHgAwLMMk6qmlq0emY0h6DBqtDrzoQ/r3H//dB4vNidFZcbhujPBDOKWMm+d0VKZBDrdd5cvJKgCI0qqQ4JkkL4V2Cr7wHh/3/Y2Bty5HfltWDqcL+8si+/h4Rx64qD80SgU2HqnBv77f3+3lT9RYsOirvQCAeRfkynKLnYIcGaluqUG1pxeZvcYBe7U47xK5IMfX4+NtjcryFh+Ho1HYLk+QMzwzVtSfo1AwWHTJIADAx1tP4D87T3V62dXbT+LHwnIoFQyevHKIIH175IQLcoqqAyt4DDdu28nXTA7g7S8lhy2r6iYrqhqtYBj3NpSvuMtyYxHk5GhVM1rtLhg1SuR00+AxkmQlGPHszGEAgHc2FGHFhs47IdudLtz3yQ40Wh0Ymx2H+y4Qdv5VqFCQI0MKWDF26xCM3TsWCr3wv0LvySr/TxwMTTdBpWBQ1WhFaRgKTXeWuFPQwzNiRf9ZE/ok4LLhaXCxwP2f7MTcDwtQ22zjv19a34I738vHg5/vAgDcdnY28lJ7Rmq8rZzECNmu8qM+jZ9hJYMgh6u/S47WwqDxfQ5Reqz7PsqxoJyrSRmcZupxbzquGJGOR6e5t9v/+d0+/Li3rMPLvfDzIewsqUeMToWXrh8p235e8lx1D8cwLIyD9DAONoIR4T9oCT+Y0/9Mjk6t5I+gHigLbRrbYnPw7ypHiJzJ4bxw3XDMn5ILlYLBd3vKcPGL6/Dj3nK8s6EIF72wDj/tq4BKweAvk/vydTw9DZfJqWy0yqZGhdNqd6LcU1jb3UiHtnrHy6dXDhek9PKj/g4AenlmPZXJMMjhio4Hp/e8Nx2Au7Hpnyf0But5g7b9eC3/PZeLxZqDlXjd09n96WuGId2H+YVSJe3xoSQsTtb6f7KqrYG9onGgvBEHyhtxYV6KkEvrUmGpGU4Xi5QYLf8ELDb3tN/+uHBgCh78fCcOVTTh7g+2898fnRWHp64aigG9fN8GiDQxOjUSo7SobrKiuNoiq9MsXCYmWqtCnEHt8/XkNI28whPE+XPIAABSPf/HKsytcLlYWWVEuNNkkdwEsCsMw2DxZYNRVt+KXw9U4rZV+eibZESF2YrKRvfBEwC4cXxvTB+aGubVBocyOTLkYlUo+tcpFC0ugssm/KRjbyYnsOh9QC/3u6MD5aHdq+dGLYRiq+p0QzNM+GbeObhrUh8wDBCjU2Hp1UPx+V0Te3SAw+mT6M6CHJNZXU7behx/TpVw9WyyyOR4ghx/3xgkR2uhYACHi/XphKFUuFwsX2jdk4qOT6dSKvDKjSMxLMOEhhY7Ck7U41R9C+xOFgzj7jP2N0/doZxRJkeGWKhwfKm7vXbvh3sDGuFu2+rwpucDKTwGgIGegsRQb1ft5IKcEG1VnU6nVuKx6Xn48/gsxOjVMOl9f+cf6fokGbG1uFZ2J6yOB1CPA3izoCdrWySf5ShvcAco/mZyVEoFkqN1KDe3oqyhFcl+Xj9cjlU3w2JzQqdW8MF3T2XQqPD+bePx/d4ymPRq9DLp0CtGh6RorU9NIeWAghyZUDAKjEkZBRQUQCHioaXS+lawLKBXK5EYFVj0lOfJ5ByrbobV4YRWJU5X5tNxJ6tCVY/TGbkMrgsl7wkreQU5gZysAtxbOSoFA5vThcpGa8i2TwPBbVf5W5MDuLM/XJAzXCadEbitqkGpMbItphWSyaDGDeN6h3sZoqHfsEzo1Xpsu/l3bHsL0Is4MeFkm62qQJs+pcRoYdKr4XSxOFIZmu2JmiYr35NETjUfPYX3hJW8tqu4bsdZ8f6941cpFUiLlUfxcaDbVYC3Lqe8QR79gADvyaqevFXVk1CQQ9opCbLoGHAXtQ3sxW1ZhaYuZ/dJ9xNX3yQjYnS0TSQ1bTM54eifFCi+EaCfmRzAu8Ul9SCnoiGwwmOgzQkrGY124E5WDfGj8SGRLwpySDvBFh1zuH4wB0PUKCzc9Tika5lxBigVDCw2JyrM8ihSdblY/qShvzU5gDxmWDVbHfyE9ZQY/0eNeDM58glyDnoORMhpkjYJHAU5MmGxW5D95iBkzwcsIlZSBdPtuC3uRNH+EBUfS6Ueh3RMo1LwgYJctqzKza2wOV1QKRj+xdwfXDNNKU8j57aqjBologPIgPYyue+jXHrlNLbaUWdx92rK7uFFxz0FBTkywbIsjptP4HgsIGayvySIbsdt8dtVIThGzrJsWI+PE99wJ1mOyqT4mDtZlRGnD6hAVQ7bVXyPnAALo+WWyeG24+MMakRp6dxNT0BBDmnnVBDdjtvqn+IOcqoaragRuYdGSW0L6ix2aJQK/vg6kZ4cT5BTJJNj5Cdq3evsHeBsIzkFOYGcrGp7vfKGVlnUWnHb8XQCsuegIIfwLDYHqpvcs5eCfRIwalV8seZBkbM5Oz1bVYPSYkJ2XJ34r0+S54SVTBoC8sfHA8xqclu+lY1WtNpFPBIZBK5HTqBBDlesbHO62s1tkyqhtuOJfFCQQ3jcYM5onUqQRnbcltV+kYMcbquK6nGkjTthJZdBndx2lb/HxzmxBjWiPVsiJyU63iHY7SqNSoHEKHfBshzqcrjnuIwgt+OJfFCQQ3hCv8vhxjscLBe3+Jivx8mkI6FSxtXknKyzwOqQZmajrUAbAXIYhpH8CatAh3O2Jae6HG92jjI5PQUFOYTHBzkCvcvJC0Hxsd3pwl5PB1MqOpa2pGgtorQquFjgRI00X/Tb4jM5AQY5QJu6HIne3/IAh3O2lSqjXjm0XdXzUJAjEwzDYFDCQAyqBBiwMAzUwTDIAAg4Eoc/WSXQE8BAT6+cQxWNcLrEKUo8VNGIVrsLMToVsgMsECWhwTAMv2Ul9RlWDRY7GlrcR42DedfPvWHg/m9JTUUQ3Y45fJBTL837yGFZlt+uosLjnoPO0MmEQW1A4a35QFQUACvG5Q8FjMK+qJ8U+ORB73gDdGoFWu0uHK9p5gtPhbSrxJPFyYyV9BBE4paTaMTukw2Sn2HFbWskRmlh0AT+NCnlE1ZOF4vKxuAKjwFvrxypb1dVN9nQYneCYYC0WOnOEiPCokwO4XE9JILtdsxRKhgMSBF3y4qrxxlG86pkoY9MZlhxR40DPVnF4d4wlEgwyKlpssLpYqFgEPAwXqBNJkfiQQ73O+0Vo6NTmD0IBTmEJ0YPiYGe4mPRghy+03GcKLdPhMWfsJJ4JqdSgG0cQNpBDlePkxStDWoaN/cYlUu8JofqcXomCnJkwmK3YPDKMRh8D9Co0mLrmD3YOngrnBZhTqk0WOxobHXPsBEqkwN4xzscEGG8Q7PVgUOe2VjDKZMjC3xDQIkHOVWeBpZJUf7Pc2qL2wZqtjnR7JkRJRVCnKwC2mZyWiTdEJCOj/dMFOTIBMuy2FdzAPuSARYMLAdaYdlnEWzGwylP0WC8URNUDcLpuA7EYgzq3HuqAS4WSDPpkBzkEzUJDS6TU9tsQ71Fus3jKj1DRIP9uzJqVTBo3FsjVY3SGkzKFR0Hex+5k1mtdhdfrC1FlMnpmSjIkSEFbBj+/QAMXzMcCp0wv0KuW2kwe/Md4barjtdYBH8ny21V0eRx+TBoVPw7fymfsBIqkwOAb5ZXLfJ4E3+VBznSgaNTKxFvdD9vSLkuh0Y69EwU5MgQw7gQd14M4ibHgVEKc6Koptn9BMw9WQkl3qhBcrT7SV7obM5OvglgrKC3S8Qlhy0rLuuSFC1EkOP+PyW1IKfCk60Ktu4IaD/DSqq4gxWZAm7HE+mjIIcAAOo8mRyhgxzA2y9H6BlW/PFxagIoK97xDtI9YVUpaJDjvo2qJmltz1UI0AiQI/UTVk4Xi9J66pHTE1GQI0MuVolTb1Tg1Gun4LK7BLnNWjGDHBGKjysbW3GqvgUMAwylomNZ8R4jl2Ymx+liUePJuiQLEORwgZLUanKEKjwG2pywapBmQ8CyhhY4XCzUSkaQoI7IBzUDlCEWahx+8AQAoNfsXkDwszRR6ykCjTcIH+TkeYqP95YKF+Ts9mRxcpOjEKWlP2M5yU6UboM8wB3wu1iAYYQJ+iVfk2MKPpCTeibH2wPMACU1De1RKJMjEwzDICumN7LqBZ3kwBMzk8NtJ+091QC7U5jME190TFtVspPq6ZBbJtF3/ZWN7hfqBGNw/WM4iZ5MTrWEMjkWm4NvGSFEZoPveizRXjncySoh22MQeaC3wDJhUBtQfOc+ICoKYsxvrvHUC8QLcJrkdNkJRsToVDC3OnCwvBFD0oPfXqKiY/lK87wg1lnsaLU7oVNLq/uskEXHAJAkwcJjbqvKqFEiWhd8KjhN6pkcOlnVY1EmhwAA6kTcrlIoGD4Y4TIwwWBZlh/nMIKCHNmJ0aug9wQ2UnxRFDrI8RYeSyjI4YqOBThZBXhrcsrqpdkQkHrk9FyyD3KWLVuGnJwc6HQ6jB49GuvXrw/3kmRJzO0qwLutxAUnwSiuscDc6oBGpeA7KhP5YBgGqbHeLrlSw52sEqLoGPAGS9WN0jldVSFQjxwOF+Q025xolFhnZ8A7BT6Tuh33OLIOcj799FPMnz8fjz/+OHbs2IFzzz0X06dPx4kTJ8K9NMG12Fsw9v3zMHYO0CJwdt/lYlFncXcqTRC4GSCHz+R4CoaDwQVKQ9JioBagZoKEHl+oWt9zMjktdumMdihvCH76eFsGjQomvdpz29L7nVImp+eS9SvECy+8gNtvvx133HEH8vLy8NJLLyEzMxPLly8P99IE52JdyK8oQH464BK48tjcaofT5U4xxxoEOKrVAW621KHKRjQF+URP9TjylyrhQlU+yBGoPs2o9W7PSaUup0Lg7SpAuiesWu1OPjtHNTk9j2yDHJvNhu3bt+Piiy9u9/WLL74Yf/zxR5hW5Vbe0Iq9pxokPZunrRrPVlW0VgWtSpwi0OQYHdJMOrCs+5RVMLyTx2ODXxgJC+4FkWvQJiVckJMcI1wRfmK0pt1th5uQPXI4Uu2Vww3mNGqUiBPpTRyRLtkGOdXV1XA6nUhJSWn39ZSUFJSXl3d4HavVCrPZ3O5DDPd/sgOXvrIB6w9Xi3L7QuO6HceJVI/D8W5Z1Qd8GzaHC4Wefjt0fFy++EyOxN71A8LOreIkSaxXTrmA3Y45Us3ktD1ZxTDUI6enkW2Qwzn9j5Zl2U7/kJcuXQqTycR/ZGZmirImbsunXsITeduqEbnomCPECauD5Y2wOVww6dXISqDUs1xxhcelEntBBIBKTwAgVE0OIL3RDt6RDsLdx14x0gxcT/I9cuj5oieSbZCTmJgIpVJ5RtamsrLyjOwO57HHHkNDQwP/UVJSIsraYvXuYKFBJttV3MmqBLGDHP6EVeDbVTvbTB6nd2XylSrRrY1mqwPNNncnqmQBsxxSagjodLF8jYoQwzk50s3k0Mmqnky2QY5Go8Ho0aPx888/t/v6zz//jLPOOqvD62i1WsTExLT7EAOfybHII5NTG6LtqqEZJjAMcKq+he8q6y++Pw7Nq5K11DYNAVtsYrS3DAy3naRXK2HUCFefJqVeOTXNVjhdLBSMsFty3pociQU5dLKqR5NtkAMACxYswNtvv40VK1Zg//79eOCBB3DixAncfffdYV2XSaTtqkR9AhI9Mw3VCSqoE4UpogtVJidKq0Jusns44+4Aszm76GRVRIjRqWDwBBFSOmFV2aboWMhMYZKEMjkVnuPjiVHCjK3geDM50srOUbfjnk3WYx3+9Kc/oaamBv/4xz9QVlaGIUOG4Pvvv0dWVlZY18VtVwmZyTFqjKiaexyIigLQirOPjwSMRkFuO1SFx4D7RNShiibsOlmPKYM63lbsTGOrHUeqmgAAw6joWNYYhkGqSYejVc0oq29BTqIwf8vBEvr4OEdKox28gzmFncbN3Z651YFmqwNGiQzO5YZz9qYgp0eSdSYHAO655x4UFxfDarVi+/btOO+888K9JH67qqFFHjU5oSo8BrwZmJ0BnLDacqwWLOveWxeyKJSEh3dQp3QyOUI3AuR4J5GH/zlBjJNVABCtUyPaE9hI5Xfa0GJHgyejTsM5eybZBzlSFKuXZ02O2NtVQPvxDv7OuPllfwUA4IIByUIvi4SBFLc3uFoxoUY6cPiaHElsVwnfI4fDBYdSuJ+Atx4nwaiRTGaJhBYFOSIQoyanxd6CyZ9Mw+TZQLNSgx3TDmDH5B1wtgRftBmqwmMAGNArGlqVAuZWB4prLD5fz+Vi8cv+SgDwe5uLSJMUT+OIlsmJls5oB7G2q4A2p8gksC0HACc99TgZtFXVY1GQI4JYA3eE3C7YRF4X68K6kxuwLhtwMgo0bGhEw7oGwBX8bYcyk6NWKjAk3X0yyp+mgLtPNaC6yYoorQrjcxJEWh0JpdTYnrNdZdQoJTPaQay6o7a3Ge77yOG6HdNWVc9FQY4IuO0qm9OFFrvwx2MVsGHQe30x6LNBYLTBnQBpsTn5NYaiJgfwbln5U5fzyz73VtWk/knQqOjPNhL0kmAmxzuBXNgsB8Mw/GiHcAcA3Jsabj1CSpRQgTXg/dtKEyFrReSBNilFYNAooVYysDtZ1FvsMGiEfZgZxoXkq+MFOV1V62lYqFYyiArRnvXwTHcmx68gx1OPc2Ee1eNEijS+8Fg6NTliZXIAd11OSW1L2OtVajwBSLxRnPsIANWN4S+wBsQrsibyQW+JRcAwDEwiHCMXQ22T92RVqDoIc4M195WaYXN0v992ss6CA+WNUDDA+VR0HDG4TE69RBoCOl0sf9JQrCAHCO9oB5ZlUS3i9rTUanIqRaw/IvJAQY5IvPOrhH9CY1kFKr+sReXnlXD5ECR0hcvkxBlCs1UFuPtVxBrUsDldPmVzfvUUHI/Jig9JcTQJjRidiu8qLIVsTm2zDU4XC4YRJwCQQkPAZpuTf2ORECXGdpV0OjsDbYqsKZPTY1GQIxKuLqdBhEyOCxrsm3UU+67bB9YaXGFzbbP7yUiMJ7zOMAyDCwa6MzIfbTne7eW5raopgyiLE0kYhpFU8TG3jZRg1AjaCZiTKIGi3Jo2YyuE3kYH2tTkSOAIOcuyqDC710HbVT0XBTkiEWMSuUFlgEHgxFANv10V2uZ6s8/KBgB8t6esyzlWja12bD5WAwC4MI+OjkcaKR0j57IPiSKcOgK8XY/DWZPDNSMU601N26aHQp0sDVSdxc5nrSjI6bkoyBEJd4xcqJoco8aI5vmVaH4KMArYZqPOs10VbxBmDpavhmXEYlTvWNidLD7e0vk0+N8PVcPuZNEn0Yi+SVEhXCEJBT7IqQ//dhVXvyHk9PG2pJDJEbtdBLclZ3O6YG4Ncz8gT+CcYNTQicwejH7zIuG7Hkt8tENtc3gyOQBwiyeb88GW450WINOpqsjWizthJYEhnVwmR4z+MUCbmpwwFh5z21UJIt1HnVrJn9IMd/FxhchBK5EHCnJEws+vkvrpKi7ICWFNDmf6kFQkR2tR1WjFD3vLzvi+w+nCmoOeLse0VRWR0iSUyalqM4FcDFLI5NSEoPGnVOpyKviiY5pz15NRkCMSk8DbVa2OVlyy+hpcciPQqhTkJgG0CXJCeLqKo1EpcNN498T4VX8Un/H97cfrUG+xw6RXY3RWXIhXR0JBSg0BK0XsBAx4j1dbbOEb7cDX4In4pkYqw0jFHF9B5IOCHJEIvV3ldDnxfdH/8H1/wClgO5tQTiDvyA3jM6FWMthxor7dmAeWZbG64CQA4IKByaKcdiHhlybB01ViTbg3apTQqd1/x+HK5tR4TlMmirg9LYWMFeDN5FDRcc9Grxwi4U9XSXy7qi7MQU5ytA6XDksDALzryeaUNbRg1oqt+CzfHeRcMjQ1LGsj4uPeZTe02GGxhbdQld+uEinIYRgm7AEAX3gsZiZHIuMrykWctk7kg4IckcR6Oh43CHiEXGhOF8sfcQ9XkAN4C5C/3V2G9zYVY+qLv2P94WpoVQosvmwQFR1HsBidmi9UDXc2R+xMTtvbrgrT2IPqJvHf1IQ7kOOUcz1yaLuqR6MgRyRyyOTUW2zgWlnEhfgIeVsjMmMxIjMWNqcLf/9PIcytDgzPMOG7+87F7LNzQjZugoQHl80pD2OQY7E50OSpkxEzyAl3R+AakXsBAeEP5DgV1O2YgIIc0Zg8QUOL3YlWESaRC4FLXZv06rDXvNx2Tg4AQKVgsOCi/lj9l7PQL5n64vQEXK+c0jCesOKyOPo2R6DF4B1gGfogh2XZNi0jIjuTY3U4+ftKNTk9G00hF0m0VgWlgoHTxcLcYodOLeCRKIGE4jipry4blgqtSoGcRCP6p0SHezkkhLhp5OHM5LTdqhIzc8h1PQ5HAGBuccDhcqduIz3IqfRsVWlUirBmqUn4USZHJO5J5MKPdhASV3QshaGXDMNg6uBeFOD0QNx2ValEghwxJYVxSjd3sipaqxL1TVdSmyAnXKMdvCerxA1aifRRJkdEsXo1apttgtTlGDVGsA81AVFRAFoxuWksYDQGdZvhPj5OCACkxXI1OeHbrqoU+WQVh6/JCcN2VU2IGn9yp6ta7S4025yibv91hqaPEw5lckRk4ouPpTnaoU5C21Wk5+JHO/SATE5iGEc78CMdRP7/btCoYNC4M0Xh6nrMbX1SPQ6hIEdEsRLfrqqR0HYV6bnSJND1uErkbseccNar1IRwTl2463LoZBXhUJAjIm4SuRDzq1odrZj5zZ8xcyZgUapR+OcjKJxZCGdr4Ce3xJ5ITIgvpNAQsLKRG+YYmpqccIx24EY6JIZgTh33M8KxLQe06ZFDQU6PR0GOiEwCjnZwupz44tDX+GIw4GCUqPq6DlVfVAFBnE6vs1BNDgm/aJ0a0Z66jdL68GRz+AnkIm9XhXO0g3cCeSiCHGlkcqgRIKEgR0RiNQRkYEfu872R+2ouGE3gJwe4d3a0XUXCzTuoMzzFx97tKnFfFMM52iGk21VcQ8AwDemk7SrCodNVIhKrJkfBOJF+V0rQp6u4TA5tV5Fw62XS4XBlEyrMoX/n73Kx3q2c6NBkOU7WtYS8I3Bot6vCl8lhWZbmVhEeZXJEJGRNjtBYlvUWHhsoyCHhlRztfjHiamNCydxq55vkJURwUW4ouh1z+KaHYajJaWixw+pwARC/xopIHwU5IuKPkAtQk9MWyypQ97sZdWvrwDoDa7bVbHPC5nkiCMUePSFdSfG8GFWGIZPDBRsxOhU0KvGfEr2znUK9XcUdIY/cQA7w9siJM6gl2WmehBZtV4mI364SOJPjgga7ZhwEAJzbdC6URv//I3M9cnRqBQwa+jMg4cWdguFqKUKJ2zZKFLnomMNtF3FBRyi4XN65VSHZrgpjPyDqkUPaokyOiKS8XcUXIdJWFZEArtNwZVg6AYs/mbstbruICzpCob7FDs+OXEgOGoQzk1NJx8dJG/QWXkRcJqfR6oDd6YI6iEnfBrUBTfdVACkp0ArQXqPW88Qudot3QnyRHMZMDlc3EooMBwAkeAKAmhBmObjj4ya9OqjnIV+17QdksTlCmi2mkQ6kLcrkiChG751+aw7yhBXDMDBqjDDaASHGzdU2u9dDRcdECtpmckI91LGaP3UUmkwOd5qxJoSZHO4+hqr+rl0/oBCfIiunHjmkDQpyRKRUMIjRud/BSG20Q21zaObYEOIL7hSMzeFCQ4j/r4SyIBfwBhqh3K4KdXfztv2AqkK8ZVVBx8dJGxTkiIyrywm2+NjqsGL2D3dh9pWAVYDfGpfJCUVjMEK6o1Up+eaZoa7L8RYehyYA4Gpy6iw2OF2hyVqFOpADwleXw29Xmei5jVCQIzruibshyGPkDpcD7xZ+iHdHAA5BghxPTY5R3c0lCQmNlOjw1OVwL8Kh2q7itohZ1tuQU2xc/U8oa/DCFeTwIx0ok0NAQY7oTCIdIw9WbQhbvBPii+Qw9crxnq4KTQCgVir4Nz+h2rLi72MIt6eTormGgKHblrM7XXz9EW1XEYCCHNEJtV0lNG493JMtIeHGdT2uCHHXY+5FOFSZHMC7ZRWqLEcNX3gc2dtV3FanWsnQoQoCgIIc0Yk1vypY5lb3ekx6CnKINIQjk9NsdaDF7gQQ2iAnIcS9cmpCONKBE44gh2sEmBytg0IhxDlUIncU5IiMr8kJ0d67r7gTLBTkEKlI4Y+Rhy6Tw2U43J2/QzcCgCsADlmQ4wk0QjnCJRxBDj99nI6PEw8KckRmkmomp8XdUTBGR0EOkQbvaIfQvShWtSk6ZpjQvfPnCoBDNfaghj9CHsrtKvd9DOWMLpo+Tk5HQY7IpFiTY3O4+BQ9ZXKIVPDbVSHM5IT6ZBXHu10lfgDgcLr455+QZnLCML+KTlaR09FYB5EJVZNjUBtQeU8RkJ2DKEcrzioaARgNUBj8j1O5ehwAiNLRnwCRBr7w2OzuehyKzEpNU+iGVrYVypqcWs9WOcOEtsM5Fzg2WR1otTtDMhG8gnrkkNP49QqXk5MT0BPP/Pnzcd999/l9vUggVE0OwzBIMiQBFvfnmiQ1EGARITdiIlqrgpKK84hEcPOObA4XzC0OmEJw8i9cmZz4qNBlObhAKs6gCen/9xidChqlAjanC1WNVmTGG0T/meWUySGn8SvIWbVqVUA/JDs7O6DrRQIuyJFSTQ5XdBxDW1VEQnRqd9fjeosdFY2tER3khDKTwx8fD/EIF/doBw1KG1pR3RSaIKeCJpCT0/gV5EyaNEmsdUQsk979xNLQYofLxQZ8rNHqsGLBLw8AM4DnflSj5IHjgFqFfi/0g0Lr35aVudVTdExBDpGY5Ggt6i12VJqt6J8SLfrPqwnx4EpOKOdXVYfhZBUnMVrrCXLEv58sy1LhMTkDFR6LjCvsZVmg0RNcBMLhcmDZzrewbBxgVyhR+lYlSpeVgnX4P/vGe3yc6nGItHhPWIWm+LgqXNtVIZxfVRuGk1WcUB4jb2zT84gyOYRDr3Ii06gUMGqUaLY5Ud9iEyQFz8CBrMfSAI0ajNr/zBBXk0PHx4nUJPG9ckJz7DhsNTmnza8S8+eHK1sFAElckBOC3yc3fdykV0Mfwp5HRNqo8DgEYg0aNNtaUG+xIysh+NtTMA7kPJ4OGI0BXZ8aARKpCnUmJ1ynq1Se+VX1FjtqmkQOcvhhvOHYrgrd+ApvPQ6drCJeVHgcAia9GqfqWyRTfMwdIaeaHCI1oex6bHO4+IA/1JkcwB101FvsniBEvPqjcMyt4iSG8BQZnawiHZFl4XFxcTH++c9/4rfffkN5eTnS0tLw5z//GY8//jg0GukNZeNPWAk02oFlGTTvawEMgCHPAMbPYmYzZXKIRCV7XqBCMb+Ky3CoFExY/i8kGrU4VtUsevEx1+04lBPIOVyQE4qux9QIkHQkqJocu92O8vJyWCwWJCUlIT4+Xqh1denAgQNwuVx444030K9fP+zduxdz5sxBc3MznnvuuZCswR98rxyBMjkuaFEwbi8A4Nymc6E0+rf/7B3pQCVZRFq4rYZQTCLnMhzxRk1Yhjly20c1Imc5asMwnJPD1VhVhWC7qpIPcmi7inj5/SrX1NSEDz/8EB9//DG2bt0Kq9XbnTQjIwMXX3wx7rzzTowdO1aM9QIApk2bhmnTpvGf9+nTBwcPHsTy5cslGeRwx8ilMtqBn0Aegj4khPiD63pcGYKux+E6WcXh5lfViJzJ8R4hD/39TI4OXSaH266i4+OkLb+OkL/44ovIzs7GW2+9hQsuuABffvkldu7ciUOHDmHTpk144okn4HA4cNFFF2HatGk4fPiwWOs+Q0NDQ7eZJKvVCrPZ3O4jFLzbVYEHOXq1HkVzClH0EqAP/CQ6gDbNAOl0FZEY7p2/1dP1WEzciR9uxlKoJYZgfpXV4eRbV4S6GSDg/X02WR2w2MT9fXKFx8kU5JA2/Mrk/PHHH1izZg2GDh3a4ffHjRuH2267Da+//jreeecdrFu3Drm5uYIstCtHjx7FK6+8gueff77Lyy1duhRLliwRfT2n886vCvwdm4JRINuUBdQDziDXQzU5RKp0aiVMejUaWuyoFLnrcThrVYDQbFfVNbv/ryvDVHcUpVVBr1aixe5EVaMVWQnibZFTTQ7piF+ZnM8//7zTAKctrVaLe+65B3fccYdfi1m8eDEYhunyIz8/v911SktLMW3aNMycObPbn/fYY4+hoaGB/ygpKfFrfYHyzq+SxnYVjXUgUsbX5YhcfBzuTA43v0rM7SpuqypcdUcMw3jrckTcsnK5WL63Em1XkbYEC6tXrlyJW2+9NajbmDdvHq6//vouL9P2OHppaSnOP/98TJw4EW+++Wa3t6/VaqHVhv4JjavJqQvidJXNacPjax8HLgL+8SsAV2C3w7Ksd6wDbVcRCUqO1uFQRZPox8i9jQDDk8lJDMH8qprm8Mytais5WosTtRZRGzxWN1vhdLFQMOH7fRJpEizI+fLLL5GdnY3zzz8fANDS0oI77rgDH374oc+3kZiYiMTERJ8ue+rUKZx//vkYPXo0Vq5cCYVCuhMqhBjSaXfa8Vz+/wFnA39bg4CDnGabk28jT9tVRIqSQ5TJqQnjuAOgTeGxiCeP+GxVmIqrAYQkk8O1HEiM0kKllO5rAQk9wf4aPvjgAzz++OM4cOAADh8+jHPPPReTJ08W6ubbKS0txeTJk5GZmYnnnnsOVVVVKC8vR3l5uSg/L1hS2q7i6nHUSgY6NT0ZEOkJVdfjqjBvV3HBVX2LHQ5ngO9ausH1AgpndiMpBA0eqR6HdCboTM6CBQswYsQIjBgxAitWrMCNN94IlmWxYsUKjBw5Uog1nuGnn37CkSNHcOTIEWRkZLT7HsuKO+wuENy2UGOrQ/Rjsd1pO9IhnOsgpDOhOnZcHaaRDpw4g3d4b53FzgcDQqoOY7djTih+n+XUI4d0Iui38pMmTcLx48fxz3/+EzNnzsTx48eRlpaGn376Cd99950QazzD7NmzwbJshx9SFO1pumdzumB1iPOOzVc0nJNIXSgyOS4Xyx/dDtdWDje/ChCvLidcA0jbCsV2lXduFWVySHtBZ3KuuOIKXHHFFfznLS0t2Lt3L3bv3o1ffvkFl1xySbA/QvaMGhUYxv2Ozdxqh04dvgm5dLKKSF1yCCaR11ls8JSmhaUTMCdB5PlV1WGcQM7hGzyKGeQ00HYV6ZjfQU532y16vR5jx44VteOx3CgUDKK1KphbHTC3OJAs3iy+bvEnqyjIIRLVNpMj1vYu9+IfZ1BDHcZC1QSjFkermkXrlcMVHidFeiankbodk475HeRERUVhxIgRGD16NP8xaNAgSZ9ukoJonRrmVgcaW8NbfEyNAInUtet63OoQ5W+1JoyjDtqKF/kYeU2Yt+QAb2auusl9zFspQr8eb7djqskh7fkd5Dz77LMoKCjA+vXr8frrr8PpdEKn02HYsGF80DNq1CgMHz5cjPXKVoxejVP1LXyLdX/p1Xrsnb0VGDsORocVY7cOAQx6KPT+BZfekQ40nJNIU7uux+ZWUYKcqjD3yOEkiDi/yuVi+QxROLer4o0aMAzgYt3BnBgF1nS6inTG71e6e+65h/+31WqFXq/HAw88gNraWuTn52PFihWwWq1wOoMdPhBZuOJjc4CZHAWjwODEQUAVALAwDtIDRqPft8MP56RMDpGw5GitZ7SDFbkp4tWqhDPDAXib9InRK8fcaofDU3gUziBHpVQgwahBdZMNlY2tggc5VoeTz4TRdhU5XVBv57nuwddddx2GDRsGAHA6nSgsLAx+ZRGm7THycKLCYyIHKTE6HK5sEu2EVY0ETh0B4m5XcSeronUqaFXhO+wAAEnROlQ32USpy+EaAWpU3tNqhHAEL6RRKpV8wEO8uO0hc4Bdj21OGxZv/BcWTwZaFSoU/esUihYXwWXz70g6N9mZMjlEyrg6DrG6Hod7pAMnQcT5VVy2KpxFxxwxi4+5JoMpMVrq/UXOQNXCIcJtVwWaybE77ViyaSmWTAZsChWOLy3F8SXHwdr96w1EfXKIHCTHcMeOxcnk9ITtKin0yOGI2RagvMHTIyeatqrImfzerpozZw5Gjx6NMWPG8BPJKXruHrc9JMTpKgZOpM1JBtQqMCr/HnuuJidGT4XHRLq4zrWVImVyJHO6Kkq87SopFB1zxMzkUNEx6Yrfr3QHDx7EZ599hsbGRqhU7qsvWbIEkydPxqhRozBixAgYDAbBFyp33sLj4GtyFIwd/V/MCqjwuIGOkBMZ8DaQEzuTE+btKs/8qjqLe36VkMMlpZjJESXIaaQgh3TO7yDn999/BwAcPnwY27dvR0FBAbZv346///3vqK+vh1KpRP/+/an4+DTewmNp9Mmh7SoiZSkiTiJnWbbNEfLwBgBxbQplhZ5fVc1nqyI8k9NAc6tI5wLes8jNzUVubi6uv/56/mtFRUXIz8/Hjh07BFlcJIn2BBVc4W8wWBawVdkBiw3qRN8HbdqdLjTb3Ef7KZNDpIx7V14uQtfjJqsDNs8MuXAHOSqlAnEGNeosdsF7yEil7gjwFj+LkZnjAuFeJsrkkDP5FeScOHECvXv37vT7OTk5yMnJwcyZMwEAp06dQnp6enArjBDB9slpywUd/sjZCQA4t+lcKI2+HQ9tW/QcTc0AiYSlxOjAMIDN4UJts03Q2hnuxd+oUUKvCe/RasB9jLzOYvfUCQnXE0gqJ8gAbyG5mDU5yVR4TDrg1wbw2LFjMWfOHGzdurXTyzQ0NOCtt97CkCFD8OWXXwa9wEjhLTwOX58cbqsqSqsSdO+fEKFpVAo+A1HWIOy7/2qJFB1zuLocoY+R10gpk+PJUDXbnGi2CvscyAU5lMkhHfHr7fz+/fvx1FNPYdq0aVCr1RgzZgzS0tKg0+lQV1eHffv2obCwEGPGjMGzzz6L6dOni7Vu2Qk2k6NT6bD1pnXApEnQBfgcQSMdiJykmnSoarSirKEVQ9JNgt1ujYQyHIC3ZkboE1ZSKjyO0qpg0ChhsTlR1WiFUSvMc1Bjq53fgk8WYVwEkT+/3s7Hx8fjueeeQ2lpKZYvX47+/fujuroahw8fBgDcdNNN2L59OzZu3EgBzmm4Qt8mqwMul3+9bQBAqVBibOpojC0FAk2we4+PUz0OkT6uRX95Q4ugt1vFH62WxotivAi9ciw2ByyeF38pFB4DbYqPBbyfXD1OtFYlWOBEIktAfxU6nQ5TpkzB1VdfLfR6IhaXyWFZoMnmCMvpJhrpQOQkLVYPQPjtqkqztE7j8A0BBczkcFtVWpUCURJ58U+K0uJ4jUXQ3kf875K2qkgnAi7MiIuLw+rVq4VcS0TTqZXQeOpgAqnLsTlteHbrS3j2LMAW4G+NRjoQOeFqLMoFDnK4oCnVpBf0dgPFZZSE3K5qu1UllWatyTHcMXLhfp/lEgtYifQEHOSwLIvly5dj/PjxmDBhAubNm4ctW7YIubaIw3UZDqRXjt1pxyO/L8IjFwP2AH9rDdQjh8hIqifIKRV4u0pqHXK921VCBjnSaHbYlvcYufDbVVL5XRLpCeqIza5duzBu3DhMnjwZBw8exKRJk/DAAw8ItbaII2SvnEDQSAciJ1ymRbxMjjReGL3bVcK9+EvtBBkgzjFyqQWsRHqCerX76KOPcNFFF/Gf79mzB1deeSUyMjLw4IMPBr24SBOjCzyTIwQa6UDkhAtCyhqEbQjo7ZArjRdGMSaRS+0EGeDN5AhbeOz5XdLJKtKJgDM5CQkJyMzMbPe1oUOH4uWXX8brr78e9MIiEZ/JCVOQQyMdiJxwNRxWhwt1FmH+zzRZHWj09GmRSl8Vbruq3jO/SghS6nbMSRJh6Cr1yCHdCTjIGT58ON55550zvt6vXz+UlJQEtahIFc1ncsKzXUWZHCInWpWSz0SUCVSXw219RWtVkjl1FGdQg0tS1VqEyeZIcbtKnEyO+7aSJZKVI9ITcJDz5JNP4tVXX8WNN96IDRs2wGw2o6KiAk899RRycnKEXGPE8A7pDFdNjvvn0hFyIhdC1+VUSPDIsUqp4LseC5XlkNJIBw7XrK+myQpnAL3CTudysfwsrF4U5JBOBPxWZsKECdi8eTPuv/9+TJ48GSzr/qPV6XT4/PPPBVtgJOG7HreEZ7uqkTI5RGZ6mXTYc6pBsF45Uis65qTEaFHdZPW8aAff3VlKIx04CVFaKBjAxbqLrIOdNVVrscHudL/uCDnYlESWoPK1w4cPx9q1a1FZWYnt27fD5XJh/PjxSExMFGp9EYXLoJgDyOToVDqsue57YMYMGBw2DP9+AKDXQaHzPRnnbQYojTQ9Id3xFh8Ls10l1dM4KTE6FJaa+e2XYElppANHqWAQb/QEc+bggxzud5kYpYGaZvGRTgjyapecnExjHHwQzPwqpUKJyb3PA4oBwIW482IAo9Hn67Msy/9cyuQQuejV5oSVELhgSWrbG1wzO+6FOxgOp7dQWyojHTjJ0e4gR4i6HKkGrERaKPwNoegw1uS02J18apdOVxG5SBO4Jqe8wf3iKrXTOFxWQ4hMDtc5WcEAcQZpBTn8/CoBeuVQI0DiCwpyQiiYPjl2px2v7XgDr40FrIwSp96owKnXTsFl9+3IKdeAUKVgYNAEOuKTkNASOpPDHzmW2Asj90JdKUAmh8uSxBu1UCqkMdKBkyxokEOZHNI9QYKcgoIC2GzCNbKKVN6Ox/4HOTanDfN+fRDzLgGsSjUOP3gCh+cdBmvz7ZRC2+GcUpllQ0h32tbkcIcbgsEFS1LL5PDbVQLMdaqR4EgHjpCZnNJ6aW49EmkRJMgZO3YsiouLhbipiOadXRXcdhUDJ5KujEPStUmAj0kZqschcsS9S2+1u/hAPVA2h4sfnSC9IEe47SopFh1zuCCnUoBgrqTWHeT0TpDGoFUiTYIUHgvxDqsniBGo47GCsWPwB/38KjxusHDdjulkFZEPnVqJBKMGNc02lDW0IjaIGpPKxlawLKBRKhAvsVoVrrtzTZMVDqcLqiBOC3GZHKkVHQPe2iMhMjknai0AgMw4Q9C3RSIX1eSEEHe6qtXugs0hTPt2X3mHc1Imh8hLL4GOkXM1HMkxWigkVquS4KmfcfeQCW7rXx6ZnOCCHLvTxf899I6nIId0joKcEGrbRj7UQzrb1uQQIiepAhUf8yerJFjDoVQw/NiDYI+RV0s6kyNMTU5pfQtcLKBVKagRIOkSBTkhpFIqYPScbAqmLsfJ6rA2ahvWMmvhbHb6dB3udBUdHydyI9RoB75HjsTqcTjJfK+c4AIAOWRyLDYnmq2BPwdy9TiZ8QY6SEG6REFOiHGZlFD3yqHCYyJXXFBSWh9ckCPV4+Mcb6+c4O4nV1ydJMEgx6hV8W/0gtmy8tbjUNEx6RoFOSEWaNdjrUqLb6/6At9+CGh9S960QyMdiFxx21Xl5uBqcqR6fJzDHSMPtldOdaN0t6sAYY6Rl9S5gxyqxyHdoVe8EPNOIvcvyFEpVLik7zTgMBBAjMP35qFMDpEbbrsq2JocPpMj2SAn+GPkLMvymRwpblcB7vtZXGPh+9wEgs/kUJBDuiFIJueJJ56goZw+8k4iD+12FZ/JoZocIjN8JqehNah2FXwmR6LbVUI0BDS3OPjxLfFGaWZyshLcgcnxGkvAt3GSghziI8GCnPj4eCFuKuJFB9grx+60Y9XeD7BqBGAPoM6Om3xOmRwiN1zmxWJzBvzmgGVZVJql2QiQkyxAJocb6RCtU0Gnlub4lqwEd3+v4zXNAd8G9cghvqKanBALtOuxzWnDrT/ejVuvBGwBPHeZ6Qg5kSmdWok4g/vvtizAupzaZhtsTndvKq7AV2pSooOfX1Uj4ZNVHD6TUxtYJqex1c5PWc+Mp8Jj0jUKckIs0ExOsKgmh8hZsHU53PUSo7TQqKT5tMdtV9U02wJuFlot4blVnOwgMznc8fF4o4Z/PiWkM9L83x7BvIXHoavJcbpYNFq5PjlUa07kh28IGOAxcm/RsXQzHHEGDdRK91401+vGX1IvOgaA3p5MTnWTDU0B9Mqh4+PEHxTkhJi38Dh0mZy2J7lou4rIUS+++Diw7Spv0bF0XxgVCiboXjnVnmPZUj0+Drjf6HFF0YFkc07WUdEx8R0FOSHGBTmhzORwJ6sMGiXUQQz+IyRc0mKD266SQyYHCL7rcXUzt10l7fvJ9bc5EcAJKzo+Tvzh195FTk5OQC2058+fj/vuu8/v60UivuOxNXSZHBrpQOSOO/ZdHmCGo1zix8c5fPFxgMfIvZkcaQc52QkG7CypD6j4uKSWGgES3/kV5KxatSqgH5KdnR3Q9SJRTBj65HgnkFM9DpGnVH60Q2DbVeV8Jke621VAm145AQZz3BHyJAlvVwFA7yCKj+n4OPGHX696kyZNEmsdPUagHY+1Ki0+u+w94OZZ0DttGPReX0CnBaPtPrNGJ6uI3PVqM4mcZVm/M8pyyeQE2yvnZJ07COS296QqKz6whoAuF8vfR8rkEF/QW/sQ8x4hd/j1ZK1SqDBzwNXAvlkAXEi+Oh4wGn26Lp/Joe0qIlPcEXKLzYlGq8Pvv+Vyic+t4nhHO/ifyWm1O/l5UFIPALITAwtyqpqssDpcUDBAaqy0f5dEGmRfk2O1WjF+/Hjs2rULO3bswIgRI0T5OULhCo+dLhYtdicMGvHjTL4mhzI5RKb0GiViDWrUW+woq29FTC/f/5abrA6+hYLUg5zkaG5Ip/+ZHO7UUbRWJfmsbe949xu00oYWWB1OaFW+dTjl6nHSYvV0iIL4RPY1OY888gjS0tKwa9cu0X6GkAwaJZQKxt27ptXhc5DjcDnw1cEvgUHAlfsVqPuyFtA1I/GqRCi6aW7mzeRQ4o7IV68YnTvIaWjBgF7RPl+Py+JEa1WI0kr7/wCfyQmg8JhrkpcRbwjozWgoJUZpYNQo0WxzoqS2Bf2So3y6HtXjEH/Juibnhx9+wE8//YTVq1fjhx9+CPdyfMIwDKJ1KtRb7DC32Pknte5YHVZc999ZwHVAw5Ma7Jt1FABwbtO53f4WaaQDiQRpsXocKG/0+xg5t/WTIvEsDuAtPK632NFqd/o1f6qkTj5N8hiGQe8EI/aXmXGittnnIIcL5KS+HUekQ9pva7pQUVGBOXPm4Ouvv4bB4NsfvNVqhdXqTQObzWaxltelGJ077W4OsFcOAxdM50QDSoVPnY64n0M1OUTOuBe2Y1VNfl1PLkXHgPtwgEalgM3hQlWj1a9eMCUy6x+TnWDA/jIziqt9r8vhMjlc12RCuhPUpqbdbkdJSQkOHjyI2tpaodbULZZlMXv2bNx9990YM2aMz9dbunQpTCYT/5GZmSniKjvHdz0OcH6VgrFh5I8DMXLtSCj13b/T82ZyZBvTEsJvUR0ob/Tret7j49IPchiG4bM5/vbKkdu4Ay5QOeFHrxwuW5Uhk/tIws/vIKepqQlvvPEGJk+eDJPJhOzsbAwaNAhJSUnIysrCnDlzsG3btoAWs3jxYjAM0+VHfn4+XnnlFZjNZjz22GN+3f5jjz2GhoYG/qOkpCSgdQYr1F2P6XQViQRckHOows8gR0aZHMDbENDfY+TcVo58Mjnu4uNiP3rlUCNA4i+/3tq/+OKL+Ne//oXs7GxcfvnlWLhwIdLT06HX61FbW4u9e/di/fr1uOiiizBhwgS88soryM3N9fn2582bh+uvv77Ly2RnZ+PJJ5/E5s2bodW27+o5ZswY3HTTTXj33Xc7vK5Wqz3jOuEQaK+cQNHpKhIJ+qe4g5wKsxX1FhtiDb41vCuTyfFxTqDHyEtkNtMpy8/RDlaHk8/KyeU+kvDzK8j5448/sGbNGgwdOrTD748bNw633XYbli9fjhUrVmDdunV+BTmJiYlITEzs9nIvv/wynnzySf7z0tJSTJ06FZ9++inGjx/v888LF75XToBdj52sDhuzdgAMgwnFE6A0dr1lRZkcEgmitCpkxOlxsq4FB8sbMb5Pgk/X4+dWySSTE8j8qgaLnc8My2UrJyvRnckpqbPA6WKhVHR9IuxUXQtY1n1CNcEo7Y7ORDr8CnI+//xzny6n0+lwzz33BLQgX/Tu3bvd51FR7sr8vn37IiMjQ7SfKxSuNiaYTI69xvcAiWpySKQYkBLtDnIqfA9y5FSTA3gzOZV+ZHK4LE5ilDYkvbeE0CtGB41SAZvThdL6lm6zM22Pj0v9iDyRDkH+N9TX1+N///sfTp06BYZhkJqaiqlTpyIuLk6Im4843q7Hvgc5GqUGK6e9Dtx9NzRO33+Ww+lCs819BcrkELkb0Csavx6oxEEfi4+brQ5Ue+Y5SX3UAYefX+VH4bH3ZJU87iMAKBUMMuP1OFrVjBO1lm6DnJI6edUcEWkIumXkO++8g3HjxmHz5s1wuVxwOp3YvHkzJkyYgHfeeUeINXYrOzsbLMtKvtsxJyaAwmO1Uo3ZQ/6M2TsBNev7z2r7M6KpGSCROa742Ncgp7DUDJZ1Zw3iZbLFEUjhsbdHjrwCgCw/io/lGMiR8Av6Ve+ZZ55BQUEBv2XE+ec//4nRo0fj9ttvD/ZHRBxv4bH4p6u4bJFBo4SK2qATmeOKjw9WNPo0+233yXoAwNAMk9hLE0xyAIXH3pNV8goAshJ8Lz6mk1UkEEG/6jEMg6amM5tzNTU10b5pJ/g+OS2+b1c5XA58d/RHfJcLOPx4WPmTVbRVRSJA36QoqBQMGlsdPnU+3nuqAQAwNF0+QQ63XdXY6oDF5tsbIbmOO+BOWPmSyZHrfSThFXQm57nnnsOkSZMwZMgQpKenAwBOnjyJwsJCPP/880EvMBJxR7n9yeRYHVZc+tW1wE1Aw5MAfLwqf7KKio5JBNCoFMhJNOJwZRMOVjR2W2ezmwtyZJTJidKqYNAoYbE5UWm2Ijux+/+7cjs+zuFOWPkyjbyEuh2TAAT9ynfppZdi+vTp2Lp1K0pLS8GyLNLT0zFu3Dgolb7PXelJgu147I9GOj5OIsyAXtHuIKe8EecPSO70co2tdhRVuzMEcsrkuLse61BU3YwKcyuyPYFAZ1wuFie5olyZZTn4Xjm1li63H+stNn48jdzuIwkvv4Ocjv4QlUolJk6cKNiiIl10KGtyqBEgiTADUqLxLcpwqJviY67oOM2kQ2JU+JuA+iM5Woui6mZUNnZffFzVZIXN4YKCAVJj5XFMnpMRZ4CCASw2J6qarEiO7nj9W4rcY4OyEgzQa+jNM/Gd30FOVFQURowYgdGjR/MfgwYNgkJBRa2+4k5XNVkdPjXBCoa3ESBtV5HI4OsMK64eZ4iMsjgcf4qPuW2cVJMeapkdLtCoFEiLdTd4PF5j6TTIWXOgEgC6zNwR0hG/X/meffZZFBQUYP369Xj99dfhdDqh0+kwbNgwPugZNWoUhg8fLsZ6I0J0m62jplYHTAbxsizeRoCUySGRgQtyjlQ1weF0dXpqcPdJd5AzTEb1OJyUaG5IZ/eZHK4eR66njrITjHyQMzY7/ozvsyyLNQc9Qc5ACnKIf/wOctp2MrZardDr9XjggQdQW1uL/Px8rFixAlarFU6nHx3rehiNSgGdWoFWuwvmVru4QU4rna4ikSUzzgC9WokWuxPFNRb0S47q8HJyzuRw3ZlP1vlSkCvP4+Oc3gkG4AhwvJMTVoWlZlSYrdCrlRifc2YQREhXgtrD4IZdXnfddRg2bBgAwOl0orCwMPiVRbhonRqtdqvoxcc00oFEGoWCQf+UKOw62YBDFY0dBjnmVjuOybDomJOXGgMA2OMJ1LpSIvOj1dme01KdnbDitqrO7pcInZrqcYh/BN/AVSqVfMBDOudv12ONUoNXL3wer34HaJ125D7fG7mv5oLRdF3PQ8M5SSTqri6n8JQZAJAeq0eCzIqOAW/2qaS2BbXNti4vK9fj45ze8e7TY8eqz+y3BgC/eoKcC/Noq4r4T15VahHE3xNWaqUac0fehbnbAC3rRPpdKUifmw6FuutfIZ2uIpGI63zc2QmrPafqAcgziwMAJr0aOZ6j491lc+S+XTUswwQFA+w9Zea3GDk1TVbs8nStpqJjEgi/g5w5c+bg9ddfR35+PqxWd1EcdTb2XyBdjwNBmRwSifgZVhWdBTnuTI6cmgCejiuY3l1S3+ll7E4Xyhrk2SOHkxarx6XD0gAAy9Yeafe9tQerwLLAoNQY2UyRJ9Lid5Bz8OBBPProoxg3bhyio91PNEuWLMGrr76KP/74AxZL94VypG3XY9+CHKfLibUnfsfabMABBep+N6NubR1YZ9fTOqkmh0QiLsgprmlGq/3MQw57uJlVMs3kAN617+4ik1Na3wIXC2hVCiRFy29bjjP3/H4AgB/2luNIpTdw/c1zquoCOlVFAuR3kPP777+joaEBBw8exHvvvYeHHnoIdXV1+Pvf/45zzjkHJpMJgwcPFmOtEYXLrDS0+LZd1epoxfmfzcD5swGLSoNdMw5i1/m74Gp1dXk9Ol1FIlFSlBZxBjVYFjhc0b6Wo6HFjmJPEaucg5zhmbEAvENGO8JtVWXE6WWdUR/QKxoXDUoBywLL1hwF4M5S/X6oCgBwAdXjkAAF/PY+NzcXubm5uP766/mvFRUVIT8/Hzt27BBkcZGMy6z4mslpj4VhoA5QKIAuntccThearFSTQyIPwzAY0Csam4/V4mBFY7ttqUJP5iMjTo84oyZcSwza4LQYKBigwmxFhbkVKTFnbtfIvei4rXnn98PP+yrwn12lmD+lP0obWtDY6kC8UYPhGbHhXh6RKb8yOSdOnOjy+zk5OZg5cyaeeuopAMCpU6cCX1mE4zIrgRwhVzJWjMsfinGF46A0dH6kkgtwAG8NECGRYoCn+Phgubnd1/fIcPJ4RwwaFXKT3feRa2x4On5oZQQEOcMzY3FubiKcLhav/34Uv3lOVU3unyRqV3gS2fwKcsaOHYs5c+Zg69atnV6moaEBb731FoYMGYIvv/wy6AVGKi6z0iBi4TF3ssqgUcqu3Tsh3RnQy91L5uBp21VynDzeGb74uJMtqxKZDubsDFeb80X+SXy7qxQAdTkmwfHr7f3+/fvx1FNPYdq0aVCr1RgzZgzS0tKg0+lQV1eHffv2obCwEGPGjMGzzz6L6dOni7Vu2TN5ghyzjzU5gaCTVSSSDejlbgK452Q9jlY1oW+S+/O9EZLJAYBhmbH4fPtJ7OomkyPX4+OnG58TjzFZccg/XofShlYoFQzO658U7mURGfPr7X18fDyee+45lJaWYvny5ejfvz+qq6tx+PBhAMBNN92E7du3Y+PGjRTgdINrBhjIdpWT1WLrmD3YOngrnJbOx2dwJ6toq4pEorzUGKTEaFFnsWP6S+vxf78cRlWjle+cGxFBjuc+7DlZD5Y98yQlF+RkREgmh2EYzL2gH//5mKw4/g0hIYEI6NVPp9NhypQpuPrqq4VeT48R3HYVA8sBz3TiLk6Q85kcepIgEcigUeGLu8/Coq/3Yt2hKrz4yyG8t6kYgLtGJdYg36JjzsDUaKiVDOosdpysa2lXYNxsdaDG0w05EgqPOZP7J2FIegz2njJjSl5KuJdDZC7gQo24uDisXr1ayLX0KHzhsY9BjlqpxjPnPYlnfgLUXZ8a5/HdjimTQyJUZrwBq24di5dvGInEKC3/oh8JWRwA0KqUGOipPdp1Wl3OSU89ToxOFVHZDoZhsPym0fjrjIGYdVZWuJdDZC7gIIdlWSxfvhzjx4/HhAkTMG/ePGzZskXItUU07kmp0eqAy9V1Qz/APbvq4XHz8fAfgMbXIIcyOaQHYBgGlw9Pw68LJuGGcb1h0Chx6bDUcC9LMFzx8Z7T6nL2l7lPlUVSFoeTGW/Anef1hVZFAzlJcII6crNr1y6MGzcOkydPxsGDBzFp0iQ88MADQq0tonF1MizrDnTEQI0ASU9iMqix9Oqh2Lt4KqYPjZwgh+sR0zaTY3U48eIvhwDQTCdCuhLUPsZHH32Eiy66iP98z549uPLKK5GRkYEHH3ww6MVFMp1aCa1KAavDBXOLvdt0s9PlREHZdiANGF7q28+gkQ6kJ1JEWE8V7ij83lNmuFwsFAoGKzcW43iNBcnRWtw9uW+YV0iIdAWcyUlISEBmZma7rw0dOhQvv/wyXn/99aAX1hPwx8h9OGHV6mjFuA8nYdydQKuPMQsdISdE/nKTo6BTK9BkdeBYdTMqza145Vf3idZHpw1ElJbexBDSmYCDnOHDh+Odd9454+v9+vVDSUlJUIvqKWJE7pXDFx5TTQ4hsqVSKjAkzdsU8OkfD6LZ5sSIzFhcNTI9zKsjRNoCfgvw5JNP4vzzz8epU6dwzz33YNiwYWhpacFTTz2FnJwcIdcYsbhTT2J1PaZMDiGRYWiGCfnH6/Dx1hPYVlwHAFh8+eCI25ojRGgBBzkTJkzA5s2bcf/992Py5Ml8oyqdTofPP/9csAVGMn+2qwJBNTmERAau+JgLcK4dnYERninlhJDOBfXqN3z4cKxduxaVlZXYvn07XC4Xxo8fj8TERKHWF9G821XiBDmNdLqKkIjQdg6XUaPEI9MGhHE1hMiHIG/xk5OTaYxDAPxtCOgvbyaHghxC5CwnwYhonQqNrQ7ce2EukqN14V4SIbJA+xhhxG0jcf1shOR0sXz/Hep4TIi8KRQM/nXVUBSeasBtZ1PNIyG+8uvVLycnBwzjf6Hb/Pnzcd999/l9vUhn8mO7Sq1U44mJjwFLl0LjciDrsTRAowaj7vj30dQmcIqm7SpCZO/y4Wm4fHhauJdBiKz4FeSsWrUqoB+SnZ0d0PUiHbdd5cvpKo1Sg8VnPw6sXQrAgZzH0wGjsdPLc8XMerUSGlVQja0JIYQQWfIryJk0aZJY6+iRYkQ8XdVAJ6sIIYT0cPQWP4xMfjQDdLEuFFbvQ2ES4ASD5n0taC5sBtvJcE/qkUMIIaSno5qcMPJnu6rF3oIhq8YBc4GGJ7UoGLcXAHBu07lQGs+c1MsFTtFUdEwIIaSHopqcMPKervJ/u0qdoAK6CDj5TA4dHyeEENJDUU1OGHHbVRabE3anC2qlb7uHSqYVZx8f2XXhcQttVxFCCOnZqCYnjNpOD24UuFcO13uHCo8JIYT0VBTkhJFKqeADHaGHdFImhxBCSE9HQU6Ycd2I/Rnt4GI12DHtAHZM3gFni7PDy/Bzq6gmhxBCSA9FexlhFqNXo7Sh1a/iYxYKNGxodH/i6vgydIScEEJIT0eZnDDjMi3dbVeplWo8NOZ+PLQRUHcS2LRlpmaAhBBCejh6BQwz7yTyrguPNUoNnp38L+DS/0PHG1Tt8YXHlMkhhBDSQ1EmJ8xMIo128GZyKMghhBDSM1GQE2bcdlJ321Uu1oXihuMoju20DKcdb00OJesIIYT0TBTkhJl3u6rrIKfF3oKctwYjZz7Q0k3c4nKxaLLS6SpCCCE9GwU5YebdrhKuGWCj1QHWM7eTZlcRQgjpqSjICTNfT1f5g8sK6dQKaFVnDu8khBBCegJZBznfffcdxo8fD71ej8TERFx99dXhXpLfAmkG2B3qkUMIIYTI+Aj56tWrMWfOHDz11FO44IILwLIs9uzZE+5l+S1GhNNV3HF0qschhBDSk8kyyHE4HLj//vvx7LPP4vbbb+e/PmDAgDCuKjB8TU43fXL8QSerCCGEEJluVxUUFODUqVNQKBQYOXIkUlNTMX36dBQWFoZ7aX7jMzktdrBctXCQuK2vaNquIoQQ0oPJMsg5duwYAGDx4sVYtGgRvv32W8TFxWHSpEmora3t9HpWqxVms7ndR7hx2Rab0wWro/MOOCqFCveMmIN7tgJqlxNpc5KRdk8aGBVzxmXNNJyTEEIIkVaQs3jxYjAM0+VHfn4+XC53MPD444/jmmuuwejRo7Fy5UowDIPPP/+809tfunQpTCYT/5GZmRmqu9apKK0KCk+c0lXxsValxWtTXsRr3wN6lx39X8xC/9f6Q6E981fIdzum7SpCCCE9mKReBefNm4frr7++y8tkZ2ejsdE9gXvQoEH817VaLfr06YMTJ050et3HHnsMCxYs4D83m81hD3QYhkGMXo16ix0NLXYkx+iCvk2+JocyOYQQQnowSQU5iYmJSExM7PZyo0ePhlarxcGDB3HOOecAAOx2O4qLi5GVldXp9bRaLbRarWDrFUqMzh3kdHXCimVZVFuqAAOQYAEcVXbAYoM6UQ2Gab9lxZ+uopocQgghPZikghxfxcTE4O6778YTTzyBzMxMZGVl4dlnnwUAzJw5M8yr858vJ6wsdguSl+UAjwANT+pQkLMTAHBu07lQGts3/PNmcmT56yWEEEIEIdtXwWeffRYqlQo333wzWlpaMH78ePz222+Ii4sL99L85uuQTl81UjNAQgghRL5BjlqtxnPPPYfnnnsu3EsJGj+k08eGgEqmFZObxgJGY4ffp2aAhBBCiMROV/VUvk4i91W9xQbAuw1GCCGE9EQU5EiAySDskM5aT5ATb9AIcnuEEEKIHFGQIwHeIZ2+jXZwsWoU/vkICmcWwtnqbPe9FpsTrXZ3H6E4I2VyCCGE9FwU5EiAv0M6WShR9XUdqr6oAtrHOKjzZHHUSgZRWtmWXBFCCCFBoyBHAkw+BDkqhQq3DL4Jt+wEVJ1Pf0BtszvIiTNozuifQwghhPQk9FZfArjC465qcrQqLVZNfwOY+eHpyZt2uExOvJHqcQghhPRslMmRAK5Pjq81OV2ps7gDpVgD1eMQQgjp2SiTIwG+bFexLAuLrRlQA9ouSnfqmimTQwghhACUyZGEtn1yXC62w8tY7BZEvZyCqMcBSxehaduaHEIIIaQnoyBHArjTVS4WaLYFt2VFNTmEEEKIGwU5EqBVKaBRun8V5tZggxyuJoeCHEIIIT0bBTkSwDAMn81psATX9dhbk0OFx4QQQno2CnIkgj9h5WNDwM5QTQ4hhBDiRkGORAg1pJNqcgghhBA3CnIkgjtGHuyQTsrkEEIIIW7UJ0civPOrOi48ViqUuLb/lcBXX0PFOpF0ZRygUgFK72VabE5YHdxwTgpyCCGE9GwU5EiEdxJ5x5kcnUqHzy//ALgxCoAdgz/oBxiN7S5T69mq0igVMGqUHdwKIYQQ0nPQdpVE+NL1uDvcyao4o5qGcxJCCOnxKMiRiBgBanKoHocQQgjxoiBHIrynqzquyWm2NYN5LgrMYsCs0mFt1DasZdbC2eydSc6drKIghxBCCKEgRzKE6JNDwzkJIYQQLyo8lgi+JseH7SoFWnFW0QjAaIDC4I1Taz3dkuOo2zEhhBBCQY5U+NMMkGEATZIaOC1jw2dyaLuKEEIIoe0qqeiuT44vuJocGs5JCCGEUJAjGdx2VZPVAYfT1eVlXawahx44jkNzD8Fl9V6WRjoQQgghXhTkSIRJr4bC09qGa+rXGRZKlL5VidJlpWAdLP/12mauJoeCHEIIIYSCHIlQKhjEG7UAgKpGawffV2JGzlTMOAQo2TO+DYBqcgghhJC2qPBYQhKjNKhusnYY5OhUOnx3zWrglig4O7guy7J8BijWQKerCCGEEMrkSEhStDuTU93U9XZVR1rsTtg8wzmpJocQQgihTI6kJEV1vl3VHW6kg0algIGGcxJCZI5lWTgcDjidHeWuSaRTKpVQqVRBz2GkIEdCvJmcM4OcZlszkl9KBv4KlD0D4LST5nWeouN4g4aGcxJCZM1ms6GsrAwWiyXcSyFhZDAYkJqaCo0m8N0JCnIkhAtyOsvkWBwWoJPfNdXjEEIigcvlQlFREZRKJdLS0qDR0Bu3noZlWdhsNlRVVaGoqAi5ublQKAKrrqEgR0ISozrP5HSnnnrkEEIigM1mg8vlQmZmJgwGQ7iXQ8JEr9dDrVbj+PHjsNls0Ol0Ad0OFR5LSHeZnK5wNTnUI4cQEgkCfedOIocQfwP0VyQhXCanKoBMDvXIIYQQQtqjIEdCuExOvcXOHwf3FVeTQ5kcQgghxI2CHAmJ1auh9Mx2qGn2L5tTZ/GMdKDCY0IIkZXi4mIwDIOdO3d2epm1a9eCYRjU19eHbF1CYxgGX3/9dUh/JhUeS4hCwSAxSoMKsxXVjTakmvTe7zEKTMo4B9iwAUrWBdM50YBSwYep/HYVZXIIIURWMjMzUVZWhsTExHAvJeJQkCMxSdFaVJitqGpqBWDiv65X67H2+h+BO6IA2DDyx4GA0ch/ny88ppocQgiRDZvNBo1Gg169eoV7KUGx2+1Qq6W3k0DbVRLDHyNv9G+0Qx0dISeERCqWBZqbw/PBdjIRuRONjY246aabYDQakZqaihdffBGTJ0/G/PnzAQDZ2dl48sknMXv2bJhMJsyZM6fD7arvv/8e/fv3h16vx/nnn4/i4mKf13D8+HFcdtlliIuLg9FoxODBg/H999/z39+3bx9mzJiBqKgopKSk4Oabb0Z1dTX//R9//BHnnHMOYmNjkZCQgEsvvRRHjx7lv8+t97PPPsPkyZOh0+nwwQcfAABWrFiBwYMHQ6vVIjU1FfPmzWu3turqalx11VUwGAzIzc3FN99848ej6z8KciQmKYATVizL8jU51AyQEBJxLBYgKio8H352XV6wYAE2btyIb775Bj///DPWr1+PgoKCdpd59tlnMWTIEGzfvh1/+9vfzriNkpISXH311ZgxYwZ27tyJO+64AwsXLvR5DXPnzoXVasXvv/+OPXv24Omnn0ZUVBQAoKysDJMmTcKIESOQn5+PH3/8ERUVFbjuuuv46zc3N2PBggXYtm0bfv31VygUClx11VVwudofiHn00Udx3333Yf/+/Zg6dSqWL1+OuXPn4s4778SePXvwzTffoF+/fu2us2TJElx33XXYvXs3ZsyYgZtuugm1tbU+3ze/sT1YQ0MDC4BtaGgI91J4//5hP5v16LfsE//Z2+7rTdYmNvHpBDbxYbANKh27IWE9uyFxA+tocrBNrXY269Fv2axHv2WbrfYwrZwQQoLX0tLC7tu3j21pafF+samJZd05ldB/NDX5vHaz2cyq1Wr2888/579WX1/PGgwG9v7772dZlmWzsrLYK6+8st31ioqKWADsjh07WJZl2ccee4zNy8tjXS4Xf5lHH32UBcDW1dV1u46hQ4eyixcv7vB7f/vb39iLL7643ddKSkpYAOzBgwc7vE5lZSULgN2zZ0+79b700kvtLpeWlsY+/vjjna4LALto0SL+86amJpZhGPaHH37o8PId/i14+Pr6TTU5EtNVJqe6pQbwlOHYa7zDq7h6HK1KAb2ahnMSQiKMwQA0NYXvZ/vo2LFjsNvtGDduHP81k8mEAQMGtLvcmDFjuryd/fv3Y8KECe3GWUycONHnddx33334y1/+gp9++glTpkzBNddcg2HDhgEAtm/fjjVr1vCZnbaOHj2K/v374+jRo/jb3/6GzZs3o7q6ms/gnDhxAkOGDOnwflRWVqK0tBQXXnhhl2vj1gEARqMR0dHRqKys9Pm++YuCHIlJ9KHrsQJWjN06BDDoodArUFfnrcehGS+EkIjDMO0OWkgV66nfOf15mPs6x9jNfTn98v664447MHXqVHz33Xf46aefsHTpUjz//PO499574XK5cNlll+Hpp58+43qpqakAgMsuuwyZmZl46623kJaWBpfLhSFDhsBma18r2vZ+6PV6+OL04mSGYc7YBhMS1eRITJIP86sYhoVxkB7GwUYwCobP5MTSySpCCAmbvn37Qq1WY+vWrfzXzGYzDh8+7NftDBo0CJs3b273tdM/705mZibuvvtufPnll3jwwQfx1ltvAQBGjRqFwsJCZGdno1+/fu0+jEYjampqsH//fixatAgXXngh8vLyUFdX1+3Pi46ORnZ2Nn799Ve/1ik2CnIkJpD5VfWeouN4IxUdE0JIuERHR+OWW27Bww8/jDVr1qCwsBC33XYbFAqFX1n2u+++G0ePHsWCBQtw8OBBfPTRR1i1apXP158/fz7+97//oaioCAUFBfjtt9+Ql5cHwF2UXFtbixtuuAFbt27FsWPH8NNPP+G2226D0+lEXFwcEhIS8Oabb+LIkSP47bffsGDBAp9+7uLFi/H888/j5ZdfxuHDh1FQUIBXXnnF53WLgYIcieEyOY2tDrTanR1exsWqUPSvUyhaXASXzUU9cgghRCJeeOEFTJw4EZdeeimmTJmCs88+G3l5eX5N0e7duzdWr16N//73vxg+fDhef/11PPXUUz5f3+l0Yu7cucjLy8O0adMwYMAALFu2DACQlpaGjRs3wul0YurUqRgyZAjuv/9+mEwmKBQKKBQKfPLJJ9i+fTuGDBmCBx54AM8++6xPP/eWW27BSy+9hGXLlmHw4MG49NJL/c5iCY1hg938kzGz2QyTyYSGhgbExMSEezkA3HuxAxb9CJvThQ2Pno+MOHfRW7OtGVFL3YViDU/qUOD4AQBwbtO5eGnjEbzy2xHMmpiFf1wxpNPbJoQQqWttbUVRURFycnL8Cgykqrm5Genp6Xj++edx++23h3s5stLV34Kvr9+UyZEYhnGPdgCA6iZvkZeCUWBMyiiMOQUoTgtLKZNDCCHSsGPHDnz88cc4evQoCgoKcNNNNwEArrjiijCvrGeiIEeCOqrL0av12Hbz79j2FqA/bRernoZzEkKIZDz33HMYPnw4pkyZgubmZqxfv17QuVTTp09HVFRUhx/+bGv1BLI9Qn7o0CE8/PDD2LhxI2w2G4YOHYonn3wS559/friXFjRutIOvxcd8JodGOhBCSFiNHDkS27dvF/VnvP3222hpaenwe/Hx8aL+bLmRbZBzySWXoH///vjtt9+g1+vx0ksv8fM15D7ojMvkdHWMvC2aW0UIIT1Henp6uJcgG7LcrqqursaRI0ewcOFCDBs2DLm5ufj3v/8Ni8WCwsLCcC8vaB1lcix2C7LfHITs+YDltNCUanIIIYSQM8kyk5OQkIC8vDy89957GDVqFLRaLd544w2kpKRg9OjRnV7ParXCavUGDmazORTL9VtHmRyWZXHcfAKIBdrWHbMs663JoUwOIYQQwpNlkMMwDH7++WdcccUViI6OhkKhQEpKCn788UfExsZ2er2lS5diyZIloVtogPxpCNhsc8LmdLfEjqdMDiGEEMKT1HbV4sWLwTBMlx/5+flgWRb33HMPkpOTsX79emzduhVXXHEFLr30UpSVlXV6+4899hgaGhr4j5KSkhDeO98l+jDagVPv2arSqRXQa2g4JyGEEMKRVCZn3rx5uP7667u8THZ2Nn777Td8++23qKur45sALVu2DD///DPeffddLFy4sMPrarVaaLVawdctNH8yOXzRMWVxCCEkrCZPnowRI0bgpZdeCvdSiIekgpzExESfeglYLBYAgELRPhGlUChEnWYaKlwzwGabExabAwZN57+mOk89Dg3nJIQQIqbFixfj66+/xs6dO8O9FJ9JarvKVxMnTkRcXBxuueUW7Nq1i++ZU1RUhEsuuSTcywtalFYFndr9q6lutHV5WTo+TgghpDNOpzMi3vwHSpZBTmJiIn788Uc0NTXhggsuwJgxY7Bhwwb85z//wfDhw8O9vKC5Rzt4tqyaWvmvDUoYiEGVAAMWhoE6GAYZUFLnzmqlmuQ/44UQQuTO5XLhkUceQXx8PHr16oXFixcDAG677TZceuml7S7rcDjQq1cvrFixAoB7u2vevHmYN28eYmNjkZCQgEWLFqHtiEmbzYZHHnkE6enpMBqNGD9+PNauXct/f9WqVYiNjcW3336LQYMGQavV4vjx46irq8OsWbMQFxcHg8GA6dOntxueyV3v66+/Rv/+/aHT6XDRRRfxtaurVq3CkiVLsGvXLr5G1p/J6OEiqe0qf4wZMwb/+9//wr0M0SRFa3GyrgVVnkyOQW1A4a35QFQUACvG5Q8FjEa8+1EBACA3JSqMqyWEEPE125o7/Z5SoYROpfPpsgpGAb1a3+1ljRqj32t89913sWDBAmzZsgWbNm3C7NmzcfbZZ+OOO+7Aeeedh7KyMqSmpgIAvv/+ezQ1NeG6665rd/3bb78dW7ZsQX5+Pu68805kZWVhzpw5AIBbb70VxcXF+OSTT5CWloavvvoK06ZNw549e5CbmwvAXdKxdOlSvP3220hISEBycjJuvPFGHD58GN988w1iYmLw6KOPYsaMGdi3bx/UajV/vX/961949913odFocM899+D666/Hxo0b8ac//Ql79+7Fjz/+iF9++QUAYDKZ/H58Qk22QU6kS+IzOV0XHx+tbAIA5CZHi74mQggJp6ilnb+Zm5E7A9/d+B3/efJzybDYLR1edlLWJKydvZb/PPv/slFtqT7jcuwT7Blf686wYcPwxBNPAAByc3Px6quv4tdff8W///1vDBgwAO+//z4eeeQRAMDKlSsxc+ZMREV571dmZiZefPFFMAyDAQMGYM+ePXjxxRcxZ84cHD16FB9//DFOnjyJtLQ0AMBDDz2EH3/8EStXruTnVtntdixbtozf2eCCm40bN+Kss84CAHz44YfIzMzE119/jZkzZ/LXe/XVVzF+/HgA7oArLy8PW7duxbhx4xAVFQWVSiWrqQKy3K7qCRK5hoBdnLByOF04VuV+B9IvmTI5hBASbsOGDWv3eWpqKiorKwEAd9xxB1auXAkAqKysxHfffYfbbrut3eUnTJgAhmH4zydOnIjDhw/D6XSioKAALMuif//+7YZyrlu3DkePHuWvo9Fo2q1j//79UKlUfPACuJvqDhgwAPv37+e/plKpMGbMGP7zgQMHIjY2tt1l5IYyORJ1eibHYrdg7MoxwD3A5je12D9mD+wsgEtc0BkUSI/Vd3FrhBAif02PNXX6PaWifZ+wyocqO72sgmn//r74/uKg1tUWt/XDYRiGL/ydNWsWFi5ciE2bNmHTpk3Izs7Gueee6/Ntu1wuKJVKbN++HUpl+/vbNhuk1+vbBUpta3raYlm23eW49Z6uo6/JBQU5EnV6JodlWeyrOQAkAywYWA64C5Ixw53FUSjk+0dICCG+8KdGRqzLBiMhIQFXXnklVq5ciU2bNuHWW2894zKbN28+4/Pc3FwolUqMHDkSTqcTlZWVfgVHgwYNgsPhwJYtW/jtqpqaGhw6dAh5eXn85RwOB/Lz8zFu3DgAwMGDB1FfX4+BAwcCcGeInE6n3/c7nGi7SqK6qslRwIbh3w9A0QuJsKuAfkm0VUUIIXJwxx134N1338X+/ftxyy23nPH9kpISLFiwAAcPHsTHH3+MV155Bffffz8AoH///rjpppswa9YsfPnllygqKsK2bdvw9NNP4/vvv+/0Z+bm5uKKK67AnDlzsGHDBuzatQt//vOfkZ6ejiuuuIK/nFqtxr333ostW7agoKAAt956KyZMmMAHPdnZ2SgqKsLOnTtRXV3dbhakVFGQI1FJ0e6+Nx11PWYYF+LOi8HuNAdYBZCbQkXHhBAiB1OmTEFqaiqmTp3KFw+3NWvWLLS0tGDcuHGYO3cu7r33Xtx5553891euXIlZs2bhwQcfxIABA3D55Zdjy5YtyMzM7PLnrly5EqNHj8all16KiRMngmVZfP/99+221wwGAx599FHceOONmDhxIvR6PT755BP++9dccw2mTZuG888/H0lJSfj4448FeETERdtVEpUU5T4KWd1k7XQ/9YjnZBUVHRNCSPi17VfD+frrr9t93tLSgvr6etx+++0d3oZarcZLL72E5cuXd/r9JUuWdDpsevbs2Zg9e/YZX4+Li8N7773X5foB4Oqrr8bVV1/d4fe0Wi2++OKLbm9DSiiTI1GJnkxOq92FJquj3fdcrBInX69A+vctUDqBXApyCCFE0lwuF0pLS/G3v/0NJpMJl19+ebiX1CNQJkeiDBoVjBolmm1OVDfZkBzj/R4LNY48dALXQ40NQxzoHW8I30IJIYR068SJE8jJyUFGRgZWrVoFlYpefkOBHmUJS4rWornGgqpGK1JMOmTF9AZOnEDbc1TZCQaolJSQI4QQKcvOzu609IDT0XZXqHS2zSV3FORIWGKUFsU1FlQ3WWFQx6P4zn1AVBTaHuDrQ1tVhBBCSIcoBSBhSZ5eOR2dsOL0TQxNfwdCCCFEbijIkTBuEnl1F/Or+lImhxBCCOkQBTkSlhnvHtWws6QeLfYWjH3/PIydA7S06eZNQQ4hhBDSMQpyJGzqYPek141HqlFutiC/ogD56YCrTeVxVgKdrCKEEEI6QkGOhGUlGDE6Kw4uFvh+T1mHl9GqlB1+nRBCCOnpKMiRuCtHpgMAvtlVGuaVEEIIEdOqVasQGxsb7mX4ZPHixRgxYoRf12EY5owO0GKjIEfiLh2aCrWSwf6yxnAvhRBCCAEAPPTQQ/j111/DvYxuUZAjcXFGDSYPSA73MgghhBBeVFQUEhISwr2MblGQIwNXebasCCGESNfkyZMxb948zJs3D7GxsUhISMCiRYv4Tsd1dXWYNWsW4uLiYDAYMH36dBw+fLjD2youLoZCoUB+fn67r7/yyivIysoCy7JYu3YtGIbBr7/+ijFjxsBgMOCss87CwYMH211n+fLl6Nu3LzQaDQYMGID333+/3fcZhsEbb7yBSy+9FAaDAXl5edi0aROOHDmCyZMnw2g0YuLEiTh69Ch/ndO3q7Zt24aLLroIiYmJMJlMmDRpEgoKCoJ5OAVBQY4MXDAwGdFaFZSuGCQ2u7/WqHdBlUgNqwkhPYez2en3h8vh4q/vcrjcX29x+nS7gXj33XehUqmwZcsWvPzyy3jxxRfx9ttvA3CPTsjPz8c333yDTZs2gWVZzJgxA3a7/Yzbyc7OxpQpU7By5cp2X1+5ciVmz54NhvEes3388cfx/PPPIz8/HyqVCrfddhv/va+++gr3338/HnzwQezduxd33XUXbr31VqxZs6bd7f7zn//ErFmzsHPnTgwcOBA33ngj7rrrLjz22GN8oDVv3rxO73djYyNuueUWrF+/Hps3b0Zubi5mzJiBxsYwl1qwPVhDQwMLgG1oaAj3Urr1yOe72IEPfMGyAMsC7IX/+DbcSyKEEMG1tLSw+/btY1taWs743hqs8fuj4rMK/voVn1Wwa7CGLZhU0O52NyRu6PC6/po0aRKbl5fHulwu/muPPvoom5eXxx46dIgFwG7cuJH/XnV1NavX69nPPvuMZVmWXblyJWsymfjvf/rpp2xcXBzb2trKsizL7ty5k2UYhi0qKnI/HmvWsADYX375hb/Od999xwLgH7+zzjqLnTNnTrt1zpw5k50xYwb/OQB20aJF/OebNm1iAbDvvPMO/7WPP/6Y1el0/OdPPPEEO3z48E4fC4fDwUZHR7P//e9/2/2cr776qtPrnK6rvwVfX78pkyMTV41qv2XVN4maABJCiNRMmDChXZZl4sSJOHz4MPbt2weVSoXx48fz30tISMCAAQOwf//+Dm/ryiuvhEqlwldffQUAWLFiBc4//3xkZ2e3u9ywYcP4f6empgIAKisrAQD79+/H2Wef3e7yZ5999hk/s+1tpKSkAACGDh3a7mutra0wm80drrWyshJ33303+vfvD5PJBJPJhKamJpw4caLDy4cK7XfIxLjseKSatPznfZNoZhUhpGc5t+lcv6/DaL0BR+JVie7bOO3t/YTiCcEuLWAsy7YLitrSaDS4+eabsXLlSlx99dX46KOP8NJLL51xObVazf+buy2Xy3XG17r6mR3dRne329bs2bNRVVWFl156CVlZWdBqtZg4cSJsNluHlw8VyuTIhNXZihPGxZg8G2hWajDySRt2TN5xxt4yIYREKqVR6feHQuV9mVOoFO6v65U+3W4gNm/efMbnubm5GDRoEBwOB7Zs2cJ/r6amBocOHUJeXl6nt3fHHXfgl19+wbJly2C323H11Vf7tZ68vDxs2LCh3df++OOPLn9mINavX4/77rsPM2bMwODBg6HValFdXS3ozwgEZXJkwsW6cLR5O45mA05GAfVOGxpgAzoOqgkhhIRBSUkJFixYgLvuugsFBQV45ZVX8PzzzyM3NxdXXHEF5syZgzfeeAPR0dFYuHAh0tPTccUVV3R6e3l5eZgwYQIeffRR3HbbbdDr9X6t5+GHH8Z1112HUaNG4cILL8R///tffPnll/jll1+Cvavt9OvXD++//z7GjBkDs9mMhx9+2O+1ioEyOTKkgA39V/XBoM8GtUvFEkIICa9Zs2ahpaUF48aNw9y5c3HvvffizjvvBOA+GTV69GhceumlmDhxIliWxffff99uW6gjt99+O2w2W7tTU7668sor8X//93949tlnMXjwYLzxxhtYuXIlJk+eHMjd69SKFStQV1eHkSNH4uabb8Z9992H5OTw93hjPBXPPZLZbIbJZEJDQwNiYmLCvZwuNduaEbXUXWzc9C/AWNcEGKkuhxASWVpbW1FUVIScnBzodLpwL8cvkydPxogRIzqsmwnGv/71L3zyySfYs2ePoLcrdV39Lfj6+k2ZHEIIIUSCmpqasG3bNrzyyiu47777wr0cWaIgR4ZYVoHKL2tR+Xllu0ZXhBBCIse8efNwzjnnYNKkSQFtVREqPJYlFzTYN8vdXvvcpnPpt0gIIRKwdu1aQW9v1apVWLVqlaC32dNQJkdGDCoDDOFtOUAIIYTIBuUAZMKoMaJ5fiUQFQXqjEMIIYR0jzI5hBBCJKcHH/wlHkL8DVCQQwghRDK4njEWiyXMKyHhxv0NdNdHqCu0XSUTrY5WXLP6GuBG4LNPAdqzIoREIqVSidjYWH7ApMFg6HS2E4lMLMvCYrGgsrISsbGxUCoDG7EBUJAjG06XE98X/Q/oDzjp/zshJIL16tULgHeSNumZYmNj+b+FQFGQQwghRFIYhkFqaiqSk5Nht9vDvRwSBmq1OqgMDoeCHEIIIZKkVCoFeaEjPRcVHhNCCCEkIlGQQwghhJCIREEOIYQQQiJSj67J4RoNmc3mMK+ke822ZqDV/W8zy6IZze5/m81QOmnPmhBCSM/BvW531zCQYXtwW8mTJ08iMzMz3MsghBBCSABKSkqQkZHR6fd7dJDjcrlQWlqK6OhoQZtNmc1mZGZmoqSkBDExMYLdbiSix8o/9Hj5jh4r39Fj5Tt6rHwn5mPFsiwaGxuRlpYGhaLzypsevV2lUCi6jACDFRMTQ/8JfESPlX/o8fIdPVa+o8fKd/RY+U6sx8pkMnV7GSo8JoQQQkhEoiCHEEIIIRGJghwRaLVaPPHEE9BqteFeiuTRY+Uferx8R4+V7+ix8h09Vr6TwmPVowuPCSGEEBK5KJNDCCGEkIhEQQ4hhBBCIhIFOYQQQgiJSBTkEEIIISQiUZAToGXLliEnJwc6nQ6jR4/G+vXru7z8unXrMHr0aOh0OvTp0wevv/56iFYafv48VmVlZbjxxhsxYMAAKBQKzJ8/P3QLlQB/Hqsvv/wSF110EZKSkhATE4OJEyfif//7XwhXG37+PF4bNmzA2WefjYSEBOj1egwcOBAvvvhiCFcbXv4+Z3E2btwIlUqFESNGiLtACfHnsVq7di0Yhjnj48CBAyFccfj4+3dltVrx+OOPIysrC1qtFn379sWKFSvEWyBL/PbJJ5+warWafeutt9h9+/ax999/P2s0Gtnjx493ePljx46xBoOBvf/++9l9+/axb731FqtWq9kvvvgixCsPPX8fq6KiIva+++5j3333XXbEiBHs/fffH9oFh5G/j9X999/PPv300+zWrVvZQ4cOsY899hirVqvZgoKCEK88PPx9vAoKCtiPPvqI3bt3L1tUVMS+//77rMFgYN94440Qrzz0/H2sOPX19WyfPn3Yiy++mB0+fHhoFhtm/j5Wa9asYQGwBw8eZMvKyvgPh8MR4pWHXiB/V5dffjk7fvx49ueff2aLiorYLVu2sBs3bhRtjRTkBGDcuHHs3Xff3e5rAwcOZBcuXNjh5R955BF24MCB7b521113sRMmTBBtjVLh72PV1qRJk3pUkBPMY8UZNGgQu2TJEqGXJklCPF5XXXUV++c//1nopUlOoI/Vn/70J3bRokXsE0880WOCHH8fKy7IqaurC8HqpMXfx+qHH35gTSYTW1NTE4rlsSzLsrRd5SebzYbt27fj4osvbvf1iy++GH/88UeH19m0adMZl586dSry8/Nht9tFW2u4BfJY9VRCPFYulwuNjY2Ij48XY4mSIsTjtWPHDvzxxx+YNGmSGEuUjEAfq5UrV+Lo0aN44oknxF6iZATzdzVy5EikpqbiwgsvxJo1a8RcpiQE8lh98803GDNmDJ555hmkp6ejf//+eOihh9DS0iLaOnv0gM5AVFdXw+l0IiUlpd3XU1JSUF5e3uF1ysvLO7y8w+FAdXU1UlNTRVtvOAXyWPVUQjxWzz//PJqbm3HdddeJsURJCebxysjIQFVVFRwOBxYvXow77rhDzKWGXSCP1eHDh7Fw4UKsX78eKlXPeZkI5LFKTU3Fm2++idGjR8NqteL999/HhRdeiLVr1+K8884LxbLDIpDH6tixY9iwYQN0Oh2++uorVFdX45577kFtba1odTk9569XYAzDtPucZdkzvtbd5Tv6eiTy97HqyQJ9rD7++GMsXrwY//nPf5CcnCzW8iQnkMdr/fr1aGpqwubNm7Fw4UL069cPN9xwg5jLlARfHyun04kbb7wRS5YsQf/+/UO1PEnx5+9qwIABGDBgAP/5xIkTUVJSgueeey6igxyOP4+Vy+UCwzD48MMP+QniL7zwAq699lq89tpr0Ov1gq+Pghw/JSYmQqlUnhGpVlZWnhHRcnr16tXh5VUqFRISEkRba7gF8lj1VME8Vp9++iluv/12fP7555gyZYqYy5SMYB6vnJwcAMDQoUNRUVGBxYsXR3SQ4+9j1djYiPz8fOzYsQPz5s0D4H5xYlkWKpUKP/30Ey644IKQrD3UhHrOmjBhAj744AOhlycpgTxWqampSE9P5wMcAMjLywPLsjh58iRyc3MFXyfV5PhJo9Fg9OjR+Pnnn9t9/eeff8ZZZ53V4XUmTpx4xuV/+uknjBkzBmq1WrS1hlsgj1VPFehj9fHHH2P27Nn46KOPcMkll4i9TMkQ6m+LZVlYrVahlycp/j5WMTEx2LNnD3bu3Ml/3H333RgwYAB27tyJ8ePHh2rpISfU39WOHTsitgyBE8hjdfbZZ6O0tBRNTU381w4dOgSFQoGMjAxxFhqyEucIwh2be+edd9h9+/ax8+fPZ41GI1tcXMyyLMsuXLiQvfnmm/nLc0fIH3jgAXbfvn3sO++80+OOkPv6WLEsy+7YsYPdsWMHO3r0aPbGG29kd+zYwRYWFoZj+SHl72P10UcfsSqVin3ttdfaHV2tr68P110IKX8fr1dffZX95ptv2EOHDrGHDh1iV6xYwcbExLCPP/54uO5CyATy/7CtnnS6yt/H6sUXX2S/+uor9tChQ+zevXvZhQsXsgDY1atXh+suhIy/j1VjYyObkZHBXnvttWxhYSG7bt06Njc3l73jjjtEWyMFOQF67bXX2KysLFaj0bCjRo1i161bx3/vlltuYSdNmtTu8mvXrmVHjhzJajQaNjs7m12+fHmIVxw+/j5WAM74yMrKCu2iw8Sfx2rSpEkdPla33HJL6BceJv48Xi+//DI7ePBg1mAwsDExMezIkSPZZcuWsU6nMwwrDz1//x+21ZOCHJb177F6+umn2b59+7I6nY6Ni4tjzznnHPa7774Lw6rDw9+/q/3797NTpkxh9Xo9m5GRwS5YsIC1WCyirY9hWU8FLCGEEEJIBKGaHEIIIYREJApyCCGEEBKRKMghhBBCSESiIIcQQgghEYmCHEIIIYREJApyCCGEEBKRKMghhBBCSESiIIcQQgghEYmCHEIIIYREJApyCCGEEBKRKMghhEScL774AkOHDoVer0dCQgKmTJmC5ubmcC+LEBJiqnAvgBBChFRWVoYbbrgBzzzzDK666io0NjZi/fr1oDF9hPQ8NKCTEBJRCgoKMHr0aBQXFyMrKyvcyyGEhBFtVxFCIsrw4cNx4YUXYujQoZg5cybeeust1NXVhXtZhJAwoEwOISTisCyLP/74Az/99BO++uorlJeXY8uWLcjJyQn30gghIURBDiEkojmdTmRlZWHBggVYsGBBuJdDCAkhKjwmhESULVu24Ndff8XFF1+M5ORkbNmyBVVVVcjLywv30gghIUZBDiEkosTExOD333/HSy+9BLPZjKysLDz//POYPn16uJdGCAkx2q4ihBBCSESi01WEEEIIiUgU5BBCCCEkIlGQQwghhJCIREEOIYQQQiISBTmEEEIIiUgU5BBCCCEkIlGQQwghhJCIREEOIYQQQiISBTmEEEIIiUgU5BBCCCEkIlGQQwghhJCIREEOIYQQQiLS/wMvQnIKuESGbAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -136,9 +188,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "# Generate the digaonal operators\n", "Z_str = \"Z\"*nqubits\n", @@ -150,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -168,9 +229,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", + "hyperopt_search step: 0.30457003862873383 loss -6.158069649792722\n", + "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -188,9 +259,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.30303525252525254\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -222,9 +311,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.04141414141414142\n", + "hyperopt_search step: 0.041686777442654525\n" + ] + } + ], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -243,9 +341,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.04141414141414142\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -275,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -285,9 +401,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-05 15:06:25]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 15.582565474255802\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -301,9 +432,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -312,9 +465,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------Scheduling grid search----------\n", + "New optimized step at iteration 1/8: 0.09091818181818181 with operator -IIIZ, loss 12.06390502880173\n", + "New optimized step at iteration 2/8: 0.08081727272727272 with operator -IIIZ, loss 9.635355222386766\n", + "New optimized step at iteration 3/8: 0.09091818181818181 with operator ZZII, loss 8.551120821934958\n", + "New optimized step at iteration 4/8: 0.06061545454545455 with operator -IIIZ, loss 7.454888988134408\n", + "New optimized step at iteration 5/8: 0.09091818181818181 with operator ZZII, loss 6.526038310796992\n", + "New optimized step at iteration 6/8: 0.07071636363636363 with operator -IIIZ, loss 5.906198775254362\n", + "New optimized step at iteration 7/8: 0.07071636363636363 with operator -IIIZ, loss 5.558604782647778\n", + "New optimized step at iteration 8/8: 0.09091818181818181 with operator IIZI, loss 5.248002043412237\n", + "----------Scheduling hyperopt----------\n", + "New optimized step at iteration 1/8: 0.0952680083828445 with operator -IIIZ, loss 12.048611508414254\n", + "New optimized step at iteration 2/8: 0.0759399266935567 with operator -IIIZ, loss 9.647010146511933\n", + "New optimized step at iteration 3/8: 0.0953305046594857 with operator ZZII, loss 8.545812587336131\n", + "New optimized step at iteration 4/8: 0.0638318397684811 with operator -IIIZ, loss 7.391689830573071\n", + "New optimized step at iteration 5/8: 0.0857170843370093 with operator ZZII, loss 6.534188669695426\n", + "New optimized step at iteration 6/8: 0.06796907471647104 with operator -IIIZ, loss 5.930126378868041\n", + "New optimized step at iteration 7/8: 0.06714742808838461 with operator -IIIZ, loss 5.582951426889378\n", + "New optimized step at iteration 8/8: 0.10283381512622272 with operator IIZI, loss 5.253925034956114\n", + "----------Scheduling polynomial----------\n" + ] + }, + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for *: 'complex' and 'NoneType'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:111\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 110\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n\u001b[0;32m--> 111\u001b[0m \u001b[43mdbi_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep_best\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 112\u001b[0m optimal_steps[i] \u001b[38;5;241m=\u001b[39m step_best\n\u001b[1;32m 113\u001b[0m norms_off_diagonal_restriction[i] \u001b[38;5;241m=\u001b[39m dbi_eval\u001b[38;5;241m.\u001b[39moff_diagonal_norm\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:87\u001b[0m, in \u001b[0;36mDoubleBracketIteration.__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 85\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 86\u001b[0m operator \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbackend\u001b[38;5;241m.\u001b[39mcalculate_matrix_exp(\n\u001b[0;32m---> 87\u001b[0m \u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43mj\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mstep\u001b[49m,\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommutator(d, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mh\u001b[38;5;241m.\u001b[39mmatrix),\n\u001b[1;32m 89\u001b[0m )\n\u001b[1;32m 90\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketGeneratorType\u001b[38;5;241m.\u001b[39mgroup_commutator:\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'complex' and 'NoneType'" + ] + } + ], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -374,9 +566,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", + "[Qibo 0.2.5|INFO|2024-03-05 15:10:49]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -403,25 +611,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], "source": [ - "step, coef = dbi.polynomial_step(n=1)\n", - "print(step, coef)" + "step = dbi.choose_step(n=1)\n", + "print(step)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.026973122528658938 None None\n" + ] + } + ], "source": [ - "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=1, n_max=5)\n", + "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=4, n_max=5)\n", "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", "step_backup_hyper = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.hyperopt, n=1)\n", "print(step_backup_poly, step_backup_grid, step_backup_hyper)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index ffd371110c..9433befa0d 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -1,15 +1,16 @@ -import math from copy import deepcopy from enum import Enum, auto -from functools import partial from typing import Optional import hyperopt import numpy as np from qibo.hamiltonians import Hamiltonian - -error = 1e-3 +from qibo.models.dbi.utils_scheduling import ( + grid_search_step, + hyperopt_step, + polynomial_step, +) class DoubleBracketGeneratorType(Enum): @@ -27,11 +28,11 @@ class DoubleBracketGeneratorType(Enum): class DoubleBracketScheduling(Enum): """Define the DBI scheduling strategies.""" - hyperopt = auto() + hyperopt = hyperopt_step """Use hyperopt package.""" - grid_search = auto() + grid_search = grid_search_step """Use greedy grid search.""" - polynomial_approximation = auto() + polynomial_approximation = polynomial_step """Use polynomial expansion (analytical) of the loss function.""" @@ -131,135 +132,6 @@ def backend(self): """Get Hamiltonian's backend.""" return self.h0.backend - def grid_search_step( - self, - step_min: float = 1e-5, - step_max: float = 1, - num_evals: int = 100, - space: Optional[np.array] = None, - d: Optional[np.array] = None, - ): - """ - Greedy optimization of the iteration step. - - Args: - step_min: lower bound of the search grid; - step_max: upper bound of the search grid; - mnum_evals: number of iterations between step_min and step_max; - d: diagonal operator for generating double-bracket iterations. - - Returns: - (float): optimized best iteration step (minimizing off-diagonal norm). - """ - if space is None: - space = np.linspace(step_min, step_max, num_evals) - - if d is None: - d = self.diagonal_h_matrix - - loss_list = [self.loss(step, d=d) for step in space] - idx_max_loss = np.argmin(loss_list) - return space[idx_max_loss] - - def hyperopt_step( - self, - step_min: float = 1e-5, - step_max: float = 1, - max_evals: int = 500, - space: callable = None, - optimizer: callable = None, - look_ahead: int = 1, - verbose: bool = False, - d: Optional[np.array] = None, - ): - """ - Optimize iteration step using hyperopt. - - Args: - step_min: lower bound of the search grid; - step_max: upper bound of the search grid; - max_evals: maximum number of iterations done by the hyperoptimizer; - space: see hyperopt.hp possibilities; - optimizer: see hyperopt algorithms; - look_ahead: number of iteration steps to compute the loss function; - verbose: level of verbosity; - d: diagonal operator for generating double-bracket iterations. - - Returns: - (float): optimized best iteration step (minimizing off-diagonal norm). - """ - if space is None: - space = hyperopt.hp.uniform - if optimizer is None: - optimizer = hyperopt.tpe - if d is None: - d = self.diagonal_h_matrix - - space = space("step", step_min, step_max) - best = hyperopt.fmin( - fn=partial(self.loss, d=d, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, - ) - return best["step"] - - def polynomial_step( - self, - n: int = 2, - n_max: int = 5, - d: np.array = None, - backup_scheduling: DoubleBracketScheduling = None, - ): - r""" - Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. - e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) - Args: - n (int, optional): the order to which the loss function is expanded. Defaults to 4. - n_max (int, optional): maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. - d (np.array, optional): diagonal operator, default as $\delta(H)$. - backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. - """ - - if d is None: - d = self.diagonal_h_matrix - - if n > n_max: - raise ValueError( - "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." - ) - - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = self.commutator(d, self.sigma(self.h.matrix)) - Gamma_list = self.generate_Gamma_list(n + 2, d) - sigma_Gamma_list = list(map(self.sigma, Gamma_list)) - exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) - # coefficients for rotation with [W,H] and H - c1 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[1:] - c2 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[:-1] - # product coefficient - trace_coefficients = [0] * (2 * n + 1) - for k in range(n + 1): - for j in range(n + 1): - power = k + j - product_matrix = c1[k] @ c2[j] - trace_coefficients[power] += 2 * np.trace(product_matrix) - # coefficients from high to low (n:0) - coef = list(reversed(trace_coefficients[: n + 1])) - roots = np.roots(coef) - real_positive_roots = [ - np.real(root) - for root in roots - if np.imag(root) < error and np.real(root) > 0 - ] - # solution exists, return minimum s - if len(real_positive_roots) > 0: - return min(real_positive_roots), coef - # solution does not exist, return None - else: - return None, coef - def choose_step( self, d: Optional[np.array] = None, @@ -271,28 +143,25 @@ def choose_step( ): if scheduling is None: scheduling = self.scheduling - if scheduling is DoubleBracketScheduling.grid_search: - return self.grid_search_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.hyperopt: - return self.hyperopt_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.polynomial_approximation: - step, coef = self.polynomial_step(d=d, **kwargs) - # if no solution - if step is None: - if ( - backup_scheduling - == DoubleBracketScheduling.polynomial_approximation - and coef is not None - ): - # if `n` is not provided, try default value - kwargs["n"] = kwargs.get("n", 2) - kwargs["n"] += 1 - step, coef = self.polynomial_step(d=d, **kwargs) - # if n==n_max, return None - else: - # Issue: cannot pass kwargs - step = self.choose_step(d=d, scheduling=backup_scheduling) - return step + return scheduling(self, d=d, **kwargs) + # if scheduling is DoubleBracketScheduling.polynomial_approximation: + # step, coef = self.polynomial_step(d=d, **kwargs) + # # if no solution + # if step is None: + # if ( + # backup_scheduling + # == DoubleBracketScheduling.polynomial_approximation + # and coef is not None + # ): + # # if `n` is not provided, try default value + # kwargs["n"] = kwargs.get("n", 2) + # kwargs["n"] += 1 + # step, coef = self.polynomial_step(d=d, **kwargs) + # # if n==n_max, return None + # else: + # # Issue: cannot pass kwargs + # step = self.choose_step(d=d, scheduling=backup_scheduling) + # return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 52f8a33294..b8f4a2ccca 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -1,9 +1,10 @@ +import math from copy import deepcopy from itertools import product from typing import Optional +import hyperopt import numpy as np -from hyperopt import hp, tpe from qibo import symbols from qibo.config import raise_error @@ -150,3 +151,26 @@ def cs_angle_sgn(dbi_object, d): ) ) return np.sign(norm) + + +def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) + sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients for rotation with [W,H] and H + c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:] + c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1] + # product coefficient + trace_coefficients = [0] * (2 * n + 1) + for k in range(n + 1): + for j in range(n + 1): + power = k + j + product_matrix = c1[k] @ c2[j] + trace_coefficients[power] += 2 * np.trace(product_matrix) + # coefficients from high to low (n:0) + coef = list(reversed(trace_coefficients[: n + 1])) + return coef diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py new file mode 100644 index 0000000000..d847f33ea5 --- /dev/null +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -0,0 +1,145 @@ +import math +from functools import partial +from typing import Optional + +import hyperopt +import numpy as np + +error = 1e-3 + + +def grid_search_step( + dbi_object, + step_min: float = 1e-5, + step_max: float = 1, + num_evals: int = 100, + space: Optional[np.array] = None, + d: Optional[np.array] = None, +): + """ + Greedy optimization of the iteration step. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + mnum_evals: number of iterations between step_min and step_max; + d: diagonal operator for generating double-bracket iterations. + + Returns: + (float): optimized best iteration step (minimizing off-diagonal norm). + """ + if space is None: + space = np.linspace(step_min, step_max, num_evals) + + if d is None: + d = dbi_object.diagonal_h_matrix + + loss_list = [dbi_object.loss(step, d=d) for step in space] + idx_max_loss = np.argmin(loss_list) + return space[idx_max_loss] + + +def hyperopt_step( + dbi_object, + step_min: float = 1e-5, + step_max: float = 1, + max_evals: int = 500, + space: callable = None, + optimizer: callable = None, + look_ahead: int = 1, + verbose: bool = False, + d: Optional[np.array] = None, +): + """ + Optimize iteration step using hyperopt. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + max_evals: maximum number of iterations done by the hyperoptimizer; + space: see hyperopt.hp possibilities; + optimizer: see hyperopt algorithms; + look_ahead: number of iteration steps to compute the loss function; + verbose: level of verbosity; + d: diagonal operator for generating double-bracket iterations. + + Returns: + (float): optimized best iteration step (minimizing off-diagonal norm). + """ + if space is None: + space = hyperopt.hp.uniform + if optimizer is None: + optimizer = hyperopt.tpe + if d is None: + d = dbi_object.diagonal_h_matrix + + space = space("step", step_min, step_max) + best = hyperopt.fmin( + fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + return best["step"] + + +def polynomial_step( + dbi_object, + n: int = 2, + n_max: int = 5, + d: np.array = None, + coef: Optional[list] = None, +): + r""" + Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. + e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) + Args: + n (int, optional): the order to which the loss function is expanded. Defaults to 4. + n_max (int, optional): maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. + d (np.array, optional): diagonal operator, default as $\delta(H)$. + backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. + """ + + if d is None: + d = dbi_object.diagonal_h_matrix + + if n > n_max: + raise ValueError( + "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." + ) + if coef is None: + coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n) + roots = np.roots(coef) + real_positive_roots = [ + np.real(root) for root in roots if np.imag(root) < error and np.real(root) > 0 + ] + # solution exists, return minimum s + if len(real_positive_roots) > 0: + return min(real_positive_roots) + # solution does not exist, return None + else: + return None + + +def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) + sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients for rotation with [W,H] and H + c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:] + c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1] + # product coefficient + trace_coefficients = [0] * (2 * n + 1) + for k in range(n + 1): + for j in range(n + 1): + power = k + j + product_matrix = c1[k] @ c2[j] + trace_coefficients[power] += 2 * np.trace(product_matrix) + # coefficients from high to low (n:0) + coef = list(reversed(trace_coefficients[: n + 1])) + return coef From 027dc0006ed12b2370f254f31ec1d67223622792 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 5 Mar 2024 16:00:38 +0800 Subject: [PATCH 046/116] Simplify backup option in `choose_step` --- examples/dbi/dbi_scheduling.ipynb | 308 +++----------------------- src/qibo/models/dbi/double_bracket.py | 32 +-- 2 files changed, 44 insertions(+), 296 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 34a49760b5..f871394c4f 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -43,25 +43,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", - "[Qibo 0.2.5|INFO|2024-03-05 15:06:24]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -87,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -110,19 +94,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.030312727272727272\n", - "hyperopt_search step: 0.028991467713834373\n", - "polynomial_approximation step: 0.032960905003724034\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -136,34 +110,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is:" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0.030312727272727272\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -188,18 +137,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "# Generate the digaonal operators\n", "Z_str = \"Z\"*nqubits\n", @@ -211,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -229,19 +169,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", - "hyperopt_search step: 0.30457003862873383 loss -6.158069649792722\n", - "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -259,27 +189,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.30303525252525254\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -311,18 +223,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.04141414141414142\n", - "hyperopt_search step: 0.041686777442654525\n" - ] - } - ], + "outputs": [], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -341,27 +244,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.04141414141414142\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -391,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -401,24 +286,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-05 15:06:25]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 15.582565474255802\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -432,31 +302,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -465,48 +313,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------Scheduling grid search----------\n", - "New optimized step at iteration 1/8: 0.09091818181818181 with operator -IIIZ, loss 12.06390502880173\n", - "New optimized step at iteration 2/8: 0.08081727272727272 with operator -IIIZ, loss 9.635355222386766\n", - "New optimized step at iteration 3/8: 0.09091818181818181 with operator ZZII, loss 8.551120821934958\n", - "New optimized step at iteration 4/8: 0.06061545454545455 with operator -IIIZ, loss 7.454888988134408\n", - "New optimized step at iteration 5/8: 0.09091818181818181 with operator ZZII, loss 6.526038310796992\n", - "New optimized step at iteration 6/8: 0.07071636363636363 with operator -IIIZ, loss 5.906198775254362\n", - "New optimized step at iteration 7/8: 0.07071636363636363 with operator -IIIZ, loss 5.558604782647778\n", - "New optimized step at iteration 8/8: 0.09091818181818181 with operator IIZI, loss 5.248002043412237\n", - "----------Scheduling hyperopt----------\n", - "New optimized step at iteration 1/8: 0.0952680083828445 with operator -IIIZ, loss 12.048611508414254\n", - "New optimized step at iteration 2/8: 0.0759399266935567 with operator -IIIZ, loss 9.647010146511933\n", - "New optimized step at iteration 3/8: 0.0953305046594857 with operator ZZII, loss 8.545812587336131\n", - "New optimized step at iteration 4/8: 0.0638318397684811 with operator -IIIZ, loss 7.391689830573071\n", - "New optimized step at iteration 5/8: 0.0857170843370093 with operator ZZII, loss 6.534188669695426\n", - "New optimized step at iteration 6/8: 0.06796907471647104 with operator -IIIZ, loss 5.930126378868041\n", - "New optimized step at iteration 7/8: 0.06714742808838461 with operator -IIIZ, loss 5.582951426889378\n", - "New optimized step at iteration 8/8: 0.10283381512622272 with operator IIZI, loss 5.253925034956114\n", - "----------Scheduling polynomial----------\n" - ] - }, - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for *: 'complex' and 'NoneType'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[15], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:111\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 110\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n\u001b[0;32m--> 111\u001b[0m \u001b[43mdbi_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep_best\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 112\u001b[0m optimal_steps[i] \u001b[38;5;241m=\u001b[39m step_best\n\u001b[1;32m 113\u001b[0m norms_off_diagonal_restriction[i] \u001b[38;5;241m=\u001b[39m dbi_eval\u001b[38;5;241m.\u001b[39moff_diagonal_norm\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:87\u001b[0m, in \u001b[0;36mDoubleBracketIteration.__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 85\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 86\u001b[0m operator \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbackend\u001b[38;5;241m.\u001b[39mcalculate_matrix_exp(\n\u001b[0;32m---> 87\u001b[0m \u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43mj\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mstep\u001b[49m,\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommutator(d, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mh\u001b[38;5;241m.\u001b[39mmatrix),\n\u001b[1;32m 89\u001b[0m )\n\u001b[1;32m 90\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketGeneratorType\u001b[38;5;241m.\u001b[39mgroup_commutator:\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'complex' and 'NoneType'" - ] - } - ], + "outputs": [], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -566,25 +375,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", - "[Qibo 0.2.5|INFO|2024-03-05 15:10:49]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -609,50 +402,17 @@ "For demonstration purposes, we let `n=1` which is a linear fit to the loss function. This results in no valid solutions and function `polynomial_step` returns `None`." ] }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None\n" - ] - } - ], - "source": [ - "step = dbi.choose_step(n=1)\n", - "print(step)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.026973122528658938 None None\n" - ] - } - ], - "source": [ - "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=4, n_max=5)\n", - "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", - "step_backup_hyper = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.hyperopt, n=1)\n", - "print(step_backup_poly, step_backup_grid, step_backup_hyper)" - ] - }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "for n in range (5):\n", + " step = polynomial_step(dbi, n=n)\n", + " print(n, step)\n", + "print(dbi.choose_step(n=1))" + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 9433befa0d..fe5ef050f8 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -136,32 +136,20 @@ def choose_step( self, d: Optional[np.array] = None, scheduling: Optional[DoubleBracketScheduling] = None, - backup_scheduling: Optional[ - DoubleBracketScheduling - ] = DoubleBracketScheduling.hyperopt, **kwargs, ): if scheduling is None: scheduling = self.scheduling - return scheduling(self, d=d, **kwargs) - # if scheduling is DoubleBracketScheduling.polynomial_approximation: - # step, coef = self.polynomial_step(d=d, **kwargs) - # # if no solution - # if step is None: - # if ( - # backup_scheduling - # == DoubleBracketScheduling.polynomial_approximation - # and coef is not None - # ): - # # if `n` is not provided, try default value - # kwargs["n"] = kwargs.get("n", 2) - # kwargs["n"] += 1 - # step, coef = self.polynomial_step(d=d, **kwargs) - # # if n==n_max, return None - # else: - # # Issue: cannot pass kwargs - # step = self.choose_step(d=d, scheduling=backup_scheduling) - # return step + step = scheduling(self, d=d, **kwargs) + if ( + step is None + and scheduling == DoubleBracketScheduling.polynomial_approximation + ): + kwargs["n"] = kwargs.get("n", 3) + kwargs["n"] += 1 + # if n==n_max, return None + step = scheduling(self, d=d, **kwargs) + return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ From 743f947ab79e7e5822fbc928456b6fe7231ca233 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 6 Mar 2024 09:08:29 +0800 Subject: [PATCH 047/116] Fix test for new structure --- examples/dbi/dbi_scheduling.ipynb | 4 ++-- tests/test_models_dbi.py | 23 +++++++---------------- 2 files changed, 9 insertions(+), 18 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index f871394c4f..3440716a85 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -276,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 111079f8a7..1dcbb960d0 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -72,25 +72,25 @@ def test_hyperopt_step(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) - + dbi.scheduling = DoubleBracketScheduling.hyperopt # find initial best step with look_ahead = 1 initial_step = 0.01 delta = 0.02 - step = dbi.hyperopt_step( + step = dbi.choose_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100 ) assert step != initial_step - # evolve following the optimized first step + # evolve following with optimized first step for generator in DoubleBracketGeneratorType: dbi(mode=generator, step=step, d=d) # find the following step size with look_ahead look_ahead = 3 - step = dbi.hyperopt_step( + step = dbi.choose_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100, @@ -134,13 +134,8 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( @pytest.mark.parametrize("nqubits", [3, 4, 6]) -@pytest.mark.parametrize("n", [2, 3]) -@pytest.mark.parametrize( - "backup_scheduling", [None, DoubleBracketScheduling.polynomial_approximation] -) -def test_double_bracket_iteration_scheduling_polynomial( - backend, nqubits, n, backup_scheduling -): +@pytest.mark.parametrize("n", [2, 4]) +def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( @@ -150,10 +145,6 @@ def test_double_bracket_iteration_scheduling_polynomial( ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - step1 = dbi.choose_step(n=n, backup_scheduling=backup_scheduling) + step1 = dbi.choose_step(d=d, n=n) dbi(d=d, step=step1) - # step2 = dbi.choose_step( - # scheduling=DoubleBracketScheduling.polynomial_approximation, n=n - # ) - # dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 00f6d8c89b03fccb3494779dbb25b0f1aa360a82 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 6 Mar 2024 09:34:04 +0800 Subject: [PATCH 048/116] Test coverage for fail cases in polynomial step --- tests/test_models_dbi.py | 6 ++--- tests/test_models_dbi_utils.py | 1 + tests/test_models_dbi_utils_scheduling.py | 30 +++++++++++++++++++++++ 3 files changed, 34 insertions(+), 3 deletions(-) create mode 100644 tests/test_models_dbi_utils_scheduling.py diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 1dcbb960d0..5fa277f7ac 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -137,7 +137,6 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( @pytest.mark.parametrize("n", [2, 4]) def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) - d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, @@ -145,6 +144,7 @@ def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - step1 = dbi.choose_step(d=d, n=n) - dbi(d=d, step=step1) + # by default, d is the diagonal resctriction of H + step1 = dbi.choose_step(n=n) + dbi(step=step1) assert initial_off_diagonal_norm > dbi.off_diagonal_norm diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index cd9f74e9de..a19ee502c5 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -37,6 +37,7 @@ def test_select_best_dbr_generator(backend, nqubits, step): dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, + scheduling=DoubleBracketScheduling.grid_search, ) generate_Z = generate_Z_operators(nqubits) Z_ops = list(generate_Z.values()) diff --git a/tests/test_models_dbi_utils_scheduling.py b/tests/test_models_dbi_utils_scheduling.py new file mode 100644 index 0000000000..392727f144 --- /dev/null +++ b/tests/test_models_dbi_utils_scheduling.py @@ -0,0 +1,30 @@ +"""Unit testing for utils_scheduling.py for Double Bracket Iteration""" + +import numpy as np +import pytest + +from qibo.hamiltonians import Hamiltonian +from qibo.models.dbi.double_bracket import ( + DoubleBracketGeneratorType, + DoubleBracketIteration, + DoubleBracketScheduling, +) +from qibo.models.dbi.utils_scheduling import polynomial_step +from qibo.quantum_info import random_hermitian + +NSTEPS = 1 +seed = 10 +"""Number of steps for evolution.""" + + +@pytest.mark.parametrize("nqubits", [5, 6]) +def test_polynomial_fail_cases(backend, nqubits): + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + scheduling=DoubleBracketScheduling.polynomial_approximation, + ) + with pytest.raises(ValueError): + polynomial_step(dbi, n=2, n_max=1) + assert polynomial_step(dbi, n=1) == None From 08f8977e924151f9d5957da2c683f6f9a0dbf426 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Tue, 12 Mar 2024 17:25:43 +0100 Subject: [PATCH 049/116] added new cost functions --- src/qibo/models/dbi/double_bracket.py | 30 +++++++++++++- src/qibo/models/dbi/utils.py | 1 + src/qibo/models/dbi/utils_scheduling.py | 52 +++++++++++++++++++++++-- 3 files changed, 78 insertions(+), 5 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index fe5ef050f8..e5db4629ee 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -35,6 +35,15 @@ class DoubleBracketScheduling(Enum): polynomial_approximation = polynomial_step """Use polynomial expansion (analytical) of the loss function.""" +class DoubleBracketCostFunction(Enum): + """Define the DBI cost function.""" + + off_diagonal_norm = auto() + """Use off-diagonal norm as cost function.""" + least_squares = auto() + """Use least squares as cost function.""" + energy_fluctuation = auto() + """Use energy fluctuation as cost function.""" class DoubleBracketIteration: """ @@ -65,11 +74,15 @@ def __init__( hamiltonian: Hamiltonian, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, scheduling: DoubleBracketScheduling = DoubleBracketScheduling.grid_search, + cost: DoubleBracketCostFunction = DoubleBracketCostFunction.off_diagonal_norm, + state: int = 0, ): self.h = hamiltonian self.h0 = deepcopy(self.h) self.mode = mode self.scheduling = scheduling + self.cost = cost + self.state = state def __call__( self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None @@ -126,6 +139,14 @@ def off_diagonal_norm(self): return np.sqrt( np.real(np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h))) ) + @property + def least_squares(self,d: np.array): + """Least squares cost function.""" + H = self.backend.cast( + np.matrix(self.backend.to_numpy(self.h)).getH() + ) + D = d + return -(np.linalg.trace(H@D)-0.5(np.linalg.norm(H)**2+np.linalg.norm(D)**2)) @property def backend(self): @@ -166,8 +187,13 @@ def loss(self, step: float, d: np.array = None, look_ahead: int = 1): for _ in range(look_ahead): self.__call__(mode=self.mode, step=step, d=d) - # off_diagonal_norm's value after the steps - loss = self.off_diagonal_norm + # loss values depending on the cost function + if self.cost == DoubleBracketCostFunction.off_diagonal_norm: + loss = self.off_diagonal_norm + elif self.cost == DoubleBracketCostFunction.least_squares: + loss = self.least_squares(d=d) + else: + loss = self.energy_fluctuation(self.state) # set back the initial configuration self.h = h_copy diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index b8f4a2ccca..b1dd5daf61 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -174,3 +174,4 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) return coef + diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index d847f33ea5..5ceb3eba64 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -7,6 +7,15 @@ error = 1e-3 +def variance(A, state): + """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\langle\mu|A^2|\mu\rangle-\langle\mu|A|\mu\rangle^2$""" + B = A@A + return B[state,state]-A[state,state]**2 + +def covariance(A, B, state): + """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\langle\mu|AB|\mu\rangle-\langle\mu|A|\mu\rangle\langle\mu|B|\mu\rangle$""" + C = A@B + return C[state,state]-A[state,state]*B[state,state] def grid_search_step( dbi_object, @@ -64,7 +73,7 @@ def hyperopt_step( d: diagonal operator for generating double-bracket iterations. Returns: - (float): optimized best iteration step (minimizing off-diagonal norm). + (float): optimized best iteration step (minimizing loss function). """ if space is None: space = hyperopt.hp.uniform @@ -90,6 +99,7 @@ def polynomial_step( n_max: int = 5, d: np.array = None, coef: Optional[list] = None, + cost: str = None, ): r""" Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. @@ -100,7 +110,8 @@ def polynomial_step( d (np.array, optional): diagonal operator, default as $\delta(H)$. backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. """ - + if cost is None: + cost = dbi_object.cost if d is None: d = dbi_object.diagonal_h_matrix @@ -109,7 +120,15 @@ def polynomial_step( "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." ) if coef is None: - coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n) + if cost == "off_diagonal_norm": + coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n) + elif cost == "least_squares": + coef = least_squares_polynomial_expansion_coef(dbi_object, d, n) + elif cost == "energy_fluctuation": + coef = energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, dbi_object.state) + else: + raise ValueError(f"Cost function {cost} not recognized.") + roots = np.roots(coef) real_positive_roots = [ np.real(root) for root in roots if np.imag(root) < error and np.real(root) > 0 @@ -143,3 +162,30 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) return coef + +def least_squares_polynomial_expansion_coef(dbi_object, d, n): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + Gamma_list = dbi_object.generate_Gamma_list(n, d) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients + coef = np.empty(n) + for i in range(n): + coef[i] = exp_list[i]*np.trace(d@Gamma_list[i+1]) + + return coef + +#TODO: add a general expansion formula not stopping at 3rd order +def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + Gamma_list = dbi_object.generate_Gamma_list(n, d) + # coefficients + coef = np.empty(3) + coef[0] = 2*covariance(Gamma_list[0], Gamma_list[1],state) + coef[1] = 2*variance(Gamma_list[1],state) + coef[2] = covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state) + return coef From f2061f80a549d9f4289674ca8720fce96ef567ff Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Tue, 12 Mar 2024 17:40:23 +0100 Subject: [PATCH 050/116] bug fix: use string of cost function --- examples/dbi/dbi_scheduling.ipynb | 51 +++++++++++++++++++++---- src/qibo/models/dbi/double_bracket.py | 1 + src/qibo/models/dbi/utils_scheduling.py | 2 +- 3 files changed, 45 insertions(+), 9 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 3440716a85..1953c1272d 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -43,9 +43,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-12 17:24:06]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -71,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -94,9 +109,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "loss() got an unexpected keyword argument 'state'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m# grid_search\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m step_grid \u001b[39m=\u001b[39m dbi\u001b[39m.\u001b[39;49mchoose_step(scheduling\u001b[39m=\u001b[39;49mDoubleBracketScheduling\u001b[39m.\u001b[39;49mgrid_search)\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mgrid_search step:\u001b[39m\u001b[39m'\u001b[39m, step_grid)\n\u001b[0;32m 4\u001b[0m \u001b[39m# hyperopt\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\double_bracket.py:164\u001b[0m, in \u001b[0;36mDoubleBracketIteration.choose_step\u001b[1;34m(self, d, scheduling, **kwargs)\u001b[0m\n\u001b[0;32m 162\u001b[0m \u001b[39mif\u001b[39;00m scheduling \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 163\u001b[0m scheduling \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mscheduling\n\u001b[1;32m--> 164\u001b[0m step \u001b[39m=\u001b[39m scheduling(\u001b[39mself\u001b[39m, d\u001b[39m=\u001b[39md, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 165\u001b[0m \u001b[39mif\u001b[39;00m (\n\u001b[0;32m 166\u001b[0m step \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m 167\u001b[0m \u001b[39mand\u001b[39;00m scheduling \u001b[39m==\u001b[39m DoubleBracketScheduling\u001b[39m.\u001b[39mpolynomial_approximation\n\u001b[0;32m 168\u001b[0m ):\n\u001b[0;32m 169\u001b[0m kwargs[\u001b[39m\"\u001b[39m\u001b[39mn\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m kwargs\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mn\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m3\u001b[39m)\n", + "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\utils_scheduling.py:47\u001b[0m, in \u001b[0;36mgrid_search_step\u001b[1;34m(dbi_object, step_min, step_max, num_evals, space, d, state)\u001b[0m\n\u001b[0;32m 44\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 45\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m---> 47\u001b[0m loss_list \u001b[39m=\u001b[39m [dbi_object\u001b[39m.\u001b[39mloss(step, d\u001b[39m=\u001b[39md, state\u001b[39m=\u001b[39mstate) \u001b[39mfor\u001b[39;00m step \u001b[39min\u001b[39;00m space]\n\u001b[0;32m 48\u001b[0m idx_max_loss \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmin(loss_list)\n\u001b[0;32m 49\u001b[0m \u001b[39mreturn\u001b[39;00m space[idx_max_loss]\n", + "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\utils_scheduling.py:47\u001b[0m, in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 44\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 45\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m---> 47\u001b[0m loss_list \u001b[39m=\u001b[39m [dbi_object\u001b[39m.\u001b[39;49mloss(step, d\u001b[39m=\u001b[39;49md, state\u001b[39m=\u001b[39;49mstate) \u001b[39mfor\u001b[39;00m step \u001b[39min\u001b[39;00m space]\n\u001b[0;32m 48\u001b[0m idx_max_loss \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmin(loss_list)\n\u001b[0;32m 49\u001b[0m \u001b[39mreturn\u001b[39;00m space[idx_max_loss]\n", + "\u001b[1;31mTypeError\u001b[0m: loss() got an unexpected keyword argument 'state'" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -417,7 +447,7 @@ ], "metadata": { "kernelspec": { - "display_name": "DBF_qibo", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -431,7 +461,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.9.18" + }, + "vscode": { + "interpreter": { + "hash": "48caf7dabad7b721a854729228548373f17e53f40870080394d552284aea7c35" + } } }, "nbformat": 4, diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index e5db4629ee..0446ffbb9a 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -82,6 +82,7 @@ def __init__( self.mode = mode self.scheduling = scheduling self.cost = cost + self.cost_str = cost.name self.state = state def __call__( diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 5ceb3eba64..2017b57cd1 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -111,7 +111,7 @@ def polynomial_step( backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. """ if cost is None: - cost = dbi_object.cost + cost = dbi_object.cost.name if d is None: d = dbi_object.diagonal_h_matrix From 93eb20a5743aa57f17f31b3b72dbd6a02de64262 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Fri, 15 Mar 2024 20:18:35 +0100 Subject: [PATCH 051/116] added full diagonal gradients and a tutorial file --- examples/dbi/dbi_costs.ipynb | 548 ++++++++++++++++++++++++ src/qibo/models/dbi/double_bracket.py | 23 +- src/qibo/models/dbi/utils_scheduling.py | 103 ++++- 3 files changed, 645 insertions(+), 29 deletions(-) create mode 100644 examples/dbi/dbi_costs.ipynb diff --git a/examples/dbi/dbi_costs.ipynb b/examples/dbi/dbi_costs.ipynb new file mode 100644 index 0000000000..558f74cff3 --- /dev/null +++ b/examples/dbi/dbi_costs.ipynb @@ -0,0 +1,548 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-bracket Iteration other cost functions and respective scheduling\n", + "\n", + "This notebook presents two additional cost functions for the double-bracket flow: least-squares and energy fluctuation with their respectice scheduling methods." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Least-squares\n", + "\n", + "The cost function is defined as: $\\frac{1}{2}||D-H_k||^2 =\\frac{1}{2}(||D||^2+||H||^2) -Tr(D H_k)$ as in https://epubs.siam.org/doi/abs/10.1137/S0036141092229732?journalCode=sjmael. We seek to maximize this function at each iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-15 18:17:05]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.02021181818181818\n", + "hyperopt_search step: 0.2796044748864459\n", + "polynomial_approximation step: 0.016462159944159827\n" + ] + } + ], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "s_space = np.linspace(1e-5, 0.6, 1000)\n", + "off_diagonal_norm_diff = []\n", + "potential = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " potential.append(dbi_eval.least_squares(D=d))\n", + "\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.02021181818181818\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHFCAYAAAAe+pb9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC7eElEQVR4nOydd3wb9f3/X6dtybY8ZDt24sTZZJAQMkigkEChhNHSskoXpJS0FAJlddDyhaTfFvotUPql/ICWQkK/nazSFiilBcIeGSSE7OEkTry3ra27+/1x+pxkW+PudLJO8vv5ePgRR5bkj+TT3evzei9OFEURBEEQBEEQYxBTrhdAEARBEASRK0gIEQRBEAQxZiEhRBAEQRDEmIWEEEEQBEEQYxYSQgRBEARBjFlICBEEQRAEMWYhIUQQBEEQxJiFhBBBEARBEGMWEkIEQRAEQYxZSAgRBJGWDRs2gOO4hF+33XYbDh8+DI7jsGHDBt1+58MPP6zq+RoaGuQ1mUwmuN1uzJo1C1deeSVeeeWVhI8Z/lpcLhdmzZqFdevWwev1DrnvqlWrUFxcnMlLklH72giCyB6WXC+AIIj8Yf369TjhhBOG3FZXV4eamhq89957mDp1qm6/6+GHH4bH48GqVasUP+a0007DfffdBwAYHBzE3r178ec//xnnnnsuLrnkEvzpT3+C1Wod8phLL70Ut956q/yYN954Az/+8Y/x8ccf49lnn9Xt9cSj5bURBJEdSAgRBKGYuXPnYtGiRQl/tnTp0rSP9/l8cDqdei9LpqysbMg6zj77bFx//fVYu3Yt1q1bhzvuuAP/8z//M+QxNTU1Ix5z5MgR/OEPf0AgEIDD4cjaegmCyD0UGiMIImMShcbWrl0LjuOwdetWXHrppSgvL5cdo0OHDuGKK65AXV0d7HY7ampq8OlPfxrbtm0DIIW5du7ciTfeeEMOWzU0NGhe39q1azFnzhw89NBDCAQCae/vdrvBcRzMZrPq35Xpa+vv78dtt92GyZMnw2azYfz48bjppptGhOo4jsOaNWvw61//GjNmzIDdbsfs2bPx5z//WfWaCWIsQ44QQRCK4XkekUhkyG0WS+rTyMUXX4wrrrgC1157rXwxP//888HzPH7+859j4sSJ6OzsxLvvvove3l4AwF//+ldceumlcLvdePjhhwEAdrs9o7V/9rOfxc9+9jNs3rwZn/rUp+TbRVGUXxMLjT355JO44oorRoTRlJDJa/P5fFi+fDmOHTuGH/7wh5g3bx527tyJO++8Ezt27MB//vMfcBwn/66///3veP311/HjH/8YLpcLDz/8ML70pS/BYrHg0ksv1fpWEcTYQiQIgkjD+vXrRQAJv8LhsNjY2CgCENevXy8/5q677hIBiHfeeeeQ5+rs7BQBiL/85S9T/s45c+aIy5cvV7zGSZMmiRdccEHSnz/yyCMiAPEvf/mLfFuy13TeeeeJg4ODQx5/1VVXiS6XK+UaMn1t99xzj2gymcRNmzYNuf2ZZ54RAYgvvfTSkLUXFRWJra2t8m2RSEQ84YQTxGnTpqX8/QRBxCBHiCAIxfzud7/DrFmzhtyWzhG65JJLhvy/oqICU6dOxb333gue53HmmWdi/vz5MJmyG6kXRTHh7Zdffjm++93vAgD8fj+2bduG//7v/8bKlSvxn//8R5UTlelre+GFFzB37lycdNJJQ5y3c889FxzHYePGjTjvvPPk2z/96U+jpqZG/r/ZbMYXv/hFrFu3DseOHcOECRMUr50gxiqUI0QQhGJmzZqFRYsWDflKR21t7ZD/cxyHV199Feeeey5+/vOf4+STT0ZVVRVuvPFGDAwMZGvpOHLkCACpyi2eqqoq+bWcfvrpuOGGG/Dggw/i7bffVl3inulra2trw8cffwyr1Trkq6SkBKIoorOzc8j9x40bN+I52G1dXV2q1k4QYxVyhAiCyCrxOS2MSZMm4fHHHwcA7Nu3D0899RTWrl2LUCiERx99VPc1iKKIf/zjH3C5XIrE27x58wAA27dvV/27MnltHo8HRUVFeOKJJ5L+PJ7W1tYR92G3VVZWql47QYxFSAgRBJFTZsyYgTvuuAPPPvsstm7dKt9ut9vh9/t1+R3r1q3Drl278MMf/lBROTyr8Kqurs7o96p9bRdeeCHuvvtuVFZWYvLkyWmf/9VXX0VbW5scHuN5Hn/5y18wdepUCosRhEJICBEEMap8/PHHWLNmDS677DJMnz4dNpsNr732Gj7++GP84Ac/kO934okn4s9//jP+8pe/YMqUKXA4HDjxxBNTPndvby/ef/99AIDX65UbKr711lu4/PLLsW7duhGPaWtrkx8TCASwbds2/OQnP0FZWRm+/vWvj+pru+mmm/Dss8/ijDPOwM0334x58+ZBEAQcPXoUr7zyCm699Vaccsop8vN4PB6cddZZ+K//+i+5amzPnj1UQk8QKiAhRBDEqDJu3DhMnToVDz/8MJqamsBxHKZMmYL7778fN9xwg3y/devWoaWlBatXr8bAwAAmTZqEw4cPp3zud955B8uWLZPHZYwfPx5LlizBHXfcgc985jMJH/PMM8/gmWeeAQBYrVbU19fjc5/7HH70ox9h0qRJo/raXC4X3nrrLfzsZz/Db37zGzQ2NqKoqAgTJ07E2WefPaKX0uc+9znMmTMHd9xxB44ePYqpU6fiD3/4A774xS+qWjdBjGU4MVkpBUEQBGFYOI7D9ddfj4ceeijXSyGIvIaqxgiCIAiCGLOQECIIgiAIYsxCOUIEQRB5CGU1EIQ+kCNEEARBEMSYhYQQQRAEQRBjFhJCBEEQBEGMWShHKA2CIKC5uRklJSUJRwUQBEEQBGE8RFHEwMAA6urqUg4+JiGUhubmZtTX1+d6GQRBEARBaKCpqSnlyBkSQmkoKSkBIL2RpaWlOV4NAK8XYNOzm5sBlyu36yGIHOENeVF3v/RZaL61GS4bfRYIgojR39+P+vp6+TqeDBJCaWDhsNLSUmMIIbM59n1pKQkhYsxiDpmB6PzU0tJSEkIEQSQkXVoLCaE8gQ/w2PO1PUAkghNghRnhXC+JIAiCIPIeEkL5Ag90PNMBADgBZoCEEEEQBEFkDAkhgiDyEovJgqvmXyV/TxAEoQU6exAEkZfYLXZs+PyGXC+DIIg8hxoqEgRBEAQxZiFHiCCIvEQURfjCPgCA0+qkhqcEQWiCHCGCIPISX9iH4nuKUXxPsSyICIIg1EJCiCAIgiCIMQsJIYIgCIIgxiwkhAiCIAiCGLOMCSH08MMPY/LkyXA4HFi4cCHeeuutXC+JIAiCIAgDUPBC6C9/+Qtuuukm/OhHP8JHH32E008/Heeddx6OHj2a66URBEEQBJFjCl4I/eIXv8A3vvENXHPNNZg1axZ++ctfor6+Ho888khO13WoYxAHOwZzugaCIAjCuPhCEQiCmOtlFDwF3UcoFAphy5Yt+MEPfjDk9s985jN49913Ez4mGAwiGAzK/+/v79d9XYIg4nvPfIyPj/Xh3svm4aKTxqd/kBmourQKiESA53nd10QQ+YbZZMalsy+VvyeIQuK3bx3C3S/txvz6Mvz+G6fAZS/oy3VOKWhHqLOzEzzPo6amZsjtNTU1aG1tTfiYe+65B263W/6qr6/XfV2DoQjsVhNCvIA7/7YTg8FI2seYHWbMeXoO5vx+Gk2eJwgADosDT1/2NJ6+7Gk4LI5cL4cgdONYjw/3/HMPBBH46GgvNrx7ONdLKmgKWggxhnecFUUxaRfa22+/HX19ffJXU1OT7uspdVjxu6tPwaRKJ/r8Yby6u03330EQBEHkJ3/b1gw+LiT27JZjOVxN4VPQQsjj8cBsNo9wf9rb20e4RAy73Y7S0tIhX9nAbOJw4bxaAMBre9qz8jsIgiCI/OOdA50AgNvPOwE2swmHOr1o7PTmeFWFS0ELIZvNhoULF+Lf//73kNv//e9/49RTT83RqmKcOtUDANh8uCftfXkvj43cRmws3gQeFAYgCG/IC24dB24dB2+ILhJEYcALIrY39QIAls+swkn1ZQCAzYe7c7eoAqeghRAA3HLLLfjtb3+LJ554Art378bNN9+Mo0eP4tprr8310nBSfRk4Djje60f7QCDXyyEIgiByzL62AXhDPIrtFkyvLsGCSWUAgK1He3O6rkKm4NPQv/jFL6Krqws//vGP0dLSgrlz5+Kll17CpEmTcr00uOwWTKpw4nCXD/vbBlFdktzpMTlNOLX9VMDrg2kyiSaCIIhCZOtRKUIwv94Ns4nDnDo3AEkgEdmh4B0hALjuuutw+PBhBINBbNmyBWeccUaulyQzvaYEQPqDnOM42KpssFVZkTjNmyAIgsh39rRI14K54yUBNL26GACwv20Aokg9hbLBmBBCRmamLISouSJBEMRYhyVFT62SBNBkjwsmDugPRNAxGEz1UEIjBR8aMzrTa6SDPZ0jJAQFHLjlABCOYBqsMFEvIYIgiIIjJoRcAACH1YxJlS40dnpxIE0KBaENcoRyzIyoI7Q/jRASIyKaH25G82PtEEFddAmCIAqNQJhHc58fADDZUyzfPo2Fx9opcpANyBHKMZMqnQAk27PPH4a7yJrjFRFEfmA2mXH+9PPl7wki3znS5YMoAu4iK8qdsWvBlKg7RL2EsgMJoRzjtFlQ6bKhyxvCsR4f3EXuXC+JIPICh8WBF7/8Yq6XQRC60dgpOT6TPa4h0w8mlEsb5mM9/pysq9Ch0JgBmFBeBIAOcoIgiLHMkS4fgFikgDGhTLpGHO+la0Q2ICFkAEjtEwRBEC19Uo+48VHhw4htln2jvqaxAAkhA0AHOUGoxxvywnW3C667XTRigygImqOOT+0wITQ+eo0YCETQH6CKYb0hIWQAmBA6To4QQajCF/bBF6YNBFEYsIqxOvfQEnmnzSInT9N1Qn9ICBkAFhprogOcIAhizNLSK4XGat1FI342njbMWYOEkAGoLZPUf1s/zRAjCIIYiwTCPLq8IQBAXdnIponjKWE6a5AQMgA10U6h3d4QghE+x6shCIIgRpvWaKJ0kdWcsJ8cc4low6w/JIQMQJnTCptZ+lN0DNAsGYIgiLEGS5SuK3MM6SHEqCqxAwDa+ukaoTckhAwAx3GoLqWDnCAIYqzSNiA5PePciWeJ1ZRKt7cPkCOkN9RZ2iDUlDpwrMeP9mS2pwlwL3cDvAC8LYzu4gjCgJg4E5ZPWi5/TxD5DIsGVBXbE/68JrpZbqfNsu6QEDIINbIjlFgImYvMWLBxAeD1AsWh0VwaQRiSImsRNq7amOtlEIQudA5K53UWAhsOmzpPjpD+0DbKILCDvI1yhAiCIMYczBHypHGEenxhKqrRGRJCBoHFf6kigCAIYuzRORgNjSVxhNxFVtgs0iWbwmP6QkLIIKQLjfFeHu9UvYN3Jn0EHomT6QhiLOENeVF1bxWq7q2iERtE3pPOEeI4DtVRkdROkQNdoRwhg8AO/q7B5Pk/4U6aMUMQ8XT6OnO9BILQhXSOEABUl9hTF9UQmiAhZBAqi20AIHcWHY6pyITFnywGfH6YltBugCAIolCI8IJ87k/mCMX/rDPJdYLQBgkhg8AO8G5vCIIgwmQa2lCLM3FwzXEBXgAQR3+BBEEQRFbo9oUgioCJAypctqT3q2TXiRSRA0I9lCNkEMqd0sHPCyL6/BQCIwiCGCuw/KAKlx1m08iu0oxKF4scUFRAT8gRMgg2iwnuIiv6/GF0eYMoH7YrEEICjtx9BAiFMQkWmBDJ0UoJgiAIPZGbKabIDwLiUijIEdIVEkIGotJlQ58/jM7BEKZVD/2ZGBZxZN0RAMBEWAASQgRBEAVBumaKDBYaI0dIX0gIGYjKYhsOdXpJ7ROEAkycCYvqFsnfE0S+EiudT54fBMSFxugaoSskhAxEpYvUPkEopchahE2rN+V6GQSRMUpK54H01cWENmgbZSAo/ksQBDH2SDdwlcE2yz2+EHiBqof1goSQgaD4L0EQxNijxydtfivThMbKnVYAgCjGHkNkDgkhA+EhR4ggFOML+9DwywY0/LIBvrAv18shCM10R0NdZc7UQshiNsliiK4T+kE5QgaighLhCEIxoijiSN8R+XuCyFd6fVLvuIo0QgiQrhM9vnA0clCS5ZWNDQrWETp8+DC+8Y1vYPLkySgqKsLUqVNx1113IRQyrshg8d9OCo0RBEGMGZgjVK5ACFUqmEtJqKNgHaE9e/ZAEAT8+te/xrRp0/DJJ59g9erV8Hq9uO+++3K9vIRQaIwgCGJsEQjz8Id5AEC5y5r2/rHrBG2Y9aJghdDKlSuxcuVK+f9TpkzB3r178cgjjxhWCDGl3+cPIxQRYLMUrGFHEARBIJb0bDFxKLanvySzFIpuKqHXjYIVQono6+tDRUVFyvsEg0EEgzGl3d/fn+1lyZQVWWHiACFaEVBT6hi1300QBEGMPnJYzGUDxyWfM8aIpVCQENKLMWM5HDx4EL/61a9w7bXXprzfPffcA7fbLX/V19eP0goBk4mTqwaoNJIgCKLwYYnSrBosHZUUGtOdvBNCa9euBcdxKb82b9485DHNzc1YuXIlLrvsMlxzzTUpn//2229HX1+f/NXU1JTNlzOCsuiHocc7bAI9BzhnO+E8wQGAKmQIguM4zK6ajdlVsxXtpAnCiKhJlAZiobER1whCM3kXGluzZg2uuOKKlPdpaGiQv29ubsaZZ56JZcuW4Te/+U3a57fb7bDbU3f3zCYVThsOwTvCETI7zViycwng9QLFtBMgCKfViZ3X7cz1MggiI3p9KoUQRQ10J++EkMfjgcfjUXTf48eP48wzz8TChQuxfv16mEzGN8AoNEYQBDF26I46O+UuZUKI3Y+uEfqRd0JIKc3NzVixYgUmTpyI++67Dx0dHfLPxo0bl8OVpYbFiVncmCAIgihcmKCpUFA6L92PCaEwBEGEyURh4UwpWCH0yiuv4MCBAzhw4AAmTJgw5GdG7kIrq/1hFQG8j8eWxVsAQcBC2GEGhceIsY0v7MPixxYDADat3gSn1ZnjFRGEenpUhsZYHikviBgIROBWmGRNJMf4sSKNrFq1CqIoJvwyMuzD0D3c9hQB3y4ffHsCAGgHQBCiKGJXxy7s6thl+M81QSRDbbK03WKW+w2NuE4QmihYIZSvJAuNmRwmzH99Pua/NBMm0MFPEARRCMjl8wpDY/H3paaK+lCwobF8JVmyNGfmUL6iXKoag5CDlREEQRB6o9YRAqTKsaZu/4gUCkIb5AgZDEqWJgiCGDuozRECYrmkFBrTB3KEDEayOTJCWEDLb1qAYBC1MMMEPhfLIwiCIHQiEObhC7GBq+ocIWBkUQ2hDRJCBoOFxvoDYfCCCHO0NFIMidi/Zj8AYBysAAkhgiCIvIY5/2YTh1KH8ssxOUL6QkLIYLDSSFGUptBXqNglEMRYguM4THJPkr8niHwjFhazqjqGy+VRTCSE9ICEkMGwmk0osVswEIygxxciIUQQSXBanTh80+FcL4MgNNOjIVEaiHOEaN6YLlCytAFhB3kv2Z4EQRAFS488eV6dEKJ5Y/pCQsiAMNuT1D5BEEThwnJ81PQQku5PydJ6QkLIgNDgVYJIjz/sx+LHFmPxY4vhD/tzvRyCUI3W0FgFJUvrCuUIGZBYLyE6yAkiGYIoYHPzZvl7gsg35GRplbmgTDj1+cOI8AIsZvI0MoHePQNSHjddmCAIgihMYo6QutDY8OpiIjNICBmQcmqWRRAEUfBoTZa2mk1y3yFKocgcEkIGRO4RQQc4QRBEwaJlvAajgkrodYOEkAGJJUvTAU6MDURRxL92tmLj3vZcL4UgRg2tOULxj6EJ9JlDydIGpIL6CBFjjMffbsRPXtwNAPh/Xz4ZF8yrzfGKCCL79ETdHC2Nc6mXkH6QI2RAypL0EbJ6rLBWknYlCgteEPHoGwfl/8d/nw6P0wOP05ONZRFEVglFBAwGIwDUJ0sD8UU1JIQyha6qBoTFi3t9IYiiCI7jYHaZcVrHaYDXCxQHcrxCgtCPbU296ByMncx3HO9DW38ANaWOlI9z2Vzo+G5HtpdHEFmBOf4mDih1qBdCFdRUUTfIETIgTAhFBFHeMRBEofL+oS4AwPknjsOJ490AgPcOduVySQSRdVgzxDKnDSaT+qHB7DpBydKZQ0LIgBTZzHBYpT9NLyVMEwXOjmN9AIAF9eVYOKlcuu14Xy6XRBBZh+UHaQmLAUCFi6qL9YJCYwal3GlDS18A3d4Q6iuc4P08Pj7vY4AXMA82mEEHP1EY7GyRRM/c8W45P25nc3oh5A/7cd4fzgMA/PMr/0SRtSh7iyQIncmkdD7+cVQ1ljkkhAxKWVQIyWpfAPreYBcHMvKIwiAY4XG8R5oTNq26GMV26ZR0oN2b9rGCKOCNI2/I3xNEPtETFxrTQgUlS+sGCSGDEps3JtmnnJ3D7KdmA4EguCvpwCcKg6ZuHwQRKLZb4Cm2wWaRRH7nYBDeYAQuO52iiMKEJTlXqJw8z6A+QvpB1oJBGV4aabKYUH1ZNaovroAJtPslCoPGTh8AoMHjBMdxcBdZ5U3AkS5fLpdGEFmFJTlraaYIxEJjA4EIwjxdEzKBhJBBqaB5Y8QY4HCnFAJrqHTJt02Mfn+0O314jCDyFVY+X6ExNOYusoKLFptReCwzSAgZFLYrZiWWQkRA+9PtaH+uGwL92YgCobFLEjuTPTEh1FDpBAAcJkeIKGC6M0yWNps4lBVFK8eohD4jKABvUGKhMekAF4Midl2+CwBwOmwAqKkikf8ciQqhSXGO0KQKZ/RnJISIwkWePK8xNMYe2+MLU55QhpC1YFCoaygxFmjplQT9+LJY6bua0JjT6oTT6szO4ggii7Bzu9Y+QgDNG9MLcoQMShn1iCAKHFEU0dovCaFx7tg4jbro9619qV1Pl80F7w8pj4jITzKZPM+gyjF9IEfIoJDSJwqdgWAEvhAPABgXN1esOvp9e38wJ+siiGwT5gUMBNjAVe1CiIpq9IGEkEEpl9unhyGKYo5XQxD60xZ1fEodFhTZzPLtzB0aCEbgpVl7RAHCNrgcJ1V/aUV2hGjDnBFjQggFg0GcdNJJ4DgO27Zty/VyFMF2CaGIIO+aCaKQSBQWA6Tmiq6oMGrrTx4eC0QCuOCPF+CCP16AQISKB4j8gTXKdRdZYdYwcJUhzxsjRygjxoQQ+t73voe6urpcL0MVTptZ7rJL8V+iEGE5QDWljhE/Y7e1pQiP8QKPl/a/hJf2vwReoM0CkT+wc7rWHkIMed4YDefOiIIXQv/85z/xyiuv4L777sv1UlTBcZz8IaEJ9EQhwtyecSmEUPsAOT1E4dGrQ6I0QNXFelHQVWNtbW1YvXo1nn/+eTidykpsg8EggsHYLrS/vz9by0tLmdOK1v6AFP8tz9kyCCIrJAuNAUBNqV26T5rKMYLIR+TxGhmUzgNUNaYXBesIiaKIVatW4dprr8WiRYsUP+6ee+6B2+2Wv+rr67O4ytSQ2icKGVYVVq0xNEYQ+UpPhl2lGVRdrA95J4TWrl0LjuNSfm3evBm/+tWv0N/fj9tvv13V899+++3o6+uTv5qamrL0StIzfPAqQRQSbBdbmSA8wMRRG4XGiAJEbqaYYWiMPd4X4hEIU56cVvIuNLZmzRpcccUVKe/T0NCAn/zkJ3j//fdht9uH/GzRokX4yle+gieffDLhY+12+4jH5Apmm5IjRBQicsJogouBpzhq+Q/SsU8UHpnOGWOUOiwwmzjwgoheXxjj3Ob0DyJGkHdCyOPxwOPxpL3fgw8+iJ/85Cfy/5ubm3HuuefiL3/5C0455ZRsLlE3KpzUI4IoXLpSOEIVlPtAFDCsACbTHCGO41DutKFzMIhubyhhvh2RnrwTQkqZOHHikP8XFxcDAKZOnYoJEybkYkmqiR+8anaZsUJcAXi9QDGFC4j8JswL6PNLF4NEjhC7rSuFEHLZXBDvomajRP7RrVNoDJB6CXUOBimFIgPyLkdoLFFO7dOJAiW+s25ZgvCAp9gu308QSOwQhUWvTqGx+Ocg91Q7BesIDaehoSHvRlVQaSRRqMg7YqctYWdddnLnBRF9/rAuO2eCMAqx/LjMQmPSc1BRTaaMGSGUj8Q3VOQDPPZ8bQ8QieAEWGEGNVkk8heWBJ0oLAYANosJJQ4LBgIRdHlDCYVQIBLA1/76NQDA/33h/+CwUH4EYXwivIB+HQauMsrIEcoYCo0ZmLJoIl23LwQxIqLjmQ50PN8DgCoDiPymK0XFGIOFx7oGE/cS4gUez+x6Bs/seoZGbBB5Q68/tonNZOAqg+aNZQ4JIQPDLhKhiAA/BEx/aDqm3z8RHLlBRJ6TqocQgyrHiEKECZZShwUWc+aXYJo3ljkUGjMwbPBqKCKgNxRB/fXjpaqxW2n3S+Q3ShwhJZVjBJFvsOOZOZ6ZQhMIMoccIQMTP3iVdsVEIdHtlcJdqRwh1lSxi5oqEgVEZzTUW1msTwEAFdVkDjlCBsdTYkNrfwCdfQH0HOwB/AGUwQQOQq6XRhCaSdVVmlFOc5SIAqRzQBJCujlC9DnJGBJCBod9WDq7A9h+5h4AwOmwwQxqqkjkL8zlqUhxMSiXqybpBE8UDp2D2QmNdXtDEEURHDeyHQWRGgqNGZxY5QxdDIjCQUmytDtaNRlfZUMQ+U6XV19HiIXGghEBfhq8qglyhAyO7AiRECIKiPiGiskoi5YW9yaphnFanRi8fVD+niDygY6B6CZApxwhl80Mm9mEEC+g2xuC00aXdbWQI2RwYgmjiXupEES+IQiinM+Q6mLAGsX1JXGEOI6Dy+aCy+aicACRN7Bkab0cIY7jUC73EiL3VAskhAxOVUk0NOYlIUQUBgOBCNj4sLIU07fZzyhHiCgk2Lm8qkS/sTGxXkL0WdECCSGDQzlCRKHBHB6H1QS7JXmXdBYa6/OHEw5eDUaCWPX8Kqx6fhWCEdooEPlB54C+ydIA9RLKFBJCBifmCNEBng3+5+U9WPnLN/HyJ625XsqYgQmhdOMFSqM/F0RgIBgZ8fOIEMGT25/Ek9ufREQY+XNCG3/+8CjO/sUb+P37R3K9lILDG4zICc2VOgoh6iWUGSSEDA7bNSRLGCW08+a+Djyy8SD2tA7gu89sx0CA3uPRQKkQcljNKLJKjlEfHf+jQlO3Dz/86w4caB/EHc9/gv1tA7leUkHBnH2H1QSXTb+ZkdRLKDNICBmcsiIrzCZKBM0Gz2w5Jn8/EIjglZ1tOVzN2EGpEALi8oT8dIIfDZ7behzxUcjntx3P3WIKkI64RGk9E/zJEcoMEkIGx2TiUvZaIbQhCCLe2t8BAFg2pRIA5P8T2UWNEHKnKaEn9OWdA50AgKVTKgAAr++hz4SexMZr6BcWA4CK6IaBckm1QUIoD9AzqY6QONQ5iB5fGA6rCavPmAwA2HykJ8erGhswIVSqQAjJ3aWpqWLWCUUEbGvqBQB859MzAAB7WvvhTZCfRWiDCaEqnXoIMWpKHQCA9gGaOKAFEkJ5gKeEhJDe7GzuBwDMri3FogZp93usx49+yhPKOkwIlRWlvxiw0Fgf5T5knf3tAwjxAkodFiydUoFxpQ4IYuyzQmROl87jNRjVUSHU1k/Vk1ogIZQHeHTePRDAwXapI/GMmhKUOqyoKZVOTIc6vLlc1phAU44Qhcayzu4WKTF6Vm0pOI7DjHElAICDHYO5XFZBwRybKp03t+z81T4QgCiObDVBpIaEUB5QXeJAyAq887tKnNp4Ekw0cDVjDkRP7tOqiwEAUzzSv0wgEdmjXxZC6UcBuItYNcxIIeS0OtF+Wzvab2unERs6cKgjtjkAgCke15Dbicxp7ZPO3ePcDl2ft7pEer4wL1LCtAZUDSWZPHmypkz3m266CTfeeKPqxxEStW4HwAFNCMFWlX4XTaTnQFTwTI0KoanVLrx3qIt2v6MAqwBzp+gqzUhVNcZxHKpcVfoubgxztNsHAJhUKYlK9tkgl1Q/WqJCqFZnIWSzmFDpsqHLG0Jbf1D3ZOxCR5UQ2rBhg6Zf0tDQoOlxhATbPbT0+XO8ksIgwgto7JRO7tOqokKoik76o4Wq0BjrLk2hsazDhFB9RVQIMUeokz4TeiE7QqVFuj93dalDEkIDAcxGqe7PX8ioEkLLly/P1jqIFNS5i2CJAKf8PoR9Hx/BNFhhQvILQ8dAEFYzJw+tzBahiACLiYMpz/ocHevxI8yLcFhNGF8mnZCYECJHKPto6yM08ngPRoK45V+3AAB+ce4vYLfQLjgTmBCaGBVCU6KfiaPdPoQiAmyW/MqkCEUEAMj6ursGg+A4Th5zkYxAmJcnBOjtCAHAuFI7drcA7f3pUydCEQGtfQFMKC/K6vlbFEWEedHwx46xV0cAkBwhkwCc+oEJzY+1Q0TyjqS/fesQltz9Hyy951W8vrc9a2v627bjmLfuXzj/wbeSTgc3Ksd7JWdtQrlTPgmwcMCxHj8lG2YZ5u4o6yMULZ9PUDUWESJ4ePPDeHjzwzRiI0P6/GE5IZ0JoZpSO5w2M3hBRFOPL5fLU01Ttw9n3b8RJ//3v/H2/s6s/Z6nNjVh8U//g1Pu/g/+vr055X3boxVdNosp5bBhrbAS+ta+1JVjHQNBnPvLN3HGva/jqvUfyoJRbwaDEXzuoXdw4tp/4enNTVn5HXpBQigPqHTZYLaZ8PxpIVTcXAUOiU/6+9sGcPdLuyGKQCAs4IfP7UAwwuu+Hm8wgh/99RMEwgL2tA7gsTcP6f47sklzVAjF78rYScQf5tHvp4tqthAEUZ4bpqSPkFw+n2diO99oirpBnmIbXHYpUMBxHOqijikL6eQLv/j3Phzr8WMwGMEP/7oj4dDeTOkaDGLtP3ZCEKUk5R8+tyNlonJrfyw/SM+u0gylKRT//cIuOTXgrf2d+EuWRMoTbzdix/E+BCMC/utvnxi6NYkqITR58mRMmTJF9deDDz6YrfWPCUwmDp4KO57/VBjha0phSiKEfvtWIwQROGNGFapL7GjpC2SlM+wru1oxGNdk7bmtx/LKRWnulU5ILCwGSHOtmLXd0k+5WNliIBABO1SUOEJMLPUHSJxmEyaEJpQPrb5jmwW2ecgHAmEeL+1okf9/tNuHLUf1b5b614+OwxfiMau2FLNqSzEYjKR0PphAGVeqf1gMiP3tUrl3x3v9+MfHknN12cIJAIA/ZGm47nNbYyOMAmHB0IOtKVk6T6h1F6Gp24/WJA2z4j/816+Yiv/sbsNjbzXilV2tWDl3nK5ref9gNwBg1akN+OMHR9HcF0Bjp1fOKTA67IRU6x6asDiu1IFubwgtvQGcMI6SDbMBc3YcVhPslvRDJ0sd0ikqFBEQCPNwWPUbVEnEYNVM8ZsDICaE8skR+qCxG8GIgFq3A6dMrsDz25qxcW87Fkcbp+rFK7uk2YRXLK6Hw2rC95/dgT9+eBSrT5+SMO+GbcCykR8EAPXl0t/uWE9y0fr8R8chitIIlR9dMAt//eg49rQO4EiXF5MqXbqtpb0/gMNdPpg44OunTcbjbzfinQOduHxRvW6/Q08oWTpPGF/qQF0Hh45t/RDBgcNQB+b1Pe0YCEZQ53ZgcUMFAhEBj73ViM2H9d8JfdQkPeepUyuxu6UfHzR2Y9Ph7rwRQs2shLVs6Amp1u3ArpZ++aJA6I+aRGkAcNksMHGAIAL9gTAJoSzRFm30V106NOF8XHSz0JxHn4mt0VE5y6ZWYkmDJIQ26Xwe9AYj8u85c2Y1PCU2rPvHLhzp8mFncz9OnOAe8Zij3VI4aqKOgiOeCdHcruZeP3hBTDis+2/RIboXL5iAMqcNJ9WXYfORHmw63KOrEGLjik4YV4pPz6rG4283YlNjt27PrzcZ5QiFw2E0NTVh79696O427ossBCYXF+HuJ5xo+HY/BIysjmG7kwvn18Fk4rBgYhk4TrKF9Zw/0x8IY3+0B8+CieWYF/3A51Mbfmbzj9j9lrHdb/6EAfINtULIZOJQ4oiGxyh3K2t0RJ1m1piPUefOv8/Ex8d6AQDzJ5Rh4aRyAMDO43265gntaulHRBAxrtSBiZVOOG0WfGqaBwDw2p7ERSqHO6N9miqy0/xzXKkDVjOHMC/K+UjxHO3yYV/bICwmDitPlKIEJ0ffn606hw43HZb0wKKGcswdL10jmvsChs31Uy2EBgcH8etf/xorVqyA2+1GQ0MDZs2ahaqqKkyaNAmrV6/Gpk2bsrHWMc0kT3K1Lggi3twn5QKddUI1AKDUYcXMaIfYLTruhrY39UIUgfqKIlSV2OWDPF+EkCiKaEmQLC39XxJG5AhlD7VCCABKox2ojZxsme8wR6hmhCPEEnDz5zOxr03aqM2pK0WDxwWrmYM3xMvVonrwyfE+AJDPf0Ds3Ptakmpd1p6gwZMdIWQ2xZLbWc5XPBv3SetaOKkcpdHNxYL6MgAxF00v2PBe9rvYufZA+4Cuv0cvVAmhBx54AA0NDXjsscdw1lln4bnnnsO2bduwb98+vPfee7jrrrsQiURwzjnnYOXKldi/f3+21j3mmJhiF7GzuR9d3hCK7RacPLFcvp3thrZFd0h6sLdVOpDn1kknANZ/53CeNF0bCEbgDUmVdIlyhID8OunnG3JXaTVCSHaEhgqhImsRGr/TiMbvNKLIqn+DurFEezJHqCy/NgeBcEzwTKkqhtVsksfn7NfxIrxDFkKxXMIzo0Lo42O98pR5RjDCoznqqukZghpOPUuYTiCE3tgrbZZXzKyWb2OO0L62AXiD+jiuoijKo4pmRufVsVFG+9uM2adNlRB699138frrr2Pz5s248847sXLlSpx44omYNm0alixZgquvvhrr169HW1sbPve5z+GNN97I1roV8+KLL+KUU05BUVERPB4PLr744lwvSROTKpJ/eN6IKv1Tp1YOaVx1AhuaqOP8LFZ2OaVKWk9D1Knq8obyYsfeOSCdoErsFhTZhuab1MgTnPPjpJ+PMEdISek8QxZCwyrHTJwJDWUNaChrgImjTiCZwI75ZI5Qnz8Mf0j/Vhx6c6RLEgClDgvKo60X2PDYfTpehHcelxxwtiEEpPPHnLpSiCKwce/Qat2mbj9EEXDZzKhM03gxE1hX8MNdQzemgTCPdw92AQCWz4iNpakpdcBTbIcgxsYOZYp0LYiA44CGqOibXi39DfYbdJajqmTpp59+WtH97HY7rrvuOk0L0pNnn30Wq1evxt13342zzjoLoihix44duV6WJlLNZXojGhZbPnPo3CU2K0jPg48JocnRXVax3QJPsR2dg0Ec7fINsYqNSOeg5EhUFo88GXlKpNtoaGH2YEKorEj5xUAOjRk0vyDfCYR5WWQOd4RK7BbYLSYEIwI6B4PyhdaoNHZK57rJVcVyr54Z0fPgvlZ9HKFQRJCHNs+uG1pdeubMauxs7scb+zpwabQ8HQCORIXJpEpXVnoIMWbWSK9177DXuulwN/xhHtUldsyqLRnys6lVLnQOBnGocxDzo6GyTGBjisaXFcnFDTOi69rXVgChsVSsX79er6fShUgkgu985zu49957ce2112LGjBmYOXMmLr300lwvTVd6fSFsicZ3z5g+VAgxO7Kp24dAWJ/dXEwIxRyqhmhX5sY8CI91RS1rT4KhhJUu6bZuXwgRPjvdVsc6/RpyhORk6WGOY4gP4buvfBfffeW7CPEkXrUS3/GYiU4Gx3HyZ6VjMHXHYiPA5qJNrowJtunRXMkDOo3PaerxgRdEOG3mEXmGbDP69v4O8HHJ2XuiwoRtTrPFzGjbjz3DhBBzqJbPqBohxNiaDrbrc/5mY4riq4jZ7zDqNUI3IfTcc8/h9ddfl//v9/vxla98Ra+nV83WrVtx/PhxmEwmLFiwALW1tTjvvPOwc+fOlI8LBoPo7+8f8mVk3tjXAUGUFPfw3VpVsR0lDgsEUZ8D0B/i5VyBKXFCiMW8j3QZ8yCPh8XuEzlC5U4rOA4QRaCHhnxmhViytHIzujRJ1ViYD+O+9+7Dfe/dhzBPfy+ttMclSidyKzwlUSE0YHwhdHiYYw3E8itT9dfR8jsSuTsL6stQ4rCgxxeW84iAWHL1ieOz25+MpUOwrtoMNm6JJXTHw87les1ZPMSEUNw1glXotvUHhghEo6CbEPr973+PH/3oR9izZw/279+P008/HStWrNDr6VVz6JA09mHt2rW444478MILL6C8vBzLly9PWep/zz33wO12y1/19cZsAMV4PVqqeWaCA5zjONkV0iP+y+LOZU4ryuPi3DFHyPjziFhoLJEjZDGbUB4dVNvlNf5JPx+RhZCKWUtUNZZdUn0mAKAqumkYngBsRFhl1qQ4R2hChXQR7vaGdEkIjrniI8OEFrNJLqN/Iy5PaEeCKrNsUO6yyXleLDx2pMuLQx1eWEwcTpvuGfEY2RHSSQgdjuZpsTxSAKguscNskkr7jXgcZSyEbrnlFvzud7/DkSNH8MQTT+DLX/4yLr/8cjz22GNYvXq1Hmscwtq1a8FxXMqvzZs3QxCk0MaPfvQjXHLJJVi4cCHWr18PjuNS5jrdfvvt6Ovrk7+amow7LI4XRDk/6KyZI4UQALli4miCKgK1yCeZYc5TfVwjL6MTc4QSn/RZImPXIIVasoGm8vkkVWOEPrCcuGRJvEwgdQ4Y/zPBOmDHh6xKHVb5eNPDFWIJ2Q1Jqr9YMvKre6Tebr2+kPx759RlP4eSdcVnLhQLiy1qiJXNxzNNrvz16eLWNMtDrWOVnBazSa7KNeJ1QlWydCKWL1+Ojz/+GP/4xz+wZ88eNDc3Y+nSpXjllVfQ3NyMCy64QI91yqxZswZXXHFFyvs0NDRgYEBSw7Nnz5Zvt9vtmDJlCo4ePZr0sXa7HXZ74ouk0dhypBs9vjBKHRa5VH44E+S265kLIXYA1w1rRJhP1VZM4FQlCI0B0kl/f/ugIXcthQALb6nrIyTdd4DmjWWF7qj7ydzQ4chCyOCfCVEU5dD98NYYE8qL0OcP41iPTy7p1gpzxhuS9Hb79KwamE2f4ONjfWjs9MaF0pyqjnutLG4oxxv7OvBBYxeuOrVBHr10ZpLNcq3bAbOJQ4gX0D4QGPHeqeV4kutEXZkDx3v9aO4NYMHEjH6F7mQshC666CJcdNFF8v/9fj8++eQTfPzxx/jPf/6juxDyeDzweEbae8NZuHAh7HY79u7di0996lMApE7Yhw8fxqRJk3RdU654apM01O68ubWwmBObexMUzJ9RCjvJDD/AWYlta38AoihmtSoiU9I6QnIYwPi733yEhbcS7UyTweaNUWgsO3R7pfe1IunmID9CY33+MIIRKRIwfFTIhPIi7Gzu1+U8KAuhJI5QVYkdp03z4M19HXj+o+Oy43batPTXLT1YNtUDYB/e2t+JPa3SCCQTB3zupLqE92duzfFeP473+DMSQt5gBL3R/MqRc+uKAPQUhiOU7kJXVFSExYsXY/HixRktLFNKS0tx7bXX4q677kJ9fT0mTZqEe++9FwBw2WWX5XRtevHijhbA5sDXliUXdmwisR4ngGRKn1mevhCPgWBE1UVutOlMUTUWf3uXwU/6+YgoinJ4S1UfoSIKjWUT5gglDY2V5IcjxDZqFS7biJl0sfNgZs64IIhy+C0+9DOcS04ejzf3deBXr+0HizZ9ZnZNRr9bKQvqyzCu1IHW/gDO+9+3AEhNFFMJnAnlRZIQ6vVjUQa/mw20LnFY5GpPBrtu6NnhWy9U5wgVFxfjtNNOw4033ognn3wSn3zyiZyPYzTuvfdeXHHFFfja176GxYsX48iRI3jttddQXp44jJSPnDq1MmUCHvuwHu/xZzxrh42mqBtWMlpkM8u79jaDd6DtStFHCKAcoWziDfHyRUGdI5S4oSKhD11RxyJ9aMzYnwkmUNjGLB69nPFObxBhXoSJkxKAk3H+ibWYUuWSj/cpVa4R7U2yhcnE4cpTpc2xGP393zpjSsrHjNfp/TneK/0NhrtB0m2O6H2MJ4RUO0L33nsvtm7dirfeeguPPvooeJ6Hw+HAvHnzsHDhQixcuBAnn3wy5s+fn431qsJqteK+++7Dfffdl+ulZIypyITFnywGfH6Ylkg7s2VTK/DTy1O/z/Hx347BoJzPo4Xm3sShMUAKj/UHBtHaH5D7dhiNQFhyrIDkjhALmVHVmP4wR8dq5uCwKt+DJWuoWGQtwiff/kT+ntBGjy/15iCWLG3szwQbNDrOPfIcx5KnM81jbImeA6tLHEnTEQDAajbh0a8uxHef+Ri8IODeS+fDlGAafLa45lNTcLjTi3cOdGH16ZNxypTKlPfXK3KQLI8UiOWSthvwOFIthOI7RgeDQRQVFeHmm29Gd3c3Nm/ejCeeeALBYBA8b/x27PkEZ+LgmuMCvAAgyfwnVi0BXKkvAPHx32M9Ps1CKBxNpAOSH+T72gblXZkRYTtfm9kkO1jDYW35e6mPkO6wHJ8Sh1VVHhkLjQUjAgJhXg57mDgT5lTP0X+hY4zuqNNT4Uq8OaiIuqQDwQjCvABrCgGQS1hoLJEQqpYLOjK7CKf6HcOZUVOCv11/Wka/Tys2iwk/v1S5GTFBp7AVE0KJHKGqEuMK6oySpVl11eWXX4558+YBAHieT9u0kBhdxkfjv8d6/FioMU+8rT8AQZRERKJcgnF5UDnGPoCVxbakF2LW36aX8lF0h1WMJROhySi2WeRGlwOByIj8D0I7oijKG4RkOULuolij0V5fWL6gGY22FKGx6rimkJkUdLAcmLoy7c66ERkvp1BklkPVmkIoxncoN1pRje7S3mw2y6KI0A8hJKBxbSMaf3ocgkr9yk4MmXSGZXZmVYk9ocVbo9OOK5uwcFeyEAAQy5Po9Rk7HyIfGQioT5QGpJyHEvvIyrEQH8LajWuxduNaGrGhEX+YlyutypMIIbOJk/O0jPy5YMnciYQauy3ECxm5vbE8pMIKxTKXvyVDRz9WjDLyWJL/BhHBcPl+xvQ4iRGIYRFH1h3BkXuaIaoUQqzTaCZuDXNTPEl2g+wgN3JuDWsIlyw/CJC6ZgPSzlcUjdcKPp/RUjrPSFQ5FubDWPfGOqx7Yx2N2NAIKwqwWUxw2ZI7bSw8ZuSBxJ0pnC27xSy/hrYB7efBlgQNGwsB5pj5QvyQ0RxqSdWl3GE1yxsao1UgqhZCq1evxqOPPorNmzcjGJRejJEsrkKFs3Cou64OdaurwUFd/hWbKJ2JW8Ps82SNCPOh/w5LCk1WHQPEpqJHBBHeEOW56YkcGlMxZ4xRQpVjWYF1+pbm7CU/j7MNgpFn8MkDlZNs1tjFPpPzIAuN1RZYaMxlt6A4KlIy2TCnGmoNxDbMRptbp/qMtHfvXjz11FMYGBiAxSI9fN26dVixYgVOPvlknHTSSXA6R85gITLDZDdhxv+bAXi9wGPqTkbVejpCSUdTGL//Tq+C8Q4Oqwk2iwmhiIBeX0g+ORCZI/cQ0uIIORJXjhGZofRvYvSQsSjGZlh5kiR9V5c6sKd1AO0ZnAcL1RECpOvEYEcE7f1BTI2bHK8U6W8QdYSSiFFPsR2HOr2Gc4RUn+XffPNNAMD+/fuxZcsWbN26FVu2bMGdd96J3t5emM1mzJgxgxKmDYQeZYupprYDsZhwl4Gtc7b7LUsx8JPjOJQ7rWjrD6LXF8aEwmk5lXP6NeYIxT+GukvrC3PY0v1NmBAyqiPkC/EIhKVcp2TnqJroxVnreVAQRHkzOS7DMRRGpKbEgUMdXrk6WC39gQhCfPRvkCTfrGAcIcb06dMxffr0IXO/GhsbsXnzZnz00Ue6LI6IIYoiwp1hwBuGFYCaYKQshDJxhNJMqGbx915f2LAltn0+ZQM/y4psshAi9ENr1Zj0GJo3lg1ieVup/yblcmjMmBsdluvksJrgTJLrlKkzrrSZYr6S8fsT3SyX2C1JKzvZhjmvhdDRo0cxcWLyaWmTJ0/G5MmT5REWx48fx/jx4zNbIQEAEHwC3q1+FwBwOhwwQ/nByj603mginJZwT7rRFGVOG0wcIIjSyZLlJRkJJY4QEF9Cb8yTfr6SmSNEobFswN7P4eMQhsMqynoM6vh2xJ2fkuU6xTaE2i7CrJliVYndkBu9TMn0/UlXUAMYd4Cvqr/m4sWLsXr1anz44YdJ79PX14fHHnsMc+fOxXPPPZfxAonMcdktcrZ+pmo/me1sNnGyK2TU8RRM2KR3hKipYjbIqGrMQaGxbBALjaXeHBk9WborzTBlIC5ZWmPoh7kYmXTnNzKx90ejEJKjBsmLUdhgXzbo1yiosgZ2796Nu+++GytXroTVasWiRYtQV1cHh8OBnp4e7Nq1Czt37sSiRYtw77334rzzzsvWugmVVJfaMdARQVt/QFMiHDvIq1KcaCpddnQOhgwrhPrkZOnkH1Qglg/RR+6DrmRSNRYrn4+FxhwWBz685kP5e0I9AwrFaYWcI2TMzzbLTfQkyU0BYt2lNTseaVzxfKc6w6a4rHVKqven3KDHkSpHqKKiAvfddx+am5vxyCOPYMaMGejs7MT+/fsBAF/5ylewZcsWvPPOOySCDEYmtmcoIsiiINVBXiknTBvL9mT0Ks0RYrtfg4YB8pXMHKGRDRXNJjMWj1+MxeMXw2yibtNaYMIyXWiszKAXMEa6qlYgvmgkoKlHmOyKpxBb+UxNhonM8Z37k2FUIaQpWdrhcODss8/GxRdfrPd6iCxRk4HaZ03ULCYupYiQB5Ya0BHiBVFOtFWeI0SOkJ7IpdqZVI3R30RXYnlbaZKlXcYOF3ezHmEpRApzs8O8iF5fOOV9E5GuNDzfydQR6khTUAMY9zjSnPFVXl6OZ599Vs+1EFkkVhGgXu2znVCFy5ZygjLbKRnREYq/gCqpGgOM92HNZ0RRjOWjZJQjFAuNhfgQ7n3nXtz7zr00YkMjakNjvb4QBMF4HddZRWh5ik2OzRIbtqylzUdHoYfGMuwurSR0WG7Q40izEBJFEY888ghOOeUULF26FGvWrMEHH3yg59oIHakp0a72lZ4A3AZOMmahPZfNnLbigzlGfVQ1phv+MA8+euLTliM0smoszIfxvf98D9/7z/doxIZGYqGxdMnS0gVMEI2ZsM5CLencXk+x9savXSnmaBUCmRbVKBFC7O8jiMZqhZFRDeD27duxZMkSrFixAnv37sXy5ctx880367U2QkfkRlaaTgDKLOFyA4eUlHSVZhi9QiYfYRdci4lDkYbp8VQ1lh2UtjSIn0VmxM9Fr9waI7VIqcyg8auSgpF8pyqDXkLsOlFVkvxvYLeY5eOo20B5QhnND/jjH/+Ic845R/7/jh078PnPfx4TJkzArbfemvHiCP2Q+zdoSIRLNVE4HnYS6jPgiVKuGEtzogQoNJYN4i+4WmYTsgt1ICwgGOFht1BytB4MqAhXljlt8Ib86PGFMBmubC9NFeyzWpZG0GUyCqhTQYl+vlNVbMehDq+mmZGxZPLU748RjyPNjlBlZSXq6+uH3HbiiSfiwQcfxKOPPprxwgh9ycQRUlKRARi7ESGbkeRWEJaJD43RBHp9iM200rb3im8CaiRLPZ8RBDEuRyj93yXWPd54n+8eBcnSgPbh0GFekMVWoYbGAO0jMHyhCHzRIdVpIwdywrRxjiPNQmj+/Pl4/PHHR9w+bdo0NDU1ZbQoQn/YAT4QiCAQVjdVXbEjVMTKzo3npLALcVmaHkJATAiFeZpArxfMEUpXpp0Ms4mT8xeockwfvKEIWL6qkko+9rkwmlMqCGKsa3w6R4jlCKks6GBhH7OJkxN+CxGtQqhzIDbixJVkxAlDLqE30HVCc2jsJz/5Cc4880wcP34c1113HebNmwe/34+7774bkydP1nONhA6UOiywmU0I8QI6B4OYUO5U/Fi5WVkaR8jIjQiV9hACgCKrGRYTh0h0x0wT6DMnk2aKjNIiKwaCkSGVY4R2mLNmM5tgt6TfExu1GKI/EAYzbt1pk6W1db9XWjmb72gdgaFkxAnDiL2ENDtCS5cuxfvvv4/m5masWLEC5eXlqKurwzPPPIP7779fzzUSOsBxnGa13zGgLDbOdoyDwQjC0SnERkHpnDFAeq/YDpnCMPqQSTNFBqtsGqCEaV2I7yGkJG+rzKDFEEyYOW3mtLljsRwhbUKoUJspMrReI7pUtBYw4gDfjLa68+fPx8aNG9He3o4tW7ZAEASccsop8Hg8eq2PiGJymDD/9fmAPwDT+doOIE+xDcd7/eptTwUzZAAp7MFxgChKJ6cqAzUe61XZzK/EYUG3N0RhGJ2I5QhpF0LDx2w4LA68ftXr8veEOpR2lWawsHKfgS5gQFx+kIKQlZwjpDI0JleMGeiclg00h8YUXiOA+C7lxjm36uL5V1dX00iNLMOZOZSvKAe8XgDa3BZ2kKtJFOQFEd3Rk0a6slGziUOpw4o+fxh9/pChThpqHCGAyrX1Rulwz1QM/5uYTWasaFiR8drGKmoT2A3rCKlojZFpaKxQmyky2DlebVGNmvdHbrNiIEGdUR8hIr/QovZ7fSE5obJCgS1cbtCEyj4VOUJA7IJNoTF90McRomRpPRkIqnNJjZoj1CtXjKV/HSw01ucPIxRRvqGMVc6OjdBYtzckN0BVgioh5CqgZGlidBHCAlp+0wIEg6iFGSaor2bSkgjH3KNypxWWNB2ZgWifni6f4U6WfSqqxgCgxE6zrfREaeO+VAx3hMJ8GL/Z8hsAwDcXfhNWs/bnHoso7SrNYCENwzlCPuWfbXeRFWYTF3W6QxjnVhZSVVowku9UuGzgOCkS0OMLKX69SiuLgQJLlo5n69atCIWM86IKETEkYv+a/dh/61GI0HbC1+IIqbWE5RJ6Ax3kQKy3keLQGHMfyBHSBb2qxoCYqA3xIaz55xqs+ecamjWmAbUundxfy2CfbZZrouSzbTJxsrOtbkNY+M0UAcBqNslz5VRdJwaUD6QtWCG0ePFiHD58WI+nIpJhBqourULV58sBDW4QoNURUimEnEMvVkahT0UeARBLIKUcIX3Qo2qM5bIwUUVkxkCQiVOlydLGzBHqUzhnjBEbDq38QtwxRkJjgMbrhFdZV2nAmCOMdAmNUffd7GN2mDHn6TlSsnSxtgNIS3dpFhqrVHgCiE0XNs5BHgjzCISlfIB0fUYY7IJNOUL6II9yyCA05i4ypsjOV5gjVKKwT5Y7bpMjCKJh+un0yJPnlZ2jpAv9gKoxG7GqqMJ2hADpOrG3bUClIxQtqEkxZ4zBhFAoIiAQ5uHQMHtQbyhZegzBPsTZDI25DRgaYyd8EwcU25Sd9EsclJirJ3okS5MQ0he1eVvs/RcNNjlcTdUYEDd4VWHl2JDKWQNVwmYLtSkUwQgvpxAouU64bBYwDW2U8ysJoTEEO8B9IR7eoLITWUzpqwuNGck+jz9RKt3FUkNF/RBFcUjzPq245T5Cxjm28pkBlS0N7BYznNHxCUYSo70q+ggBsfCN0l5CPSorZ/MdT7G6HComKK1mTpEYNZliDWuNknpAQihP4L08NnIbsbF4E3hoax7nsplRFLUhFR/kXuWNsoD4hEpjHOCA+vwgIM4RMsgHNZ8JhAWEeelKkpEjZECRnc9ocelieULGcXx7VSRLA4CnRJ0jxO5X5rTCqqByNt9R6wjFT51X0qEciB1zRhHUBf1X3bdvHy666CJ4PB6UlpbitNNOw+uvv57rZeUMjuPkk4BSIRR/kCshVmJrvBOlW8WwRMoR0o9YA0ROdhS0EB8ao7zEzGHhDDWDcN0GzAFkx5fSjY5HHrOh7hw4FvKDAPW5pF0q80iB+J5gxji/FrQQuuCCCxCJRPDaa69hy5YtOOmkk3DhhReitbU110vLGVUq84TkRmIKQ2NyjpCBmmVl5AgZZMeSz8R3MFa6Y0wE6xPDCyK8IR52ix0vfOkFvPClF2C3jI2LlJ4MaAhXGq1yTBTF2PGlNkdIYdWYmh45hYBcNTag7P3p0CAU3RQaGx06Oztx4MAB/OAHP8C8efMwffp0/OxnP4PP58POnTtzvbycoSZhWhRFVTNkgHgnxRgHOBDLIShTIYTclCOkG3o0UwQAh9UEWzQ00ecPw2Ky4IIZF+CCGRfAYqLesGqQBEQ0R0hNaMxgvYS8IV7O31H6OlgvIKWhsVjp/NgQ22odIS2OWUGGxu666y7DDVqtrKzErFmz8Lvf/Q5erxeRSAS//vWvUVNTg4ULFyZ9XDAYRH9//5CvQiJ2kKc/CQwEIwhFp8grPcjl0RTBCAQVLdqzSb8GR4h9UP1hXlUrfmIkWi64ieC4WJKlkXLQ8pFgRJA/20o7SwNxxRAGef/ZZ9tq5uCwKrucVcY1VFQSYh1LpfNALGrQ7Q0hzKc/98WaKapPPTCK466bEKqoqNDjqXSD4zj8+9//xkcffYSSkhI4HA488MADePnll1FWVpb0cffccw/cbrf8VV9fP3qLHgXUJMKxsFix3aK41wM7wEURGAwZw01hNr7SZEoAKI67OBjJ3cpH9KgYY7ijz9HnDyPMh7Fh2wZs2LYBYZ7+RmqIbynhUthSAgDcRcYasxHfqFNp2JWFxoIRAd5Q+ua0XWMsNFbutMEcra7tVhA+ZI5QuqHc8bDCB6N07s+70NjatWvBcVzKr82bN0MURVx33XWorq7GW2+9hQ8//BAXXXQRLrzwQrS0tCR9/ttvvx19fX3yV1NT0yi+uuyjpmuo2rAYADisZtgs0mFllLCSlhwhs4lDsZ0Gr+pBrHFf5rPA4hOmQ3wIX//b1/H1v32dRmyoJD5RWk1jROM5QuobdTptFjlpX0nC9FhLljaZONk1U7Jh7mJdpdUkS0c3mkZxdvMusL5mzRpcccUVKe/T0NCA1157DS+88AJ6enpQWloKAHj44Yfx73//G08++SR+8IMfJHys3W6H3V64B7wqR0jjCaDUYUXnYBD9/jDGlxWpX6TO9KqcPM8ocVgwGIwYJqEvX+lX2a8mFdRLSB/YMa0mLAbE8uz6DFIVGp+Ir4bKYht83X50DoYwqdKV8r5jLTQGSNeJ9oGgwsiB+vfHaH2E8k4IeTweRflIPp8PAGAyDTW9TCYTBGHs5nyocYS6BtUrfUC64DEhZAS0OEKAJOha+gJ54QgdaB9EtzeEJZONFaIG9OkqzTByd2lRFPHm/k5M8bhQX+HM9XJSovVvYjhHSGMifqXLjqZuv0JnXF3lbCEgF9VkyTGjqrFRYtmyZSgvL8dVV12F7du3Y9++ffjud7+LxsZGXHDBBbleXs6ojnOE0iUKdmjcCcmJcAYREH1yjpA6QZcvJfQfNnbjvP99E5f/+j38ZdPRXC9nBGob3qXCbcCGfowH/rMfVz3xIc795Zs42DGY6+WkRG1XaYbhcoQ0CjqlG0JRFOXqsrGSIwQojxxEeAHdPg2OUCFWjRkRj8eDl19+GYODgzjrrLOwaNEivP322/jb3/6G+fPn53p5OYMdrMGIIE+fTobm0JjBwheaHaE8KaF/6PUDcufm//f6QcM1G2SiRa0QTYRRHSFvMILH3zoEQBph89u3GnO8otTEJxmrQRaihnGEtAk6Nhw0Xa+c/oD6ytlCQKkQ6vaFIIoAx6kbP2K0hoqqjp7Jkydraoh200034cYbb1T9uExZtGgR/vWvf4367zUyRTYziu1S7kvnQDDliVBtM0VGqYHGU4iiGOcIqc8RAozxOpIxGIzgvYOd8v+Pdvuwq6Ufc+rcOVzVUPR0hOTyeYOcQBnvHewaUoH02p42iOLcjBpIZhN2AVLTVRqI6yPkD0EUxZy/Pq2OkNxYdjCQ8n5sM6imcrYQUOqYMSFZEVdppgSjhcZUCaENGzZo+iUNDQ2aHkdkh6oSOwaDEXQMBDGlqjjp/eQ5YyoHDZbIPSJyf7EaDEbAR/sZackRAowT4kvEtqO9CPMixpcVYWp1Md7c14EtR3qMKYSKMneEmKtkNEfo/UNdAICLTx6PFz9uQVt/EI2d3pSfr1yipas0EBNCYV6EL8TDZc9tmqnWHCG2uUvnCMmbwTEUFgOUO0KsYkxz+oQ/DEEQVVUuZgNVR/Hy5cuztQ4iDZydw+ynZgOBILgrM8uP8BTb0NjplashkqE1SVC2PQ2g9tlF2G4xqd7R5UOO0PZjvQCAkyaWYUZ1Cd7c14GPjvbiymW5XVc8sdCYvsnSdosdT136FADkfMTGzmap8eqyKZU41OHFtqZe7GzuN6wQ0hoaK7KaYTObEOIF9PrDuRdCcrNOdetQ7HiMwYoxIN4xS/f+sGuE2oIa6bgTRMAbiqh2JvWmYHOECg2TxYTqy6pRfXEFTMis6i2m9tPYwhpbyxupa6jW/CAgP3KE9rYOAADm1rkxc1wJABguUVdr+4JExJfPW0wWXDbnMlw257Kcj9g4EH3Pp9eUYE6d1K6DiSMjEguNqXvfOI6Tm+H1GmDMhlZHSOkYiU6NlbP5jlJHSEvpPDC035wRHPeCzhEiEqOkNNIf4uWcB/Xl88YREFrzg4D40FjuBV0yjnR5AQCTPS5MrZL6oRzq8BoifwMAAmEeweiIknKVIdZEGDFZus8Xli8YU6tcmF4tuUCHO725XFZKBjKY/1ZWZEXHQNAQzfDk6jetVWNpLvTs71pd4tCwuvyFOUIDgQgCYT6pm55Js0kj9ZujHKE8QYgI6PxrJxAIwgNTRq5QVXH6+Dg7wG0WE0pU2t9GSpbOxBHKh9DY4S6pX1aDx4mJlU6YOMj5X9WluT95MzfIYuLgsmWebBovhMJ8GM/veR4A8IVZX8iZK3SgQ3Llat0OlDiscoO+I92+nKxHCf0aBQQQ10vIAJ8LreNbWM6PN8TDF4rAmWTMCBNCVWOohxAgvZ8sBNo5GMSE8sR9sToycMxYvzkjbGooRyhPEIMidl2+CwBwOmwAUoe1UqHEFo6fH6PWWTBS19BYWEbLB9U4zlYien0h+SQyscIJu8WM+gonjnT5cKBj0BhCKC4/SA+HigkhXhDR7fPh8mcuBwAM3j4Ii4qZWXpyoF0Ki02LOkGsmWJTt88wztxwtHZkBuJ6CRnAEdJaNSZVgZkQCAvoHAhhYmUSITTIHKGxJYQ4jkNViR3He/3oGEghhDJwzIzUJZ5yhPIFE+Be7ob7UyVAhjlCShIF2zWWzgPxOUK5FxC6OEIGEHSJYG5QTald3tFOjSbnHuowRlimx6tffhAAOKwm2MzSacsoYx4ORt9r9t5PKC8CF3XmlAytzAVac2uAeEcot69NFMW4PkLqXgfHcYpSBNqjeZRjzRECYq5ZqqKaTBwzI1XlZiSEwuEwmpqasHfvXnR3d+u1JiIB5iIzFmxcgAUvnwAzMjsBKUmEax/QvhNyG6lqLIOKJbZbNqojxPKD4mclTfZI3xslP6VPx2aKgHQBKzVYntDxHj+AmBPksJoxLurGHTVoeExrbg0QN28sx46QL8TLrTHUJn0DcbmSKc6DYzU0BmT/OmGkz7FqITQ4OIhf//rXWLFiBdxuNxoaGjB79mxUVVVh0qRJWL16NTZt2pSNtRI6IffQGEw+ZqOjX9oJaTrA46rGct3luD8jR0h6zGAwkvPXkYgjUUdoUtxcq7po0mFLv/bQqZ6w8Em5DqXzDCMJbQBo6ZOEUK07Fh5gosiIQijMC/BFCyG0CAijzBtjf3+LiUORhmaHVSWpnXFBEGU3hITQSMK8IDueGW2Y800IPfDAA2hoaMBjjz2Gs846C8899xy2bduGvXv34r333sNdd92FSCSCc845BytXrsT+/fuztW4iA5jlGebFpGq8PYPYLxMQUo8IPs29s0smXY2ZoOMFUb5wGInWqNipi6u4YBfj1j6DCCG/9hytZDBRO2CA0CsAtETf63ghNDEuT8hoxDucWoSQ28nmjeU2NCb3ECrSln+WzhHq8YVkx2ms9REC0qdQsNstJg7lGhxfI1XlqvoUvPvuu3j99ddx4oknJvz5kiVLcPXVV+ORRx7BE088gTfeeAPTp0/XZaFjHd7L4/2G9wFRxFI4YM4gWdpuMcNdZEWfXyr7TRS2kIVQqfoTgMNqgtXMIcyL6PeHUZzDpmuZ9LBxWE2wmDhEBBH9gdw3jxtOO3Pt4v5G44wmhHQcr8EwUnfpCC+gLYEgZaGxtv7007tHG1Y677KZYTGrz45goTGjOEJaEr6B9I4QOwdWuGywanif8p10jlB7f6x0XktnaCOFxlQdQU8//bSi+zkcDlx33XWaFkQkJ9yp3wHjKbZJQmgwiOk1JSN+zpIEtVieHMeh1GFFlzeE/kAYdchdj4hMkqU5jkOJw4IeXxgDgQhqjTO1AkDsIlsT59oxV6KtP2CI1vVyjpBOydKAscq32weCEERpVxzvGjBx2p6maWkuiHdStBCbN5ZjIeTXnvANAFVyMnDiC72cHzQG3SAgfXfpTDbLQHzVWO6dXV22uL29vfjXv/6F48ePg+M41NbW4txzz0V5ebkeT09kgaoSOw52eJOqfXaR1dpIrLRIEkK5TjTORAgBUphPEkK5v+gOh11ka+LK5KuK7TBxQEQQ0ekN6toI7t2Dnbjjr59ganUx7rtsvqL3lFWN6ekIVUQdoX6fiPUXrQcA2MzJrfnmXj++/Yet8Ici+N8rFmBWbalua2FhsZpSx5Chk2wD0Z6mYV8uYE6KlrAYEJsZZxxHSNuxlS401pHhhT7f8aRxzDoySJQGjBUay9jve/zxx7FkyRK8//77EAQBPM/j/fffx9KlS/H444/rsUYiC8TivyPj/Lwgomsws5NAqUGaEcY6S2vLUYmV0Od+1xIPL4gJT9QWs0kWP3qGx4IRHjf+aRsOdXrx711t+MUrexU9juWRuHWqGgOAimIWGhOx6qRVWHXSKljNyS+Gd/7tE2xv6sW+tkHc8tR2XRPfEyVKA0BV9G/QbuDQmFYBYRxHiDlbmYbGEuc6tZMjBCBFaCzD1gKlBkqWztgR+vnPf46tW7eiuHjocMH//u//xsKFC/GNb3wj019BZIFU8d+uQcnu5zigUuNYBCM0VQzzAgaD0slSqyPELha5draG0+WV/kamBH+jGrcDrf0BtPQFMG+CPr/vP7vah+wMn9p8DN8/74SkHXkZ2agaY46Qkh49Td0+/Gd3u/z/3S39+PhYH+bXl+myFiY2a4eNCKiOa1pqtKaKmYbG2Kwxf5hPOX4h22htpshQ6giNxYoxIPa6fSEe3mBkRI6kLBQ1us4lBjq3ZuwIcRyHwcGRQx4HBwcN9eEnhpKqIoAd4JUuu6ZkSsAYTRXjdxpaEyqNOmYjPlFx+N+otlR/R+j1vZKY+OYZUzCxwgl/mMfGvR1pHycnS+tYNVbhYrkdPry470W8uO9FRITEx9kru9oASFPhLzixFgDw2p72hPfVQrLwALuIhCKCIXIg4sk0NFZit8hhwFx+LjJpCgnEQj/+sHShHw7LjRmrQshlt8htCRJeJ/ozDY0Zpw1Gxo7Qfffdh+XLl2Pu3LkYP348AODYsWPYuXMn7r///owXSGSHVI5QJonSDCPYniyZtsRu0SzojLRriactQcUYg92WqnO4Wt4/1AUA+NQ0D0IRARvePYz3D3Xh/Ki4SIQoirJro+f0biaEurxeXPinCwEkH7Hx3kFp3StmVqHEYcWLO1rwQWOXbmvpSDJ00mGNVWa2DwRkF8UIZDJnDIhOoC+yotsbQq8/nLNRLrKzpVHQuWxmOG1m+EI82voDmFI1NKrBqjLHqhACpNd+tNuHjoHgkMatANCRYWgsvk9brgs7MhZCF154Ic477zx8+OGHaG5uhiiKGD9+PJYsWQKzOTeWKZGelEKoP/MkQSMkwsmJ0hlchErk7tK537XEk6rPU6Urde6DWvoDYRyLdk+eP6EM3mAEG949jA8bU3eTHwhGEOKlcTAVOkyeZ7Dn6vWFU3ravCDKomfZ1ErYLdL5aOfxft3CVew9TiT0qkvsUSGUuDIzV8SqrbSf/suYEMphwvRAMDNHiOM41LodONjhRWvfSCEU6w+V28nouSReCA0n02Rpdm4VRWAwFNEszPVA9Sch0QnEbDZj2bJlui2KyD5VCkJjmTlCuQ+N9WXQQ4hh1DEbzGnxJLgAV6YpC1bLvtbYdHW304rFkysAAHtaB9DrCyVNRO+KigRpwKV+myImhAaCEaTqzLC7pR8DgQhK7BbMri2Vy9wHghG09AWG9P3RSmeKhNrqUjv2tw8aroQ+FhrT/rlwy92lc9dUMeYIaX8dte4iHOzwonlYGFkQxFj+lzs3jpcR8CQ5lwiCGBtIq9ERdFjNsFlM0fBxOKdCSHW8oLi4GKeddhpuvPFGPPnkk/jkk08gCJkNASVGH+YIdXlDEIShVTQs7FKTgeVthIGlsYqxDISQPIHeWI4QExnlCZwWdvLq0kkI7Y4KoRPGlUSf344pVZJNvvVoT4o1RnPNdAyLAdKFz6zARt9xvA8AcNLEMljMJtgsJnkW2762AV3W0uVNHBoDYs5cl07OnF7oISDkpoqGyBHS7mwxkdPS6x9ye5c3hBAvgONiTUrHIskiB52DQYR5ESYuww2zAXJJAQ1C6N5778WsWbPw1ltvYfXq1Zg/fz5KSkqwbNkyrFmzBuvXr8f27duzsVZCR9iumhdE9Azb1R2PnhTGZ7BjNkJojO1WM0nUNWr5PPubJarqYxflLp0mn+9t7QcAzBwX679z4nipu+TuluSCQg4b6RgWAwCTiVNUhbanRVp3fN+gGVExp4cQEgRRFjmekpGvkX3Ghn++cs2ADgJC7u6dw9BYplVjQKzab7gj1Bw9B1aX2MdkV2lGVbEkAoc3VTwWfX9qSh0ZvT+lBkk9UP1JiO8YHQwGUVRUhJtvvhnd3d3YvHkznnjiCQSDQfC88WYzETGsZhMqXDZ0e0NoHwiiMm5Hy/JBxpdnIISKch9S6s2w8ywQnyxtMEcoKnISzfhhf0u9nIh9rVJVKHOEpO9L8Tc0Y1dUbCReI3OE9E82rXDZ0D6yWHUIzMmaGZefM6O6BC+iBfva0jxYAX3+MCJRN5W5P/GUy2X+xjp2Mk2WBmLh5lzOG5NfRwaf7zrmCPUNdYRi/aHGbn4QkNwROt6T+WYZAErkNiu53WhmlCxtt0tv0uWXX4558+YBAHiex86dOzNfGZF1xpcVodsbwrEev7xrFkVRPsgnlDtTPTwl8RPoc4UePWxKDJoj1JOiGovdNhiM6NLnhU1QZ2ElAJhVK4mLPamE0GDyPKZMSSQ84hFFEXtZSK82JoSm10gJsQfSqSgFsLyJUocFNsvIXXGFSzruenRy5vSCfSa1ls8DuZ9AL4qiro5QS+9wR4jNjxu7YTEgJoTYgGeGHDXIYLMM5LEjlA6z2SyLIkI/OBuH6Q9NB4JBcLfqc9BMrHBix/E++UIHSEm4/rDk5mVyEig1gNJnoTEtk5EZRi2f707hCJXYLXISYudgMCNBG4zwaIsm+8af9GZHhXNjpzep2JJzhNKIFi1Ul9rBwYIvTV+L06Z5RozYaO0PoM8fhtnEYVp1rBqoPvpeHB+WE6IFuXQ+SY4Ey9/qNmxoLH9zhPxhXnbjMgnxMUeoOYkjVDfGHaGJFdLn5WiXb8jtejlCRtgwAzo0VCRGB5PVhPHXj8f4b9XABH3CjvXRg7wpTgixsFh1iV0uN9ZC/AGeyUiDXc39uPWp7fjH9mbVj+1hVWOZJEsbIOk7EXJ/ngQig+M4eFivnQzDYy29AYgi4LCahuT6VJXYUemyQRAhOy/D6cxCDyFGdYkkhOa4L8P1S64fMWJjT3RNUzyuIccxE3MdA0EEwpl9jmKOV2IhxDpgG8kREgRRqrZDhsnSGnOERFHE798/gu89s33IeUctLLnWbOLkpn9aYJWDA4HIkNfCzoPDO4aPNZgQ6g9EhlQINuvkCBnFcVcthFavXo1HH30UmzdvRjAo7Yiog3R+MqkyqvbjTkhspzwhU8szukuLCKLsMKmlzxfG1x7/AM9uPYYb/vQR3j3QqerxejpCrOmXEfCHePk9LXclvpjJeULezCrHjsWFSeM/5xzHyeHU3UnCY7GqsSw4QtH+SW1JZnntiSZxzxw3tH9PudMKh1U67WXaeZsdXxVJjq9yAyZLD4YiYPuSTEJjcvm8yhyhZ7Ycwx3Pf4KnNh/DqvUfIsxrqzhmGxN3kTWj64/LbkFNtF9aY5dXvr2xU/p+ske7m1oIFNnMclXYka6R14lMW1AYYRQToEEI7d27F9///vexZMkSlJRIJ5l169bhoYcewrvvvgufT7vKJ5Ij8iJ6Nvag581+iDoZebLtGSeE2C5tfAbhFAAospphiZY4ax3O+MzWY0Mqnx5546CqxzPbXo8cIdb0ywiwUIvVzKHYnvhiVqGTI3SsRzoeEgljlieUTAjFxoBkwREqtUMEj08638XGwxvBC0PFNqt0Gz5pnuM42c7PNDzWm6ZPVaxqLGwYEc123jaLKaPcMTk0psIREkVxyGf4YIcXr+5u0/T7Y/lBmWd3NEQ7Jjd2SnljgiDicFQUTfEUJ33cWIFtmI9Erw2CIMqiiF1DtFJiz1NH6M0330RfXx/27t2L3/3ud7jtttvQ09ODO++8E5/61KfgdrsxZ86cbKx1TCMEBGw/czu2n78XAvS5sMQLIXaiZkmkU+ISY7XAcVxcDx5tB/nLn7QAAK751GQAwNsHOhUN2mSwkITWyfNAtOlXtDw01x9WBntdFS5b0t1wuU7JrDFHaKQQOiFaTr8nQWhMFEW5M2828iyqSuwQEcbr3Wtw5pNnIhAZ6u7sGdb7KB4m8lmeg1bS9alit/OCaJhjR48EY0BbaGxf2yAOdXjhsJrw5VMmAgBe3NGq6fdnOmcsHtYTq7FDEj8t/QEEwgKsZi5jZ7wQmFghvT9Ho+LweK8f/jAPq5nDpAyFkFEcIc1yevr06Zg+fTquuOIK+bbGxkZs3rwZH330kS6LI+LgAOdsJyAIwB59dpe1bgesZg6hiIDmPj8mlDuxLyqEhocUtFDqsKDbG9KUCBcI89jeJDXE++rSSXhjXwf2tw/iw8ZurJw7Lu3jI7wgJ2pnOvm8xGFBlzcUTTLN/YkxVek8g12oMi1vjjlCI0947BjZ2zYwouN8vz8ih++y0ZAuVbPPUETAwY7kxzFzhI5l6gilac9gt5hRbLdgMBhBty9kiHljejkpzBEaCEYQ5gVFvWTePSiFthc3VODzJ43HHz84ivcOdmoad6JHU0gGq4Y8FA2HHYoeOxMrnJpnFBYSzBE6HHWBYpvl4ozfn7zMETp69GjKn0+ePBmXXXYZ7r77bgDA8ePHta+MGILZacaSnUuwZPOJMEOfjsEWswnTq6ULxc7mfgiCiP3RRnMzdJiNlIna/+R4H0K8AE+xHZMqnThlijTWQenAzPhwXCYjNgBk7GzpjZKO2exnPRk6QiwHZ1wC4TGtuhgmTnKd2of1GWnpl0SGlJOj/8zBVN1sD3UOIsyLKLFbEla1sF1+th2h+J8ZJU+IHcMlOn0mAOUVP+9GB+CeOtWD+fVuOKwmdA6G5HwcNejRVZoxORr+YuuI5QdRWAyAXHW5Jxpu3t8uXSOm1WT+/uRl1djixYuxevVqfPjhh0nv09fXh8ceewxz587Fc889l/ECiewyp04Kb+w83ofjvX74QjxsZhMaKjNPEsykffqmw9LohkWTysFxHE6ZXAkA+OBQ6kGfDCYAShzaJ88z5O7SOf6wMgYUzIpiblGms6DkeUIJhIfDakZDdDc9vHKMJSKPy1L5cbHdkrRaiK1l5riShE4DE3WZzgCTh/qmEBVynpBBKsdkAZGhI2Q2cfJzKCmhFwQRHxxiQkgagMtCq6maciZDrxAfAEyNhsYOdgwiwgvYH222yW4f67Au8ntbBxAI8/L7M706cyGUl47Q7t274Xa7sXLlStTU1OCCCy7A6tWrccMNN+CrX/0qTj75ZFRXV2PDhg249957ccMNN2Rr3fjpT3+KU089FU6nE2VlZQnvc/ToUXz2s5+Fy+WCx+PBjTfeiFDIGCckozA3epDvbO6XLyBTqly6WMJst6bFEdpxvBcAcPKkMgCSnQ5IuxJ/KH0VWp8/84oxhlE+rAx5V5/iYqZXwzvWUbYqiQPDcnCSCaFsDazkOE6u9hkOG/sR30gxnuro49qTVJwpRclQX/YzrQUDetOvQ7d1hlvFMdbU40N/IAKbxSRvvmJNOdWPO9GjqzSjodIFl82MQFjAgY5BfBydUTcnem4c60woL0K504owLzUp3RuNGrBoQiYYJUdI1dWuoqIC9913H5qbm/HII49gxowZ6OzsxP79+wEAX/nKV7Blyxa88847OO+887KyYEYoFMJll12Gb3/72wl/zvM8LrjgAni9Xrz99tv485//jGeffRa33nprVteVLXgfjw/nfIgPF+0AD/3KkdlJacfxPmyJDtCcU6fPCSAT25PtOliIrqY01reGWbOp6PFmXjHGKLEba8yG3BAvxW6Y5QhlEhoLRnj5Ap5MCM2sSZww3SI7QtnrzJusmVui2WjxyGMDMhxKK4fGUsyyM4r1z4iN18g8pMRed5+CPDRWWTijJpZXEku2z8QRyvx1mEycvCF890AXdjdL65k/gYQQIG065k0oAwC8f6gLu6Lvz0kTyzJ+7pjbnocjNhwOB84++2xcfPHFeq9HMevWrQMAbNiwIeHPX3nlFezatQtNTU2oq6sDANx///1YtWoVfvrTn6K0NPFJ0rCIgG8XK3PXr2/T7LpS2CwmtA8E8cTbjQCAZVMrdXnuUo274QgvyOWrLD7NcRxmjivBuwe7sKd1QP5gJoPlZGRSMcYw2uBVJY5QrGpMuwPKhqZazVxS1yOWMD30YiaHxlIkNWfKhIoiIEGfTSbKZiVJ+Gc9iLq9IYQiQsLxGEpgieipHKHYZ8Aox45+ISU1ruOuFvY3iZ13mZuYanBvMvSsGgOkvKUPGrvxPy/vQYgXUOd2ZFwaXkjMry/DG/s68It/70NEEDG+rCjjrtJA7O8X4gVdxgFpRXP8o7y8HM8++6yea9GV9957D3PnzpVFEACce+65CAaD2LJlS9LHBYNB9Pf3D/kqZJw2C06f5gEABCMCLCYOy2dU6fLcpRrV/pFuH8K8iCKreUjptbyDVHDi1GPOGMMo9i1DUWisiOUIaV+zHBYrtiet6mEXs/1tg+DjeuUc65VEe7ZCYwDQUFGKsvDXcVrVd+TO0j3ekOxGzUgihMqKrHKPK60NJ4MRHoGw1AwwVTWY8UJj+oWU3Cp6CTEXIb6v0wnR74/3+lV/tvSsGgOAT8+qBiCdA6X/11Cj4Dg+M7sGQOz9OXdO+spdJRTbLGBvcy7Pr5qFkCiKeOSRR3DKKadg6dKlWLNmDT744AM915YRra2tqKmpGXJbeXk5bDYbWluT966455574Ha75a/6+vpsLzXnrD5jinwwXnzy+KRhELVoFRCsPHNqtQsmU+xkxHI+lFjp2XCEjJMjlD5Zuizacdof5jWPkkiXHwRIJcYOqwnBSMzFA4CD7dL3U3VIqEzGFE8Z3JFLUIXL5FljO6MX3IZKZ9KLpMnEya9Ja54QEzYcF2sKl4hM8uSyQb987OgQGpO7S6d/bcwxjBdC7iKrPLZl+CyrdOhZNQZIuZKnTZOccJvFhFWnNejyvIXCnLpSLJsivT92iwlfXTpRl+c1mWJNYXN5fs0oI3b79u1YsmQJVqxYgb1792L58uW4+eabNT/f2rVrwXFcyq/Nmzcrfr5Eij5dz4rbb78dfX198ldTU5Om15JPLJ1SiT9esxRrPzsbP75orm7P69YohFgPmGlVQy+izH3Y15Z+cnivgtJmpRht8Gq/AkeoxG6BOSoitbpCSoSQycTJeVwsYXowGJGnVU/NYglyoll5nzRHE13T5LmxKrjhZf9KiU+UjhfrwzGaIzQQ0M9JkXOE0oRfA2Febsw5bZgwnphgzI8S9KwaYzzy1YX44fkn4OlvLcPUKiqdj4fjOPz2qkX474vm4I+rl2KKju/Ptcun4rbPzND1b6mWjOT0H//4R5xzzjny/3fs2IHPf/7zmDBhgqak5DVr1gxp0JiIhoYGRc81bty4EQ5VT08PwuHwCKcoHrvdDrtd/9lIRmfZ1ErdcoMYWsvn2e6wYVh3a9b4rHMwiIFAOKUjosecMUbMETLWxSzV6+c4DmVFVnR5Q+j1hzQlLSsRQoA0if7jY33YcbwP559YKzek8xTbs9pEcHy5HUFuH457gX7/GSgtsuMTueIndQ6gnDCtVQgpKJ0HjJgsrZ+TotQRaur2QRSllgfDx61MqnDio6O9Q+ZYKUHPqjFGqcOKb54xVbfnKzRcdgu+tqxB9+e9/sxpuj+nWjQ7QpWVlSPCRieeeCIefPBBPProo5qe0+Px4IQTTkj55XAoO6EvW7YMn3zyCVpaWuTbXnnlFdjtdixcuFDT+gh1aA0LNEW7GdcP62Zc4rDKk74Pd6Y+cbKqMT0coVKDOUIDCsMbcjM/r0ZHaFBydarSDE09eWI5AGDLEanqkDl62e7DYrPwaHXcglbHLdjVKnUtZkJobhpHqKoks15C6eaMMYzmCDFBlkpEK0VpjhBrUNjgcY5w4ydG53wd7VbeVFEUxaw4QsTYRbMQmj9/Ph5//PERt0+bNm1UwklHjx7Ftm3bcPToUfA8j23btmHbtm0YHJROwp/5zGcwe/ZsfO1rX8NHH32EV199FbfddhtWr16dfxVjeYrW3XCq+VZsGvShztThsR4dHaFSwzVUVFYCnWlTRaWO0MIGSQhtb+pFmBdGJT9oOHtaBtDaF8DhLh9MHDA/TVVhVdSZyLYjJIeHDXfs6FE1xsrnU782ljvGhpvGw2ZVqXGE/GEekWhivl45QsTYRvNR9JOf/ARnnnkmjh8/juuuuw7z5s2D3+/H3XffjcmTJ+u5xoTceeedePLJJ+X/L1iwAADw+uuvY8WKFTCbzXjxxRdx3XXX4bTTTkNRURG+/OUv47777sv62giJWLJ0RPE8IV4Q0RydATUhQfnqZI8Lmw73pHWEuuMGk2aKkXKERFHEYDB9aAxQl8yaCKVCaIrHhTKnFb2+MHY298sN6WbqMKZFKTtb+lBil1yhE8e704bkYpPhtYnEXqWhsbjPQK4RRTErobF0Qqgx+lmdnGCQszzZXIUQYqF2i4lL2l2cINSg+dOwdOlSvP/++/jOd76DFStWQBQlhe5wOPD000/rtsBkbNiwIWkPIcbEiRPxwgsvZH0tRGLYrpMXRPhCPFwpqmsY7QMBhHkRFhOXsAdNbC5QckdIEER5MKknTVhHCUbKEfKFeLlMPX1oLLOLPWs4mE4IcRyHxQ0V+PeuNry2px0fRUNki6JO0Wiw+XAPeF5a56nRdhCpqIgeF90aR18omTMGxITSYDCCCC/kdIhnICwgzLNjR49kaWW9qg53JneEWMJ7S59f8fsT30OIStwJPchoWzB//nxs3LgR7e3t2LJlCwRBwCmnnAKPJ/2JiCh8HFYTrGYOYV7aiSoRQk3dkhtUV1YkVz3Fw0JjqQY19vnDsljQxxGS1u2NipBE6xotmCtlVrAbLlPR52U4oijG9RFKn5d3zuwa/HtXGx58VeoyX+60yn2fRoODHV40dkhDnk9XIoSYSNSYP9WvOFk6dswPBCIo1+F41AoTECYOcNkyd1LccY6QIIhJq+fk0FgCR8hTbIfFxCEiiOgYDKJWwWw6PbtKEwSQYfk8o7q6Gueddx4uuOACEkGEDMdxsiukNFn0WDRROlF+EDB0UjRzIYfDmuS5i6yauwbHE797HsxxiCM+UTrdbphddLXkCHlDsYaBlcXpL97nzR03pJ/OZ+fX5UQw1lcUYemU9NWPTCB3aXSE2HuaarwGAFjMJll05DphOn7OmB5OChOBgggMBBN/LvwhXm5wmSg0ZjZxqIk6v+x+6dC7qzRB5M6nJcYEco6EwhJ6lh9Ul6R9O8sp6A9EkoY1Ogak25VcwJVgs5jgsJqivzfHFzMFPYQYctWYBkeITUu3WUxwKnAPShxWrP3cHJhNHKZWuXDDWdNV/85MKCuyotRhwT1fmJeyrw8jPkcomaBOhdJk6fj75FoIqVmzEuwWs3xs9CU5xo5Eq8FKHZakXd5Z9/GWXoVCSOeu0gShylucPHmypp3ETTfdhBtvvFH144gYnJXDpLsmAaEwuHtyn3ipFLUVV23RTr/JZlQ5rGaMLyvC8V4/Gju9qEyQA8QcIT3ygxglDisC4WDOhZDsCNlVXIA1CCEWTitT4R5csnACPjOnBk6bZVTcIKvZiruW3wUAuHXZObCabIpnFZW7Yvlr/f6I6n5HvX7lrkRpkRXNfYGcHzt6CyFAOj58IR69/hAmYmRxA8sPmuxxJT2OWI+rlj6/ot+pd1dpglB1JKVLTk6G0iaIRHJMNhMmr50MeL1APgkhld2lWUfimhQNABs8TlkILWqoGPHzrkGWKK1fPkaJw4KOgWDOK8eUzBljxKaDaxBCfm3tB/RIwlWKzWzD2hVrNT3WbjGj2G7BYDCCbl9ItRBSmiwNaB8+rDdZEUJOG5r7AklDjKxiLFF+EIO5v4pDY9RDiNAZVUJo+fLl2VoHUaCUquyj0taffmp5Q6UL7xzoSlpy2xmtdqp06esIAbkvoVfSVZqRSUiGhdP0aEhpVMpdVkkIeYMJ81dS0aewoWL8fdR2WNebviwIiOpSO3a1AB1JZralqhhjsM96q+IcIf27ShNjG8oRyhNEQYR3pxfeXX6IyJ+SUbmpokIBwU6G6YQQADTGDfmMp3NQ3xwhIBbiy3UJPfv9SipmYn2E1CcE6zmiJFsIooCd7Tuxs30nBFFQ/XhWOdatsnJMFEV1jpDKgoFsoefkeUZsZltiEcM+o6mEJssRalYaGqOqMUJnKEcoTxD8AjbN3QQAOB12mKFtNMBoI4/ZUHARiPCC7ObUuJO7OcxmP5ykhL5rUP8cIaPMjFIzPZxd8AJhAYEwrzh/BoiVlbNcGiPiD/sx9xFpSPDg7YNw2dS5OnLCtMrKMV8o1tl4LCdLA0B1dFRJWzpHKJUQiobGlDtCVDVG6AvlCOURVo8VEEWgK9crUU7MEUp/EegYDEIQpZLaVGEt1kvoSJcvYcdqNlFc32Rp5gjlT2isxG6BiZPKm/v9YVVCiLlI7jTl4flMucYSepYobTObFHU2dqvMk8sW2RBCNaXJHSFvMCJ/FienCI0xR6itP6CoqSJVjRF6QzlCeYLZZcZpHadJydLF+eEGAerK59musrrEnrLqqL7CCRMndevtHAyN6HzMdpZ1ZeonridDFkJJ+qWMFmqSpU0mDqVF0uiLPn8Y1SnCjcNhVWPJSp4LgUqNYzZYfpDSfjzMFS1ER6gqhSPEmp6WO60pk9HVNlWkqjFCbyhHiMgqcvm8gt0wEzA1aS7YdotZrjQ5PCxPKMIL8u50XIrKM7VkUoquJ7GGisouZvKEcJUXYT2H1hoV2REaVOsIMbdM2YW4ONpoMtfNOJV2w1YDc4QSDa9lQmhKVerhu2qbKlLVGKE3JISIrKKmdFhJxRhDTpgelifEwmsWEwePjlVjbjbJXUPisZ6oaagIxMZsqBVwY6FqrELjLLZ+OVFamUhkonUwx25iVnKEop/V9oHAiMaUhzqiQkhBRd44FU0V+1WEhwlCCSSE8gTez+OjFR/ho5V7wCN/dulqcoRYDyElTk6DnCc0VAi1xLlKSjoMK4WFiLTM7dITNaExQHsPG7lqLIezsbINS5ZWO3i1V0XpPBD7W+XaEcpKaCyahxfmxREdzA9FByNPrlIghEpjeUKpEAQxNt6kgEU6MbpQkDVfEIC+N/qi/8kf/aompNSmMDQGxByhw51DewnJ5fc6hsWAWHPC3AshdaGxMtnJUiuEYp2lCxWtQkgunVcphHLdekHuI6Rjbo3NYkKFy4ZubwitfYEhQ45jjlDq0Bgg9SMCgLYkZfiMgWAE0YI9EkKEbpAQIrIKO1n1ByJpK0La5Nye9CEt1pdkeGisJVtCKIOePHrCHCGlPVTcGhJ1eUGUHTyl4Z9cYDVbcduy2+Tv1VKusXw+JiiU/U6WI5TLRPtQRIA/zAPQ1xECgPryInR7Q2jq8WF2XSkAqdfSoQ7JEZqqxhFKkyPE3CCnzQy7RXkVJEGkgoQQkVXid819/nDC2WAMOVm6REloTDq5HunyDimhb402ZatVUSGlBDnpOIeOkCiKcp6JYkeIjdlQkQfT5w9DzINdt81sw72fuVfz41ki+EAwgjAvwJqmbJvRq6KZIgAUs9BYMAJBEHUN2SolPjStd25NfYUT24/1oak75s62DwThDfEwccDEypEzyIZTU5q8+iyenjHgVBKjT/7EWIi8xGI2yaGBdFPQ2Ukw1ZwxRn25ExYTB2+IH1JpcqwnKoSSTK/XCrvoBSNSc8Jc4Avx4KNxAaU5Qlqa+bHk4RK7RbE4yEfcRVaw6nc1Aldtrg3LkxNFwJejY4etucSh/0DciRWS0DkaJ4RYWKy+wqnIuZFDY2lyhHrk/CDjOpVE/lG4ZznCMLCdd28KV2IwGJHdDiVVYzaLCVOilvve1gH5djWVKmootltgiV5A1FQZdQ0G0Z7m5K4UFhYzmzg4bcrCAlrK5+VkYAO7QYA0YuNw72Ec7j2sacSG2cTJIiXVsTkcNXPGAMBuMcnHjl4J0y19fnVrzkKiNKM+KoTiHSGWKK30c6g0WZq990bueE7kHySEiKzDKq5SOUIsLFZit8BlV+Z2zBwn5SPsiQohXhDl2UZTFOQlqIHjuFiekEL34I19HVj2s9fwqZ+/jjf2dWS8BpZsW2y3KB51w8SMGkcoH+aMAdKIjcn/OxmT/3cy/GFlc6qGo+TYHI6aOWOAdOzomTD9zJZjOPVnr+H0n7+OT473pX8AsiuEEjlC+6KfyalpeggxWGjMG+JTthkgR4jIBiSEiKxTrqCDL3NNmEWuhBPGlQAA9rT2AwCae/0IRQTYzCZMKE+fl6AWNXlCgiDiv57/BKGIgFBEwI//sXNEnxW1xKZuK0/t0xYaK/weQowyBW7lcGINFZW/P8U6dSYPhHn89wu7IIqSQ/jfL+xS9LhsNFNkMCHU1OOHEA3dftIsfSbnjncreg6X3YKS6AYo1cwxyhEisgEJISLrKAmNqekhxGBCiIXGDkSrVBo8Tt3zIIDYRbNPQeXY+41dONrtA1vGwQ4vdkYvDlqRS+ftyi8CTMyoaaiYL46QHmjpDxULjSl/f4qjf7NMQ2Mb97ajzx+Wj6sPGrtxtMuX+kGIq3TLQhPCWrcDVjOHUETA8V4/eEHELlkIlSp+HrYJShVKHkvHJjF6kBAisk6ZgvCDnCitotqLlerubx/EQCCsqm+JFspUOEKv72kHAFxy8gScO6cGgHQRywS1zRSBoY6QUkcqNl6j8HfdZSq7S/OCKLs6atwVvYb2vrGvEwCw6tTJWDqlInpb+uNKbV6TGixmE6ZVM3d2AIc6BuEP83DazJis4rPIPvutKYTQWHIridGDhBCRdZQ4QixJUo0QqnUXob6iCLwgYvORHuxukXah02uyJITki2Z6IfTOgS4AwBkzqrB0SiUAYOvR3ox+v5rJ8wx24YsIIrwhZRVLsWTpwt91KxHp8QwEYq0FVAkhNm8smFmO0KbD3QCApVMqcOpUDwDJFUpHj5xknJ2/6ayoO7uzuQ8fH5PylmbXlqpyZscpKKEnR4jIBiSEiKwjJ6R6UzlCyueMxbMsKjLeP9iFrUd6AAAnTyzXssy0KG2q6AtFsLdNCtctbqjAguh6tjX1ZvT7WWhMaTNFACiymmGLlsArzRMaC5PnGUpEejzsPXTazLBZlJ8+i3VwhAJhHgej4d+TJpZhyWTJEfqwsTut28ccr4osVVudNLEMALD5cA/ePShtAhY2qPscViuoHOslR4jIAiSEiKyjJPzQKjtC6galLpsqCaH/e/8IDnV6YTZx2RNCCseF7GzuBy+IqCm1Y5zbgRlRh6rbG1I9ziEeLaExjuPkDshKL/ZjYfI8I1Y1puy9UTtnjKFHaOxA+yBEUVpzVbEdJ9WXwWY2oX0gOKRiKxFd3uz+TU+ZLH0O3zvUhRc+bgYAnDG9StVzjFPQS4iqxohsQEIoT+AsHOquq0Pd6mpwyE1TNq3Edt3JBUS7hhwhAFgxoxo2iwm+aNhn2ZTKrPW/UVo+vz3q/MyfUAYAcNosGB9t8Mh29FpQO2eMUaayhD5f8jAsJguuW3Qdrlt0HSwmbU3y1YQ7Ae1l6HKydAZVYwfapWNnenUJOI6Dw2rGrGie3CfHUyfiszEiFVkKjc2oKcaUKhd4QUQwIqCqxI5Too6VUmpUOEJjwa0kRg8SQnmCyW7CjP83AzMemAQTcju8US1laXbdgiBqyhECpJyHr5/aAAAwccB1Z07VvtA0uBUm1m6P5kjMry+Tb5taLblCB9szEULqHSEgdtHuVyiE+vLEEbJb7Ph/F/w//L8L/h/sFnVOIkNraEy7I6T9s7svGm6dFpcDN2tYC4lkMCcyWzlCHMfh+hXT5P/feNa0lHMFE8E6yifLEQrzgiwkyREi9IRmjRFZh518e33hIXPBGN2+ECKCCI4DqkrUX9C+t/IEzK8vw6RKJ+bUKetbooVyhc7K/ugFa1ZtiXzbtKpivLmvQ97Va6FfQ7I0oK7aDcgfR0gP1CZLq50zxiiJmzemlf2yIxQTQqyFxO6WgYSPYTDxXpklIQQAlyycgKoSO6xmkxyyVgPbBLUPBBLOZGPHL8dlp/qNGLuQEMoTRFFEuDMMeMOwAhj9sY3aYQIixAvwhfgRnaNZA7VKl13TbCuzicP5J9ZmvtA0sAGmqRyhCC/IZfzTqmJCaGq11Olan9CYNkdISWgsEOblKeVG33WLoohOn1RO7nF6FHfbjoeJ9L4kIn04WhsTyhPoM8gRYsfOtDghNKuWdVdP7ggFwrwcOs6WI8Q4Y4a6vKB4qqIDmcO8iB5faMSAZubalTqsWekTRoxdKDSWJwg+Ae9Wv4t3J2+DAH0nq2ebImuswiaRiGgfYM0UtYU3Rgs236jHm7wnT1OPHyFegMNqwvjy2OBX1tvosILmd8nQGhorVTFvjO26pTlcxt4n+cI+VN9Xjer7quELa3tfh4v0dPRqTNZlLp5WISSKIo5HBwqzTs4AcEJ0zMyxHv+QCfPxsM+cxcTJZfxGxGYxwVMsva+Jegn1UH4QkSVICBFZh+O4lB18W/uiidIlxhZ4nugONcQLcphqOCwsNsVTPGTXypKlm3v9mkdtDASznywtV+UUWTU5LPlGOpE+HO3J0pmFxrq8IQQj0mDZ+O7rbqdVbjmxvy2x2xifH2T0v2l19BzQniBPiL0OozuVRP6Rt0Lopz/9KU499VQ4nU6UlZWN+Pn27dvxpS99CfX19SgqKsKsWbPwv//7v6O/UJ0wu8xYIa7AisHFMEOfaeajCUtKTVQ+LpfOqxivkQscVrO8o+4cTJzQycZ8DG/qWOO2g+OAYETQXELP3AS1To1bYdk/kD+T5/WC4zhVOVTsPqWjnCzd3Cu5QdUldtgt5iE/Y8fagfbEeULseKvIAwHBRF4iR4h95rTkERJEKvJWCIVCIVx22WX49re/nfDnW7ZsQVVVFX7/+99j586d+NGPfoTbb78dDz300CivlABiJ6+OgZECgs0WMrojBACe6OvoTPA6gFiJ87RhU7ftFrOcA9Hcq17IiqKoqbM0oM4RGoude8tVjNmQJ89rFEJaZ42xsFhdWdGIn02PjrfYl9YRMr64rUnRS4idOzzFJIQIfTFuwDgN69atAwBs2LAh4c+vvvrqIf+fMmUK3nvvPTz33HNYs2ZNtpdHDIOJgI4ETkps4KrxT3CeYhsaO73oHEx80ZSFUPXIMR+1ZUVoHwiiuc+PEyeoq27zh3nw0cne2UyWHot5GGoqxzINjXlD0t9RbbLv8agjFJ93xmCO0P4kFYnsWK10Gf/zVZNizAY5QkS2yFshpIW+vj5UVKRu8hUMBhEMxj6E/f2ZTQzXCz7AY8/X9gCRCE6AFeY86yVUVZrcEWInvWqVPYRyAbuYJAqNiaIYa3qXYN7Z+DIHtjfFwhxqYG6Q2cTBaTOnufdQ2JT0dKNBgLHZuVdNL6E+jeXzxXHidTAYUS2kmBCakMARYp3LD7QlDo2xYoR8EBCpmiqyc0c+vA4iv8jb0Jha3nvvPTz11FP41re+lfJ+99xzD9xut/xVX18/SitMAw90PNOBjud7AKi7EBoB5gi1JxRC2uaM5QJPiXTR7EoghJr7AvCFeFhMHCZVukb8vM4dS5hWC8stKbZbVCe8qskRYhf6seQIxVcDpkOrI2S3xJKytSRMs2MmUWiMtWlo7gskzEHq0Ni1PRekCo3JjlDx2BHpxOhgKCG0du1acByX8mvz5s2qn3fnzp246KKLcOedd+Kcc85Jed/bb78dfX198ldTU5PWl0PEEcsRGnqCC0Z4OYchH07UHjnEN9I9YG7QpEpnwn5IdXLlmPocoX6NpfNAXGfpQEQOryWjJ48qcywmC66afxWumn+V5hEbgLJZeAAQisRK7FlPKTWU2LUnTLNeW+MSFBS4nVZURz9fiRp2ss1HdR44KSkdIQqNEVnCUKGxNWvW4Iorrkh5n4aGBlXPuWvXLpx11llYvXo17rjjjrT3t9vtsNvpg6Y3yZKlW6KiwGE15YULwYRQotBY/CyoRIxzJz/Jp0NrojQw1L0YCIRTipx86iptt9ix4fMbMn4epR3D2c85TpsgLXFY0OUNaUqY7kgjZmbUlKB9IIj97YNYMGzoMAuNVascaJwLmBDqHAwhFBFkF00URXQOSEK1qtj4GyYivzCUEPJ4PPB4PLo9386dO3HWWWfhqquuwk9/+lPdnpdQj9wfZJgQOhathplQ7jR8jxMgnRCKzoJKkCgNxInBJKX3qdDaVRqQGtU5bWb4Qjx6famF0FisGlPqCPVFc6xK7JYR4x+UwPKEBlSGxkRRlI+ZZHl006qL8faBTrmPVTxyDl4eVGVWumxwWE0IhAW09PnlELM3FOt4zsLTBKEXhhJCajh69Ci6u7tx9OhR8DyPbdu2AQCmTZuG4uJi7Ny5E2eeeSY+85nP4JZbbkFraysAwGw2o6pKext4QhtMBAwEIgiEeTisUp7TsR6pI/CEBNUwRkTOYegb6eqwhnaJEqWB2G4+UcJ4OrT2EGKUFVnhC/FpXQ+ts7RygSiKckdpp1W7kC5XOIE+liit7UJcYtfWXbrXF0aYl0KaniT5MckqxwLh2N+8Jg8cIY7jMKHciQPtg2jqjgkh9plx2cxw2vL2skUYFEPlCKnhzjvvxIIFC3DXXXdhcHAQCxYswIIFC+QcoqeffhodHR34wx/+gNraWvlr8eLFOV752KTUYZFt7nghEHOE8kMIsQ7Rrf0BRHhBvl0URfkilMwRYm6SL8TDq9IViDlC2gRKqcIS+nxyhHxhH4rvKUbxPcWaR2wAMdGXrmpMa6I0o1hjLyHmopY5rSOaKTJm1Ejh2OHdpdlnzWYx5c2gUnYuaOqJ/U1ZjlQ+5BES+UfeCqENGzZAFMURXytWrAAgJV4n+vnhw4dzuu6xCsdxqI3myMRXTcUcIWfCxxkNT7EdNrMJgji0+23nYAh9/jA4DphalVgIuewWuKKl72pdIa1zxhhuBfPGRFGUOyfngyOkFyxHqCdNx+9M35sSecyGumTpdPlBQKyB5/Fe/xCRzURUVbE9L0LPAFAfPRc0dceEEDtPJOqjRBCZkrdCiMg/5BNcT7wQyi9HyGTiUFsmCbrjca9jfzQ/aGKFUw77JYKFCBO1EUhFpkJISXfpgWAEkWhVWT44QnrBQl39gcgQl2847L1TO16DERuzodYRiiY7p8jxKXfZZMcxvnKspU86RhNVmxmV+grmCCU6T+THhonIL0gIEaMGO8EdHbLTy78TnNwPqC92oj6YZLTGcFKNGklFf4ahsVgvoeSuR2+0j47Dakop5gqN+HEZqYRipl23izULIWVl49OrR+YJHemSPmuTKvLn88U2TMd6Ep0n8mPDROQXJISIUYOJnWNRIeQNRuTwUj6dqJk9P9QRigqhJInSDLarH95PKR2ZO0KS65H6Qp8/+UF6YjGb5Pc1VcI0yyHS0kMIiIlYtUJISWgMiHWY3h83fPVoVAhNrMyfz9eEFKExEkJENiAhRIwaEytYaEw6qTEL31NsR7krfy6+rDHi8bjGiHLFWJIeQgytJfSZJku7FUxYH6tCCIi95r4UY0gyzREqzjBHKJ0jNC1BwvSRbi8AqclnvjC5SqoU6xwMyc1W89E5JvIHEkLEqFEfFUIsNLYv2vNkepIqK6PC5j2xHasoitjdKs2km5HGEZJzhBIMlUyFXsnSihyhPJhSrjexhOn074/m8nlWNaayYpD93oo0m4VYaCzmCMmhsQQjX4xKsd0ih9H3tg4gwguyc0yOEJENqCFDvmAGqi6tAiIR4Hk+16vRRH30JNbWH0QgzMvhpHTiwWiw8NeeVumCc7Tbh15fGDazCTPHpXaE2MUsXfO+4WTaR0iREPKyHJj8cITMJjMunX2p/H0mKGmqmOkcNq3J0swVSeeashL6Yz1++EIRmDguL0PPADCzpgRN3X7sbe3HOLcDvCDCbjHJMwsJQk9ICOUJZocZc56eA3i9QHF+TZ5nVLhsKHNa0esL40D7oNwFd3pNavFgNE4YVwKOk7pLtw8EsP1YHwBgVm1J0j4vDCaEutKUag9Hr9CYEkconfNgFBwWB56+7GldnqvcqTx0qNURKo42VFTbR4iV9Vek+b0VLhsqXTZ0eUM40D6IIqsZoig5LPnyN2XMHFeC/+xux962QbnibUZNiaaO3gSRDgqNEaMGx3GYXVsKANjZ3IddLSyclF9CyGmzYLJHCjXsbhnAx029AID59WVpH8suSN0qhJAoiqNSPi87D3niCOmJEkeIVdVlmiPUr9YRUiFQZ9dJn6/Nh3vkz9f0muK86SHEYOeEPa392NUibZjSua0EoRUSQsSoMne8GwDwt23NaOsPwmrmMG+CO8erUs+sqKDb3dKPzUd6AADzJpSlfZwWIRQIC3J/n9FJlh57OUJM3CSrGgvzgjwjTKtQjOUIKXd0/SEegbDU20hJQcHp06VZjW/t78DHUady3vj8+3zNj36WPjneh7f2d0Rvy7/XQeQHJITyBN7LYyO3ERuLN4FH/jRHG86pUysBAO8e7AIALKgvz8ueNXOiO+9/72rD9mO9AIDTplWmfRwLbwwEIghFkjfvi4eFxUwc5M7UamEl3/4wj2AkcY6ZnCOUJ2EUb8gLbh0Hbh0Hb8ib0XMxcZNszEa8k6Z1VEVpVMQGwgLCKRo3xsPcIJvZpOhv/6lp0hzFDxq7sXFvOwCMmEafD0yqdGJ8WRHCvIiPjvYCAE6Zkv7zRRBaICFEjCqnTK4cciH57PzaHK5GO2fOrAYAbDnSA1EEThzvRq07fUWLu8gKczTPQWnCNAulFNstmkMcJQ4L2EOThcfyLUdIT2KOUOK/CXPSSh0W+e+nFpc9JmSUJkz3eGOVfEr+9ieMK0FViR2+EI+DHV5wHHDGjPwbMs1xHC6MOzdMqy7Ou+pSIn8gIZQnmJwmnNp+Kk5tPAkmqGvGZySKbGbcccEsWEwcTqovw6UL63O9JE2cMK5kiFW/6tQGRY8zmTg59KQ0PJZpojT7vcyR6E8ihMZyjlDMEUr83sjDaDMQiRazCc6oq8P+pulQ+zcxmThcuXSS/P/z59bmrbC95lNTMMXjgsNqwo/On5V3eU5E/kBVY3kCx3GwVdkAZ35WjMVz2aJ6XDCvFjazCRZzfmpxjuPw0JdPxv2v7MWUqmJcfPJ4xY8td9qGNItLR6aJ0gx3kRV9/nBCRyh+4Gq+hMb0JJ0Q6pGbKWb23pQ4LPCFeOWOkAaX7lvLp6LPH0avP4wfnj9L0zqNQFWJHa/cfAYCEUFONCeIbEBHF5ETnLb8P/TqK5z45RULVD9ObQl9rIdQZknMqRKmvSEeoWjeSroy7UIkfWiMjdfI7G9Q4rCirT+oWAgp7SEUj81iwh0Xzta0PqNhMZtQnKebJSJ/yP+r0RhBCAo4cMsBIBzBNFhhQv47Q2MVuami6tBYZh/XVCX0bC0OqwlFGhOy8xkmNIIRAf4QP+I96M1w4CqDORtKQ2NKewgRBKEdEkJ5ghgR0fxwMwBgKswACaG8RasjlKkQKk3hCHWP8Quuy2aG1cwhzIvo8YVQZBua+N7rz6yZIkNtd+luHXKTCIJIDQkhghhlKuVeQsrmjemRLA3EwjoJHaEMuybnArPJjPOnny9/nwkcx6HMaUPHQBA9vpA8WJfRk+HAVQYLbyqdN8ZaGlSMwd5OBDFakBAiiFGmXA6NKXP1+nVMlgZSC6F8qjByWBx48csv6vZ85U4rOgaCCR0zuWpMN0dIXdVYBc3YIoisQVloBDHKxEJjSh0hJoQydIRS5Ah151kzxWzAmk4mSpju1ckRiuUIqUuWHqshS4IYDcgRIohRptIl7e6VOkJ6JUundITkC+7YDcGkGrOhV48lJmaVzhuL5QiN3b9LKkRRRCQSAc8n7pZOFDZmsxkWi/ZGswwSQgQxyrCL2mgnS7uLks85Y+5UPjlC3pAX1fdJHb7bb2uHy+bK6PnkXkIJ3p/OQen98WQYoorNG0svhERRjAnUPPq7jBahUAgtLS3w+Xy5XgqRQ5xOJ2pra2GzZdDsVMf1EAShANkR8oUgimLa3cxAkI13yMwVqCpJHpLrGJBuqy7Jrzl2vrB+F8GK4sTVfLwgyuLRU5KZIClWkSM0EIzIw3bHYrfvVAiCgMbGRpjNZtTV1cFms1Hn6TGGKIoIhULo6OhAY2Mjpk+fDpNJW7YPCSGCGGVYCIYXRPQHImmHeOrlCFUVSyKnYyA4QoAxIVRVMnaTcquibk/H4FCh2O0NQRABjss8V6dURfk8c4OcNnNeDibOJqFQCIIgoL6+Hk6nM9fLIXJEUVERrFYrjhw5glAoBIdD20aOkqUJYpRxWM3yJHElTRX1SpZmbkYgLMAbGppTQUIIqC6NCqH+oUKIhcUqnLaMR8Kwv6ESR2gsz35TilYHgCgc9DgG6CgiiBzAcnG600ygF0VRt2Rpp80iCzAmfNjvYC7IWBZCyRwhvfKDgLgcISWOUB62NCCIfISEEEHkAKVjNoIRAWFeyhPJVAgBMaETL4T6/GH5d3iKx+5Ft7pUstXb+wNDbmdCqFKH90ZN+Ty1NCCI0YGEEEHkABbuSDeBvj/qBnEc4NJhUC1zNTrjXA8mitxFVtgtYzcXhYlEb4iHN66qq3MgmiitiyMU7SwdikCIJkIng1oaEIzDhw+D4zhs27Yt6X02btwIjuPQ29s7auvSG47j8Pzzz4/676Vk6XzBBLiXuwFeAN4Wcr0aIkNkRyhNaIw5B8V2C0ymzKtiEjlC+ZofZOJMWD5pufx9prhsZhRZzfCHeXQMBOGKujfZCI2JIuANRVLmfdGcMYJRX1+PlpYWeDyeXC+lICEhlCeYi8xYsHEB4PUCxcr6zxDGJeYIpU6aZUIo09J5RkJHiOUH5dkYhyJrETau2qjb83Ech+pSO450+dAxGESDR+pLxN6fTEvnASlR3mY2IcQLGAikFkI0eZ4ApAo5m82GcePG5XopGREOh2G1GtPdpNAYQeSActbFOE1oTK9EaUYiR6i9Pz8doWzAxGB7f4L3RyehWKywhF6uGiNHSBmiKG0Uc/Elpg5zxjMwMICvfOUrcLlcqK2txQMPPIAVK1bgpptuAgA0NDTgJz/5CVatWgW3243Vq1cnDI299NJLmDFjBoqKinDmmWfi8OHDitdw5MgRfPazn0V5eTlcLhfmzJmDl156Sf75rl27cP7556O4uBg1NTX42te+hs7OTvnnL7/8Mj71qU+hrKwMlZWVuPDCC3Hw4EH552y9Tz31FFasWAGHw4Hf//73AIAnnngCc+bMgd1uR21tLdasWTNkbZ2dnfjCF74Ap9OJ6dOn4+9//7vi16UVEkIEkQOUVo31+/V1hGqiJeKtcQnBx3v9ADBi4vpYhJXQtyV4f8aX6/P+KB28SlVjKvH5gOLi3Hyp6G59yy234J133sHf//53/Pvf/8Zbb72FrVu3DrnPvffei7lz52LLli34r//6rxHP0dTUhIsvvhjnn38+tm3bhmuuuQY/+MEPFK/h+uuvRzAYxJtvvokdO3bgf/7nf1BcXAwAaGlpwfLly3HSSSdh8+bNePnll9HW1obLL79cfrzX68Utt9yCTZs24dVXX4XJZMIXvvAFCMLQtI3vf//7uPHGG7F7926ce+65eOSRR3D99dfjm9/8Jnbs2IG///3vmDZt2pDHrFu3Dpdffjk+/vhjnH/++fjKV76C7u5uxa9NC3kbGvvpT3+KF198Edu2bYPNZkuZINbV1YX58+fj+PHj6OnpQVlZ2aitUy94L4/3G94HRBFL4YAZgfQPIgyL0qoxlixdmqbpolImlEvN5471+OXbjvX4oj/LLyHkDXnR8L8NAIDD3zmc8YgNYOT7IwiiLIQmlOnTuE8WQmnGbFAfocJjYGAATz75JP74xz/i05/+NABg/fr1qKurG3K/s846C7fddpv8/+FuzyOPPIIpU6bggQceAMdxmDlzpixolHD06FFccsklOPHEEwEAU6ZMGfLcJ598Mu6++275tieeeAL19fXYt28fZsyYgUsuuWTI8z3++OOorq7Grl27MHfuXPn2m266CRdffLH8/5/85Ce49dZb8Z3vfEe+bfHixUOea9WqVfjSl74EALj77rvxq1/9Ch9++CFWrlyp6LVpIW+FUCgUwmWXXYZly5bh8ccfT3nfb3zjG5g3bx6OHz8+SqvLDuFOZUM6CePDLm7pkqXZgNTSIn0+qkzsHOvxyd2l2UU/34QQAHT6OtPfSQX10fegKSoOO71BhCICOA4Y59Zn/IjSEno2/JUcIYU4ncDgYO5+twIOHTqEcDiMJUuWyLe53W7MnDlzyP0WLVqU8nl2796NpUuXDukOv2zZMsXLvfHGG/Htb38br7zyCs4++2xccsklmDdvHgBgy5YteP3112WHKJ6DBw9ixowZOHjwIP7rv/4L77//Pjo7O2Un6OjRo0OEUPzraG9vR3NzsywAk8HWAQAulwslJSVob29X/Nq0kLdCaN26dQCADRs2pLzfI488gt7eXtx555345z//OQoryw6mIhMWf7IY8PlhWjJyVhSRX8SqxlKL236/PnPGGLXuInCc1F26czAET7EtTgjRqIIJFdJ70NQtCaHj0fempsQBm0WfTAIl3aV5QUQvTZ5XB8cBrsxdwWwiRnOJhs9FE4flGLnSvI7h91fLNddcg3PPPRcvvvgiXnnlFdxzzz24//77ccMNN0AQBHz2s59N6C7V1tYCAD772c+ivr4ejz32GOrq6iAIAubOnYtQaOjGLv51FBUp22gNT6jmOG5EyE1vCjpHaNeuXfjxj3+M3/3ud4rbcAeDQfT39w/5MgKciYNrjguu2UXgkNmHgMg97OLW6wuBT9FPhoXG0s0jU4rNYkJttHFgU48Pff6wPAk9Hx0hvZkYJ4REUdQ9PwiIzxFK7gj1+8NghwWFxgqHqVOnwmq14sMPP5Rv6+/vx/79+1U9z+zZs/H+++8PuW34/9NRX1+Pa6+9Fs899xxuvfVWPPbYYwCAk08+GTt37kRDQwOmTZs25MvlcqGrqwu7d+/GHXfcgU9/+tOYNWsWenp60v6+kpISNDQ04NVXX1W1ztGgYIVQMBjEl770Jdx7772YOHGi4sfdc889cLvd8ld9fX0WV0mMVdjFTRBjrk8i+liytE5CCBiaB8PcIE+xnQZ7AhgfTRj3hnh0e0OyIzRex0Ry5u6lGrPBkuhLHBZYM5xvRhiHkpISXHXVVfjud7+L119/HTt37sTVV18Nk8k0wiVKxbXXXouDBw/illtuwd69e/HHP/4xbXQknptuugn/+te/0NjYiK1bt+K1117DrFmzAEiJ1N3d3fjSl76EDz/8EIcOHcIrr7yCq6++GjzPo7y8HJWVlfjNb36DAwcO4LXXXsMtt9yi6PeuXbsW999/Px588EHs378fW7duxa9+9SvF684WhvqErV27FhzHpfzavHmzoue6/fbbMWvWLHz1q19VtYbbb78dfX198ldTU5OWl6I7QkhA49pGNP70OIT8jWgSUaxmk+wMpKoci4XG9PubT6iI5Qnla6J0tnBYzRgnO2YxoainIxTLEUougFmiNOUHFR6/+MUvsGzZMlx44YU4++yzcdppp2HWrFmqJqdPnDgRzz77LP7xj39g/vz5ePTRR4ckN6eD53lcf/31mDVrFlauXImZM2fi4YcfBgDU1dXhnXfeAc/zOPfcczF37lx85zvfgdvthslkgslkwp///Gds2bIFc+fOxc0334x7771X0e+96qqr8Mtf/hIPP/ww5syZgwsvvFC1G5YNDHVFXbNmDa644oqU92loaFD0XK+99hp27NiBZ555BkAspurxePCjH/1IzjEajt1uh91uvH4qYljEkXVHAAATYQGQflYRYWwqXDYMBCJS5VhV4vvoHRoDYuGfxg4v+OiMsckeY+dWjCYTK5xo7Q+gsXMQ+9sHAADTqkYmjmpFSWiMKsYKl5KSEvzhD3+Q/+/1erFu3Tp885vfBDCyQgyQrnvD84IuvPBCXHjhhUNu+/rXv65oDelcmOnTp+O5555L+vOzzz4bu3btGnJb/PoSrZfxrW99C9/61rcS/izRY0ZjZIihhJDH49Gthfizzz4Lvz9WIrxp0yZcffXVeOuttzB16lRdfgdBZEK504YjXb6U88ZiVWP6CaETxpUAAHa39sMX4gEAs2pLdHv+0cLEmbCobpH8vV7MHFeCDw93Y1dzP/a2Dsi36QVLlu5PIYR6yBEqWD766CPs2bMHS5YsQV9fH3784x8DAC666KIcr2zsYighpIajR4+iu7sbR48eBc/zcsfNadOmobi4eITYYV0xZ82alZd9hIjCQ8m8MdZQUU9HaHatGwCwr3VQ7jB9wrhS3Z5/tCiyFmHT6k26P++cOum9eHlnK3p8YVhMHKbq6Aixv2V/qtAYNVMsaO677z7s3bsXNpsNCxcuxFtvvaXrHLHzzjsPb731VsKf/fCHP8QPf/hD3X5XIZC3QujOO+/Ek08+Kf9/wYIFAIDXX38dK1asyNGqCEI56eaNiaIYyxHSUQjVVxShusSO9oEg2vqDsJg4nDypXLfnz3cWNUjvRVO35CjPm+BGkU2/RPKy6HiVvhStE7oHSQgVKgsWLMCWLVuy+jt++9vfDomIxFNRUZHV352P5K0Q2rBhg6os+RUrVmTce4Eg9KQiWkKfzBEKRgSEeKl/hp7J0hzHYcXMKjy1+RgA6cLPEngJYGpVMeorimQhtHxGta7PzxyhXn9yJ1CePE85QoQGxo8fn+sl5BWGqhojiLGEPG8sSY4Qc4NMHHQXKt9aPhVOmxkmDrjhrOm6Pvdo4Qv70PDLBjT8sgG+sPJZT+ngOA63nDMDgFRN99WlyttvKIE5Qr0pHCGWI1RJjhBBZB3aBhJEjqhwpp43Fp8orabHiBKmVhXjze+dCUEUUV2iz+iI0UYURRzpOyJ/rydfWDABCydWwFNig9Om72myLPp3D0YEBMJ8wv5NNHmeIEYPEkIEkSPK0yRLywNXdRqvMRxPsfHaRBiJiZXZGTnisplhMXGICCJ6fWGMcycQQpQsTRCjBoXGCCJHxAavJg6RMEdIz4oxIvdwHBcLjyXJE6JkaYIYPUgIEUSOYMnSyXOE2HgNMm4LDVYFmChPKBDm4Y32dyIhVHisWLECN910U66XQcRBQoggcgRzhPr8YUT4kdOVs9FVmjAGZSmEELvNbOJ0rRYkiNFg7dq1OOmkk3K9DFWQECKIHOEusoLlQPcmGLzK+sxkK0eIyB1lsgge6QZ2eaUml+VOm+5J8gSRCJ7nIQgjN2NjBRJC+QIHOGc74TzBAYD6IRUCFrNJdnsSVY7JydLkCCWE4zjMrpqN2VWz804wpHKEeqINNql0vnARBAHf+973UFFRgXHjxmHt2rUAgKuvvnrE/LBIJIJx48bhiSeeACCF1tasWYM1a9agrKwMlZWVuOOOO4ZUToZCIXzve9/D+PHj4XK5cMopp2Djxo3yzzds2ICysjK88MILmD17Nux2O44cOYKenh5ceeWVKC8vh9PpxHnnnTdkKCp73PPPP48ZM2bA4XDgnHPOkYeTb9iwAevWrcP27dvlQelq+v3lCvJd8wSz04wlO5cAXi9QHMz1cgidqHDa0OsLJ8wT6svC5PlCwml1Yud1O3O9DE245WTpkUJIbqboIgGsBW/Im/RnZpMZDotD0X1NnAlF1qK093XZ1A8sfvLJJ3HLLbfggw8+wHvvvYdVq1bhtNNOwzXXXIMzzjgDLS0tqK2tBQC89NJLGBwcxOWXXz7k8d/4xjfwwQcfYPPmzfjmN7+JSZMmYfXq1QCk4auHDx/Gn//8Z9TV1eGvf/0rVq5ciR07dmD6dKlvmM/nwz333IPf/va3qKysRHV1Nb785S9j//79+Pvf/47S0lJ8//vfx/nnn49du3bBarXKj/vpT3+KJ598EjabDddddx2uuOIKvPPOO/jiF7+ITz75BC+//DL+85//AADcbrfq92e0oTMsQeSQcpcN6PQmLKFn1WRl1F244Cgrkv6miRyh7kFpo1PpovYGWii+J/lcuPOnn48Xv/yi/P/q+6qTNuNcPmk5Nq7aKP+/4X8b0OnrHHE/8S71Dv28efNw1113AZAmvT/00EN49dVX8bOf/QwzZ87E//3f/+F73/seAGD9+vW47LLLUFwce1319fV44IEHwHEcZs6ciR07duCBBx7A6tWrcfDgQfzpT3/CsWPHUFdXBwC47bbb8PLLL2P9+vW4++67AQDhcBgPP/ww5s+fDwCyAHrnnXdw6qmnAgD+8Ic/oL6+Hs8//zwuu+wy+XEPPfQQTjnlFACSKJs1axY+/PBDLFmyBMXFxbBYLBg3bpzq9yVXUGiMIHJIqnljNIG8cJHnjSXIEeqOiiNyhAqXefPmDfl/bW0t2tvbAQDXXHMN1q9fDwBob2/Hiy++iKuvvnrI/ZcuXTokHLxs2TLs378fPM9j69atEEURM2bMQHFxsfz1xhtv4ODBg/JjbDbbkHXs3r0bFotFFjgAUFlZiZkzZ2L37t3ybRaLBYsWLZL/f8IJJ6CsrGzIffINcoTyBN7HY8viLYAgYCHsMIPCY4VAqnlj1FQvNb6wD4sfWwwA2LR6E5zW7DRAzAapxmx0R5OlK8gJ1MTg7YNJf2Y2DW1e2X5be9L7mrihPsHh7xzOaF3xsDATg+M4OVn5yiuvxA9+8AO89957eO+999DQ0IDTTz9d8XMLggCz2YwtW7bAbB76euNdpaKioiFiKll3dlEUR+TgJcrJy7c8vXhICOULIuDbxSzc/D3giKGkmjfWTY5QSkRRxK6OXfL3+YRbQbI0/d21oSZnJ1v3zYTKykp8/vOfx/r16/Hee+/h61//+oj7vP/++yP+P336dJjNZixYsAA8z6O9vV2VgJo9ezYikQg++OADOTTW1dWFffv2YdasWfL9IpEINm/ejCVLlgAA9u7di97eXpxwwgkAJKeJ53nVrzuXUGgsTzA5TJj/+nzMf2kmTEg+tZrIL5LNG4vwgpwsTRfEwqMsrofUcDqiOUIVNAJlzHLNNdfgySefxO7du3HVVVeN+HlTUxNuueUW7N27F3/605/wq1/9Ct/5zncAADNmzMBXvvIVXHnllXjuuefQ2NiITZs24X/+53/w0ksvJf2d06dPx0UXXYTVq1fj7bffxvbt2/HVr34V48ePx0UXXSTfz2q14oYbbsAHH3yArVu34utf/zqWLl0qC6OGhgY0NjZi27Zt6OzsRDBo/OgFCaE8gTNzKF9RjvIzSsFh7PZ7KDSYyOkcJoT6/GEwk6OMyucLjlj5/MhNTeeAdOGoLiEhNFY5++yzUVtbi3PPPVdOeI7nyiuvhN/vx5IlS3D99dfjhhtuwDe/+U355+vXr8eVV16JW2+9FTNnzsTnPvc5fPDBB6ivr0/5e9evX4+FCxfiwgsvxLJlyyCKIl566aUhoTyn04nvf//7+PKXv4xly5ahqKgIf/7zn+WfX3LJJVi5ciXOPPNMVFVV4U9/+pMO70h2odAYQeSQqujFrr0/MOR2FhZzF1lhMdN+pdBgOULeEI9QRIDNEvsbd0SFUBUJoYIkvp8P4/nnnx/yf7/fj97eXnzjG99I+BxWqxW//OUv8cgjjyT9+bp167Bu3bqEP1+1ahVWrVo14vby8nL87ne/S7l+ALj44otx8cUXJ/yZ3W7HM888k/Y5jAQJoTxBCAto+U0LEAyiFmaYkF8xWCIx1SVST5POwaH2MRNC1FSvMCl1WGE2ceAFEd3eEMa5pePAH+IxEJRmzJEjNPYQBAGtra24//774Xa78bnPfS7XSxoTkBDKE8SQiP1rpA6f42AFSAgVBNWl0sWuyxtChBdk96dHbqpHQqgQMZk4VLpsaB8IonMwKAsh5gY5rCYU2+n0PNY4evQoJk+ejAkTJmDDhg2wWOgYGA3oXSaIHFLhtMnOQOdgzBnoijpC5VRCnRSO4zDJPUn+Pt+oKrGjfSAoix8A6BgMyD/Lx9dEZEZDQ0PaCshEobXRIllILd8hIUQQOcRk4uAptqGtP4j2gYAshHooNJYWp9WJwzcdzvUyNMNygOKFUHs/S5R2JHwMQRD6Q1mYBJFj2EWPXQQBoHMw2kOomIRQoVIVLY/vGIx3hIJDfkYQRPYhIUQQOYYlxbbHOQMtfX4AQK2bnIFCJZEjRBVjBDH6kBAiiBzDEqbjL4itUXeoppSEUDL8YT8WP7YYix9bDH/Yn+vlqCaREGqLtlGgijGCGD0oR4ggcgwLjbXG9RJqJUcoLYIoYHPzZvn7fEPuITUQ+7sf75X+7uPLi3KyJoIYi5AjRBA5ZkL0onesR5olF+EF2SUYR0KoYGECON4ROtYjCaEJ5fkzQJYg8h0SQgSRY+orpIve0W5JCHUMBiGIgMXEweOiEEmhUhWXGyaKInhBRHMvE0LkCBGJ2bBhA8rKynK9DEWsXbsWJ510kqrHcBw3otN2tiEhRBA5ZmJUCB3v8YMXRLT0SaGSmlIHTCbqJVOo1Lod4DjAF+LR5Q2hrT+AMC/CYuIoN4woCG677Ta8+uqruV5GWihHiCByTE2pA1YzhzAvoqXPjzZZCJEbVMg4rGbUuYtwvNePI11e8NE0p7qyIphJABMFQHFxMYqLi3O9jLSQI0QQOcZs4uSckKZuv5wwW+um8Eih0+CR/u6NnT45R4zCYoXNihUrsGbNGqxZswZlZWWorKzEHXfcIXeU7unpwZVXXony8nI4nU6cd9552L9/f8LnOnz4MEwmEzZv3jzk9l/96leYNGkSRFHExo0bwXEcXn31VSxatAhOpxOnnnoq9u7dO+QxjzzyCKZOnQqbzYaZM2fi//7v/4b8nOM4/PrXv8aFF14Ip9OJWbNm4b333sOBAwewYsUKuFwuLFu2DAcPHpQfMzw0tmnTJpxzzjnweDxwu91Yvnw5tm7dmsnbqQskhPIIq8cKayWZeIUIu/g1dfvQ2OkFELtIEsnxOD3wOD25XoZmJlW6AABHurxyjtj4MhJCmcB7edVfQiRWdShEBOl2P6/oebXw5JNPwmKx4IMPPsCDDz6IBx54AL/97f9v796Doqr7P4C/geWq7mogSsKzoiIXRSX8CUiFiuJ4mbw8akle09Ixc5UscbTUKWu8W6Z5eRTN1C4mZVN5mUYIVCgTfFRImMTE1AAv3OS6+/39QWzygMAuu3sWz/s1szPu4ezZ93446/lwzvec8x8ANbexOHfuHI4ePYqzZ89CCIGRI0eiqqqq3nK6du2KoUOHIi4urs70uLg4zJgxo85tWpYtW4YNGzbg3LlzUCgUeOmll/Q/i4+Ph0ajweuvv45Lly5hzpw5mDlzJk6dOlVnue+88w6mTZuG9PR0+Pn5ITo6GnPmzMHSpUv1zdj8+fMf+bmLi4sxffp0JCUlISUlBT4+Phg5ciSKi4sNL6IJcavaSti1sUN4fjhQWgq0LW/6BdSqqF1dkJQN/F5Qgt/zSwAA3dysf5eylNo4tEH+G/lSx2gR778boZyCUtTeYsqnE3/vLZHUNsng1wR8EQD3ie4AgIL4AmRMyoAqQoWghCD9PCldU1BVUL8ZGSQGGfx+Xl5e2LRpE2xsbODr64uLFy9i06ZNGDRoEI4ePYrTp09j4MCBAIADBw7Ay8sLX3/9NSZOnFhvWbNnz8bcuXOxceNGODo64sKFC0hPT8eRI0fqzLd69WpEREQAAGJjYzFq1CiUl5fDyckJ69evx4wZMzBv3jwAQExMDFJSUrB+/XoMHjxYv4yZM2di0qRJAIAlS5YgLCwMb731FoYPHw4A0Gg0mDlz5iM/95AhQ+o837FjBzp06IDExESMHj3a0DKaTKvdI7R69WoMHDgQLi4ujY6g37t3L/r06QMnJyd07ty50W6VSCr+HkoAQMbNImT/VdMIdXfnBvFxp3at2et37U4pfrtdBADw7ayUMhJZQGhoaJ29NWFhYcjOzkZGRgYUCgVCQkL0P3N1dYWvry8yMzMbXNbYsWOhUCgQHx8PANizZw8GDx6Mrl271pmvT58++n97eHgAAPLy8gAAmZmZCA8PrzN/eHh4vfd8eBmdOnUCAAQGBtaZVl5ejqKiogaz5uXlYe7cuejZsydUKhVUKhVKSkpw/fr1Bue3lFa7R6iyshITJ05EWFgYdu/e3eA8GzduxIYNG7Bu3TqEhISgvLwcV69etXBSoqb1flIFAEjKLgAA2NvZwK9zOykjkQX4/v07vvTnPxuOAA82Qi3xTMkzBr/GxvGfpsRtnFvNMv5nN0HotdCWRjOaEKJO4/QwBwcHTJ06FXFxcRg/fjwOHjyIzZs315vP3t5e/+/aZel0unrTGnvPhpbR1HIfNmPGDOTn52Pz5s1Qq9VwdHREWFgYKisrG5zfUlptI7Rq1SoANXt8GnLv3j0sX74c3377LSIjI/XTe/XqZYl4Jqct0+K/I/4LaHXoAwfYQdoVh0wr4Ekl2jkqUFxR/fdzFZzs7SROZd3Kqsow4sAIAMAPL/4AZ/vWN7bmX0+4oJPSEX/9fUuVHu5teZ+xFrJr07Lvja3CtsEtY0uX+7CUlJR6z318fBAQEIDq6mqkpqbqD43duXMHWVlZ8Pf3f+TyZs+ejd69e2Pbtm2oqqrC+PHjDcrj7++P5ORkTJs2TT/tzJkzjb6nMZKSkrBt2zaMHDkSAJCbm4uCggKTvocxWu2hsaacPHkSOp0Of/75J/z9/eHp6YlJkyYhNze30ddVVFSgqKiozsMq6IDCxEIUJhfjMf61yZa9nS2G+Lvrn48O9JAwTeugEzok/pGIxD8SW+UtNoCav6CjAjrrnw/v1UnCNGQpubm5iImJwZUrV3Do0CFs2bIFGo0GPj4+GDNmDF5++WUkJyfjwoULmDJlCrp06YIxY8Y8cnn+/v4IDQ3FkiVLMHnyZDg7G/ZHwRtvvIG9e/di+/btyM7OxsaNG3HkyBEsXry4pR+1jh49emD//v3IzMxEamoqXnzxRYOzmsNju0W9evUqdDod3nvvPWzevBmHDx/G3bt3MWzYsEZ3w73//vv6Y5cqlQpeXl4WTP1oNo42CPgiAAGfdIcN9wY9lt4Y7gu/zu0Q6eeO6JB/SR2HLOTVwT3Q16s9/q9rB7z8TDep45AFTJs2DWVlZRgwYABeffVVvPbaa3jllVcA1JzxFRwcjNGjRyMsLAxCCHz//fd1DkE1ZNasWaisrKxzNlhzjR07Fh988AHWrVuHXr16YceOHYiLi8OgQYOM+XiPtGfPHty7dw9BQUGYOnUqFixYAHd396ZfaG7CiqxYsUIAaPTxyy+/1HlNXFycUKlU9Za1evVqAUAcP35cPy0vL0/Y2tqKY8eOPTJDeXm5KCws1D9yc3MFAFFYWGiyz9kiJSVCADWPkhKp0xBJpqSiRGAlBFZClFTwuyAnZWVlIiMjQ5SVlUkdxWARERFCo9GYfLnvvvuu6N27t8mXa+0aWxcKCwubtf22qjFC8+fPxwsvvNDoPP87Ev5RakfFBwQE6Kd17NgRbm5ujY5Qd3R0hKMjj9ETEZH1KykpQWZmJrZs2YJ33nlH6jitklU1Qm5ubnBzM83F0WpPBbxy5Qo8PT0BAHfv3kVBQQHUarVJ3sOSdNU6FMQXAOUVcIMtbNE6x0QQEZHpzJ8/H4cOHcLYsWONOixGVtYIGeL69eu4e/curl+/Dq1Wi/T0dAA1g7Hatm2Lnj17YsyYMdBoNNi5cyeUSiWWLl0KPz+/OheIai1EhUDGpAwAwDNwAMCLKhIRtTYJCQkmXd7evXsfefY0NU+rbYTefvtt7Nu3T/88KKjmCqCnTp3SD/D65JNPsGjRIowaNQq2traIiIjAsWPHmhx0RkStg4s9b0NCRC1jI0Tthd2pIUVFRVCpVCgsLIRSKd2FzrSlWv2l45/BCNihHCgpAdq0kSwTEZEUysvLkZOTA29vbzg5OUkdhyTU2LrQ3O33Y3v6PBERPd74dzyZYh1gI0RERK1K7fCGBw8eSJyEpFa7DrRkyEurHSNERPJWXl2Of3/xbwDAV5O+gpOCh0jkws7ODu3bt9ffNNTFxeWR9+Kix5MQAg8ePEBeXh7at28POzvjb4HCRoiIWiWtTovvs7/X/5vkpXPnmluT1DZDJE/t27fXrwvGYiNEREStjo2NDTw8PODu7o6qqiqp45AE7O3tW7QnqBYbISIiarXs7OxMsjEk+eJgaSIiIpItNkJEREQkW2yEiIiISLY4RqgJtRdrKioqkjSHtlSLUpTWZIGAXU0oQMuzZUieSitL9bfcKyoqgtaB3wUi+kftdrupiy7yFhtNuHHjBry8vKSOQUREREbIzc2Fp6fnI3/ORqgJOp0ON2/eRLt27Ux6wa6ioiJ4eXkhNzdX0nuYtQasVfOxVoZhvZqPtWo+1qr5zFkrIQSKi4vx5JNPwtb20SOBeGisCba2to12ki2lVCr5RWkm1qr5WCvDsF7Nx1o1H2vVfOaqlUqlanIeDpYmIiIi2WIjRERERLLFRkgijo6OWLFiBRwdHaWOYvVYq+ZjrQzDejUfa9V8rFXzWUOtOFiaiIiIZIt7hIiIiEi22AgRERGRbLERIiIiItliI0RERESyxUbIjLZt2wZvb284OTkhODgYSUlJjc6fmJiI4OBgODk5oVu3bti+fbuFkkrPkFrdunUL0dHR8PX1ha2tLRYuXGi5oFbAkFodOXIEw4YNQ8eOHaFUKhEWFobjx49bMK20DKlVcnIywsPD4erqCmdnZ/j5+WHTpk0WTCs9Q//PqnX69GkoFAr069fPvAGtiCG1SkhIgI2NTb3Hb7/9ZsHE0jF0vaqoqMCyZcugVqvh6OiI7t27Y8+ePeYLKMgsPvvsM2Fvby927dolMjIyhEajEW3atBF//PFHg/NfvXpVuLi4CI1GIzIyMsSuXbuEvb29OHz4sIWTW56htcrJyRELFiwQ+/btE/369RMajcaygSVkaK00Go1Ys2aN+Pnnn0VWVpZYunSpsLe3F+fPn7dwcssztFbnz58XBw8eFJcuXRI5OTli//79wsXFRezYscPCyaVhaL1q3b9/X3Tr1k1ERUWJvn37WiasxAyt1alTpwQAceXKFXHr1i39o7q62sLJLc+Y9eq5554TISEh4uTJkyInJ0ekpqaK06dPmy0jGyEzGTBggJg7d26daX5+fiI2NrbB+d98803h5+dXZ9qcOXNEaGio2TJaC0Nr9bCIiAhZNUItqVWtgIAAsWrVKlNHszqmqNW4cePElClTTB3NKhlbr+eff14sX75crFixQjaNkKG1qm2E7t27Z4F01sXQWv3www9CpVKJO3fuWCKeEEIIHhozg8rKSvz666+IioqqMz0qKgpnzpxp8DVnz56tN//w4cNx7tw5VFVVmS2r1IyplVyZolY6nQ7FxcV44oknzBHRapiiVmlpaThz5gwiIiLMEdGqGFuvuLg4/P7771ixYoW5I1qNlqxbQUFB8PDwQGRkJE6dOmXOmFbBmFodPXoU/fv3x9q1a9GlSxf07NkTixcvRllZmdly8qarZlBQUACtVotOnTrVmd6pUyfcvn27wdfcvn27wfmrq6tRUFAADw8Ps+WVkjG1kitT1GrDhg0oLS3FpEmTzBHRarSkVp6ensjPz0d1dTVWrlyJ2bNnmzOqVTCmXtnZ2YiNjUVSUhIUCvlsSoyplYeHB3bu3Ing4GBUVFRg//79iIyMREJCAp599llLxJaEMbW6evUqkpOT4eTkhPj4eBQUFGDevHm4e/eu2cYJyWftlYCNjU2d50KIetOamr+h6Y8jQ2slZ8bW6tChQ1i5ciW++eYbuLu7myueVTGmVklJSSgpKUFKSgpiY2PRo0cPTJ482ZwxrUZz66XVahEdHY1Vq1ahZ8+elopnVQxZt3x9feHr66t/HhYWhtzcXKxfv/6xboRqGVIrnU4HGxsbHDhwQH/n+I0bN2LChAnYunUrnJ2dTZ6PjZAZuLm5wc7Orl7Hm5eXV68zrtW5c+cG51coFHB1dTVbVqkZUyu5akmtPv/8c8yaNQtffvklhg4das6YVqEltfL29gYABAYG4q+//sLKlSsf+0bI0HoVFxfj3LlzSEtLw/z58wHUbMCEEFAoFDhx4gSGDBlikeyWZqr/s0JDQ/Hpp5+aOp5VMaZWHh4e6NKli74JAgB/f38IIXDjxg34+PiYPCfHCJmBg4MDgoODcfLkyTrTT548iYEDBzb4mrCwsHrznzhxAv3794e9vb3ZskrNmFrJlbG1OnToEGbMmIGDBw9i1KhR5o5pFUy1XgkhUFFRYep4VsfQeimVSly8eBHp6en6x9y5c+Hr64v09HSEhIRYKrrFmWrdSktLe2yHPNQyplbh4eG4efMmSkpK9NOysrJga2sLT09P8wS12LBsmak9ZXD37t0iIyNDLFy4ULRp00Zcu3ZNCCFEbGysmDp1qn7+2tPnFy1aJDIyMsTu3btld/p8c2slhBBpaWkiLS1NBAcHi+joaJGWliYuX74sRXyLMrRWBw8eFAqFQmzdurXOabv379+X6iNYjKG1+uijj8TRo0dFVlaWyMrKEnv27BFKpVIsW7ZMqo9gUcZ8Dx8mp7PGDK3Vpk2bRHx8vMjKyhKXLl0SsbGxAoD46quvpPoIFmNorYqLi4Wnp6eYMGGCuHz5skhMTBQ+Pj5i9uzZZsvIRsiMtm7dKtRqtXBwcBBPPfWUSExM1P9s+vTpIiIios78CQkJIigoSDg4OIiuXbuKjz/+2MKJpWNorQDUe6jVasuGloghtYqIiGiwVtOnT7d8cAkYUqsPP/xQ9OrVS7i4uAilUimCgoLEtm3bhFarlSC5NAz9Hj5MTo2QEIbVas2aNaJ79+7CyclJdOjQQTz99NPiu+++kyC1NAxdrzIzM8XQoUOFs7Oz8PT0FDExMeLBgwdmy2cjxN8jcomIiIhkhmOEiIiISLbYCBEREZFssREiIiIi2WIjRERERLLFRoiIiIhki40QERERyRYbISIiIpItNkJEREQkW2yEiIiISLbYCBEREZFssREiIlk6fPgwAgMD4ezsDFdXVwwdOhSlpaVSxyIiC1NIHYCIyNJu3bqFyZMnY+3atRg3bhyKi4uRlJQE3nqRSH5401Uikp3z588jODgY165dg1qtljoOEUmIh8aISHb69u2LyMhIBAYGYuLEidi1axfu3bsndSwikgD3CBGRLAkhcObMGZw4cQLx8fG4ffs2UlNT4e3tLXU0IrIgNkJEJHtarRZqtRoxMTGIiYmROg4RWRAHSxOR7KSmpuLHH39EVFQU3N3dkZqaivz8fPj7+0sdjYgsjI0QEcmOUqnETz/9hM2bN6OoqAhqtRobNmzAiBEjpI5GRBbGQ2NEREQkWzxrjIiIiGSLjRARERHJFhshIiIiki02QkRERCRbbISIiIhIttgIERERkWyxESIiIiLZYiNEREREssVGiIiIiGSLjRARERHJFhshIiIiki02QkRERCRb/w8P7Q/vB95wPQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the results\n", + "plt.figure()\n", + "plt.plot(s_space, potential)\n", + "plt.xlabel('s')\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.title('First DBI step')\n", + "plt.ylabel('Least squares cost function')\n", + "plt.legend()\n", + "plt.figure()\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('First DBI step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Comparison of the least-squares cost function with the original cost function using the polynomial scheduling method" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", + "off_diagonal_norm_diff_least_squares = [dbi.off_diagonal_norm]\n", + "iters = 100\n", + "dbi_ls = deepcopy(dbi)\n", + "cost = DoubleBracketCostFunction.off_diagonal_norm\n", + "dbi_od = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "for _ in range(iters):\n", + " step_poly = dbi_od.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_od(step_poly,d=d)\n", + " step_poly = dbi_ls.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_ls(step_poly,d=d)\n", + " off_diagonal_norm_diff.append(dbi_od.off_diagonal_norm)\n", + " off_diagonal_norm_diff_least_squares.append(dbi_ls.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff, label=r'Off-diagonal norm')\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff_least_squares, label=r'Least squares')\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Energy fluctuation\n", + "\n", + "This cost function is defined as: $\\Xi_k^2 (\\mu) = \\langle \\mu | H_k^2| \\mu \\rangle - \\langle \\mu | H_k| \\mu \\rangle^2$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-15 18:17:12]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 3\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the energy fluctuation cost function\n", + "cost = DoubleBracketCostFunction.energy_fluctuation\n", + "# define the state\n", + "state = 0\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, state=state)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.8585872727272726\n", + "hyperopt_search step: 0.3413442272248831\n", + "polynomial_approximation step: 0.028303853122485182\n" + ] + } + ], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "s_space = np.linspace(1e-5, 0.9, 1000)\n", + "off_diagonal_norm_diff = []\n", + "fluctuation = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " fluctuation.append(dbi_eval.energy_fluctuation(state=state))\n", + "\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.8585872727272726\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the results\n", + "plt.figure()\n", + "plt.plot(s_space, fluctuation)\n", + "plt.xlabel('s')\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label ='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.title('First DBI step')\n", + "plt.ylabel('Energy fluctuation')\n", + "plt.legend()\n", + "plt.figure()\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('First DBI step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", + "energy_fluc = [dbi.energy_fluctuation(state=state)]\n", + "iters = 50\n", + "dbi_ = deepcopy(dbi)\n", + "for _ in range(iters):\n", + " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_(step_poly,d=d)\n", + " off_diagonal_norm_diff.append(dbi_.off_diagonal_norm)\n", + " energy_fluc.append(dbi_.energy_fluctuation(state=state))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Energy fluctuation')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff)\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "\n", + "plt.figure()\n", + "plt.plot(range(iters+1), energy_fluc)\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'Energy fluctuation')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "iters = 10\n", + "columnNorm = np.empty((2**nqubits,iters))\n", + "d = (np.diag(np.linspace(1,2**nqubits,2**nqubits)))\n", + "for i in range(2**nqubits):\n", + " dbi_ = deepcopy(dbi)\n", + " dbi_.state = i\n", + " for j in range(iters):\n", + " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_(step_poly,d=d)\n", + " columnNorm[i,j] = np.linalg.norm(dbi_.h.matrix[:,i])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Iterations')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n", + "plt.figure()\n", + "for i in range(2**nqubits):\n", + " plt.plot(range(iters), columnNorm[i], label='State ' + str(i))\n", + " plt.axhline(y=eigvals[i], color='r', linestyle='--')\n", + "plt.xlabel('Iterations')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[20], line 8\u001b[0m\n\u001b[0;32m 5\u001b[0m step \u001b[39m=\u001b[39m \u001b[39m1e-2\u001b[39m\n\u001b[0;32m 6\u001b[0m iterations \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m----> 8\u001b[0m d, loss, grad, diags \u001b[39m=\u001b[39m gradient_ascent(dbi, d,step, iterations)\n\u001b[0;32m 10\u001b[0m n \u001b[39m=\u001b[39m \u001b[39m3\u001b[39m\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:253\u001b[0m, in \u001b[0;36mgradient_ascent\u001b[1;34m(dbi_object, d, step, iterations)\u001b[0m\n\u001b[0;32m 250\u001b[0m diagonals[:,\u001b[39m0\u001b[39m] \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mdiag(d)\n\u001b[0;32m 252\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(iterations):\n\u001b[1;32m--> 253\u001b[0m grad[i,:] \u001b[39m=\u001b[39m gradientDiagonal(dbi_object, d, H)\n\u001b[0;32m 254\u001b[0m \u001b[39mfor\u001b[39;00m j \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[0;32m 255\u001b[0m d[j,j] \u001b[39m=\u001b[39m d[j,j] \u001b[39m+\u001b[39m step\u001b[39m*\u001b[39mgrad[i,j] \u001b[39m# note the plus sign as we maximize the potential\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:237\u001b[0m, in \u001b[0;36mgradientDiagonal\u001b[1;34m(dbi_object, d, H)\u001b[0m\n\u001b[0;32m 235\u001b[0m grad \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(\u001b[39mlen\u001b[39m(d))\n\u001b[0;32m 236\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[1;32m--> 237\u001b[0m derivative \u001b[39m=\u001b[39m dpolynomial_diDiagonal(dbi_object,d,H,i)\n\u001b[0;32m 238\u001b[0m grad[i] \u001b[39m=\u001b[39m derivative\u001b[39m-\u001b[39md[i,i]\n\u001b[0;32m 239\u001b[0m \u001b[39mreturn\u001b[39;00m grad\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:224\u001b[0m, in \u001b[0;36mdpolynomial_diDiagonal\u001b[1;34m(dbi_object, d, H, i)\u001b[0m\n\u001b[0;32m 220\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdpolynomial_diDiagonal\u001b[39m(dbi_object, d,H,i):\n\u001b[0;32m 221\u001b[0m \u001b[39m# Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz)\u001b[39;00m\n\u001b[0;32m 222\u001b[0m \u001b[39m# Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation\u001b[39;00m\n\u001b[0;32m 223\u001b[0m derivative \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m--> 224\u001b[0m s \u001b[39m=\u001b[39m polynomial_step(dbi_object, d, H, i)\n\u001b[0;32m 225\u001b[0m A \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(d\u001b[39m.\u001b[39mshape)\n\u001b[0;32m 226\u001b[0m Gamma_list \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mgenerate_Gamma_list(\u001b[39m4\u001b[39m, d)\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:127\u001b[0m, in \u001b[0;36mpolynomial_step\u001b[1;34m(dbi_object, n, n_max, d, coef, cost)\u001b[0m\n\u001b[0;32m 124\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 125\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m--> 127\u001b[0m \u001b[39mif\u001b[39;00m n \u001b[39m>\u001b[39;49m n_max:\n\u001b[0;32m 128\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 129\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mNo solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 130\u001b[0m )\n\u001b[0;32m 131\u001b[0m \u001b[39mif\u001b[39;00m coef \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" + ] + } + ], + "source": [ + "cost = DoubleBracketCostFunction.least_squares\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "\n", + "step = 1e-2\n", + "iterations = 100\n", + "\n", + "d, loss, grad, diags = gradient_ascent(dbi, d,step, iterations)\n", + "\n", + "n = 3" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 0446ffbb9a..2069296058 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -82,7 +82,6 @@ def __init__( self.mode = mode self.scheduling = scheduling self.cost = cost - self.cost_str = cost.name self.state = state def __call__( @@ -100,7 +99,7 @@ def __call__( if d is None: d = self.diagonal_h_matrix operator = self.backend.calculate_matrix_exp( - 1.0j * step, + 1.0j*step, self.commutator(d, self.h.matrix), ) elif mode is DoubleBracketGeneratorType.group_commutator: @@ -115,6 +114,7 @@ def __call__( operator_dagger = self.backend.cast( np.matrix(self.backend.to_numpy(operator)).getH() ) + self.h.matrix = operator @ self.h.matrix @ operator_dagger @staticmethod @@ -140,20 +140,17 @@ def off_diagonal_norm(self): return np.sqrt( np.real(np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h))) ) - @property - def least_squares(self,d: np.array): - """Least squares cost function.""" - H = self.backend.cast( - np.matrix(self.backend.to_numpy(self.h)).getH() - ) - D = d - return -(np.linalg.trace(H@D)-0.5(np.linalg.norm(H)**2+np.linalg.norm(D)**2)) @property def backend(self): """Get Hamiltonian's backend.""" return self.h0.backend + def least_squares(self, D: np.array): + """Least squares cost function.""" + H = self.h.matrix + return -np.real(np.trace(H@D)-0.5*(np.linalg.norm(H)**2+np.linalg.norm(D)**2)) + def choose_step( self, d: Optional[np.array] = None, @@ -192,7 +189,7 @@ def loss(self, step: float, d: np.array = None, look_ahead: int = 1): if self.cost == DoubleBracketCostFunction.off_diagonal_norm: loss = self.off_diagonal_norm elif self.cost == DoubleBracketCostFunction.least_squares: - loss = self.least_squares(d=d) + loss = self.least_squares(d) else: loss = self.energy_fluctuation(self.state) @@ -213,7 +210,9 @@ def energy_fluctuation(self, state): Args: state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ - return self.h.energy_fluctuation(state) + state_vector = np.zeros(len(self.h.matrix)) + state_vector[state] = 1.0 + return np.real(self.h.energy_fluctuation(state_vector)) def sigma(self, h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 2017b57cd1..5f217cc948 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -1,12 +1,17 @@ import math from functools import partial from typing import Optional - +from copy import deepcopy import hyperopt import numpy as np + error = 1e-3 +def commutator(A, B): + """Compute commutator between two arrays.""" + return A@B-B@A + def variance(A, state): """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\langle\mu|A^2|\mu\rangle-\langle\mu|A|\mu\rangle^2$""" B = A@A @@ -14,8 +19,8 @@ def variance(A, state): def covariance(A, B, state): """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\langle\mu|AB|\mu\rangle-\langle\mu|A|\mu\rangle\langle\mu|B|\mu\rangle$""" - C = A@B - return C[state,state]-A[state,state]*B[state,state] + C = A@B+B@A + return C[state,state]-2*A[state,state]*B[state,state] def grid_search_step( dbi_object, @@ -44,6 +49,7 @@ def grid_search_step( d = dbi_object.diagonal_h_matrix loss_list = [dbi_object.loss(step, d=d) for step in space] + idx_max_loss = np.argmin(loss_list) return space[idx_max_loss] @@ -83,12 +89,14 @@ def hyperopt_step( d = dbi_object.diagonal_h_matrix space = space("step", step_min, step_max) + + best = hyperopt.fmin( - fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, + fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, ) return best["step"] @@ -112,6 +120,7 @@ def polynomial_step( """ if cost is None: cost = dbi_object.cost.name + if d is None: d = dbi_object.diagonal_h_matrix @@ -135,7 +144,11 @@ def polynomial_step( ] # solution exists, return minimum s if len(real_positive_roots) > 0: - return min(real_positive_roots) + sol = min(real_positive_roots) + for s in real_positive_roots: + if dbi_object.loss(s, d) < dbi_object.loss(sol, d): + sol = s + return sol # solution does not exist, return None else: return None @@ -167,14 +180,13 @@ def least_squares_polynomial_expansion_coef(dbi_object, d, n): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) - Gamma_list = dbi_object.generate_Gamma_list(n, d) + Gamma_list = dbi_object.generate_Gamma_list(n+1, d) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients coef = np.empty(n) for i in range(n): - coef[i] = exp_list[i]*np.trace(d@Gamma_list[i+1]) - + coef[i] = np.real(exp_list[i]*np.trace(d@Gamma_list[i+1])) + coef = list(reversed(coef)) return coef #TODO: add a general expansion formula not stopping at 3rd order @@ -182,10 +194,67 @@ def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - Gamma_list = dbi_object.generate_Gamma_list(n, d) + Gamma_list = dbi_object.generate_Gamma_list(n+1, d) # coefficients coef = np.empty(3) - coef[0] = 2*covariance(Gamma_list[0], Gamma_list[1],state) - coef[1] = 2*variance(Gamma_list[1],state) - coef[2] = covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state) + coef[0] = np.real(2*covariance(Gamma_list[0], Gamma_list[1],state)) + coef[1] = np.real(2*variance(Gamma_list[1],state)) + coef[2] = np.real(covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state)) + coef = list(reversed(coef)) return coef + +def dGamma_diDiagonal(dbi_object, d, H, n, i,dGamma, Gamma_list): + # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) + A = np.zeros(d.shape) + A[i,i] = 1 + B = commutator(commutator(A,H),Gamma_list[n-1]) + W = commutator(d,H) + return B + commutator(W,dGamma[-1]) + +def dpolynomial_diDiagonal(dbi_object, d,H,i): + # Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz) + # Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation + derivative = 0 + s = polynomial_step(dbi_object, n=3, d=d) + A = np.zeros(d.shape) + Gamma_list = dbi_object.generate_Gamma_list(4, d) + A[i,i] = 1 + dGamma = [commutator(A,H)] + derivative += np.real(np.trace(Gamma_list[0]@A)+np.trace(dGamma[0]@d+Gamma_list[1]@A)*s) + for n in range(2,4): + dGamma.append(dGamma_diDiagonal(dbi_object,d,H,n,i,dGamma,Gamma_list)) + derivative += np.real(np.trace(dGamma[-1]@d + Gamma_list[n]@A)*s**n/math.factorial(n)) + + return derivative + +def gradientDiagonal(dbi_object,d,H): + # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz) + grad = np.zeros(len(d)) + for i in range(len(d)): + derivative = dpolynomial_diDiagonal(dbi_object,d,H,i) + grad[i] = d[i,i]-derivative + return grad + +def gradient_ascent(dbi_object, d, step, iterations): + H = dbi_object.h.matrix + loss = np.zeros(iterations+1) + grad = np.zeros((iterations,len(d))) + dbi_new = deepcopy(dbi_object) + s = polynomial_step(dbi_object, n = 3, d=d) + dbi_new(s,d=d) + loss[0] = dbi_new(d) + diagonals = np.empty((len(d),iterations+1)) + diagonals[:,0] = np.diag(d) + + for i in range(iterations): + dbi_new = deepcopy(dbi_object) + grad[i,:] = gradientDiagonal(dbi_object, d, H) + for j in range(len(d)): + d[j,j] = d[j,j] - step*grad[i,j] + s = polynomial_step(dbi_object, n = 3, d=d) + dbi_new(s,d=d) + loss[i+1] = dbi_new.least_squares(d) + diagonals[:,i+1] = np.diag(d) + + + return d,loss,grad,diagonals \ No newline at end of file From f17eb1d611aff90020751d669af4362cfe41f3e8 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Sat, 16 Mar 2024 09:03:10 +0100 Subject: [PATCH 052/116] Revert "Test coverage for fail cases in polynomial step" This reverts commit 00f6d8c89b03fccb3494779dbb25b0f1aa360a82. --- tests/test_models_dbi.py | 6 ++--- tests/test_models_dbi_utils.py | 1 - tests/test_models_dbi_utils_scheduling.py | 30 ----------------------- 3 files changed, 3 insertions(+), 34 deletions(-) delete mode 100644 tests/test_models_dbi_utils_scheduling.py diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 5fa277f7ac..1dcbb960d0 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -137,6 +137,7 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( @pytest.mark.parametrize("n", [2, 4]) def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) + d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, @@ -144,7 +145,6 @@ def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - # by default, d is the diagonal resctriction of H - step1 = dbi.choose_step(n=n) - dbi(step=step1) + step1 = dbi.choose_step(d=d, n=n) + dbi(d=d, step=step1) assert initial_off_diagonal_norm > dbi.off_diagonal_norm diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index a19ee502c5..cd9f74e9de 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -37,7 +37,6 @@ def test_select_best_dbr_generator(backend, nqubits, step): dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, - scheduling=DoubleBracketScheduling.grid_search, ) generate_Z = generate_Z_operators(nqubits) Z_ops = list(generate_Z.values()) diff --git a/tests/test_models_dbi_utils_scheduling.py b/tests/test_models_dbi_utils_scheduling.py deleted file mode 100644 index 392727f144..0000000000 --- a/tests/test_models_dbi_utils_scheduling.py +++ /dev/null @@ -1,30 +0,0 @@ -"""Unit testing for utils_scheduling.py for Double Bracket Iteration""" - -import numpy as np -import pytest - -from qibo.hamiltonians import Hamiltonian -from qibo.models.dbi.double_bracket import ( - DoubleBracketGeneratorType, - DoubleBracketIteration, - DoubleBracketScheduling, -) -from qibo.models.dbi.utils_scheduling import polynomial_step -from qibo.quantum_info import random_hermitian - -NSTEPS = 1 -seed = 10 -"""Number of steps for evolution.""" - - -@pytest.mark.parametrize("nqubits", [5, 6]) -def test_polynomial_fail_cases(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) - dbi = DoubleBracketIteration( - Hamiltonian(nqubits, h0, backend=backend), - mode=DoubleBracketGeneratorType.single_commutator, - scheduling=DoubleBracketScheduling.polynomial_approximation, - ) - with pytest.raises(ValueError): - polynomial_step(dbi, n=2, n_max=1) - assert polynomial_step(dbi, n=1) == None From b0c6958958caa31827a4764902ad6b7855a68188 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 19 Mar 2024 14:54:14 +0800 Subject: [PATCH 053/116] Scheduling test --- tests/test_models_dbi_utils_scheduling.py | 30 +++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 tests/test_models_dbi_utils_scheduling.py diff --git a/tests/test_models_dbi_utils_scheduling.py b/tests/test_models_dbi_utils_scheduling.py new file mode 100644 index 0000000000..392727f144 --- /dev/null +++ b/tests/test_models_dbi_utils_scheduling.py @@ -0,0 +1,30 @@ +"""Unit testing for utils_scheduling.py for Double Bracket Iteration""" + +import numpy as np +import pytest + +from qibo.hamiltonians import Hamiltonian +from qibo.models.dbi.double_bracket import ( + DoubleBracketGeneratorType, + DoubleBracketIteration, + DoubleBracketScheduling, +) +from qibo.models.dbi.utils_scheduling import polynomial_step +from qibo.quantum_info import random_hermitian + +NSTEPS = 1 +seed = 10 +"""Number of steps for evolution.""" + + +@pytest.mark.parametrize("nqubits", [5, 6]) +def test_polynomial_fail_cases(backend, nqubits): + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + scheduling=DoubleBracketScheduling.polynomial_approximation, + ) + with pytest.raises(ValueError): + polynomial_step(dbi, n=2, n_max=1) + assert polynomial_step(dbi, n=1) == None From 032603972a3eadde65cba30334498ba2d9209f42 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 19 Mar 2024 15:30:57 +0800 Subject: [PATCH 054/116] Initial commits for SA --- src/qibo/models/dbi/double_bracket.py | 11 +- src/qibo/models/dbi/utils_scheduling.py | 189 +++++++++++++++++------- tests/test_models_dbi.py | 8 +- 3 files changed, 147 insertions(+), 61 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 2069296058..941e5dccd4 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -10,6 +10,7 @@ grid_search_step, hyperopt_step, polynomial_step, + simulated_annealing_step, ) @@ -34,6 +35,9 @@ class DoubleBracketScheduling(Enum): """Use greedy grid search.""" polynomial_approximation = polynomial_step """Use polynomial expansion (analytical) of the loss function.""" + simulated_annealing = simulated_annealing_step + """Use simulated annealing algorithm""" + class DoubleBracketCostFunction(Enum): """Define the DBI cost function.""" @@ -45,6 +49,7 @@ class DoubleBracketCostFunction(Enum): energy_fluctuation = auto() """Use energy fluctuation as cost function.""" + class DoubleBracketIteration: """ Class implementing the Double Bracket iteration algorithm. @@ -99,7 +104,7 @@ def __call__( if d is None: d = self.diagonal_h_matrix operator = self.backend.calculate_matrix_exp( - 1.0j*step, + 1.0j * step, self.commutator(d, self.h.matrix), ) elif mode is DoubleBracketGeneratorType.group_commutator: @@ -149,7 +154,9 @@ def backend(self): def least_squares(self, D: np.array): """Least squares cost function.""" H = self.h.matrix - return -np.real(np.trace(H@D)-0.5*(np.linalg.norm(H)**2+np.linalg.norm(D)**2)) + return -np.real( + np.trace(H @ D) - 0.5 * (np.linalg.norm(H) ** 2 + np.linalg.norm(D) ** 2) + ) def choose_step( self, diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 5f217cc948..548a7a8eec 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -1,26 +1,30 @@ import math +from copy import deepcopy from functools import partial from typing import Optional -from copy import deepcopy + import hyperopt import numpy as np - error = 1e-3 + def commutator(A, B): """Compute commutator between two arrays.""" - return A@B-B@A + return A @ B - B @ A + def variance(A, state): - """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\langle\mu|A^2|\mu\rangle-\langle\mu|A|\mu\rangle^2$""" - B = A@A - return B[state,state]-A[state,state]**2 + """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\\langle\\mu|A^2|\\mu\rangle-\\langle\\mu|A|\\mu\rangle^2$""" + B = A @ A + return B[state, state] - A[state, state] ** 2 + def covariance(A, B, state): - """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\langle\mu|AB|\mu\rangle-\langle\mu|A|\mu\rangle\langle\mu|B|\mu\rangle$""" - C = A@B+B@A - return C[state,state]-2*A[state,state]*B[state,state] + """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\\langle\\mu|AB|\\mu\rangle-\\langle\\mu|A|\\mu\rangle\\langle\\mu|B|\\mu\rangle$""" + C = A @ B + B @ A + return C[state, state] - 2 * A[state, state] * B[state, state] + def grid_search_step( dbi_object, @@ -49,7 +53,7 @@ def grid_search_step( d = dbi_object.diagonal_h_matrix loss_list = [dbi_object.loss(step, d=d) for step in space] - + idx_max_loss = np.argmin(loss_list) return space[idx_max_loss] @@ -89,14 +93,13 @@ def hyperopt_step( d = dbi_object.diagonal_h_matrix space = space("step", step_min, step_max) - - + best = hyperopt.fmin( - fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, + fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, ) return best["step"] @@ -120,7 +123,7 @@ def polynomial_step( """ if cost is None: cost = dbi_object.cost.name - + if d is None: d = dbi_object.diagonal_h_matrix @@ -134,10 +137,12 @@ def polynomial_step( elif cost == "least_squares": coef = least_squares_polynomial_expansion_coef(dbi_object, d, n) elif cost == "energy_fluctuation": - coef = energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, dbi_object.state) + coef = energy_fluctuation_polynomial_expansion_coef( + dbi_object, d, n, dbi_object.state + ) else: raise ValueError(f"Cost function {cost} not recognized.") - + roots = np.roots(coef) real_positive_roots = [ np.real(root) for root in roots if np.imag(root) < error and np.real(root) > 0 @@ -176,85 +181,155 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): coef = list(reversed(trace_coefficients[: n + 1])) return coef + def least_squares_polynomial_expansion_coef(dbi_object, d, n): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - Gamma_list = dbi_object.generate_Gamma_list(n+1, d) + Gamma_list = dbi_object.generate_Gamma_list(n + 1, d) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients coef = np.empty(n) for i in range(n): - coef[i] = np.real(exp_list[i]*np.trace(d@Gamma_list[i+1])) + coef[i] = np.real(exp_list[i] * np.trace(d @ Gamma_list[i + 1])) coef = list(reversed(coef)) return coef -#TODO: add a general expansion formula not stopping at 3rd order + +# TODO: add a general expansion formula not stopping at 3rd order def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - Gamma_list = dbi_object.generate_Gamma_list(n+1, d) + Gamma_list = dbi_object.generate_Gamma_list(n + 1, d) # coefficients coef = np.empty(3) - coef[0] = np.real(2*covariance(Gamma_list[0], Gamma_list[1],state)) - coef[1] = np.real(2*variance(Gamma_list[1],state)) - coef[2] = np.real(covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state)) + coef[0] = np.real(2 * covariance(Gamma_list[0], Gamma_list[1], state)) + coef[1] = np.real(2 * variance(Gamma_list[1], state)) + coef[2] = np.real( + covariance(Gamma_list[0], Gamma_list[3], state) + + 3 * covariance(Gamma_list[1], Gamma_list[2], state) + ) coef = list(reversed(coef)) return coef -def dGamma_diDiagonal(dbi_object, d, H, n, i,dGamma, Gamma_list): + +def dGamma_diDiagonal(dbi_object, d, H, n, i, dGamma, Gamma_list): # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) A = np.zeros(d.shape) - A[i,i] = 1 - B = commutator(commutator(A,H),Gamma_list[n-1]) - W = commutator(d,H) - return B + commutator(W,dGamma[-1]) + A[i, i] = 1 + B = commutator(commutator(A, H), Gamma_list[n - 1]) + W = commutator(d, H) + return B + commutator(W, dGamma[-1]) -def dpolynomial_diDiagonal(dbi_object, d,H,i): + +def dpolynomial_diDiagonal(dbi_object, d, H, i): # Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz) # Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation derivative = 0 s = polynomial_step(dbi_object, n=3, d=d) A = np.zeros(d.shape) Gamma_list = dbi_object.generate_Gamma_list(4, d) - A[i,i] = 1 - dGamma = [commutator(A,H)] - derivative += np.real(np.trace(Gamma_list[0]@A)+np.trace(dGamma[0]@d+Gamma_list[1]@A)*s) - for n in range(2,4): - dGamma.append(dGamma_diDiagonal(dbi_object,d,H,n,i,dGamma,Gamma_list)) - derivative += np.real(np.trace(dGamma[-1]@d + Gamma_list[n]@A)*s**n/math.factorial(n)) + A[i, i] = 1 + dGamma = [commutator(A, H)] + derivative += np.real( + np.trace(Gamma_list[0] @ A) + np.trace(dGamma[0] @ d + Gamma_list[1] @ A) * s + ) + for n in range(2, 4): + dGamma.append(dGamma_diDiagonal(dbi_object, d, H, n, i, dGamma, Gamma_list)) + derivative += np.real( + np.trace(dGamma[-1] @ d + Gamma_list[n] @ A) * s**n / math.factorial(n) + ) return derivative -def gradientDiagonal(dbi_object,d,H): + +def gradientDiagonal(dbi_object, d, H): # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz) grad = np.zeros(len(d)) for i in range(len(d)): - derivative = dpolynomial_diDiagonal(dbi_object,d,H,i) - grad[i] = d[i,i]-derivative + derivative = dpolynomial_diDiagonal(dbi_object, d, H, i) + grad[i] = d[i, i] - derivative return grad + def gradient_ascent(dbi_object, d, step, iterations): H = dbi_object.h.matrix - loss = np.zeros(iterations+1) - grad = np.zeros((iterations,len(d))) + loss = np.zeros(iterations + 1) + grad = np.zeros((iterations, len(d))) dbi_new = deepcopy(dbi_object) - s = polynomial_step(dbi_object, n = 3, d=d) - dbi_new(s,d=d) + s = polynomial_step(dbi_object, n=3, d=d) + dbi_new(s, d=d) loss[0] = dbi_new(d) - diagonals = np.empty((len(d),iterations+1)) - diagonals[:,0] = np.diag(d) + diagonals = np.empty((len(d), iterations + 1)) + diagonals[:, 0] = np.diag(d) for i in range(iterations): dbi_new = deepcopy(dbi_object) - grad[i,:] = gradientDiagonal(dbi_object, d, H) + grad[i, :] = gradientDiagonal(dbi_object, d, H) for j in range(len(d)): - d[j,j] = d[j,j] - step*grad[i,j] - s = polynomial_step(dbi_object, n = 3, d=d) - dbi_new(s,d=d) - loss[i+1] = dbi_new.least_squares(d) - diagonals[:,i+1] = np.diag(d) - - - return d,loss,grad,diagonals \ No newline at end of file + d[j, j] = d[j, j] - step * grad[i, j] + s = polynomial_step(dbi_object, n=3, d=d) + dbi_new(s, d=d) + loss[i + 1] = dbi_new.least_squares(d) + diagonals[:, i + 1] = np.diag(d) + + return d, loss, grad, diagonals + + +def simulated_annealing_step( + dbi_object, + d: Optional[np.array] = None, + initial_s=None, + step_min=1e-5, + step_max=1, + s_jump_range=None, + s_jump_range_divident=5, + initial_temp=1, + cooling_rate=0.85, + min_temp=1e-5, + max_iter=200, + verbose=False, +): + + if d is None: + d = dbi_object.diagonal_h_matrix + if initial_s is None: + initial_s = polynomial_step(dbi_object=dbi_object, d=d, n=4) + if s_jump_range is None: + s_jump_range = (step_max - step_min) / s_jump_range_divident + current_s = initial_s + current_loss = dbi_object.loss(d=d, step=current_s) + if verbose: + print("initial_s", current_s) + print("initial loss", current_loss) + temp = initial_temp + + for _ in range(max_iter): + candidate_s = max( + step_min, + min(current_s + np.random.uniform(-s_jump_range, s_jump_range, step_max)), + ) + candidate_loss = dbi_object.loss(d=d, step=candidate_s) + + # Calculate change in loss + delta_loss = candidate_loss - current_loss + + # Determine if the candidate solution is an improvement + if delta_loss < 0 or np.random.rand() < math.exp(-delta_loss / temp): + current_s = candidate_s + current_loss = candidate_loss + if verbose: + print( + f"Iter {_} s {candidate_s} accepted with loss {candidate_loss} and prob {math.exp(-delta_loss / temp)} at temp {temp}" + ) + elif verbose: + print( + f"Iter {_} s {candidate_s} loss {candidate_loss} not accepted with prob {math.exp(-delta_loss / temp)}" + ) + # Cool down + temp *= cooling_rate + if temp < min_temp: + break + + return current_s diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 1dcbb960d0..8cda5a2296 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -112,10 +112,14 @@ def test_energy_fluctuations(backend): @pytest.mark.parametrize( "scheduling", - [DoubleBracketScheduling.grid_search, DoubleBracketScheduling.hyperopt], + [ + DoubleBracketScheduling.grid_search, + DoubleBracketScheduling.hyperopt, + DoubleBracketScheduling.simulated_annealing, + ], ) @pytest.mark.parametrize("nqubits", [3, 4, 5]) -def test_double_bracket_iteration_scheduling_grid_hyperopt( +def test_double_bracket_iteration_scheduling_grid_hyperopt_annealing( backend, nqubits, scheduling ): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) From 0b241b16fdee28c56b1470f3af44df97c4b00581 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Wed, 20 Mar 2024 11:47:42 +0100 Subject: [PATCH 055/116] Update utils_scheduling.py fixed coefficient values for energy fluctuation --- src/qibo/models/dbi/utils_scheduling.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 5f217cc948..3aebfddff2 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -198,7 +198,7 @@ def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): # coefficients coef = np.empty(3) coef[0] = np.real(2*covariance(Gamma_list[0], Gamma_list[1],state)) - coef[1] = np.real(2*variance(Gamma_list[1],state)) + coef[1] = np.real(2*variance(Gamma_list[1],state)+2*covariance(Gamma_list[0],Gamma_list[2],state)) coef[2] = np.real(covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state)) coef = list(reversed(coef)) return coef From b3a5b0e77facd3063ca1ee5dc315e047b8497c53 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 25 Mar 2024 13:35:18 +0800 Subject: [PATCH 056/116] Fix lint error --- src/qibo/models/dbi/utils_scheduling.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 548a7a8eec..3c3968e773 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -308,7 +308,9 @@ def simulated_annealing_step( for _ in range(max_iter): candidate_s = max( step_min, - min(current_s + np.random.uniform(-s_jump_range, s_jump_range, step_max)), + min( + current_s + np.random.uniform(-1 * s_jump_range, s_jump_range, step_max) + ), ) candidate_loss = dbi_object.loss(d=d, step=candidate_s) From f91956b5d89e5745863b81c5930b149141fe1021 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 25 Mar 2024 14:27:23 +0800 Subject: [PATCH 057/116] Style changes for readability --- src/qibo/models/dbi/double_bracket.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 941e5dccd4..9d909d06ce 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -197,7 +197,7 @@ def loss(self, step: float, d: np.array = None, look_ahead: int = 1): loss = self.off_diagonal_norm elif self.cost == DoubleBracketCostFunction.least_squares: loss = self.least_squares(d) - else: + elif self.cost == DoubleBracketCostFunction.energy_fluctuation: loss = self.energy_fluctuation(self.state) # set back the initial configuration @@ -205,18 +205,20 @@ def loss(self, step: float, d: np.array = None, look_ahead: int = 1): return loss - def energy_fluctuation(self, state): + def energy_fluctuation(self, state=None): """ Evaluate energy fluctuation .. math:: - \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, + \\Xi(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, for a given state :math:`|\\mu\\rangle`. Args: state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ + if state is None: + state = self.state state_vector = np.zeros(len(self.h.matrix)) state_vector[state] = 1.0 return np.real(self.h.energy_fluctuation(state_vector)) From 9e914ded35154ace6376d43dcd38fb944e895868 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 25 Mar 2024 14:38:55 +0800 Subject: [PATCH 058/116] Remove verbose option for SA --- src/qibo/models/dbi/utils_scheduling.py | 37 ++++++++----------------- 1 file changed, 12 insertions(+), 25 deletions(-) diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 3c3968e773..7972b6e8e7 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -66,7 +66,6 @@ def hyperopt_step( space: callable = None, optimizer: callable = None, look_ahead: int = 1, - verbose: bool = False, d: Optional[np.array] = None, ): """ @@ -79,7 +78,6 @@ def hyperopt_step( space: see hyperopt.hp possibilities; optimizer: see hyperopt algorithms; look_ahead: number of iteration steps to compute the loss function; - verbose: level of verbosity; d: diagonal operator for generating double-bracket iterations. Returns: @@ -99,7 +97,6 @@ def hyperopt_step( space=space, algo=optimizer.suggest, max_evals=max_evals, - verbose=verbose, ) return best["step"] @@ -182,7 +179,7 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): return coef -def least_squares_polynomial_expansion_coef(dbi_object, d, n): +def least_squares_polynomial_expansion_coef(dbi_object, d: np.array = None, n: int = 3): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H @@ -197,7 +194,9 @@ def least_squares_polynomial_expansion_coef(dbi_object, d, n): # TODO: add a general expansion formula not stopping at 3rd order -def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): +def energy_fluctuation_polynomial_expansion_coef( + dbi_object, d: np.array = None, n: int = 3, state=0 +): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H @@ -214,7 +213,7 @@ def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): return coef -def dGamma_diDiagonal(dbi_object, d, H, n, i, dGamma, Gamma_list): +def dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list): # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) A = np.zeros(d.shape) A[i, i] = 1 @@ -236,7 +235,7 @@ def dpolynomial_diDiagonal(dbi_object, d, H, i): np.trace(Gamma_list[0] @ A) + np.trace(dGamma[0] @ d + Gamma_list[1] @ A) * s ) for n in range(2, 4): - dGamma.append(dGamma_diDiagonal(dbi_object, d, H, n, i, dGamma, Gamma_list)) + dGamma.append(dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list)) derivative += np.real( np.trace(dGamma[-1] @ d + Gamma_list[n] @ A) * s**n / math.factorial(n) ) @@ -257,21 +256,21 @@ def gradient_ascent(dbi_object, d, step, iterations): H = dbi_object.h.matrix loss = np.zeros(iterations + 1) grad = np.zeros((iterations, len(d))) - dbi_new = deepcopy(dbi_object) + dbi_eval = deepcopy(dbi_object) s = polynomial_step(dbi_object, n=3, d=d) - dbi_new(s, d=d) - loss[0] = dbi_new(d) + dbi_eval(s, d=d) + loss[0] = dbi_eval(d) diagonals = np.empty((len(d), iterations + 1)) diagonals[:, 0] = np.diag(d) for i in range(iterations): - dbi_new = deepcopy(dbi_object) + dbi_eval = deepcopy(dbi_object) grad[i, :] = gradientDiagonal(dbi_object, d, H) for j in range(len(d)): d[j, j] = d[j, j] - step * grad[i, j] s = polynomial_step(dbi_object, n=3, d=d) - dbi_new(s, d=d) - loss[i + 1] = dbi_new.least_squares(d) + dbi_eval(s, d=d) + loss[i + 1] = dbi_eval.least_squares(d) diagonals[:, i + 1] = np.diag(d) return d, loss, grad, diagonals @@ -289,7 +288,6 @@ def simulated_annealing_step( cooling_rate=0.85, min_temp=1e-5, max_iter=200, - verbose=False, ): if d is None: @@ -300,9 +298,6 @@ def simulated_annealing_step( s_jump_range = (step_max - step_min) / s_jump_range_divident current_s = initial_s current_loss = dbi_object.loss(d=d, step=current_s) - if verbose: - print("initial_s", current_s) - print("initial loss", current_loss) temp = initial_temp for _ in range(max_iter): @@ -321,14 +316,6 @@ def simulated_annealing_step( if delta_loss < 0 or np.random.rand() < math.exp(-delta_loss / temp): current_s = candidate_s current_loss = candidate_loss - if verbose: - print( - f"Iter {_} s {candidate_s} accepted with loss {candidate_loss} and prob {math.exp(-delta_loss / temp)} at temp {temp}" - ) - elif verbose: - print( - f"Iter {_} s {candidate_s} loss {candidate_loss} not accepted with prob {math.exp(-delta_loss / temp)}" - ) # Cool down temp *= cooling_rate if temp < min_temp: From 8d2b8fc842f41c50ce17da377c57d56e26cce2d8 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 25 Mar 2024 06:51:34 +0000 Subject: [PATCH 059/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/models/dbi/utils.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 1f0c2bce4d..d80d453f7d 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -175,4 +175,3 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) return coef - From 59a56ec82ad2d3565d93076fa0b7e01e932ab18f Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 26 Mar 2024 16:15:55 +0800 Subject: [PATCH 060/116] Fix errors emerged from merch --- examples/dbi/dbi_scheduling.ipynb | 48 +- examples/dbi/dbi_strategy_Pauli-Z 2.ipynb | 514 ---------------- .../dbi/dbi_strategy_magnetic_field.ipynb | 567 ++++++++++++++++-- src/qibo/models/dbi/utils.py | 48 +- src/qibo/models/dbi/utils_scheduling.py | 4 +- 5 files changed, 552 insertions(+), 629 deletions(-) delete mode 100644 examples/dbi/dbi_strategy_Pauli-Z 2.ipynb diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 1953c1272d..a7a813fcba 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -43,27 +43,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-12 17:24:06]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "\n", "# hamiltonian parameters\n", "nqubits = 5\n", @@ -86,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -109,24 +94,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "loss() got an unexpected keyword argument 'state'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[16], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m# grid_search\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m step_grid \u001b[39m=\u001b[39m dbi\u001b[39m.\u001b[39;49mchoose_step(scheduling\u001b[39m=\u001b[39;49mDoubleBracketScheduling\u001b[39m.\u001b[39;49mgrid_search)\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mgrid_search step:\u001b[39m\u001b[39m'\u001b[39m, step_grid)\n\u001b[0;32m 4\u001b[0m \u001b[39m# hyperopt\u001b[39;00m\n", - "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\double_bracket.py:164\u001b[0m, in \u001b[0;36mDoubleBracketIteration.choose_step\u001b[1;34m(self, d, scheduling, **kwargs)\u001b[0m\n\u001b[0;32m 162\u001b[0m \u001b[39mif\u001b[39;00m scheduling \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 163\u001b[0m scheduling \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mscheduling\n\u001b[1;32m--> 164\u001b[0m step \u001b[39m=\u001b[39m scheduling(\u001b[39mself\u001b[39m, d\u001b[39m=\u001b[39md, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 165\u001b[0m \u001b[39mif\u001b[39;00m (\n\u001b[0;32m 166\u001b[0m step \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m 167\u001b[0m \u001b[39mand\u001b[39;00m scheduling \u001b[39m==\u001b[39m DoubleBracketScheduling\u001b[39m.\u001b[39mpolynomial_approximation\n\u001b[0;32m 168\u001b[0m ):\n\u001b[0;32m 169\u001b[0m kwargs[\u001b[39m\"\u001b[39m\u001b[39mn\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m kwargs\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mn\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m3\u001b[39m)\n", - "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\utils_scheduling.py:47\u001b[0m, in \u001b[0;36mgrid_search_step\u001b[1;34m(dbi_object, step_min, step_max, num_evals, space, d, state)\u001b[0m\n\u001b[0;32m 44\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 45\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m---> 47\u001b[0m loss_list \u001b[39m=\u001b[39m [dbi_object\u001b[39m.\u001b[39mloss(step, d\u001b[39m=\u001b[39md, state\u001b[39m=\u001b[39mstate) \u001b[39mfor\u001b[39;00m step \u001b[39min\u001b[39;00m space]\n\u001b[0;32m 48\u001b[0m idx_max_loss \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmin(loss_list)\n\u001b[0;32m 49\u001b[0m \u001b[39mreturn\u001b[39;00m space[idx_max_loss]\n", - "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\utils_scheduling.py:47\u001b[0m, in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 44\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 45\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m---> 47\u001b[0m loss_list \u001b[39m=\u001b[39m [dbi_object\u001b[39m.\u001b[39;49mloss(step, d\u001b[39m=\u001b[39;49md, state\u001b[39m=\u001b[39;49mstate) \u001b[39mfor\u001b[39;00m step \u001b[39min\u001b[39;00m space]\n\u001b[0;32m 48\u001b[0m idx_max_loss \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmin(loss_list)\n\u001b[0;32m 49\u001b[0m \u001b[39mreturn\u001b[39;00m space[idx_max_loss]\n", - "\u001b[1;31mTypeError\u001b[0m: loss() got an unexpected keyword argument 'state'" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -306,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -321,7 +291,7 @@ "outputs": [], "source": [ "# Hamiltonian\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "nqubits = 4\n", "h0 = random_hermitian(2**nqubits)\n", "\n", diff --git a/examples/dbi/dbi_strategy_Pauli-Z 2.ipynb b/examples/dbi/dbi_strategy_Pauli-Z 2.ipynb deleted file mode 100644 index 5f563a172a..0000000000 --- a/examples/dbi/dbi_strategy_Pauli-Z 2.ipynb +++ /dev/null @@ -1,514 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Double-Bracket Iteration Strategy: Pauli-Z products\n", - "\n", - "In this example, we demonstrate the usage of a DBI strategy, where the diagonal operators for double bracket iterations are variationally chosen from all possible local Pauli-Z operators." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initial setup" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "!python -m pip install hyperopt # required to optimize the DBF step" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from copy import copy, deepcopy\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from qibo import hamiltonians, set_backend\n", - "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Below are some useful functions to visualize the diagonalization process." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def visualize_matrix(matrix, title=\"\"):\n", - " \"\"\"Visualize absolute values of a matrix in a heatmap form.\"\"\"\n", - " fig, ax = plt.subplots(figsize=(5, 5))\n", - " ax.set_title(title)\n", - " try:\n", - " im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n", - " except TypeError:\n", - " im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n", - " fig.colorbar(im, ax=ax)\n", - "\n", - "\n", - "def visualize_drift(h0, h):\n", - " \"\"\"Visualize drift of the evolved hamiltonian w.r.t. h0.\"\"\"\n", - " fig, ax = plt.subplots(figsize=(5, 5))\n", - " ax.set_title(r\"Drift: $|\\hat{H}_0 - \\hat{H}_{1}|$\")\n", - " try:\n", - " im = ax.imshow(np.absolute(h0 - h), cmap=\"inferno\")\n", - " except TypeError:\n", - " im = ax.imshow(np.absolute((h0 - h).get()), cmap=\"inferno\")\n", - "\n", - " fig.colorbar(im, ax=ax)\n", - "\n", - "\n", - "def plot_histories(loss_histories: list, steps: list, labels: list = None):\n", - " \"\"\"Plot off-diagonal norm histories over a sequential evolution.\"\"\"\n", - " plt.figure(figsize=(5, 5 * 6 / 8))\n", - " if len(steps) == 1:\n", - " # fixed_step\n", - " x_axis = [i * steps[0] for i in range(len(loss_histories))]\n", - " else:\n", - " x_axis = [sum(steps[:k]) for k in range(1, len(steps) + 1)]\n", - " plt.plot(x_axis, loss_histories, \"-o\")\n", - "\n", - " x_labels_rounded = [round(x, 2) for x in x_axis]\n", - " x_labels_rounded = [0] + x_labels_rounded[0:5] + [max(x_labels_rounded)]\n", - " x_labels_rounded.pop(3)\n", - " plt.xticks(x_labels_rounded)\n", - "\n", - " y_labels_rounded = [round(y, 1) for y in loss_histories]\n", - " y_labels_rounded = y_labels_rounded[0:5] + [min(y_labels_rounded)]\n", - " plt.yticks(y_labels_rounded)\n", - "\n", - " if labels is not None:\n", - " labels_copy = copy(labels)\n", - " labels_copy.insert(0, \"Initial\")\n", - " for i, label in enumerate(labels_copy):\n", - " plt.text(x_axis[i], loss_histories[i], label)\n", - "\n", - " plt.grid()\n", - " plt.xlabel(r\"Flow duration $s$\")\n", - " plt.title(\"Loss function histories\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Example: TFIM\n", - "\n", - "As an example, we consider the Transverse Field Ising Model (TFIM):\n", - "$$ H_{\\rm TFIM} = - \\sum_{i=1}^{N}\\bigl( Z_i Z_{i+1} + h X_i \\bigr),$$\n", - "which is already implemented in `Qibo`. For this tutorial we set $N=5$ and $h=3$." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# set the qibo backend (we suggest qibojit if N >= 20)\n", - "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", - "set_backend(\"qibojit\", \"numba\")\n", - "\n", - "# hamiltonian parameters\n", - "nqubits = 5\n", - "h = 3\n", - "\n", - "# define the hamiltonian\n", - "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", - "\n", - "# initialize class\n", - "# Note: use deepcopy to prevent h being edited\n", - "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", - "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(H_TFIM.matrix)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate local Pauli-Z operators" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "generate_local_Z = generate_Z_operators(nqubits)\n", - "Z_ops = list(generate_local_Z.values())\n", - "Z_names = list(generate_local_Z.keys())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Iteration from a list of operators\n", - "The idea of this strategy is to chose the Z operator that reduces the off-diagonal norm of the hamiltonian most efficiently. Given a list of operators (np.array), the function `select_best_dbr_generator_and_run` searches for the maximum decrease in off-diagonal norm for each operator and runs one double bracket rotation using the optimal operator from the list.\n", - "\n", - "Note that the hyperopt settings can be set as positional arguments." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "NSTEPS = 15\n", - "max_evals = 100\n", - "step_max = 1\n", - "Z_optimal = []\n", - "# add in initial values for plotting\n", - "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", - "steps = [0]\n", - "scheduling = DoubleBracketScheduling.use_hyperopt\n", - "for _ in range(NSTEPS):\n", - " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", - " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", - " steps.append(steps[-1]+step)\n", - " if flip_sign < 0:\n", - " Z_optimal.append('-' + Z_names[idx])\n", - " else:\n", - " Z_optimal.append(Z_names[idx])\n", - " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi.off_diagonal_norm}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plot_histories(off_diagonal_norm_history, steps, Z_optimal)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It is worth noting that due to the nature of `hyperopt`, the iterations may be unstable and multiple runs may be required for the optimal result (alternatively, we can perform a grid search on the optimal step). Hence, it is sometimes needed to adjust its parameters including the following:\n", - "\n", - "- step_min\n", - "- step_max\n", - "- max_evals" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compare with canonical\n", - "\n", - "We compare the effectiveness at diagonalzation between the Pauli-Z operators and the canonical generator:\n", - "\n", - "$$ d = [H,\\sigma(H)]$$" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# set the qibo backend (we suggest qibojit if N >= 20)\n", - "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", - "set_backend(\"qibojit\", \"numba\")\n", - "\n", - "\n", - "# initialize class|\n", - "# Note: use deepcopy to prevent h being edited\n", - "dbi_canonical = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", - "print(\"Initial off diagonal norm\", dbi_canonical.off_diagonal_norm)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n", - "steps_canonical = [0]\n", - "steps_canonical_plot = [0]\n", - "for s in range(NSTEPS):\n", - " # same settings as iteration from list\n", - " step = dbi_canonical.hyperopt_step(\n", - " step_min = 1e-5,\n", - " step_max = 1,\n", - " space = hp.uniform,\n", - " optimizer = tpe,\n", - " )\n", - " dbi_canonical(step=step)\n", - " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", - " off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n", - " steps_canonical.append(step)\n", - " steps_canonical_plot.append(steps_canonical_plot[-1]+step)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.figure()\n", - "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", - "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n", - "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n", - "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n", - "plt.xlabel(\"Iterations\")\n", - "plt.ylabel(\"Norm off-diagonal restriction\")\n", - "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(off_diagonal_norm_history)\n", - "print(off_diagonal_norm_history_canonical)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here, we make 2 observations:\n", - "\n", - "1. The canonical strategy has a steeper decrease at the beginning than Pauli-Z operators.\n", - "2. However, the canonical strategy is also prone to getting stuck at a local minimum and hence resultting in a lesser degree of diagonalization.\n", - "\n", - "Therefore, we explore the possibility of mixing the two strategies by including the canonical generator in the list." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Mixed strategy: optimal at each step" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dbi_mixed = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", - "print(\"Initial off diagonal norm\", dbi_mixed.off_diagonal_norm)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dbi_eval = deepcopy(dbi_mixed)\n", - "dbi_eval.mode = DoubleBracketGeneratorType.canonical\n", - "if step is None:\n", - " step = dbi_eval.hyperopt_step(\n", - " step_max=step_max,\n", - " space=hp.uniform,\n", - " optimizer=tpe,\n", - " max_evals=max_evals,\n", - " )\n", - "dbi_eval(step=step)\n", - "print('canonical norm', dbi_eval.off_diagonal_norm, 'step', step)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "Z_optimal_mixed = []\n", - "# add in initial values for plotting\n", - "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", - "steps = [0]\n", - "for _ in range(NSTEPS):\n", - " dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, scheduling=scheduling, compare_canonical=True, max_evals=max_evals, step_max=step_max)\n", - " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", - " steps.append(steps[-1]+step)\n", - " if idx == len(Z_ops):\n", - " Z_optimal_mixed.append('Canonical')\n", - " elif flip_sign < 0:\n", - " Z_optimal_mixed.append('-' + Z_names[idx])\n", - " else:\n", - " Z_optimal_mixed.append(Z_names[idx])\n", - " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal_mixed[-1]}, loss {dbi_mixed.off_diagonal_norm}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.figure()\n", - "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", - "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n", - "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n", - "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n", - "plt.plot(off_diagonal_norm_history_mixed, label=\"Mixed\")\n", - "plt.xlabel(\"Iterations\")\n", - "plt.ylabel(\"Norm off-diagonal restriction\")\n", - "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "After a few tests, we realize that the mixed strategy does not always outperform just using Pauli-Z operators. This could be caused by 2 reasons: \n", - "\n", - "1. Unstability of hyperopt\n", - "2. Tendency of canonical operator to get stuck at a near local minimum" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Mixed strategy: initial canonical\n", - "\n", - "Since the canonical double bracket iteration performs better at the initial steps, we attempt to combine the two strategies: iterate a few steps using the canonical bracket before switching to the variational Z-operators." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dbi_mixed_can= DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", - "print(\"Initial off diagonal norm\", dbi_mixed_can.off_diagonal_norm)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Run the initial iterations using canonical iterations\n", - "off_diagonal_norm_history_mixed_can = [dbi_mixed_can.off_diagonal_norm]\n", - "steps_mixed_can = [0]\n", - "cannonical_NSTEPS = 2\n", - "for i in range(cannonical_NSTEPS):\n", - " step = steps_canonical[i+1]\n", - " dbi_mixed_can(step=step)\n", - " off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n", - " steps_mixed_can.append(step)\n", - " \n", - "print(\"After 2 steps, off diagonal norm:\", dbi_mixed_can.off_diagonal_norm)\n", - "print(\"By comparison, the Pauli-Z:\", off_diagonal_norm_history[2])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Continue the remaining steps with Pauli-Z operators\n", - "Z_optimal_mixed_can = [\"Cannonical\" for _ in range(cannonical_NSTEPS)]\n", - "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", - "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n", - "for _ in range(remaining_NSTEPS):\n", - " dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", - " off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n", - " steps_mixed_can.append(step)\n", - " if idx == len(Z_ops):\n", - " Z_optimal_mixed.append('Canonical')\n", - " elif flip_sign < 0:\n", - " Z_optimal_mixed.append('-' + Z_names[idx])\n", - " else:\n", - " Z_optimal_mixed.append(Z_names[idx])\n", - " print(f\"New optimized step at iteration {_+1}/{remaining_NSTEPS}: {step} with operator {Z_optimal_mixed_can[-1]}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.figure()\n", - "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", - "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n", - "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n", - "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n", - "plt.plot(off_diagonal_norm_history_mixed, label=\"Mixed: optimal steps\")\n", - "plt.plot(off_diagonal_norm_history_mixed_can, label=\"Mixed: initial canonical\")\n", - "plt.xlabel(\"Iterations\")\n", - "plt.ylabel(\"Norm off-diagonal restriction\")\n", - "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This example also shows that the canonical generator is more likely to drive the model into a local minimum than variationally assigned diagonal operator, and that it is hard to get it unstuck even with the Pauli-Z operators." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index 1455a1daca..fc1c51bd40 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -58,12 +58,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-03-26 16:07:47]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 31.576176740060667\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# backend\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "# initialize dbi object\n", "nqubits = 5\n", "h0 = random_hermitian(2**nqubits, seed=2)\n", @@ -77,15 +102,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 691.96trial/s, best loss: 27.607175404720753]\n", + "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j)]\n", + "Gradient: [-0.20478337 0.418433 -0.03167988 0.18669773 -0.86435984]\n", + "s: 0.11660954506915275\n" + ] + } + ], "source": [ "# generate the onsite Z operators\n", "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi, d, n_taylor=5, onsite_Z_ops=onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi, d=d, onsite_Z_ops=onsite_Z_ops)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", "print('s:', s)" @@ -93,15 +140,52 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 703.22trial/s, best loss: 27.607182422340095] \n", + "100%|██████████| 500/500 [00:00<00:00, 729.43trial/s, best loss: 24.35179754917795] \n", + "100%|██████████| 500/500 [00:00<00:00, 729.08trial/s, best loss: 22.089444283591433] \n", + "100%|██████████| 500/500 [00:00<00:00, 698.65trial/s, best loss: 20.347120765676763]\n", + "100%|██████████| 500/500 [00:00<00:00, 623.16trial/s, best loss: 18.94635121785982]\n", + "100%|██████████| 500/500 [00:00<00:00, 605.13trial/s, best loss: 17.773702241529776] \n", + "100%|██████████| 500/500 [00:00<00:00, 687.10trial/s, best loss: 16.784805711373227] \n", + "100%|██████████| 500/500 [00:00<00:00, 695.51trial/s, best loss: 15.934402363491223] \n", + "100%|██████████| 500/500 [00:00<00:00, 652.85trial/s, best loss: 15.197822552085507] \n", + "100%|██████████| 500/500 [00:00<00:00, 685.77trial/s, best loss: 14.481250187299748] \n", + "100%|██████████| 500/500 [00:00<00:00, 692.66trial/s, best loss: 14.044172334074341] \n", + "100%|██████████| 500/500 [00:00<00:00, 692.91trial/s, best loss: 13.670766358199891] \n", + "100%|██████████| 500/500 [00:00<00:00, 684.26trial/s, best loss: 13.325331286760488] \n", + "100%|██████████| 500/500 [00:00<00:00, 636.50trial/s, best loss: 13.01668686825596] \n", + "100%|██████████| 500/500 [00:00<00:00, 612.11trial/s, best loss: 12.711623339299685] \n", + "100%|██████████| 500/500 [00:00<00:00, 697.36trial/s, best loss: 12.409020875491057] \n", + "100%|██████████| 500/500 [00:00<00:00, 683.72trial/s, best loss: 12.08748982503799] \n", + "100%|██████████| 500/500 [00:00<00:00, 738.27trial/s, best loss: 11.75348065601818]\n", + "100%|██████████| 500/500 [00:00<00:00, 724.55trial/s, best loss: 11.410208539441799] \n", + "100%|██████████| 500/500 [00:00<00:00, 729.97trial/s, best loss: 11.06582875641592] \n", + "100%|██████████| 500/500 [00:00<00:00, 723.17trial/s, best loss: 10.734278849532725] \n", + "100%|██████████| 500/500 [00:00<00:00, 736.09trial/s, best loss: 10.391106227243483] \n", + "100%|██████████| 500/500 [00:00<00:00, 695.73trial/s, best loss: 9.835687097799866] \n", + "100%|██████████| 500/500 [00:00<00:00, 645.00trial/s, best loss: 9.836151362023536]\n", + "100%|██████████| 500/500 [00:00<00:00, 662.94trial/s, best loss: 9.83679254247866] \n", + "100%|██████████| 500/500 [00:00<00:00, 692.56trial/s, best loss: 9.83815541734947] \n", + "100%|██████████| 500/500 [00:00<00:00, 683.98trial/s, best loss: 9.838623865790995] \n", + "100%|██████████| 500/500 [00:00<00:00, 691.24trial/s, best loss: 9.83915601848446] \n", + "100%|██████████| 500/500 [00:00<00:00, 697.64trial/s, best loss: 9.843010172903082] \n", + "100%|██████████| 500/500 [00:00<00:00, 669.37trial/s, best loss: 9.844996826247685] \n" + ] + } + ], "source": [ "iters = 30\n", "off_diagonal_norm = [dbi.off_diagonal_norm]\n", "s_step = [0]\n", "for i in range(iters):\n", - " s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef=d_coef, d=d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", " dbi(step=s, d=d)\n", " off_diagonal_norm.append(dbi.off_diagonal_norm)\n", " s_step.append(s)" @@ -109,9 +193,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.title(str(nqubits) + ' spins random hamiltonian')\n", "plt.plot(off_diagonal_norm)\n", @@ -131,9 +236,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:13]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# generate the Hamiltonian\n", "nqubits = 5\n", @@ -148,27 +271,58 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-03-26 16:08:14]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], "source": [ "# backend\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "# initialize dbi object\n", "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:01<00:00, 383.66trial/s, best loss: 8.1443761719701] \n", + "Initial off-diagonal norm: 9.844996868109437\n", + "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n", + "Gradient: [-0.22567346 -0.52080864 -0.59637211 -0.52080864 -0.22567346]\n", + "s: 0.05271207518843116\n" + ] + } + ], "source": [ "# generate the onsite Z operators\n", "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi_TFIM, d, n_taylor=5, onsite_Z_ops=onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi_TFIM, d, n=5, onsite_Z_ops=onsite_Z_ops)\n", "print('Initial off-diagonal norm:', dbi.off_diagonal_norm)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", @@ -177,15 +331,52 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 591.53trial/s, best loss: 8.145383187499851]\n", + "New optimized step at iteration 1/15: 0.05372645731587117 with d_coef [(-0.9894224152921011+0j), (-0.9787695132043422+0j), (-0.9750406784474285+0j), (-0.9787695132043422+0j), (-0.9894224152921011+0j)], loss 8.143621474679835\n", + "100%|██████████| 500/500 [00:00<00:00, 645.70trial/s, best loss: 7.605789256028495]\n", + "New optimized step at iteration 2/15: 0.05650469375482817 with d_coef [(-0.967659680502992+0j), (-1.1697984701193866+0j), (-1.1812229848159992+0j), (-1.169798470119386+0j), (-0.9676596805029926+0j)], loss 7.597613753384701\n", + "100%|██████████| 500/500 [00:00<00:00, 655.89trial/s, best loss: 7.428351470243482] \n", + "New optimized step at iteration 3/15: 0.0398775478554277 with d_coef [(-0.9211510601202757+0j), (-1.8583923563596692+0j), (-1.3920649030243233+0j), (-1.8583923563596683+0j), (-0.9211510601202774+0j)], loss 7.340829616091421\n", + "100%|██████████| 500/500 [00:00<00:00, 662.71trial/s, best loss: 7.044497387511533] \n", + "New optimized step at iteration 4/15: 0.04899248221924902 with d_coef [(-0.6972643143931548+0j), (-2.4626900070115862+0j), (-0.9844514837970455+0j), (-2.462690007011585+0j), (-0.6972643143931571+0j)], loss 6.642213913279594\n", + "100%|██████████| 500/500 [00:00<00:00, 657.76trial/s, best loss: 5.999678025090855] \n", + "New optimized step at iteration 5/15: 0.022874588399740523 with d_coef [(-0.5466790556822081+0j), (-2.999350700331548+0j), (-0.3794556667684317+0j), (-2.9993507003315476+0j), (-0.5466790556822098+0j)], loss 5.886447625252318\n", + "100%|██████████| 500/500 [00:00<00:00, 574.02trial/s, best loss: 5.3112300777947405]\n", + "New optimized step at iteration 6/15: 0.019141369630992236 with d_coef [(-0.7333858133569751+0j), (-3.0535952858417934+0j), (0.5756460221651358+0j), (-3.053595285841793+0j), (-0.7333858133569763+0j)], loss 5.250048883689106\n", + "100%|██████████| 500/500 [00:00<00:00, 675.11trial/s, best loss: 4.816608426854996] \n", + "New optimized step at iteration 7/15: 0.023987091082236008 with d_coef [(-1.0481221272508368+0j), (-3.1124649418400363+0j), (1.4655494332027308+0j), (-3.1124649418400367+0j), (-1.048122127250837+0j)], loss 4.718211391122002\n", + "100%|██████████| 500/500 [00:00<00:00, 679.58trial/s, best loss: 4.284286113986318] \n", + "New optimized step at iteration 8/15: 0.02139251957239659 with d_coef [(-1.4568864129920867+0j), (-3.060562777832911+0j), (2.2749298849030803+0j), (-3.0605627778329114+0j), (-1.4568864129920873+0j)], loss 4.141138157155743\n", + "100%|██████████| 500/500 [00:00<00:00, 707.05trial/s, best loss: 3.539292516453598] \n", + "New optimized step at iteration 9/15: 0.02678154139520766 with d_coef [(-1.8702833982016478+0j), (-2.970343142930349+0j), (3.048114960756174+0j), (-2.9703431429303495+0j), (-1.8702833982016478+0j)], loss 3.3574911798518396\n", + "100%|██████████| 500/500 [00:00<00:00, 712.38trial/s, best loss: 2.874231151326864] \n", + "New optimized step at iteration 10/15: 0.01690916984115942 with d_coef [(-2.3030995103215814+0j), (-2.7605226880132614+0j), (3.777805532801257+0j), (-2.7605226880132614+0j), (-2.3030995103215792+0j)], loss 2.8230284010126816\n", + "100%|██████████| 500/500 [00:00<00:00, 666.99trial/s, best loss: 2.6088111056187437]\n", + "New optimized step at iteration 11/15: 0.026384092579150507 with d_coef [(-2.303103545745607+0j), (-2.76052331639202+0j), (3.7778137111811922+0j), (-2.76052331639202+0j), (-2.303103545745605+0j)], loss 2.6088111361606745\n", + "100%|██████████| 500/500 [00:00<00:00, 698.11trial/s, best loss: 2.546900361123962] \n", + "New optimized step at iteration 12/15: 0.015856203984303208 with d_coef [(-2.4537053596179947+0j), (-2.9677391380139637+0j), (4.069082377286002+0j), (-2.9677391380139513+0j), (-2.453705359617996+0j)], loss 2.546553818422246\n", + "100%|██████████| 500/500 [00:00<00:00, 742.58trial/s, best loss: 2.5253329418331236] \n", + "New optimized step at iteration 13/15: 0.022393088088665674 with d_coef [(-2.3237315151526348+0j), (-3.577847645999822+0j), (4.518564738562181+0j), (-3.577847645999736+0j), (-2.323731515152562+0j)], loss 2.500500419765173\n", + "100%|██████████| 500/500 [00:00<00:00, 746.30trial/s, best loss: 2.477865397687387] \n", + "New optimized step at iteration 14/15: 0.015967541185165194 with d_coef [(-1.9364597181792154+0j), (-4.149207093868703+0j), (4.441437397182407+0j), (-4.149207093868369+0j), (-1.936459718178632+0j)], loss 2.4579020061866172\n", + "100%|██████████| 500/500 [00:00<00:00, 742.62trial/s, best loss: 2.435713071167654] \n", + "New optimized step at iteration 15/15: 0.01431296703708781 with d_coef [(-1.5093021425133906+0j), (-4.700001486852238+0j), (4.295827265099874+0j), (-4.700001486851165+0j), (-1.5093021425092228+0j)], loss 2.422561227610107\n" + ] + } + ], "source": [ "NSTEPS = 15\n", "off_diagonal_norm_delta = [dbi_TFIM.off_diagonal_norm]\n", "s_step_delta = [0]\n", "for _ in range(NSTEPS):\n", - " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100, n_taylor=5, use_ds=True)\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100, n=5, use_ds=True)\n", " dbi_TFIM(step=s, d=d)\n", " off_diagonal_norm_delta.append(dbi_TFIM.off_diagonal_norm)\n", " s_step_delta.append(s)\n", @@ -194,9 +385,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", "plt.plot(off_diagonal_norm_delta)\n", @@ -206,9 +418,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# the final matrix\n", "visualize_matrix(dbi_TFIM.h.matrix)" @@ -224,9 +447,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(-2.580645161290323+0j), (-1.2903225806451613+0j), (-0.6451612903225807+0j), (-0.32258064516129037+0j), (-0.16129032258064518+0j)]\n" + ] + } + ], "source": [ "H = H_TFIM.matrix\n", "L = int(np.log2(H.shape[0]))\n", @@ -238,9 +469,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "visualize_matrix(H, 'Initial hamiltonian')\n", "visualize_matrix(N, 'Min-max diagonal matrix')\n", @@ -256,21 +518,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-03-26 16:08:28]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], "source": [ "# backend\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "# initialize dbi object\n", "dbi_TFIM_MMH = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 688.27trial/s, best loss: 9.336239342915379]\n", + "New optimized step at iteration 1/15: 0.039240166337035656 with d_coef [(-2.3180340693309422+0j), (-0.9042157574954297+0j), (-0.6267094129284807+0j), (-0.37510402952816974+0j), (-0.16137910360026844+0j)], loss 9.263805656974093\n", + "100%|██████████| 500/500 [00:00<00:00, 654.86trial/s, best loss: 8.253271106315344] \n", + "New optimized step at iteration 2/15: 0.0636971166898561 with d_coef [(-2.8893154826347565+0j), (-1.3328071932958503+0j), (-0.5996311871447069+0j), (-0.38812640871658144+0j), (-0.16592899239661785+0j)], loss 8.248988639626276\n", + "100%|██████████| 500/500 [00:00<00:00, 705.90trial/s, best loss: 7.820911729728226] \n", + "New optimized step at iteration 3/15: 0.026774099108320803 with d_coef [(-3.9047191557345737+0j), (-1.3620955366051533+0j), (-1.094932722170599+0j), (-0.5744178736473565+0j), (-0.04727696085745736+0j)], loss 7.79237041903216\n", + "100%|██████████| 500/500 [00:00<00:00, 522.76trial/s, best loss: 7.506187222292692]\n", + "New optimized step at iteration 4/15: 0.029295596624437686 with d_coef [(-3.894655859483571+0j), (-1.866243073713661+0j), (-0.7092145648013096+0j), (-0.7039608847825699+0j), (-0.023283739763302808+0j)], loss 7.4962199726801755\n", + "100%|██████████| 500/500 [00:00<00:00, 576.24trial/s, best loss: 7.262455656549131]\n", + "New optimized step at iteration 5/15: 0.02836170693029348 with d_coef [(-3.9671435812064013+0j), (-1.748374386604198+0j), (-0.9350901630745362+0j), (-0.6281543245247632+0j), (-0.021512156595171472+0j)], loss 7.242940534826334\n", + "100%|██████████| 500/500 [00:00<00:00, 671.15trial/s, best loss: 7.044926289914773]\n", + "New optimized step at iteration 6/15: 0.027897015043668715 with d_coef [(-3.948390041694754+0j), (-1.8847156433519916+0j), (-0.8262997874928508+0j), (-0.6276868981090158+0j), (-0.03885078124692265+0j)], loss 7.026681601151195\n", + "100%|██████████| 500/500 [00:00<00:00, 690.94trial/s, best loss: 6.855318614477858] \n", + "New optimized step at iteration 7/15: 0.027095778110113995 with d_coef [(-3.9519653973013913+0j), (-1.911636257457286+0j), (-0.8907292589911223+0j), (-0.6344354980656255+0j), (-0.0239873577390306+0j)], loss 6.826359605831807\n", + "100%|██████████| 500/500 [00:00<00:00, 520.20trial/s, best loss: 6.6782408641935875]\n", + "New optimized step at iteration 8/15: 0.027670995126608866 with d_coef [(-3.9302491674477538+0j), (-1.9666365073691627+0j), (-0.8561543524586357+0j), (-0.6383800207112388+0j), (-0.004655769048021813+0j)], loss 6.636290444352086\n", + "100%|██████████| 500/500 [00:00<00:00, 576.02trial/s, best loss: 6.500633770102917]\n", + "New optimized step at iteration 9/15: 0.027675484066740867 with d_coef [(-3.910374644169554+0j), (-1.9831418560231258+0j), (-0.9056736621483122+0j), (-0.6540987589359828+0j), (0.02406147464053876+0j)], loss 6.447464047229631\n", + "100%|██████████| 500/500 [00:00<00:00, 686.99trial/s, best loss: 6.319748615035787]\n", + "New optimized step at iteration 10/15: 0.026930095210157 with d_coef [(-3.886824281463916+0j), (-1.99625546879924+0j), (-0.9414450075378732+0j), (-0.6563760409606512+0j), (0.03970055245590362+0j)], loss 6.2592485638502575\n", + "100%|██████████| 500/500 [00:00<00:00, 678.32trial/s, best loss: 6.1400705423264075]\n", + "New optimized step at iteration 11/15: 0.027416250931757133 with d_coef [(-3.8475665420145373+0j), (-2.037392997099672+0j), (-0.9264643353804642+0j), (-0.6830139042784837+0j), (0.08321313069136971+0j)], loss 6.056764516965165\n", + "100%|██████████| 500/500 [00:00<00:00, 729.97trial/s, best loss: 5.940597947808348] \n", + "New optimized step at iteration 12/15: 0.028200202317592835 with d_coef [(-3.82460449840812+0j), (-2.035906559623582+0j), (-0.9702033338205296+0j), (-0.6848609304443387+0j), (0.11118456157172787+0j)], loss 5.848596463276441\n", + "100%|██████████| 500/500 [00:00<00:00, 743.16trial/s, best loss: 5.72938416138] \n", + "New optimized step at iteration 13/15: 0.025525484486623708 with d_coef [(-3.8277137978993436+0j), (-2.0402358325723036+0j), (-0.9967614632890175+0j), (-0.6822006377994072+0j), (0.09661303923602668+0j)], loss 5.643243093952352\n", + "100%|██████████| 500/500 [00:00<00:00, 722.17trial/s, best loss: 5.532276668994669] \n", + "New optimized step at iteration 14/15: 0.028418788139760974 with d_coef [(-3.7489089984244486+0j), (-2.114017010442895+0j), (-0.9183197191620466+0j), (-0.7036125621442609+0j), (0.16285610695072883+0j)], loss 5.4057916657046725\n", + "100%|██████████| 500/500 [00:00<00:00, 739.76trial/s, best loss: 5.288910417094644] \n", + "New optimized step at iteration 15/15: 0.02625000676004677 with d_coef [(-3.789232226109539+0j), (-2.092494639505251+0j), (-1.0022140546781002+0j), (-0.6714823814533052+0j), (0.13551681944910254+0j)], loss 5.191808803025761\n" + ] + } + ], "source": [ "NSTEPS = 15\n", "off_diagonal_norm_MMH = [dbi_TFIM_MMH.off_diagonal_norm]\n", @@ -289,9 +596,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", "plt.plot(off_diagonal_norm_MMH, label='MMH')\n", @@ -305,17 +633,42 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Effect of `n_taylor`" + "## Effect of `n`" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-03-26 16:08:41]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 31.576176740060667\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# backend\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "# initialize dbi object\n", "nqubits = 5\n", "h0 = random_hermitian(2**nqubits, seed=2)\n", @@ -331,15 +684,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 697.70trial/s, best loss: 9.558186537868679] \n", + "The initial D coefficients: [(-3.321354431855655-1.7961649980378765e-16j), (-0.7143725995296772+3.608986798092513e-17j), (0.472710854506152+9.347215093087467e-17j), (-0.5707798509274735-1.3813111045761499e-17j), (0.34536980200226214-1.1499770144849896e-16j)]\n", + "Gradient: [ 0.65534217 0.16603388 -0.31270245 0.27247095 0.60904527]\n", + "s: 0.024282460160549718\n" + ] + } + ], "source": [ "# generate the onsite Z operators\n", "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi,d,n_taylor=5, onsite_Z_ops=onsite_Z_ops)\n", + "grad, s = gradient_onsite_Z(dbi,d,n=5, onsite_Z_ops=onsite_Z_ops)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", "print('s:', s)" @@ -347,9 +722,76 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 596.09trial/s, best loss: 27.467491165569765]\n", + "100%|██████████| 500/500 [00:00<00:00, 689.73trial/s, best loss: 27.469650148347917] \n", + "100%|██████████| 500/500 [00:00<00:00, 684.87trial/s, best loss: 23.138955844687388] \n", + "100%|██████████| 500/500 [00:00<00:00, 680.99trial/s, best loss: 23.147351603039073]\n", + "100%|██████████| 500/500 [00:00<00:00, 709.00trial/s, best loss: 20.03558303567074] \n", + "100%|██████████| 500/500 [00:00<00:00, 638.55trial/s, best loss: 20.01446017712839] \n", + "100%|██████████| 500/500 [00:00<00:00, 659.72trial/s, best loss: 18.534762036988734]\n", + "100%|██████████| 500/500 [00:00<00:00, 702.62trial/s, best loss: 18.511235299525854]\n", + "100%|██████████| 500/500 [00:00<00:00, 716.91trial/s, best loss: 17.667631299146947] \n", + "100%|██████████| 500/500 [00:00<00:00, 717.85trial/s, best loss: 17.623675374778802] \n", + "100%|██████████| 500/500 [00:00<00:00, 626.07trial/s, best loss: 17.043867777621116]\n", + "100%|██████████| 500/500 [00:00<00:00, 662.03trial/s, best loss: 16.99411319096819] \n", + "100%|██████████| 500/500 [00:00<00:00, 694.96trial/s, best loss: 16.644107561332255]\n", + "100%|██████████| 500/500 [00:00<00:00, 712.76trial/s, best loss: 16.467189206952877] \n", + "100%|██████████| 500/500 [00:00<00:00, 713.76trial/s, best loss: 16.046314213095602]\n", + "100%|██████████| 500/500 [00:00<00:00, 699.95trial/s, best loss: 15.878928292681035] \n", + "100%|██████████| 500/500 [00:00<00:00, 691.24trial/s, best loss: 15.62141427589626] \n", + "100%|██████████| 500/500 [00:00<00:00, 667.73trial/s, best loss: 15.306325490043811] \n", + "100%|██████████| 500/500 [00:00<00:00, 694.90trial/s, best loss: 15.001484687547642] \n", + "100%|██████████| 500/500 [00:00<00:00, 709.52trial/s, best loss: 14.685062151226393] \n", + "100%|██████████| 500/500 [00:00<00:00, 710.15trial/s, best loss: 14.382216679135025] \n", + "100%|██████████| 500/500 [00:00<00:00, 710.67trial/s, best loss: 14.119940441735679] \n", + "100%|██████████| 500/500 [00:00<00:00, 708.88trial/s, best loss: 13.78053626699668] \n", + "100%|██████████| 500/500 [00:00<00:00, 626.04trial/s, best loss: 13.454854914663409] \n", + "100%|██████████| 500/500 [00:00<00:00, 703.66trial/s, best loss: 13.234269890734126] \n", + "100%|██████████| 500/500 [00:00<00:00, 718.00trial/s, best loss: 12.91970011325924] \n", + "100%|██████████| 500/500 [00:00<00:00, 720.73trial/s, best loss: 12.720794188076404] \n", + "100%|██████████| 500/500 [00:00<00:00, 707.81trial/s, best loss: 12.318517501084749] \n", + "100%|██████████| 500/500 [00:00<00:00, 681.10trial/s, best loss: 12.239079499566277]\n", + "100%|██████████| 500/500 [00:00<00:00, 725.63trial/s, best loss: 11.84799809909737] \n", + "100%|██████████| 500/500 [00:00<00:00, 718.62trial/s, best loss: 11.791868030395284] \n", + "100%|██████████| 500/500 [00:00<00:00, 720.66trial/s, best loss: 11.327252333996837]\n", + "100%|██████████| 500/500 [00:00<00:00, 714.03trial/s, best loss: 11.399156998591792] \n", + "100%|██████████| 500/500 [00:00<00:00, 716.52trial/s, best loss: 10.930539957425072] \n", + "100%|██████████| 500/500 [00:00<00:00, 677.71trial/s, best loss: 11.030749112814767]\n", + "100%|██████████| 500/500 [00:00<00:00, 722.09trial/s, best loss: 10.541671026174445] \n", + "100%|██████████| 500/500 [00:00<00:00, 651.08trial/s, best loss: 10.710765125494259] \n", + "100%|██████████| 500/500 [00:00<00:00, 721.96trial/s, best loss: 10.218781456526894] \n", + "100%|██████████| 500/500 [00:00<00:00, 714.29trial/s, best loss: 10.415667907517046] \n", + "100%|██████████| 500/500 [00:00<00:00, 710.97trial/s, best loss: 9.86363032877] \n", + "100%|██████████| 500/500 [00:00<00:00, 719.97trial/s, best loss: 10.15401395656047] \n", + "100%|██████████| 500/500 [00:00<00:00, 723.84trial/s, best loss: 9.562300454021948] \n", + "100%|██████████| 500/500 [00:00<00:00, 718.29trial/s, best loss: 9.907794571609012] \n", + "100%|██████████| 500/500 [00:00<00:00, 674.37trial/s, best loss: 9.224080650038678]\n", + "100%|██████████| 500/500 [00:00<00:00, 697.77trial/s, best loss: 9.68514825302649] \n", + "100%|██████████| 500/500 [00:00<00:00, 725.93trial/s, best loss: 8.950894937315692] \n", + "100%|██████████| 500/500 [00:00<00:00, 722.83trial/s, best loss: 9.467012864418232]\n", + "100%|██████████| 500/500 [00:00<00:00, 720.74trial/s, best loss: 8.647047841471467] \n", + "100%|██████████| 500/500 [00:00<00:00, 722.07trial/s, best loss: 9.264932438521221] \n", + "100%|██████████| 500/500 [00:00<00:00, 724.61trial/s, best loss: 8.403247837651655] \n", + "100%|██████████| 500/500 [00:00<00:00, 686.26trial/s, best loss: 9.063835314892646]\n", + "100%|██████████| 500/500 [00:00<00:00, 717.35trial/s, best loss: 8.149990124972552] \n", + "100%|██████████| 500/500 [00:00<00:00, 715.79trial/s, best loss: 8.87960896954228] \n", + "100%|██████████| 500/500 [00:00<00:00, 726.35trial/s, best loss: 7.913881055204248]\n", + "100%|██████████| 500/500 [00:00<00:00, 724.78trial/s, best loss: 8.697803369655396] \n", + "100%|██████████| 500/500 [00:00<00:00, 687.97trial/s, best loss: 7.678966990725647] \n", + "100%|██████████| 500/500 [00:00<00:00, 720.81trial/s, best loss: 8.529279658079181] \n", + "100%|██████████| 500/500 [00:00<00:00, 728.49trial/s, best loss: 7.4907779318523815]\n", + "100%|██████████| 500/500 [00:00<00:00, 721.37trial/s, best loss: 8.367946297589626] \n", + "100%|██████████| 500/500 [00:00<00:00, 723.56trial/s, best loss: 7.305839659415738] \n" + ] + } + ], "source": [ "iters = 30\n", "d_coef_1, d_1 = d_coef, d\n", @@ -360,8 +802,8 @@ "s_step_1 = [0]\n", "s_step_2 = [0]\n", "for i in range(iters):\n", - " s_1, d_coef_1, d_1 = gradient_descent_onsite_Z(dbi_1, d_coef_1, d_1, onsite_Z_ops=onsite_Z_ops, n_taylor=n_1, max_evals=100)\n", - " s_2, d_coef_2, d_2 = gradient_descent_onsite_Z(dbi_2, d_coef_2, d_2, onsite_Z_ops=onsite_Z_ops, n_taylor=n_2, max_evals=100)\n", + " s_1, d_coef_1, d_1 = gradient_descent_onsite_Z(dbi_1, d_coef_1, d_1, onsite_Z_ops=onsite_Z_ops, n=n_1, max_evals=100)\n", + " s_2, d_coef_2, d_2 = gradient_descent_onsite_Z(dbi_2, d_coef_2, d_2, onsite_Z_ops=onsite_Z_ops, n=n_2, max_evals=100)\n", " dbi_1(step=s_1, d=d_1)\n", " dbi_2(step=s_2, d=d_2)\n", " off_diagonal_norm_1.append(dbi_1.off_diagonal_norm)\n", @@ -372,9 +814,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", "plt.plot(off_diagonal_norm_1, label=f'n_taylor={n_1}')\n", diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 6626c3db03..f478777e93 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -96,14 +96,13 @@ def select_best_dbr_generator( """ if scheduling is None: scheduling = dbi_object.scheduling - norms_off_diagonal_restriction = [ - dbi_object.off_diagonal_norm for _ in range(len(d_list)) - ] - optimal_steps, flip_list = [], [] + norms_off_diagonal_restriction = [dbi_object.off_diagonal_norm] * (len(d_list) + 1) + optimal_steps = np.zeros(len(d_list) + 1) + flip_list = np.ones(len(d_list) + 1) for i, d in enumerate(d_list): # prescribed step durations dbi_eval = deepcopy(dbi_object) - flip_list.append(cs_angle_sgn(dbi_eval, d)) + flip_list[i] = cs_angle_sgn(dbi_eval, d) if flip_list[i] != 0: if step is None: step_best = dbi_eval.choose_step( @@ -112,11 +111,10 @@ def select_best_dbr_generator( else: step_best = step dbi_eval(step=step_best, d=flip_list[i] * d) - optimal_steps.append(step_best) + optimal_steps[i] = step_best norms_off_diagonal_restriction[i] = dbi_eval.off_diagonal_norm # canonical if compare_canonical is True: - flip_list.append(1) dbi_eval = deepcopy(dbi_object) dbi_eval.mode = DoubleBracketGeneratorType.canonical if step is None: @@ -124,8 +122,8 @@ def select_best_dbr_generator( else: step_best = step dbi_eval(step=step_best) - optimal_steps.append(step_best) - norms_off_diagonal_restriction.append(dbi_eval.off_diagonal_norm) + optimal_steps[-1] = step_best + norms_off_diagonal_restriction[-1] = dbi_eval.off_diagonal_norm # find best d idx_max_loss = np.argmin(norms_off_diagonal_restriction) flip = flip_list[idx_max_loss] @@ -175,6 +173,7 @@ def dGamma_di_onsite_Z( else: Z_i = onsite_Z_ops[i] dGamma_di = [np.zeros((2**nqubits, 2**nqubits))] * (n + 1) + Gamma_list = dbi_object.generate_Gamma_list(n=n + 2, d=d) W = dbi_object.commutator(d, dbi_object.h.matrix) dW_di = dbi_object.commutator(Z_i, dbi_object.h.matrix) for k in range(n + 1): @@ -184,7 +183,7 @@ def dGamma_di_onsite_Z( dGamma_di[k] = dW_di else: dGamma_di[k] = dbi_object.commutator( - dW_di, dbi_object.Gamma(k - 1, d) + dW_di, Gamma_list[k - 1] ) + dbi_object.commutator(W, dGamma_di[k - 1]) return dGamma_di @@ -193,6 +192,7 @@ def ds_di_onsite_Z( dbi_object: DoubleBracketIteration, d: np.array, i: int, + n: int = 3, taylor_coef: Optional[list] = None, onsite_Z_ops: Optional[list] = None, ): @@ -210,15 +210,14 @@ def ds_di_onsite_Z( nqubits = int(np.log2(d.shape[0])) if onsite_Z_ops is None: onsite_Z_ops = generate_onsite_Z_ops(nqubits) - dGamma_di = dGamma_di_onsite_Z(dbi_object, 3, i, d, onsite_Z_ops=onsite_Z_ops) + dGamma_di = dGamma_di_onsite_Z(dbi_object, n=4, i=i, d=d, onsite_Z_ops=onsite_Z_ops) + Gamma_list = dbi_object.generate_Gamma_list(n=4, d=d) def derivative_product(k1, k2): r"""Calculate the derivative of a product $\sigma(\Gamma(n1,i))@\sigma(\Gamma(n2,i))""" return dbi_object.sigma(dGamma_di[k1]) @ dbi_object.sigma( - dbi_object.Gamma(k2, d) - ) + dbi_object.sigma( - dbi_object.sigma(dbi_object.Gamma(k1, d)) - ) @ dbi_object.sigma( + Gamma_list[k2] + ) + dbi_object.sigma(dbi_object.sigma(Gamma_list[k1])) @ dbi_object.sigma( dGamma_di[k2] ) @@ -242,9 +241,10 @@ def derivative_product(k1, k2): def gradient_onsite_Z( dbi_object: DoubleBracketIteration, d: np.array, - onsite_Z_ops, - n_taylor=2, + onsite_Z_ops: list, use_ds=False, + n=3, + **kwargs, ): r"""Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients Args: @@ -262,15 +262,17 @@ def gradient_onsite_Z( if onsite_Z_ops is None: onsite_Z_ops = generate_onsite_Z_ops(nqubits) grad = np.zeros(nqubits) - s, coef = dbi_object.polynomial_step( + coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n=n) + s = dbi_object.choose_step( d=d, - n=n_taylor, - backup_scheduling=DoubleBracketScheduling.polynomial_approximation, + **kwargs, ) a, b, c = coef[len(coef) - 3 :] for i in range(nqubits): - da, db, dc, ds = ds_di_onsite_Z(dbi_object, d, i, [a, b, c], onsite_Z_ops) + da, db, dc, ds = ds_di_onsite_Z( + dbi_object, d=d, i=i, n=n, taylor_coef=[a, b, c], onsite_Z_ops=onsite_Z_ops + ) if use_ds is True: ds = 0 grad[i] = ( @@ -312,7 +314,7 @@ def gradient_descent_onsite_Z( dbi_object: DoubleBracketIteration, d_coef: list, d: Optional[np.array] = None, - n_taylor: int = 2, + n: int = 2, onsite_Z_ops: Optional[list] = None, lr_min: float = 1e-5, lr_max: float = 1, @@ -348,7 +350,7 @@ def gradient_descent_onsite_Z( if d is None: d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) grad, s = gradient_onsite_Z( - dbi_object, d, n_taylor=n_taylor, onsite_Z_ops=onsite_Z_ops, use_ds=use_ds + dbi_object, d, n=n, onsite_Z_ops=onsite_Z_ops, use_ds=use_ds ) # optimize gradient descent step with hyperopt if space is None: diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 7972b6e8e7..488d52ca40 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -294,6 +294,8 @@ def simulated_annealing_step( d = dbi_object.diagonal_h_matrix if initial_s is None: initial_s = polynomial_step(dbi_object=dbi_object, d=d, n=4) + if initial_s is None: + initial_s = step_min if s_jump_range is None: s_jump_range = (step_max - step_min) / s_jump_range_divident current_s = initial_s @@ -304,7 +306,7 @@ def simulated_annealing_step( candidate_s = max( step_min, min( - current_s + np.random.uniform(-1 * s_jump_range, s_jump_range, step_max) + current_s + np.random.uniform(-1 * s_jump_range, s_jump_range), step_max ), ) candidate_loss = dbi_object.loss(d=d, step=candidate_s) From e8ab44736f8a75793863598cc5dc7814d074670a Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Tue, 26 Mar 2024 10:44:31 +0100 Subject: [PATCH 061/116] Added numerical gradient as well as Z-ansatz --- examples/dbi/dbi_costs.ipynb | 287 +++++-- examples/dbi/dbi_misc.ipynb | 944 ++++++++++++++++++++++++ src/qibo/models/dbi/utils_scheduling.py | 67 +- 3 files changed, 1208 insertions(+), 90 deletions(-) create mode 100644 examples/dbi/dbi_misc.ipynb diff --git a/examples/dbi/dbi_costs.ipynb b/examples/dbi/dbi_costs.ipynb index 558f74cff3..2170ce8c9b 100644 --- a/examples/dbi/dbi_costs.ipynb +++ b/examples/dbi/dbi_costs.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 192, "metadata": {}, "outputs": [], "source": [ @@ -39,14 +39,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 184, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-03-15 18:17:05]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.5|INFO|2024-03-20 10:46:15]: Using qibojit (numba) backend on /CPU:0\n" ] } ], @@ -55,7 +55,7 @@ "set_backend(\"qibojit\", \"numba\")\n", "\n", "# hamiltonian parameters\n", - "nqubits = 5\n", + "nqubits = 9\n", "h = 3.0\n", "\n", "# define the hamiltonian\n", @@ -70,23 +70,23 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 189, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "grid_search step: 0.02021181818181818\n", - "hyperopt_search step: 0.2796044748864459\n", - "polynomial_approximation step: 0.016462159944159827\n" + "grid_search step: 0.39394545454545454\n", + "hyperopt_search step: 0.017463998220887386\n", + "polynomial_approximation step: 0.0010293852957746303\n" ] } ], "source": [ "# generate data for plotting sigma decrease of the first step\n", - "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", - "s_space = np.linspace(1e-5, 0.6, 1000)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/2**nqubits\n", + "s_space = np.linspace(1e-5, 0.3, 100)\n", "off_diagonal_norm_diff = []\n", "potential = []\n", "for s in s_space:\n", @@ -96,31 +96,39 @@ " potential.append(dbi_eval.least_squares(D=d))\n", "\n", "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + "#step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", "print('grid_search step:', step_grid)\n", "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + "#step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", "print('hyperopt_search step:', step_hyperopt)\n", "# polynomial\n", - "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + "#step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", "print('polynomial_approximation step:', step_poly)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 191, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "The minimum for cost function in the tested range is: 0.02021181818181818\n" + "The minimum for cost function in the tested range is: 0.39394545454545454\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHFCAYAAAAT5Oa6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADOhklEQVR4nOydeZwT9f3/X5N7N5vN3hcsu9xyCoocooIVQZSqpUJbWwQPrPVE8Wy1gm21ailUrUetgldrq1Z/eIGAx1eRS045RISFXWDv3WR3cyczvz8mn0nCXpnkMzNZ9vN8PPbxyE4mk0+Smfm8P+/j9eYEQRDAYDAYDAaD0YvRaT0ABoPBYDAYDK1hBhGDwWAwGIxeDzOIGAwGg8Fg9HqYQcRgMBgMBqPXwwwiBoPBYDAYvR5mEDEYDAaDwej1MIOIwWAwGAxGr4cZRAwGg8FgMHo9zCBiMBgMBoPR62EGEYPBiJtVq1aB47gO/+6++24cPXoUHMdh1apV1N7z2WeflXW88vJyaUw6nQ52ux3Dhg3DNddcg08++aTD15z6WaxWK4YNG4alS5fC5XLF7LtgwQJkZGQk85Ek5H42BoOhHAatB8BgMHoeK1euxBlnnBGzraSkBIWFhdi0aRMGDhxI7b2effZZ5OXlYcGCBXG/ZvLkyfjLX/4CAGhra8PBgwfx5ptvYsaMGfjpT3+Kf//73zAajTGvueqqq7B48WLpNV988QUeeeQR7NmzB++88w61zxNNIp+NwWAoAzOIGAyGbEaOHIlx48Z1+NzEiRO7fb3b7UZ6ejrtYUlkZWXFjGPatGm45ZZbsGTJEixduhQPPvggHn/88ZjXFBYWtnvNsWPH8MYbb8Dr9cJisSg2XgaDoT0sZMZgMKjRUchsyZIl4DgOO3bswFVXXYXs7GzJg3TkyBH8/Oc/R0lJCcxmMwoLC3HRRRdh165dAMTw1759+/DFF19I4azy8vKEx7dkyRKMGDECzzzzDLxeb7f72+12cBwHvV4v+72S/WwtLS24++670b9/f5hMJvTp0weLFi1qF8LjOA633norXnjhBQwZMgRmsxnDhw/Hm2++KXvMDEZvhnmIGAyGbEKhEILBYMw2g6Hr28ns2bPx85//HDfddJM0qV966aUIhUJ44okn0K9fPzQ0NODrr7+Gw+EAALz77ru46qqrYLfb8eyzzwIAzGZzUmP/8Y9/jD//+c/45ptvcN5550nbBUGQPhMJmb3yyiv4+c9/3i68Fg/JfDa3240pU6bg+PHj+O1vf4vRo0dj3759+P3vf49vv/0W69evB8dx0nutXr0an332GR555BFYrVY8++yz+MUvfgGDwYCrrroq0a+KwehdCAwGgxEnK1euFAB0+BcIBISKigoBgLBy5UrpNQ8//LAAQPj9738fc6yGhgYBgLBixYou33PEiBHClClT4h5jWVmZcNlll3X6/HPPPScAEP7zn/9I2zr7TDNnzhTa2tpiXj9//nzBarV2OYZkP9tjjz0m6HQ6Ydu2bTHb3377bQGA8NFHH8WMPS0tTaipqZG2BYNB4YwzzhAGDRrU5fszGIwIzEPEYDBk8+qrr2LYsGEx27rzEP30pz+N+T8nJwcDBw7Ek08+iVAohAsvvBBnnnkmdDplI/mCIHS4fe7cubjnnnsAAB6PB7t27cIf/vAHXHLJJVi/fr0sz1Syn+2DDz7AyJEjMWbMmBhP3IwZM8BxHD7//HPMnDlT2n7RRRehsLBQ+l+v1+NnP/sZli5diuPHj6Nv375xj53B6K2wHCIGgyGbYcOGYdy4cTF/3VFcXBzzP8dx2LBhA2bMmIEnnngCZ511FvLz83H77bejtbVVqaHj2LFjAMSquGjy8/Olz3L++efjtttuw1NPPYWvvvpKdml8sp+ttrYWe/bsgdFojPmz2WwQBAENDQ0x+xcVFbU7BtnW2Ngoa+wMRm+FeYgYDIYqROe8EMrKyvDSSy8BAL7//nv897//xZIlS+D3+/H8889TH4MgCHj//fdhtVrjMuJGjx4NANi9e7fs90rms+Xl5SEtLQ0vv/xyp89HU1NT024fsi03N1f22BmM3ggziBgMRkowZMgQPPjgg3jnnXewY8cOabvZbIbH46HyHkuXLsX+/fvx29/+Nq4yelIRVlBQkNT7yv1ss2bNwqOPPorc3Fz079+/2+Nv2LABtbW1UtgsFArhP//5DwYOHMjCZQxGnDCDiMFgaMKePXtw6623Ys6cORg8eDBMJhM+/fRT7NmzB/fff7+036hRo/Dmm2/iP//5DwYMGACLxYJRo0Z1eWyHw4HNmzcDAFwulyTM+OWXX2Lu3LlYunRpu9fU1tZKr/F6vdi1axf++Mc/IisrC9dee62qn23RokV45513cMEFF+DOO+/E6NGjwfM8Kisr8cknn2Dx4sWYMGGCdJy8vDz86Ec/wkMPPSRVmX333Xes9J7BkAEziBgMhiYUFRVh4MCBePbZZ1FVVQWO4zBgwAAsW7YMt912m7Tf0qVLUV1djYULF6K1tRVlZWU4evRol8feuHEjJk2aJLXh6NOnD8aPH48HH3wQ06dP7/A1b7/9Nt5++20AgNFoRGlpKS6//HL87ne/Q1lZmaqfzWq14ssvv8Sf//xn/OMf/0BFRQXS0tLQr18/TJs2rZ0W0+WXX44RI0bgwQcfRGVlJQYOHIg33ngDP/vZz2SNm8HozXBCZyUXDAaDwUh5OI7DLbfcgmeeeUbroTAYPRpWZcZgMBgMBqPXwwwiBoPBYDAYvR6WQ8RgMBg9GJb1wGDQgXmIGAwGg8Fg9HqYQcRgMBgMBqPXwwwiBoPBYDAYvR6WQxQnPM/j5MmTsNlsHbYgYDAYDAaDkXoIgoDW1laUlJR02WCZGURxcvLkSZSWlmo9DAaDwWAwGAlQVVXVZSsbZhDFic1mAyB+oZmZmRqPJozLBZCO3SdPAlartuNhMDTA5XehZJl4HZxcfBJWE7sOGAxGhJaWFpSWlkrzeGcwgyhOSJgsMzMzdQwivT7yODOTGUSMXonerwfCfVozMzOZQcRgMDqku3QXZhD1MELeEL6b9x0A4Izn+0Hfzf4MBoPBYDC6h1WZ9TRCQP3b9ah/ux4IMUE2BoPBYDBowDxEDAajR2PQGTD/zPnSYwaDwUgEdvegTCgUQiAQUO74vhB0ZaJjzxvwQ19WJj7h88XmFDFUxWg0Qs++f00wG8xYdeUqrYfBYDB6OMwgooQgCKipqYHD4VD2fXgBtufFTPljzbXgnn9efKK6GuhCX4GhPFlZWSgqKmI6VQwGg9EDYQYRJYgxVFBQgPT0dMUmRSEkwO1xAwDSyyzgvB7xifJy5iHSCEEQ4Ha7UVdXBwAoLi7WeES9C0EQ4A6Erwmjctceg8E4vWEGEQVCoZBkDOXm5ir6XkJIQBBBAIDFYoF067dYmEGkIWlpaQCAuro6FBQUsPCZirgDbmQ8lgEAaHugjZXdMxiMhGAxFgqQnKH09HSNR8LQEvL7K5lDxmAwGAxlYAYRRZirvnfDfn8Gg8HouTCDiMFgMBgMRq+HGUQM2Rw9ehQcx2HXrl2d7vP555+D4zjFq+6UhOM4vPfee1oPg8FgMBgqwJKqGbIpLS1FdXU18vLytB4Kg8FgMBhUYB4ihiz8fj/0ej2KiopgMPRce5olPjMYDLVxegLgedZyKVVhBlFPgwMM2QYYsg0AhRze1tZW/PKXv4TVakVxcTGWL1+OqVOnYtGiRQCA8vJy/PGPf8SCBQtgt9uxcOHCDkNmH330EYYMGYK0tDRceOGFOHr0aNxjOHbsGH784x8jOzsbVqsVI0aMwEcffSQ9v3//flx66aXIyMhAYWEh5s2bh4aGBun5NWvW4LzzzkNWVhZyc3Mxa9YsHD58WHqejPe///0vpk6dCovFgtdffx0A8PLLL2PEiBEwm80oLi7GrbfeGjO2hoYG/OQnP0F6ejoGDx6M1atXy/h2GWqg1+lx1fCrcNXwq6DXMbkDRmqyfN33GPPIJ5j6l89R1eTWejiMDmAGkRIIAuByKfLHedxIK+KRVsSDc7sAj0f8I/sI8lYfd911FzZu3IjVq1dj3bp1+PLLL7Fjx46YfZ588kmMHDkS27dvx0MPPdTuGFVVVZg9ezYuvfRS7Nq1CzfccAPuv//+uMdwyy23wOfz4f/+7//w7bff4vHHH0dGhqgrU11djSlTpmDMmDH45ptvsGbNGtTW1mLu3LnS610uF+666y5s27YNGzZsgE6nw09+8hPwPB/zPvfddx9uv/12HDhwADNmzMBzzz2HW265BTfeeCO+/fZbrF69GoMGDYp5zdKlSzF37lzs2bMHl156KX75y1+iqakp7s/GUB6LwYK35ryFt+a8BYvBovVwGIx27K5y4G8bDkEQgMomN5as3qf1kBgdITDiwul0CgAEp9PZ7jmPxyPs379f8Hg84oa2NkEQTRP1/9ra4v5MLS0tgtFoFN566y1pm8PhENLT04U77rhDEARBKCsrE6688sqY11VUVAgAhJ07dwqCIAgPPPCAMGzYMIHneWmf++67TwAgNDc3dzuOUaNGCUuWLOnwuYceekiYPn16zLaqqioBgHDw4MEOX1NXVycAEL799tuY8a5YsSJmv5KSEuF3v/tdp+MCIDz44IPS/21tbQLHccLHH3/c4f7tzgMGg8EQBOH+d3YLZfd9IFz+9JdC+f0fCGX3fSBUNrq0Hlavoav5OxrmIerFHDlyBIFAAOPHj5e22e12DB06NGa/cePGdXmcAwcOYOLEiTE6PJMmTYp7HLfffjv++Mc/YvLkyXj44YexZ88e6bnt27fjs88+Q0ZGhvR3xhlnAIAUFjt8+DCuvvpqDBgwAJmZmejfvz8AoLKystPPUVdXh5MnT+Kiiy7qcmyjR4+WHlutVthsNqlFB4PBYHRHiBfwyb5aAMDdM4bi3IFiN4O1+2q0HBajA3puVmwqk54OtLUpcmghJKBtt3jsjFHp4L7dLT5x5pli6w4ZatlCOLx2qqAg2U6wWrtuhXDq/nK54YYbMGPGDHz44Yf45JNP8Nhjj2HZsmW47bbbwPM8fvzjH+Pxxx9v9zrSM+zHP/4xSktL8eKLL6KkpAQ8z2PkyJHw+/2dfg7SaqM7jEZjzP8cx7ULxTG0xeV3sdYdjJRlR2UzGl1+ZFoMmDggF4dq27Dxh0Z88X09bjh/gNbDY0TBPERKwHGA1arcX1r4z2oF0tLEP/KcDLXkgQMHwmg0YuvWrdK2lpYWHDp0SNbHHT58ODZv3hyz7dT/u6O0tBQ33XQT/ve//2Hx4sV48cUXAQBnnXUW9u3bh/LycgwaNCjmz2q1orGxEQcOHMCDDz6Iiy66CMOGDUNzc3O372ez2VBeXo4NGzbIGieDwWDIYfPhRgDAlKEFMOp1mDAgBwCwq8rBKs5SDGYQ9TR0gPVMK6xnWpP+9Ww2G+bPn4977rkHn332Gfbt24frrrsOOp1OVhuKm266CYcPH8Zdd92FgwcP4l//+hdWrVoV9+sXLVqEtWvXoqKiAjt27MCnn36KYcOGARATrpuamvCLX/wCW7duxZEjR/DJJ5/guuuuQygUQnZ2NnJzc/GPf/wDP/zwAz799FPcddddcb3vkiVLsGzZMjz11FM4dOgQduzYgaeffjrucTMYDEZ37D7uBACMKc0CAAwptMFs0KHVG8TRRpeGI2OcCjOIehgcx0Fn1EFn1NGousdf//pXTJo0CbNmzcK0adMwefJkDBs2DBZL/NU6/fr1wzvvvIP3338fZ555Jp5//nk8+uijcb8+FArhlltuwbBhw3DJJZdg6NChePbZZwEAJSUl2LhxI0KhEGbMmIGRI0fijjvugN1uh06ng06nw5tvvont27dj5MiRuPPOO/Hkk0/G9b7z58/HihUr8Oyzz2LEiBGYNWuWbO8Yg8FgdIYgCNh93AEAGFNqBwAY9TqMKMkEAOwJG0uM1IATkk0A6SW0tLTAbrfD6XQiMzMz5jmv14uKigr0799fliGRNKEQsHOn+HjsWDGHKElcLhf69OmDZcuW4frrr0/6eL0Jzc6DXg7LIWKkKtVODyY99in0Og57l8xAmkm8Ry9ZvQ+rvj6KBeeWY8nlIzQe5elPV/N3NCypuoch8AJ8VT4AgLmPMWkv0c6dO/Hdd99h/PjxcDqdeOSRRwAAV1xxRZJHZjAYjN7N3hMtAIDBBRmSMQQAI/uI3qKDNa2ajIvRMSxk1tMQgEB9AIH6AEDJt/eXv/wFZ555JqZNmwaXy4Uvv/ySap+ymTNnxpTNR//JCa0xGAxGT+KHOrEieGiRLWb7gHzRi1nRwHKIUgnmIerljB07Ftu3b1f0Pf75z3/C4/F0+FxOTo6i7804/dHr9Lh08KXSYwYjVThcLxpEA/MzYrYPzBP/r2nxwuULwmpmU3EqwH4FhuL06dNH6yEwVMYbCGHZJwdR2eTGHRcNwfCSzuP2yWIxWPDh1R8qdnwGI1GIQTSoINYgsqcbkWs1odHlR0WDSwqhMbSFhcwYDAZ1/vzxd3jxywqs3VeL+Su3wuULaj0kBkNVBEGQQmaneogAoH+eGDYjRhNDe5hBxGAwqNLY5sO/tkbaptS3+vDfb6o0HBGDoT71bT60eoPQcUBZbvsOAiSP6Eg9yyNKFZhBxGAwqLJufy38QR4j+2RiabikePXuk4q9n8vvgvVRK6yPWuHys8mFkRoca3QDAPpkp8FibJ/bVpYrGkRVTW5Vx8XoHGYQMRgMqvzfoXoAwLRhhbhkZBEAYGelA053QLH3dAfccAfYxMJIHY43i+dj36yO+0v2zRb7KZ5wdFxwwlAfZhAxGAxqBEM8vjrUAAA4f3A+CjMtKA+HC3ZUdd9jjqEMX3xfj6c3HJImaYbyHG8SDR1i+JxKnyxmEKUazCDqxUydOhWLFi3SehiM04jvalrR4g3CZjHgzL5i5czZZaK0wvajzCDSgnX7azH/5a1Ytu57zHl+E1q8ynnqGBGIodM3u2MPUZ+woVTj9CLEmrymBMwgYpy2LFmyBGPGjNF6GL2KvSfE3kyj+9ph0Iu3l3Hl2QCAb441aTau3oogCHhizXfS/9VOL17bdEzDEfUejjeLBlGfTjxEBTYLDDoOQV5AXatXzaExOoEZRIyUIhQKged5rYfBSJB9J8VWBSNKIroqpMv3vpMtYK0T1WXPcScO1bUhzajHwz8eDgB4Z/txjUfVO5ByiDoxiPQ6DkV2sefhiWYWNksFNDWIysvLwXFcu79bbrkFALBgwYJ2z02cODHmGD6fD7fddhvy8vJgtVpx+eWX4/jx2Au+ubkZ8+bNg91uh91ux7x58+BwONT6mCkNz/O49957kZOTg6KiIixZsgQAcN1112HWrFkx+waDQRQVFeHll18GIIbcbr31Vtx6663IyspCbm4uHnzwwZhJz+/3495770WfPn1gtVoxYcIEfP7559Lzq1atQlZWFj744AMMHz4cZrMZx44dQ3NzM6655hpkZ2cjPT0dM2fOjOlET1733nvvYciQIbBYLLj44otRVVUlPb906VLs3r1bOndWrVqlzJfIkNh3UvQQjYgSYhyQb4WOA1q9QdS1+rQaWq/k0+/qAAA/OqMAV53dF0Y9hyMNLqZ9ozA8L+CkQ/T6kFyhjmB5RKmFpgbRtm3bUF1dLf2tW7cOADBnzhxpn0suuSRmn48++ijmGIsWLcK7776LN998E1999RXa2towa9YshEIhaZ+rr74au3btwpo1a7BmzRrs2rUL8+bNU/zzufyuTv+8QW/c+3oCURcLB3jTvPCmecXngx7xL8Fy41deeQVWqxVbtmzBE088gUceeQTr1q3DDTfcgDVr1qC6ulra96OPPkJbWxvmzp0b83qDwYAtW7bgqaeewvLly/HPf/5Tev7aa6/Fxo0b8eabb2LPnj2YM2cOLrnkkhjjxu1247HHHsM///lP7Nu3DwUFBViwYAG++eYbrF69Gps2bYIgCLj00ksRCARiXvenP/0Jr7zyCjZu3IiWlhb8/Oc/BwD87Gc/w+LFizFixAjp3PnZz36W0HfEiI8QL+BAtdisMtogMhv0KA+XGB+qpT8R6zgdppRNwZSyKdBxzOkdzdYKMUx57qBc2CxGnF0mhi+3VbDwpZLUt/ngD/HQ6zgUh71AHdGHVZqlFJq27sjPz4/5/89//jMGDhyIKVOmSNvMZjOKioo6fL3T6cRLL72E1157DdOmTQMAvP766ygtLcX69esxY8YMHDhwAGvWrMHmzZsxYcIEAMCLL76ISZMm4eDBgxg6dKhCnw7IeKy9Oinh0sGXxrQbKPhLQadlw1PKpuDzBZ8DADgdh+EfDUeDuyF2p7WA8LD8cMTo0aPx8MMPAwAGDx6MZ555Bhs2bMCf//xnDB06FK+99hruvfdeAMDKlSsxZ84cZGREPldpaSmWL18OjuMwdOhQfPvtt1i+fDkWLlyIw4cP49///jeOHz+OkpISAMDdd9+NNWvWYOXKlVJj10AggGeffRZnnnkmAODQoUNYvXo1Nm7ciHPPPRcA8MYbb6C0tBTvvfeeZDAHAgE888wz0u/6yiuvYNiwYdi6dSvGjx+PjIwMGAyGTs8fBl1ONHvgCYRgMujQPy/23B9UkIEjDS4cqmvFeYPpNQ4GgDRjmnR9MCL4gzx2hiv7xpeLie1j+2Vj85Em7Kx04Ofj+2k5vNMakj9UlGmRcuk6ojBTNJbqWpjnNBVImeWU3+/H66+/juuuuw4cx0nbP//8cxQUFGDIkCFYuHAh6urqpOe2b9+OQCCA6dOnS9tKSkowcuRIfP311wCATZs2wW63S5MmAEycOBF2u13apyN8Ph9aWlpi/k5HRo8eHfN/cXGx9B3fcMMNWLlyJQCgrq4OH374Ia677rqY/SdOnBjze02aNAmHDh1CKBTCjh07IAgChgwZEtPh/osvvsDhw4el15hMpphxHDhwAAaDIeY3y83NxdChQ3HgwAFpm8FgwLhx46T/zzjjDGRlZcXsw1CPIw2i96d/rhV6HRfzHOnlRFoZMJRn70knvAEeOVaT9P2TfK5dVQ7tBtYLIPlDnSVUEwptZgBgSdUpQso0d33vvffgcDiwYMECadvMmTMxZ84clJWVoaKiAg899BB+9KMfYfv27TCbzaipqYHJZEJ2dnbMsQoLC1FTUwMAqKmpQUFBQbv3KygokPbpiMceewxLly5N6jO1PdD5zf/Urtx1d9d1sifahQGO3nFUfBAKAbt3i4/D3hW5GI3GmP85jpOSmq+55hrcf//92LRpEzZt2oTy8nKcf/75cR+b53no9Xps374den3s5432MqWlpcUYVZ0l3gqCELMfGe+pdLSNoTwVDWLYtjyvfZnx4ELx9z7EDCLV2Beu+BtTmiVdE2PDBtH3da1o8wWRwbqsKwLxEHWWUE0gHqJa5iFKCVLmanjppZcwc+ZMKbQCICbnY+TIkRg3bhzKysrw4YcfYvbs2Z0e69SJs6MJsqPJNZoHHngAd911l/R/S0sLSktL4/48AGA1WanvK4QECPtFg8E6wgrOEL7gZLxXvOTm5uLKK6/EypUrsWnTJlx77bXt9tm8eXO7/wcPHgy9Xo+xY8ciFAqhrq5OliE1fPhwBINBbNmyRQqZNTY24vvvv8ewYcOk/YLBIL755huMHz8eAHDw4EE4HA6cccYZAETPU3QuGUNZiEF0argMiLQpOK5AmwKX34Xyv5UDEBcLcq6705mDtWI+19Aim7StINOCokwLalq8+K66BePCoTQGXWqcosenxN61QVQgGUTMQ5QKpETI7NixY1i/fj1uuOGGLvcrLi5GWVmZlJBbVFQEv9+P5uZYwbe6ujoUFhZK+9TW1rY7Vn19vbRPR5jNZmRmZsb8pQpCUIAQVKd8+YYbbsArr7yCAwcOYP78+e2er6qqwl133YWDBw/i3//+N55++mnccccdAIAhQ4bgl7/8Ja655hr873//Q0VFBbZt24bHH3+8XXJ8NIMHD8YVV1yBhQsX4quvvsLu3bvxq1/9Cn369MEVV1wh7Wc0GnHbbbdhy5Yt2LFjB6699lpMnDhRMpDKy8tRUVGBXbt2oaGhAT4fW4UpCTGIBuS1N0hKw+J01S1e+IP0ZRUa3A3t8+p6Od/XiN64oYW2mO3EW8cqzZSDGDiFXSRUA0CBFDLzMUmKFCAlDKKVK1eioKAAl112WZf7NTY2oqqqCsXFxQCAs88+G0ajUapOA4Dq6mrs3btX8ixMmjQJTqcTW7dulfbZsmULnE6ntE+PQgekj0hH+oh0VX69adOmobi4GDNmzIjx3hGuueYaeDwejB8/Hrfccgtuu+023HjjjdLzK1euxDXXXIPFixdj6NChuPzyy7Fly5ZuvW0rV67E2WefjVmzZmHSpEkQBAEfffRRTIgvPT0d9913H66++mpMmjQJaWlpePPNN6Xnf/rTn+KSSy7BhRdeiPz8fPz73/+m8I0wOkPyEOW3N4jyMkywGHUQBKDaySpqlEYQBMlDNOQUg2hgPjGIWCNcpagNy0sQg6czCjLF5/1BHk4PUxDXGs1DZjzPY+XKlZg/fz4Mhshw2trasGTJEvz0pz9FcXExjh49it/+9rfIy8vDT37yEwCA3W7H9ddfj8WLFyM3Nxc5OTm4++67MWrUKKnqbNiwYbjkkkuwcOFCvPDCCwCAG2+8EbNmzVK0wkwpOI6DPi2cj5NkOChaD4jw3nvvxfzv8XjgcDhw/fXXd3gMo9GIFStW4Lnnnuv0+aVLl3aaj7VgwYKYvDFCdnY2Xn311S7HDwCzZ8/uNHxqNpvx9ttvd3sMRvL4g7xUOlyW2z6HiOM49M1Oxw91bahq8kghNIYy1LX64PQEoNdxGHCKgTownGB9mOVzKUY98RBldu0hMhv0yE43otkdQG2LD1npJjWGx+gEzT1E69evR2VlZbvqJb1ej2+//RZXXHEFhgwZgvnz52PIkCHYtGkTbLbIimf58uW48sorMXfuXEyePBnp6el4//33Y5J433jjDYwaNQrTp0/H9OnTMXr0aLz22muqfcaeCM/zOHnyJB566CHY7XZcfvnlWg+JkcLUtnghCIDJoEOeteNVMUkwrWINRhWH6D2V5aTDYowtaBgYNpB+YCEzReB5QRIgLczs2kMEiC08AFZplgpo7iGaPn16h7HTtLQ0rF27ttvXWywWPP3003j66ac73ScnJwevv/56UuNMFQRegL/GDwAwFRigVD1VZWUl+vfvj759+2LVqlUx3jsG41SId6jEboFO1/FZSfKIWMd15akMJ6935K0jJfhVTW54A6F2BhMjOZrcfgR5ARwH5GXEYRBlmnGwtpVVmqUAbJbraQiA/2TYIMpX7ucrLy/vNsmvo5CbWnQWamNoA8kLKumiTYHkIWpiOURKc6xJzA/qKDSZn2GG1aSHyx/CCYdHyili0IGILOZaTTB2IcpIIEZTYxsziLRG85AZg8Ho+ZC+TV0ZRMXh50hJMi10nA7jSsZhXMk41rojTFXYQ1Sa03k+FxDRy2HQozYc+iKhsO7ItYp5Q00uv2JjYsQH8xAxGIykkUJmXRhEReEE0xrKmitpxjRsW7iN6jF7OscawyGzDgwiQPTWHaxtZeFLBaiTEqq7D5cBQE6GaBA1tDGDSGvYcorBYCTNybBB1Cer81VxtEHENFeUQxAEVIYNon4d5BABkfAl8xDRh4TM5HuIWMhMa5hBxGAwkuZkHB6iaM0Vh5tpriiFwx1Aqy8IIJLIfiosZKYcJGQWr4coN1yV2chCZprDDCIGg5EUgiDgRHP3BpHFKGquAHTDZu6AG+UrylG+ohzuAAsBkfBlXoYJaaaOK8giHiL2fdGGVIsVdKNBRCAhs0YWMtMcZhAxGIykaPEG4fKLIqHd9W4qVCCPSBAEHHMewzHnMRaKQyRpvbiL34J5iJSjLk6VakKe5CFiITOtYQYRI2FWrVqFrKwsrYcRF0uWLMGYMWNkvYbjuHbK3Yz2kHBZjrVzjwShKNzbqY41s1SM6vB3W9RFH62ScK5XfatPkd5yvRlybsv1EHkDPNz+oGLjYnQPM4gYvYK7774bGzZs0HoYpyWR/KHuJwApsdrJVsNKURPWhCruwiDKsZpg1IsCmvVM/4YagiBIoa/8OD1EVpMeZoM4FbOwmbYwg4jRK8jIyEBubq7WwzgtITkTRXGsiEnIrJa1KVCMamf3HiKO46QqqFrmraNGqy8If0j0uJHqse7gOE7alyVWawsziHoxU6dOxa233opbb70VWVlZyM3NxYMPPijlYTQ3N+Oaa65BdnY20tPTMXPmTBw6dKjDYx09ehQ6nQ7ffPNNzPann34aZWVlEAQBn3/+OTiOw4YNGzBu3Dikp6fj3HPPxcGDB2Ne89xzz2HgwIEwmUwYOnRou75zHMfhhRdewKxZs5Ceno5hw4Zh06ZN+OGHHzB16lRYrVZMmjQJhw8fll5zashs27ZtuPjii5GXlwe73Y4pU6Zgx44dyXydvRbSgyk/jjLjPBtT5VUaYuB0Z6CSqr861jKCGsTDk2E2yGqJksvUqlMCZhApSMgVkv3HR8Xz+SAvbvfEdrUPecRt4nOC+OcKnfr2cfHKK6/AYDBgy5YteOqpp7B8+XL885//BCC2x/jmm2+wevVqbNq0CYIg4NJLL0Ug0L5kury8HNOmTcPKlStjtq9cuRILFiwAx0X6W/3ud7/DsmXL8M0338BgMMQ09n333Xdxxx13YPHixdi7dy9+/etf49prr8Vnn30Wc9w//OEPuOaaa7Br1y6cccYZuPrqq/HrX/8aDzzwALZu2wZeEHDLrbd2+rlbW1sxf/58fPnll9i8eTMGDx6MSy+9FK2trQl9j70ZOUmkeVYmQqc08XiIAKCQNRWlDjFocjPkda3PYR6ilIApVSvIlxlfyn7N8P8OR8GcAgBAw7sN2D93P+xT7Bj7+Vhpn71X7EWw+dTku68xVZgq+/1KS0uxfPlycByHoUOH4ttvv8Xy5csxdepUrF69Ghs3bsS5554LAHjjjTdQWlqK9957D3PmzGl3rBtuuAE33XQT/vrXv8JsNmP37t3YtWsX/ve//8Xs96c//QlTpkwBANx///247LLL4PV6YbFY8Je//AULFizAzTffDAC46667sHnzZvzlL3/BhRdeKB3j2muvxdy5cwEA9913HyZNmoSHHnoIF118MY7UuzB73kI8fPetCPEC9B00G/3Rj34U8/8LL7yA7OxsfPHFF5g1a5bs77E3Ux82iOLJmVBiJcxxHIbnD5ce92YEQYirygyI6OSwkBk9iKEfb7iMkMtK71MC5iHqYXB6Dpye3k1/4sSJMZPIpEmTcOjQIezfvx8GgwETJkyQnsvNzcXQoUNx4MCBDo915ZVXwmAw4N133wUAvPzyy7jwwgtRXl4es9/o0aOlx8XFxQCAuro6AMCBAwcwefLkmP0nT57c7j2jj1FYWAgAGDVqFOpbffAGQsjNL4DP60XFyfoOx1pXV4ebbroJQ4YMgd1uh91uR1tbGyorKzvcn9E5sjxECtz4043p2HfzPuy7eR/SjR0LEfYWWrxBuMMSCN2HzEgOEQvT0IKUzufG0eU+GqZWnRowD5GCnN92vuzXcOaIcZL3kzzxGKeYrROPThQfhELA7t3i4zPPTHSYshAEodNVuMlkwrx587By5UrMnj0b//rXv7BixYp2+xmNRukxORbP8+22dfWeHR3DYDCgOayAbDOLp3ZjmxcDO9CmWbBgAerr67FixQqUlZXBbDZj0qRJ8PvZCk0u9TLKjMlE0eoLwhsIycqzYHQP8Q5lpRu7lUAgBizzENGjMWEPEVOrTgWYh0hB9Fa97D+dIfKT6Aw6cXuavvPjpnHinzWxiWXz5s3t/h88eDCGDx+OYDCILVu2SM81Njbi+++/x7Bhwzo93g033ID169fj2WefRSAQwOzZs2WNZ9iwYfjqq69itn399dddvifBGwghGOKh5zjkhfMjAiFBWjFH8+WXX+L222/HpZdeihEjRsBsNqOhoUHWWBmisUrKtuMJmWVaDDDpwyXG7OZPnZo4E6qBSMUfCXkykod0rE84h4iFzDSFeYh6GEJIgPuAKLefPtSCZINnVVVVuOuuu/DrX/8aO3bswNNPP41ly5Zh8ODBuOKKK7Bw4UK88MILsNlsuP/++9GnTx9cccUVnR5v2LBhmDhxIu677z5cd911SEvrOo/hVO655x7MnTsXZ511Fi666CK8//77+N///of169d3+9o2XxBWADaLEfVReUNtvvZiZ4MGDcJrr72GcePGoaWlBffcc4/ssTLEvlmBkOiBy48jTMBxHHIzTKh2etHQ6kOfLlp9xIs74MY5L54DANi2cFuvDpsRDaLuEqqBKAkE5iGiRgNJqrbKC5llp4sGkcPNDCItYR6iHgjv5cF76ajLXnPNNfB4PBg/fjxuueUW3HbbbbjxxhsBiBViZ599NmbNmoVJkyZBEAR89NFHMeGqjrj++uvh9/tjqsfi5corr8Tf/vY3PPnkkxgxYgReeOEFrFy5ElOnTu32tZ6A+J3YLLF2fkceopdffhnNzc0YO3Ys5s2bh9tvvx0FBQWyx9vbIflD2elGmAzx3U6kBFJK+RKCIGB//X7sr9/f61t3EMHL+DxE4qTd7A7AF0ysSpURixQyk+khIj3+HB7W9FhLmIeop6ED0oamSY+TxWg0YsWKFXjuuefaPZednY1XX32109cuWLAACxYsaLe9uroaI0eOxDnnnBOzferUqe0mrDFjxrTb9pvf/Aa/+c1vOn3fU/cvLy8Hz/PYd7IFvCAgzaTH1KlT4fIF8ENdGzz+IB5++GEsWbJEes3YsWOxbdu2mONcddVVXb4Poz1yKswIZPXMSu/pU99GNKG6/z3saaIR6w/yqGvxoTSn93rWaEGM/DyZSdVZxCByM4NIS5iHqIfBcRwMNgMMNkPS4TLatLW1Ydu2bXj66adx++23q/re3gAPXhCg5zhJBt9i1IPjOAR5QVKPZdCFaNgUxCHKSCCTRQMToaNOQ6toZMYzIYtq1WFxRqZFRIVEPUT2NHH/Fm8AIZ4txLSCGUQMatx6660477zzMGXKlITCZcngCYgu/zSTXqo603Ec0sJVTJ4OwmaM5KlLwEOkROk9Q4QYmfF6KEgeEVOrTp4QL6DJTarMEvMQCQLQwsJmmsFCZj0MgRcQaBAvGGOOPikv0eeff05lTIRVq1Zh1apVVI8ZL9EGUTQWow5uv+hBYtCnXoYGESEiQscmYdpEDKL4PBSkPLyBVfwlTbPbD0EAOC6SExQvRr0OGWYD2nxBODwBZMss22fQgXmIehoC4Kv0wVfpA5hnVcIXNojMhliDiPzPkkaVITEPEcshUgrynebF+XsQ/Zsm9lskDfF4ZqebYNDLn1rtaSSPiP0WWsE8RBRhSbja4Qv3gDOfUulE/vcFlfcQ9cbfvyGRpGrKOUQcx6HMXiY97q14AyFJYiLekFmkyzrz1iWL1McsQe9OVroRJxwellitIcwgogApQ3e73UzLRgNCvIBAqBODyBgxiLpS2aaB2y3qQ3UnS3A6QYTocmRMArmUG7ymG9NxdNFRKsfqyZDwpcmgQ6Ylvls7aypKj4YERRkJkhaRh/0WWsEMIgro9XpkZWVJ/bjS09MVm3iFkAA/xAvG69VFcoi8XkDfO9sgeP1BCEE/9DodggE/glELLEEQgFAAvCCg1eWGyUD/OxIEAW63G3V1dcjKyoK+F/0OjYkYRBkRETqljdTeBPG45WeY4/5OyW/BQmbJE+l0Ly+hmmBnpfeawwwiShQVFQGINClVCoEX4GsQLzyzxQSOtJs4ehTQ9c6UMLc/iCZXAGaDDhWu9jejphYvAiEBfItJ0d5ZWVlZ0nnQG+B5Ac0JVNVkhUuMg7yANl8QNkvv8agpiZQ/JMNDQX63nhQya3L58fwXh8EBuPnCQVLujdYQb2leoiGzNGYQaQ0ziCjBcRyKi4tRUFCAQEC5EzrkDmH7ZdsBAEM2Dod+1mXiEzt2AOm9U1jtla8r8OqmE7hkZBHuGd2/3fMvvbsXm4404I6LBuPyMX0UGYPRaOxVniEgVjNFjocozaSH2aCDL8jD4Q4kbRB5Ah5csOoCAMD/Lfg/pBl7Z9habsk9EPndmnpIyIznBdzwyjbsqHQAAHZVOfDmjRNTwsvYIGkQJeYhYu07tIcZRJTR6/WKToyhUAj8MTFfxmI0QX/smPiE2QxY4hfHO5043OTHidYQ7BlWWDr4DjKsaTjRGsKR5kCHzzMSg4TLbBZD3G07CNnpJtS0eNHs9ietkMwLPL45+Y30uLdCEtzlGERSyMzlB88L0Om0Nyy64pP9tZIxBABbKpqw4UAdpg0v1G5QYUjITM7iIJos1r5Dc3pnjIVxWnHCITa07KxRaN9scfvxZrdqY+oNSKq8CUwA5ObfzMID1JA8RLb4fw/ileCFnjERv7fzBADgpikDceMFAwAAb26r0nJIEiR8nKhBZGchM81hBhGjx3PSIbYdKOnWIPKoNqbeQJMr8RUxCw/QJ5JDFL+HKLoirSnF84i8gRC++L4eADBrdDF+MlYMf3/1Qz28Ae11xkjYkZzbcmHXhPYwg4jRo+F5QfIQEcPnVPpmiyEZZhDRJVJhJj9nItsa9hD1kNyVnkB9AjlEQCTnJdVbqWz8oQGeQAgldgtGlGTijCIbijIt8AZ4bKlo0np4kmeHnNtyYSEz7WEGEaNH0+DywR/kwXFAkb3j/CBiKDW0+VJiJXm60JRAVRMhK7waZiEzejQmahD1EC2irWGjZ8rQfHAcB47jcOEZ+QCAzw8qW93bHdEVlzkJeohYx3vtYQYRo0dDwmWFNguMncjl29OMyDCLYQHiTWIkTyIaRITsdNamgDbEuJQrDNhTxBl3VTkAAGNLs6VtkwbmAUBMorUWtHqDIE3qsxI2iFjHe61hBlEPxJhnhDEvNbQ3tOZEOAzWp5NwGSBKIhDvUa3Tq8q4egPJGUR0PUR56XnIS8+jcqyeSIgXJONSbg5LTxBnDPEC9p5wAgDOLM2Stp/Z1w4AOHCyBX4V2vN0BvEOZZjlV1wSSFI163ivHazsvoeht+oxuX6y+I/Lpe1gUoCTYY9PZwnVhAKbGT/UtaG2lRlEtCBJuIm0KsiS2hQkf+O3mqyov6c+6eP0ZFo8gSgPhbzFUk8QZzxc3waXPwSrSY9BBRnS9n456chKN8LhDuC7mhaM7pulyfiawgaR3O8+GqNeB6tJD5c/hBYv63ivBcxDxOjRdFdyTyjMFD1EdS2pe9PvaZAk3ISSqlnIjCpkQrZZDJ2GjjujJ4TMiHdoRB879FFaSRzHSUbQ7uNOLYYGAAl7506FiJS2eIJJj4khH2YQMXo0kkHURcgMAAoyxUm7lhlE1CBlxsnpEKXuJNyTaE4ifElek8rG6Q91bQCAIYUZ7Z4b1ScTALD/ZIuqY4qmyUUqzJIziDLTxKBNi5eFzLSAGUQ9jJAnhJ1Td2Ln1J0IeXqvKi/hpOQh6lqBusAWziFiITMqCIIQMYiSCZm5kr/xewIeTF01FVNXTYUn0DuT5pPRwOkJTUUPhQ2iQfntDaIhhTYAwA91raqOKZqIhyi53M5MyUOUur/F6QzLIepp8IDzi7BrmFUiSB4fEhLrjMKwh6ieeYio0OIJIphAHzMCmbhbfUEEQrzsME80vMDji2NfSI97I8SYSeS36AlNRQ8Tg6jA1u65weFt39e2QRAETfqaJSvKSMgM/xbMQ6QNzCDqYXBmDsP/Ozz8uHc7+IIhXkoEJR6gziAGE/MQ0YF87xlmA8wG+b377GlGcJxYUeNwB5BvS6whJkMkmaTerBRXSPYHeRxrEtvuRCdUEwbkW6HjAKcngPo2X7f3AiUg1ZJJG0Rh1XCWQ6QNvXtG7YHoDDoUzClAwZwC6Ayp3YhRaRpdfggCoOO6XxkX2EgOkReCwDxryZJMuAwA9DpOCg+k6kTck5ByiBKYkEmYx+UPaVq63hlHG10I8QIyzAbJ0xuNxahHWa4VAHCotk3t4QGIzuFKMmTGPESawgwiRo+lPqq7t76bLt1k1egN8Gj1sdVXsiSjQUTIZg1eqSGFbBL4PWwW0VsHiF6WVONogygv0j/P2mk4bHDYc3SoVps8ombJQ5esh0i8Jlq97B6lBQmFzHiexw8//IC6ujrwfOyK4oILLqAyMEbH8EEeDe82AADypqf3aou2Lhz+Kuhg1XgqaSY9Mi0GtHiDqGvxSjceRmIkU2FGyEo3AY1u5iGiQDKd1om3zukJwOnxp1z4sjIcLuuXk97pPuV5ooeIhNbUpplS2b1UZZaChmlvQLZBtHnzZlx99dU4duxYu9ADx3EIhVivKCURfAL2z90PADi/9iyNR6MtRFMo3pyBgkwLWrxtqGvxdZicyYifJgoeokh4gK2GkyX5TuuiQZSK3jrSlLlvTufSGsRYqtLMIEqusStBqjJjITNNkG0Q3XTTTRg3bhw+/PBDFBcXa5LRz2AAkZBZfpzNLAszmVo1LZIJ0RBIqwIaq+F0Y+feg95AcxJVZgBgl7x1qTcRx+MhIs8da1TfIBKExNumnIq0SGBJ1Zog2yA6dOgQ3n77bQwaNEiJ8TAYcVMXNojiCZkBUVpErPQ+aWiECEhFTbJ5K1aTFa7f9u42Ns1J6uBESu9TL3xJvD6l2Z0bRGW54nOVTW7VS+/bfEEEQmK0JPkqM+Yh0hLZKSgTJkzADz/8oMRYGAxZSDlEceY8kP1Y+47kcUhlxomHCFhFDR2CIV4yKhP12JFy/VRLqhYEAVXN3XuISrLSoNdx8AV5aaGkFuRasBh1SDPJl6CIhuUQaYtsD9Ftt92GxYsXo6amBqNGjYLRGHtDHD16NLXBMRhdQW588SaBSl29U7iJZU+BeCTsacmHzFJtEu5pOD0BkHRO4umRC/FspForlfo2H7wBHhzXdQNno16HkiwLqpo8ONbo7laolSa0RBmBaA8RC5lpgWyD6Kc//SkA4LrrrpO2cRwnuSlZUjVDLaQcojiTqnOkrt6pddPviThpeIgoNbL0Br346X/F+9I7c9+BxaC+MJ+WRIxTIwwJKn7bU1StutoheoELbRaYDF1/tn456ahq8qCyyY3x/XPUGB4AehVmQMRr2uYLIhjiE/49GYkh2yCqqKhQYhwMhiwEQYjkEMXrIbISDxEziJJFmgRoJFUnGTIL8SF8dOgj6XFvgzQWTabij4TMHCnmrat2hg0ie/dGbr8cKzaiEZWN6uaTRa6F5KU8bJbIlNzmCyata8SQh2yDqKysTIlxMBiyaPEEJVXdeENmOcwgogLPC1KYK5FWEQSWL0GHSMgm8d9CyiFKMQ9RbYtoEBXHEQIjOUaVKpfeN7votO0AxNBfukkPtz+EFg8ziNQmIWHGw4cPY8WKFThw4AA4jsOwYcNwxx13YODAgbTHx2B0SH2beKPMtBhgMcaXyEhyiBrb/Jo1gZSLLxjCox8ewI5KB+afW46rzu6r9ZDQ4g1IfYWzKOQQMYMoOWiUfEv9zDyptVggHqKiODxEpNJMbXFGmiEzQAwlu/0hVmygAbIDlGvXrsXw4cOxdetWjB49GiNHjsSWLVswYsQIrFu3TokxMhjtaGgTb0J5cWoQAUBuOIfIH+LR1kPad/z1k+/xyqZj+PaEE3e/tRtbjjRqPSRJ8ybDbOg2r6MrSA4RS6pOjiYK4UuSjE28HakC8RDFYxCRpGuSd6QWNMLH0TDPqXbI9hDdf//9uPPOO/HnP/+53fb77rsPF198MbXBMRidkYhScppJjzSjHp5ACE0uP2wp3r6j2eXHqq+PAgCK7RZUO71Yvv57vHnjJG3HlURn9WhIAqnLH2IJpEnQTEE1nHiIUs04rXaKKtVFcYTMSsJGU12rF4EQD6NK51MzhQKDaJgWkXbIPmMOHDiA66+/vt326667Dvv376cyKAajOxJtLkr27wmVZh/vrYEvyGN4cSbe+c254Dhg85Em1Di1VdqmpsoblUDKmlkmDkmqTsZAzYqqbgqEUqfjPRFRjcdDlJdhhlHPgRciniU1aKZYdg8wtWotkW0Q5efnY9euXe2279q1CwUFBTTGxGB0S1M4ZEbyguJF0iJqS32D6PODdQCAmSOLUJKVhrGlWQCAdQdqNRxVJKySrIfIoNfBGhaySzXPRE/C6aGgGp6Weh3vBUGQPETFcRhEOh0nGU7VKi4aIn3MaOUQhUNmzEOkOrJDZgsXLsSNN96II0eO4NxzzwXHcfjqq6/w+OOPY/HixUqMkRGF3qrHVGGq+I+r97YrIOKKcj1EuZKHKLXFGX3BEDb+0AAAuPAMcaExfUQRdlQ68Mm+GsybqF21J80kUnuaEa4kE0itJiuEh4XudzxNIdpB9gRFGYHYjvcOt19Wbp5StHiC8AZEb1W8QovF9jRUNXlw0uFRcmgxNFOo8osmkxUbaIZsg+ihhx6CzWbDsmXL8MADDwAASkpKsGTJEtx+++3UB8hgdEST1MxS3o27p4gz7q5ywuUPIS/DjOHFmQCAC4cW4M8ff4dvjjZrmnNDJuBkPUSAePM/6fSmjFeiJyJJICRhEAHi7ykaRKnxW1S3iEZNdrox7krSEpU9RIIgKFJlBjC1ai2QbRBxHIc777wTd955J1pbWwEANpuN+sAYjK6IeIjkTQI9JWS257gDADC2XxZ0OjGWMbggAzazAa2+IA7WtmJEiV2TsUWSqim2KmD5EglDDKLMZA2iNCOOIXXUqkmunJw2HMVSpZk6HiJPIARfWA+NVZn1fJJaYtpsNmYMqUzIG8K+Ofuwb84+hLypk/yoNo1tJKlaroeoZ4gz7j3hBACM7hMxenQ6DmP6ZQEAdlQ6NBiVCI3GrgQaDV69QS/mvDUHc96aA29Q24RzLSDq0smEzIBoLaLUmIiJQRRP/hCBeIhOquQhIvlDpqh8uGRhVWbaEZeH6KyzzsKGDRuQnZ2NsWPHdilot2PHDmqDY3RACKh/ux4AcMbfSzUejHYQgyY3wSqzhhQ3iPaEDaKRfWO9QGP7ZePLQw3YeaxZszwiB4UkXgJZDScTMgvxIby9/20AwKorViU9pp6ENxCSFNuTDWFK7TtSpMErqTCT4yGStIic6niISP5QVrqRmtArqzLTjrg8RFdccQXMZrP0uKs/OZSXl4PjuHZ/t9xyCwAxPrtkyRKUlJQgLS0NU6dOxb59+2KO4fP5cNtttyEvLw9WqxWXX345jh8/HrNPc3Mz5s2bB7vdDrvdjnnz5sHhcMgaa6rAmTgMfmYwBj8zGJwp9ZWWlSA6bi83qTqvB3S8b/MFUdEgJsyP6hNrEI0pFf/fX92i+rgItKrMAKZWnSzEkNTrOGSYE2o8IJFqDV6JGn28rXkAMakaUE+ckXb+EMA8RFoS1xX08MMPS4+XLFlC7c23bduGUCjSjHHv3r24+OKLMWfOHADAE088gb/+9a9YtWoVhgwZgj/+8Y+4+OKLcfDgQSlUt2jRIrz//vt48803kZubi8WLF2PWrFnYvn079HrRhXn11Vfj+PHjWLNmDQDgxhtvxLx58/D+++9T+yxqoTPq0OeWPuI/vbTKrMUbRCAkVhXJ1yESb66pnEN0qLYVgiBOBKdW+wwtEhOsD9e3qSo+Fw0tHSKAqVUnCzFeMi2GpD0UxCBqTZGJuKFVvhp9SZboTWp0+eENhOJOxk6USMk9PZFX0uCVLRLUR/bddMCAAWhsbN8+wOFwYMCAAbKOlZ+fj6KiIunvgw8+wMCBAzFlyhQIgoAVK1bgd7/7HWbPno2RI0filVdegdvtxr/+9S8AgNPpxEsvvYRly5Zh2rRpGDt2LF5//XV8++23WL9+PQBRSHLNmjX45z//iUmTJmHSpEl48cUX8cEHH+DgwYNyPz4jBSDhMqtJL/uGl52iXb2jOVIvGrqD8jPaPVdityDDbEAgJEheJLWJKPPSCJmxippkiDTZpZjgniK/RUOb6MWV4yGypxmRFr4nqCFgSluUEYgYRK09pL3Q6YRsg+jo0aMxXh2Cz+drF6qSg9/vx+uvv47rrrsOHMehoqICNTU1mD59urSP2WzGlClT8PXXXwMAtm/fjkAgELNPSUkJRo4cKe2zadMm2O12TJgwQdpn4sSJsNvt0j4d4fP50NLSEvOXCgghAc2fN6P582YIod6pvSJVmMkUZQQizUjd/hB8wfbncSpwuL4NADAg39ruOY7jMKRQNJS+q2lVdVyAmLPiCYjfWxaFVTELmSUHrQoz8Rip5ZkgBpEcDxHHRcQZ1VCrpllxScgIG0RtviAEoXfe47Ui7qDz6tWrpcdr166F3R7JbQiFQtiwYQP69++f8EDee+89OBwOLFiwAABQU1MDACgsLIzZr7CwEMeOHZP2MZlMyM7ObrcPeX1NTU2HCtoFBQXSPh3x2GOPYenSpQl/HqXgvTx2X7gbAHB+7VlQ1iGcmpBWBTkJ3IRsFgN0HMAL4mRSYEu9b5B4iAZ24CECxLDZjkoHvq9pBc5Uc2SREI1ex8GWZM4KEFHlZSGzxCDhy2QrzIDUC19GGjjLu87zbWZUNLhQ16p8niDNiksC+R0EQezzl2xuGCN+4v6mr7zySgCiBT5//vyY54xGI8rLy7Fs2bKEB/LSSy9h5syZKCkpidl+alxcEIRuY+Wn7tPR/t0d54EHHsBdd90l/d/S0oLS0t5b1ZVKJKpSDYil6/Y0I5rdogBdgS3+Cha1IB6igQUdG0TEQ3SoTn0PkbQiTqNTVWOnUHbfm6ElygjQkUCghTcQQls4ZJQnI2QGRKrS1PQQ0QyZmQ06GHQcgryANm+QGUQqEvc3zfNiaWf//v2xbds25OXlURvEsWPHsH79evzvf/+TthUVFQEQPTzFxcXS9rq6OslrVFRUBL/fj+bm5hgvUV1dHc4991xpn9ra9r2f6uvr23mfojGbzVJlHSO1iDR2Tez3yUo3SQZRqhHiBRxtFD1EA/Lah8wAoDxX3H6s0a3auAi0Ot0TaLQpSDemo+2BNulxb6KFkgYRkFoimfVh747JoJPtiSwIG1BqeIho9zEDxAV8hsUAhzuANl8AQOot2k5XZOcQVVRUUDWGAGDlypUoKCjAZZddJm3r378/ioqKsG7dOmmb3+/HF198IRk7Z599NoxGY8w+1dXV2Lt3r7TPpEmT4HQ6sXXrVmmfLVu2wOl0SvswehaJNnYlRMqLU6/SrKbFi0BIgFHPSZoqp1KWK076xxrdqucYOCgmVAPROUSJ50twHAeryQqryUpNC6anQEuUMfoYqeAhqicJ1Rlm2b9pYWbYIFLDQ0S5jxlBqjRLkQT33oJsg+j222/HU0891W77M888g0WLFskeAM/zWLlyJebPnw+DIbIS4DgOixYtwqOPPop3330Xe/fuxYIFC5Ceno6rr74aAGC323H99ddj8eLF2LBhA3bu3Ilf/epXGDVqFKZNmwYAGDZsGC655BIsXLgQmzdvxubNm7Fw4ULMmjULQ4cOlT1ehvY0uRLTICJkpXClWVWT6PXpk5UGva7jiaBvdjp0nNg2oF6FVXA0tJNIiYfIH+KlFgiM+IlUmdFLqnb7QwiEtP0tGlpJQrX88ywSMlPDQ0Q/qRoAMszi79nGDCJVkW0QvfPOO5g8eXK77eeeey7efvtt2QNYv349Kisrcd1117V77t5778WiRYtw8803Y9y4cThx4gQ++eSTmHYhy5cvx5VXXom5c+di8uTJSE9Px/vvvy9pEAHAG2+8gVGjRmH69OmYPn06Ro8ejddee032WBmpQWOyBlF4EnamYMjseLOosNs3u/PQj8mgQ59s0Xt0VOWwGe0kUqtJLxl+iSbz+oI+LHhvARa8twC+YOoKbioBzSqz6FyVVo0nYpJQLafknkBeU9uqvIdIiaRqAFKYsI2V3quK7GytxsbGmAozQmZmJhoaGmQPYPr06Z26yjmOw5IlS7oUg7RYLHj66afx9NNPd7pPTk4OXn/9ddljY6QmibbtIER6NqVeyIx4iEpzOg6XEcpyrKhq8uBoowvj++eoMTQAUSECSjkTHCcqLDs9AbR6gyjMlH+MIB/EK7tfAQD8/dK/w4zek/tHJmQaITODXocMswFtviBaPIGEFxw0SKTknkA8RPUKe4j8QV4yWGgmVQOR0vtUEcnsLcj2EA0aNEhSfI7m448/li3MyGAkAq2QWXMKeoiqmkWDqCsPERCdR6SuOKODYoiGYGM3/4RpoVhlBkRkELTOI6JhELX6gnAp6GEhCyqOo+OhiyZyTTAPkZrI9hDddddduPXWW1FfX48f/ehHAIANGzZg2bJlWLFiBe3xMRjtSNog6hEhs649RFpVmtFs20EgoRp285cPCZnZKVb9nXR6NdciihhE8s+zDLMB6SY93P4Q6lp96K9Q2Xq0d66zfL9EyWAhM02QfaZcd9118Pl8+NOf/oQ//OEPAMQmrc899xyuueYa6gNkMKKJUUpOcFJO5ZDZ8Sa5HiJ1DaJmBYXo2M1fHoIgUK0yA1Kn9F7qY5ZADhEgeokqGlyoa/GifyfyFcmiRNsOQgbzEGlCQqbzb37zG/zmN79BfX090tLSkJHRsYAcg0Gb6O7exL0vF7KaTjUdohAvoDZcXdOnk5J7QlnYQ3S0wRWXWCktlGxVwEJm8nD5QwjxYv4laUmTLKkiztjgSjxkBkTUqmsVrMIkiwOa4WOCtEhgBpGqJOVLzM/PpzUOBiMuaHT3zkpLTYOosc2HEC9Ax3UfKiBJ162+IFq8QWoegu5wKDAJsHyJxCCLA5NeB4tRdjpoh6RKP7PmJAsnSB6RklpESoSPCSxkpg2yr6La2lrMmzcPJSUlMBgM0Ov1MX8MhpLQ6O5NXqt1nsSp1IRv3vk2Mwz6ri/NdJNBCluddHgUHxsA8LygyCTADKLEIDlwmZTaqADRHe+1uzZCfCQUmGg1Y6EKatVKeoiIQaS1p663IdtDtGDBAlRWVuKhhx5CcXFxr1OG1Rpdug7n1okK27q01MuBURoazSyJIdHmCyIQ4mHsxvhQixqnaBAVZcYn1V+SlYZmdwAnHR4MK06gXl0mrd4gwhEaqpMAEaFL1CBKN6aj7u466XFvgeTA0fwtMtO0zyFyuP0gSiyJVs8VhNWqlexnRu5FiTSZ7g6bhXmItEC2QfTVV1/hyy+/xJgxYxQYDqM7OI6DKT98Abp63+qBRtm3zWIEx4ndpB3uQELib0pAbt6FMgyifSdbVPMQkfyhdJMeZgM9b3CyZfccxyHf2vvC9zT7mBFSoey+OWrR052ntDMiITPlPERNlDW5oiF5dSyHSF1kn22lpaWq909iMAg0JgExITtcep9ClWYkZFZkj88gIonXJxzKK/ICynT2BiKTMFsNy8OphEFEJCk0DCc3hRd6yQhDFtjC7TsUVKtWMmRmS9JrykgM2QbRihUrcP/99+Po0aMKDIfRHbyPx/e3fI/vb/kevK/39X6SknqTnASyUrDSrMYprmbj9xCJ+6nlIVJClBFIvsTYF/Thlg9vwS0f3tKrWnfQuhaiiZTda2kQJd8wtUBq8Krc+aBoUjVbJGiC7JDZz372M7jdbgwcOBDp6ekwGmNP2qamJmqDY7RHCAo4+exJAMDAh4s0Ho36kLwJe5I3oaw0I44htQwiEjKTk0MEqGgQuennrADRq+HEfosgH8Sz3zwLAHji4id6TesOmn3MCJGO99pNxMQTmZyHSDwH2nxBuP1BpJvoizM2K3Q9ALE5RDwvQEdZ+JHRMbLPEqZGrS2ckUPZw2XS494GPQ8REWdMHYOoRmYOUR+VDaJmV/IVfh0h5RCx1bAslAmZaV9230RB8DDDbECaUQ9PIIT6Vh/KcukbRJHGrsqV3QNAmz8oee4YyiL7LJk/f74S42DEic6kQ/8l/cV/XOr2sUoFaE0CkZBZ6uQQ1ZIqM3t8Hg5iENW0eBEM8QknoMaLVAqdYiEztQiEeNQ4veibnZYS1bVKhDBToey+OcnWPEA40d5mRmWTG3WtPknIlBbRKuFKGERmgw5GPYdASECblxlEaiHbIKqsrOzy+X79+iU8GAajO5yUJoFUE2d0+YKShyReD1Fehlm6ada2+rpVt04WKWRGSRWZQG72qaxUXeP04uoXN+NIgwsT+ufglevGw2LUVndNkSqz8LG8AR6+YIhqNWG8NLnpVG8VhA2iegW0iFq8wYhKuAIhM47jYLMY0eTyszwiFZFtEJWXl3e5OgqFQkkNiNE1Ai/AfUDsX5XeT4D261R1oaWUbE+xfmYkXGY16WGLczWo03EotqehssmNkw6P4gaRUlU1JGTmDfAppQsVzdL39+FIg+iR3VLRhGc/+wF3TR+q6ZiUCJnZzAZJkqLVG4Q5Q32DSPIQJel5IXIaSqhVk8VBmlGvmGGcYTagyeVP6YXC6YbsO8/OnTuxY8cO6W/Lli14/vnnMWTIELz11ltKjJERBe/hsW3kNmwbuQ28pzdWmSUvzAiknodI0iCKs+SeUGxXr9JMqaoaa3S+RAqGzepavFizrwYAcPtFgwEAr2w6Bn9Q2+tPiTYqOh0n5a9oVXrfRHJzKHiIAGXUqpVocnwq5HdI9VDy6YRsD9GZZ57Zbtu4ceNQUlKCJ598ErNnz6YyMAbjVEK8IIWV7EmGbcgkkirtO4hbv0CmSCQxiJRU5CUoMQEDgFGvkxJgW71BRYTukuH9PdUQBODssmzccdFg/GtLJRrafNj4QwMuPKNAs3Ep4SECxBBmqzeoWWJ1JIcouc9VEA49KxEyU6LJ8akwtWr1oeabHjJkCLZt20brcAxGO1q9AUnSP9lJIJI8mho3m4a2cDNLmd29Sb5RrYJ6K4RIqwjldFdaffIn4TRjGiruqEDFHRVIM9IPG364R5S5uGJMCfQ6DpeOEuUu3g9v1wKeF6TEZ5pl94D2pffNFKrMACA/Q0EPEYXE7+5gPf7UR7aHqKWlJeZ/QRBQXV2NJUuWYPDgwdQGxmCcCvFQWE16mAzJ2fJkEmlNEQ9RY5t4086XaRCRVXCNGh4il3JhApvFgPpWX0I3fx2nQ3lWOfUxAYDHH8Ke404AwIVDRW/QJSOK8OqmY9j4QwMEQdCk4qzVG6S2ODgVLUvv/UFe8gIna2zkZyofMlMioZogdbxnBpFqyDaIsrKy2t0ABEFAaWkp3nzzTWoDYzBOhWaIQLrpp0jCYkPYIMrLkDcJFEk9m5Q1iAKhyESlhIfIJlWapdbNf1eVA0FeQFGmBX2zRe/T2H7ZMOo51Lb4cLzZg9Ic9RvKkmshzUi3rxygbek9yVPTcUi61JyEn5UImSmpUk3IYPpcqiPbIPrss89i/tfpdMjPz8egQYNgMNAXv2IwCET3I1mVaiC6RUFQs1V+NCRklic7ZEa6eisbMovOtaLtkQDE6iYAaEsgZOYP+fG7Db8DAPzpoj/BpKc3SX1zVFTeH1eeLZ0jaSY9RvaxY2elA98ca9LUIFLit9Cy431TlKGRrDozqTJrdPmo63RF+vop5yEii4RU9RBtP9aMJav3waDn8NjsUTijKFPrISVNXGfIWWedhebmZgDAF198gXPOOQdTpkzBlClTcP755+OMM85gxhBDcSI6ODQ8ROIx/CEePo2rhYBIyCzRHKKaFq+iTZfJd59pMUCvQBuBZPIlAqEA/rLpL/jLpr8gEKLr1dhRKd73xpVlx2w/pzwHALDtaDPV94uXSD6XAgaRhh4imh3kc61m6MISAo0uuvIakZCZgh4iqcosNbzY0Tg9Adz46jf49oQTOysdWPjqN/AGer7kTlwG0YEDB+AKqyIvXbpUesxgqAktUUZAzEMi87qWbQoIEQ+RvBssaWLpD/KKVsw1UyqF7oxUTSD9rqYVADCyjz1m+5jSLADAvhNOtYcEQJk+ZgQtc4hIe5hkNYgAQK/jJI8r7bCZFDJLshKuK1K5yuyNLcfQ6PIj32ZGVroRVU0e/G/HCa2HlTRxuXXGjBmDa6+9Fueddx4EQcCTTz6JjIyMDvf9/e9/T3WADAbB6aYXJuA4DplpRjjcAbR4A1JyshYIgoB6KYdInofIbNAjO92IZncAtS0+xVasDoVXxBnm1MshcroDqA63UxlSZIt5blixGB44WNuKEC8o4jXrcmxKhsws2klSNFE2NPJtZtS1+lDX6gVg73b/eFGqr180qWoQCYKAt7cfBwDcM2MoWjwB/PHDA/jfjuO4ekLP7lQRl0G0atUqPPzww/jggw/AcRw+/vjjDkNkHMcxg+g0QBAEvLrpGDYdbsTcc/riR2cUaj0kANE5RHRulpkW0SDSWouo1ReURP7kGkSAGDZrdgdQ0+LF0FMmblo0UwxXdkTEQ6S9t47wfZ3oHSqxW9ol+PbLSZe0kyoaXBhU0PECUSloNTnuCGJkaXFd0C5nL7CZsQ8KeogUDZmlljQI4VijG0fqXTDqOcwcWYQWbxB//PAAdlQ2o8nlV1SKQGniMoiGDh0qVZDpdDps2LABBQXaCZIxlOX1zcfw8Op9AIBP9tfgrZsm4eyyHI1HFT0J0LngIqEBbW84jeFwmdWkR5pJfsVQYaYF39W0KirO6FA4iTQVQ2YkXNaRkanXcRhSZMPuKge+q2lR3SBSoo8ZQcvfgkan+2gKbKQKk65BpKZSdVsKLRIAYNORRgDA2NJs2CxG2CxGnFFkw3c1rfj8YB1mn9VX4xEmjuy0e57nmTF0GhMM8fj7Z4cBAOkmPXgBeHzNQY1HJUI7TJAKnb2BqJJ7mSrVBFJppmTpvdIhs1QMD3wfNohODZcRhheL2w9Ut3T4vJKoUWWmhbeumbLnJV+B9h3eQAiecAJxbwyZfX1YNIgmDcyVtl00TLQJvvqhQZMx0SL1uigyNOXT7+pQ0+JFjtWENXdcAL2Ow9aKJhxr1D6R3km5skZS5NU4ZNbQmlj+EKFIBXFGpYXobCnY8f5o+JwfmN+x92dwgWgQHa5T/9pQqo0KoK2KO+3PRYoOaIbMiNGm13HItChXXZ2KXlMA2HKkvUE0LhxB2FXl0GJI1GC18j0MXZoO5+w9J/yYfpn16t1iO4Krzu6LfrnpmNA/B18fbsT6A3W4/rz+1N9PDrTzJlKlfUeDK7EKM0KBCu07iDGqVM5EMjf/NGMa9v5mr/SYFpVNbgBivlBH9M+zAogYTmqiZJUZ+S20WCg4KHu+Iu076C0WmqMU25XULyMhM7c/pEnifkfUtXpR1+qDjgPO7JslbR/dV0xYP1LvgtMdoJbnqTbMQ9TD4HQcrCOssI6wgqN8gQiCgM1h6/+icNPKi4aJCdUbDtRSfa9EoJ5UrWF5cTTEQyRXg4hQqIJadaSqRpkbXTKdvXWcDiMKRmBEwQjoODq3tGCIx4lmDwCgLLdjg6g8yiDieeU0oDpCjZCZL8jDF1RXW6bFQzc0W6BA+w6HCo1dgYhSNZA6YbP9J8XwcP88a0y+Y26GWVo47D7u0GJoVGAGEUPiUF0bGtr8sBh1GNMvCwAwLRwb3lrRpKnwliAIp38OUUqHzJSdBFItZFbt9CLICzAZdCi0dSzJ0Dc7DXodB2+ARy1FD0Q8OCkbDtEQ4xRQP1wTMTYohcxskY73tIRL1UioBkRJDdKzMVWui/3hfLnhJe0lDIg217caaXPRQLZBNGDAADQ2Nrbb7nA4MGDAACqDYnQO7+dRsaQCFUsqwPvpKiwT79C4shypP1K/nHQU2MwI8gL2aniiewO8VJpOaxLQskVBNKSyJjfBctXCqDyJkEKeCjIBK11l1uYLyp64/CE/lny+BEs+XwJ/iI4iMQmXlWanddpCwqjXoTTc36yiQd2wmZIeIr2Ok1qpqGkQ8Tz9RQ9JqvYFeWqhcaUXB9FEWtqklodoeHH7Nh2SNle4GKEnItsgOnr0KEKh9p4Cn8+HEyd6vlJlqiMEBBxbegzHlh6DEKA7+e2uEg2eceWRNgUcx0mW/85KB9X3kwNpVWDQcbAmUJreEanS4JXcYBPV78jNMEOv48ALEW8TbSI6RMrmEPGCmDMhh0AogKVfLMXSL5ZSa91xrLHr/CGCFDZrcFN533gIhHhpglTCIAKiFwvqXRtt/iCIPU/rc1mMeuncqqfkxVNagiIaEjZLlX5mRIpiWHH7ysshhWLxwfe1PdcgijupevXq1dLjtWvXwm6PuMxCoRA2bNiA8vJyqoNjtIczcCi5uUR6TBPiDh1xijt0TL8sfLK/VtMKgujqE1qJjJEGrxobRKRdQYIGkdiiwITaFh/qWnxSThEtvIEQvIGwd06hVgVpRj30Og4hXkCrNwirWdt6j+4SqgnluVYA9aomVkefr0pVOUmJ1SouFogSvdmgg8VIZ9EDiOKMrd4g6lp9GFSQvHBpJGSmvIdIyq1LAQ9RMMRL1cYd6W4NKRS/2yP1LgRCPIwUm+mqRdxX05VXXglA9BjMnz8/5jmj0Yjy8nIsW7aM6uAY7dGZdRjy9yHiPxR7yvmDPH4IK/MOL4l1hxIPkZYGkRJVNdIqWOPVVxOFvIkCm0U0iCi3KAAixmh0KIU2HMchw2yA0xNAqzeAIrt2rVQAoLJJvLb65Vq73E+qNFMxZEauBZvZQLWDezSZUk6XetcGzV6F0eTbzDhc76JWek+zAW13EIPIlQIG0QmHB4GQALNBhxJ7+2rOPllpSDfp4faHcKzRRcX4VJu47248L64Q+/fvj23btiEvL0+xQTHU51BdKwIhAZkWA0pOmYxIvPiEw4NWb0BKgFUTJVoVpIKHSBAEKu0KCsK5EkqU3ke37VCyzNhmCRtEKXDzj9tDpEHpvZIl9wQtSu+VyouKTqymQSPl9iJdYUuhkNmRevEc759n7TCvTqfjMLhQVG//vratRxpEspcXFRUV7Ywhh8NBazyMbhAEAf56P/z1fmpVEwBwoDriHTp10stKN0kT7qG6NmrvKYeIKCO9m1B0DhHN71IOrb4gguHEiWRc8ESLiKbeCqGZcuVPZ9g08Ep0RmU4h6izkntC/7AH6VijW7VzyKGQJyWaiFq1er8F7dY8hALKatVNrrBMhooeolRIqj7SEDGIOmNg+Dm1iwxoIdsgevzxx/Gf//xH+n/OnDnIyclBnz59sHv3bqqDY7SHd/P4uuBrfF3wNXg3vSqzw/WioTO4E6ue9HM6pFHCnBKrR+IhCoQEKUdGbRzh/KF0kz6pvAnaN/1onCrlTEQqm7TN6WrzBaUwaklW10KPRXYLOE6sYiKeA6VRso8ZIVOLHCKFPF9S+w5KshRNbep5iDJSSK26okGcI7oyiMqkBUIvMYheeOEFlJaWAgDWrVuH9evXY82aNZg5cybuuece6gNkqMORsEE0IL/jk50kzB2s0cZDRFaPNCeBdJNeUn/VqtKsiVLvJkmATpGQmfIeCSB1wgM1TnHitJkNMZo8HRGtU0SEHJVGyZJ7gk2DcLKDcmsegtS+g0IFpiAIkuGba01MN0wOpON9KniISCVl1waR6FElVZo9DdkZktXV1ZJB9MEHH2Du3LmYPn06ysvLMWHCBOoDZKhDRTfuUK1LKpUIE3Cc2Iuo2R2A0xOgXp0VD81SgmZynyuSJ6FkyEwdZV65N3+LwYKtN2yVHicLMYjiTewuybKgpsWLEw4PzgwXICiJkn3MCCScrEVStVI5RDQWC25/CL6wHlpOgq125JBhFr3GWi8SAOB4c1ibq4u8un5hg4jk4PU0ZHuIsrOzUVVVBQBYs2YNpk2bBkC0nDvSJ2KkPiFewNGwRT8gr+NGlqTBpVaxYacCSdWANnor0UgVK0kaG0ScUYmkaqVFGQmJtu/Q6/Q4p885OKfPOdDrki/XJorf8RpEfbLFSUBtD5GySdXqq7grdY3T7HhPrleTQUdND60rUiWHiOcFnHSI10WfLsLIZWFjqdrp1bSzQaLINohmz56Nq6++GhdffDEaGxsxc+ZMAMCuXbswaNAg6gNkKM9Jhwf+IA+jnkOf7I5PdmL5n3R6VO9vBEStHilPylq370hWlJFAVsENbT7qfbWIF0tpDxGZhLW++dc4RcOmKE6PIZkgTjhOn5CZFo2PlbrGSX6d0xNI+t7VGKUqr2TFJSGDFBpofE00tPngD/HQcV0vFHKsJsmIq+qBXiLZBtHy5ctx6623Yvjw4Vi3bh0yMkTPQXV1NW6++WbqA2QoD/H6lOVaO+2onJ9hRrpJD0EAjqu0Eo5Gyi+gXIFi17h9RzOlHKK8DBM4DgjygpSXRAs1qpqA6I738oxTf8iPJzc+iSc3PkmldYd8D5G6BpES+XSnokXjY6U+lz3NCFNYrynZ0ntSYaZGQjUQ5SHSuNCAnNuFmZYuBRc5jpOkKnpiHpHsHCKj0Yi777673fZFixbRGA9DA6qau9dcISf6dzWtqGx0SyE0tZBulrQ9RBq372hy0angMuh1yLWa0NDmR12LL+FGsR3hoGS0dUei4YFAKIB7198LALj5nJth0ic3Trk5RH2y1E2qljrCK9RGBdBGAkEpzxfHcci3mXHC4UFdqw99s7uWUuiKRhUrzIDYHn9aQgyirsJlhLLcdOyvbsGx3uAhAoDDhw/jtttuw7Rp03DxxRfj9ttvx5EjR2iPjaESJ+M82SMVBOrnESmWQ6SxOGNElDH5z5UfDpvR7rzerNB3fyqJ5hDRRvIQxR0yC+cQnVYhM+3K7pUIzZI8ouQ9RMk1YpZLxEOksUEUNvY7S6mIRkqs7oGl97INorVr12L48OHYunUrRo8ejZEjR2LLli1SCI3R84j3ZJc0JlS2/IMhXoqh054EtG7fIZXdU7jBSl3vKSdWR6qalM4hSo3VsGwPUfi6cXoCqoydhI/VKLtv8wWp56R1hpKGHq3E6iZpAaN8yT0QpUPUgzxE5RrNEzSQHTK7//77ceedd+LPf/5zu+333XcfLr74YmqDY6hDvCe7VrHhaGOFukGkQYuCaGiGoyLijPQ8RIIgSGNUOocoFUTo/EEeDeGwSLweogyzAfY0I5yeAE46PJJml1Io1fMrGmKcCoLYhT5T4XY9gRAvGZNKeCILKHmIpKRqFUrugYhYqcsXhCAIqiRyd4QcDxGZR06q5DGliWwP0YEDB3D99de3237ddddh//79VAbFUJf4PUTahMzIhKxEM8uIh6hn5xABUXorFNWq2yi1FokHGxGh09Agqg2Hy0x6naw8EaJorXQekTcQklTVlSy7txj1MBvEa02NxYIz6j2U+Fy0dLqaVOxjBkQWCbwAeDQsY5fjISqRDCL6mmhKI3t2yc/Px65du9pt37VrFwoKCmiMiaEigRAv5Ux0m0OUI7pCq5o9qrnRAeXKcYHoHCL1J2FBEKiV3QPKqFWTcJnZoEOawroriQoz0oQYRIV2s6zVeHE4vFZDqT1EZxDjhOMi3gOlsKl4bZBr3GYxdFrpmgyR9h10PERqGURpRj3I16HlQkGeQSReC2ILHG2r4+Qi+4pauHAhbrzxRhw5cgTnnnsuOI7DV199hccffxyLFy9WYowMBalt8YIXxBVxfjeVSSVZFhh0HPxB0Yjqrs8TLRwK5hZoWWXW4g0iFDYsaYQ/pI73FENmaqgiE6KrzHhe6LCjttLITagmEJVzkn+kFJIoo8Wo+PeTmWZAQ5tPld5ySksJSCGzJNt3qNnYFRAr5DLMBrR4g2j1BaGFy6HFG5DC2PHc89NNBmSlG+FwiyHkzCLl7x20kG0QPfTQQ7DZbFi2bBkeeOABAEBJSQmWLFmC22+/nfoAGbHoLDqc+dmZ0uNkIS7+4ixLtzdYg16HIrsFx5s9OOHwqGYQORWclLWsMiOhwGQbuxKkjvcUPUS0dJLigeStAIDLH5Q8FN1hMVjw2fzPpMfJQHJMSIglXogBRTN/qyPUUg0HotWqlfdMtCicF0XLe6pmY1eCzWJEizeomYeINMXNtBhgjdMrWWJPg8MdQLXDizOKMpUcHlVkG0Qcx+HOO+/EnXfeidZWsa+VzaZsEiEjAqfnkD01W/zHlXwujxxXKCCuEI43e1RNmJOSehXQXdGyyoxW2w5CdOIorQRMJb1zp2I26GDUcwiEBLR64zeI9Do9ppZPpTKGhrAHIU9m0iyp8FPaQ6SGKCMhM0GhzERQSniVQEJmRMk9Ee+aNxCCyy/m8ajR2JWgdfsO0g5ITq/HkiwL9le3qCZFQQvZLoaKigocOnQIgGgIEWPo0KFDOHr0KNXBMZRHSqiO1yAK50qomTDnDOcwKJFsSTxETk8AgqBeXhRAr20Hgdz0/SE+Jkk1GZpVzJkg4QFAu5s/8RCR7zJeCqUcIvq95KKRDFQVPHZq9vlzKmzo5WWYJSX35gSV3MkCxqDjpFC7GmhdfUny6oiXLR5I9KDaeZobRAsWLMDXX3/dbvuWLVuwYMECGmNidAEf4HHi7ydw4u8nwIerTZLhpDP+ckpAmxNdWj0q4E4nYZoQL6hexSFVmFEyNswGvfQd0WryqnYSaSI3/0AogL9v/Tv+vvXvCISSm7xJyb1cpW8SMqtVOKlaDVFGQkScUQ1tJeUKJwDAqNchJ2xEJlqFKXl0VepjRtB6kUC+r0IZYeRie8+sNJNtEO3cuROTJ09ut33ixIkdVp8x6CL4BRy69RAO3XoIgj95jwY5YYvjFKEr1qCkUimVakDM3yFVLWqvwCIaRPQ+F20tIjU9REBU6b2Mm78/5MetH9+KWz++NeleZol6iIhB1OTyK9r82CmFj9UwiEj7DvXK7pU09JIVZ2xUWaWaoHU/M2Lk58vyEJFIwmnuIeI4TsodisbpdCIU0k4nodegB/Kvykf+VfmAPvlVimT9x92mQP0TXcnmohzHSV4itROrHQoYeoWUE6u10l1RYxLuiEgOkTyDKCvdCFNYt4dmUvupqNVoF0DUdaFC2b0K7WGSbd+hdmNXQk/0EEnijKd7yOz888/HY489FmP8hEIhPPbYYzjvvPOoDo7RHr1FjxFvjcCIt0ZAT6HKjFQQxFtVQ1yhaobMlF49ZqpYTRONEp+LVosCgtoGkU3D3k2CIEQMIpkeIo7jpMRqJcNmqobMwu/R6js9PEQR4dLEfp+GVvFakOs9TBat23eQOUJOUjWJJNQ4vapq1iWL7MywJ554AhdccAGGDh2K888/HwDw5ZdfoqWlBZ9++in1ATKUIxDiJTdwYZzu0JKwQdTsDsDjDyku1gdEQkt2hSpQbBo0sgQiq32ayeLJ3vRPRSsPkRarYacngEBIvHnLrTIDxLBZVZNHUXFGdavM1BNmVMPzlayHqD5B72GyaN3glSyu5CRVF9rM0HFAICQuMgpk6npphWwXw/Dhw7Fnzx7MnTsXdXV1aG1txTXXXIPvvvsOI0eOVGKMDIUgNwajnou79DszzQBr2AhSyx2qdO+mSK6ENh4imk1TCygp8hKaVNQhArTteE+8Q5kWA8wG+Ya+GuKMSnaEPxU1FwpOBRYHp1KQpPc00fyyZNGy6bEgCBH1dhkhM4NeJxmONFsJKU1CtYMlJSV49NFHaY+FEQchVwhfZnwJADi/9iwk458hJ2p+hjluXQ6O41CclYYf6tpQ7fBiYH5GEiPoHkEQlDeI0rTJIVIiTFBIUSBQEAQpqVq1ZpYW+UnVtKhLcsKLiDMqNwFoEjJTo8pMyiFS7jwjHo76BBcL9VH3SzXR0kPU6gtKvfPkeIgA8V5U1+pDbYsXI/vYlRgedeh2ymT0KCL6EvLcmSUqdjN2+0NSGEOpSSCiyKuyQaRAF3lJkZfCpNziVa+xK8GmYVJ1oiX3BDU8RA4FzpnOUKvYQBAE6T2UKrsHIoZMou07iAdRqxwiTRYJUSrVctX0Izl1p7mHiHF6EEmolneBS+KMKoTMSG6BSa9DGoX2Fh2hdciMpqEXHTJLVq2a5A9ZKbUWiYdEKmrMBjM++MUH0uNESTYkUqhwg1eeF1TWIYpcF7SUzzvCEwjBHxK9EEpWmUVa2yT2+2gVMtOyyowYM4nkABWopM1FE809RCdOnMCvfvUr5ObmIj09HWPGjMH27dul5xcsWACO42L+Jk6cGHMMn8+H2267DXl5ebBarbj88stx/PjxmH2am5sxb9482O122O12zJs3Dw6HQ42P2CV/+GA/rvz7Rnx5qF7195Zbck8olE505S1/KaE63ajYDVmLsnulJjeSVO0JhJK+gUYL0alFIjlEBp0Blw25DJcNuQwGXeJrvERL7glKizO2+YMgBTtqhsz8IR6+YPIisJ1BrgODjkO6gkUaxJBx+UNwybw2AiFeyqfrTTlEJPQeb9FNNLQ10dRAU4OoubkZkydPhtFoxMcff4z9+/dj2bJlyMrKitnvkksuQXV1tfT30UcfxTy/aNEivPvuu3jzzTfx1Vdfoa2tDbNmzYqRBrj66quxa9curFmzBmvWrMGuXbswb948NT5mlxyub8OuKgeqFe6B1BG1CXqICpNcaclBjRWxmrkSBKUmtzSTXipdT9ZgbdJAiE7Lm38DpRyi2havIm1giFaPxahTxWNnNelBUguVXCw4opo3K6kAnWE2SAaX3EqzJpcfggDoOPXCx4QMIlaqQQ4RKc5IJG+KtiaaGsheTnk8HgiCgPT0dADAsWPH8O6772L48OGYPn26rGM9/vjjKC0txcqVK6Vt5eXl7fYzm80oKirq8BhOpxMvvfQSXnvtNUybNg0A8Prrr6O0tBTr16/HjBkzcODAAaxZswabN2/GhAkTAAAvvvgiJk2ahIMHD2Lo0KGyxk0TLRPmEvUQJVutIQc1BNu0KLsnn8tsoD+5FWSa0VofRF2rF4MKEk96b9bCQ2SRfz0EQgG88e0bAIBfjvoljPrEzpVEG7sSSP6WN8CjxROkng+jZrgMIKKlRjg9AbR4gyhQqGm5GhVmhAKbGUcb3ahr9aE8zxr364gBlZthlpTt1UJLHSIiy5KI11TKITqdPURXXHEFXn31VQCAw+HAhAkTsGzZMlxxxRV47rnnZB1r9erVGDduHObMmYOCggKMHTsWL774Yrv9Pv/8cxQUFGDIkCFYuHAh6urqpOe2b9+OQCAQY4yVlJRg5MiRUs+1TZs2wW63S8YQILYasdvtHfZlA8QwXEtLS8yfEmi5Io7EhxPzEKkRG1ZDn0SLHCIlJzcSNktUb4Wgdh8zINK6Q85v4Q/5ce3/uxbX/r9rk2rd0Rw2UhP1AFiMUb3kFJgE1KjEOhU1FgtKKLZ3Rn6CYRytKsyAyKLZH+QVbQvTEWSRkJvA5yb3oZ6UVC3bINqxY4ckyPj222+jsLAQx44dw6uvvoqnnnpK1rGOHDmC5557DoMHD8batWtx00034fbbb5cMLgCYOXMm3njjDXz66adYtmwZtm3bhh/96Efw+cQvuaamBiaTCdnZ2THHLiwsRE1NjbRPQUFBu/cvKCiQ9jmVxx57TMo3stvtKC0tlfXZ4oWc7HJj2jSob5WnUk0gln9Dmw8hhVVII0J0yk0CmRrkECkpJSBVmiV5IyJdwXNUDBFoWVEj9ZZLwgCkrQMVjdoeIkCdxUKLip8r0cVCvUYVZkBkjgAAl09dg6ixLXHZDbJwbmjzIRhSLgeNJrJDZm63GzabDQDwySefYPbs2dDpdJg4cSKOHTsm61g8z2PcuHGSptHYsWOxb98+PPfcc7jmmmsAAD/72c+k/UeOHIlx48ahrKwMH374IWbPnt3psU+tiugoNt1V5cQDDzyAu+66S/q/paVFEaOIxIfVdodGq1TL9RDlZogqpLwANCqsQnq65hAp6yGi00KC3AxzVNIgAmIranheiFsfiwYRD1Hiv0lhpgXf17Yp4j11eCIFBmqhhkYX+VxqiE0m2tpGqwozANCHk83d/hDavEFVPbaNrsTDyLlWE/Q6DiFeQEObH0VxNhDXEtkeokGDBuG9995DVVUV1q5dK4Wq6urqkJkpL8hcXFyM4cOHx2wbNmwYKisru3xNWVkZDh06BAAoKiqC3+9Hc3NzzH51dXUoLCyU9qmtrW13rPr6emmfUzGbzcjMzIz5UwKrWcwfUTuHqDkqSVCuB0Cv46SYstLuUKdHed0VLXKIlPR8Rdp39DwPEfktAMDlV++aCPGC9PsnMzHT7iUXjZqhJYIaGl1qtiNJtH2HlgYRAFhJ9aUKfeWikTxEVvmfW6fjqC3O1EK2QfT73/8ed999N8rLyzF+/HhMmjQJgOgtGjt2rKxjTZ48GQcPHozZ9v3336OsrKzT1zQ2NqKqqgrFxcUAgLPPPhtGoxHr1q2T9qmursbevXtx7rnnAgAmTZoEp9OJrVu3Svts2bIFTqdT2kcrtMohIiJ0Odb4VaqjUSuPKLoCRSlIWMDtD6nm2lXUQ5SZWJ7EqWiRQ2Q26GDUi+ej2h47UhiWjMGh5HWhZmiJoEbITM1QYKIFIVLITIMcIkCbpseCICQVMgPoeavVQnbI7KqrrsJ5552H6upqnHnmmdL2iy66CD/5yU9kHevOO+/Eueeei0cffRRz587F1q1b8Y9//AP/+Mc/AABtbW1YsmQJfvrTn6K4uBhHjx7Fb3/7W+Tl5UnvZbfbcf3112Px4sXIzc1FTk4O7r77bowaNUqqOhs2bBguueQSLFy4EC+88AIA4MYbb8SsWbM0rTADtCupTMYVCoh5RN+eUL6CQI2bZUaUV6LVG1SlqkoKfyiYVJ20h0gDg4jjOGSYDWh2B1RdJBBvmM1igEGfuBpJQZINRLtCjcXBqaih0aVG4QQhUXFG0u5DKw+RFrl1rb6gJJiZiIcIIN+3E7U9pJ9ZQld+UVERbDYb1q1bB49HVCs+55xzcMYZZ8g6zjnnnIN3330X//73vzFy5Ej84Q9/wIoVK/DLX/4SAKDX6/Htt9/iiiuuwJAhQzB//nwMGTIEmzZtkvKYAGD58uW48sorMXfuXEyePBnp6el4//33oddHypnfeOMNjBo1CtOnT8f06dMxevRovPbaa4l8fKpoVVKZtOWvksaEGu50o14n6ZOo5ZVoUSGpOtGeTQS1O90TpGtCxUWCg1IT20hljZI5ROr9Hmrk16np+ZJU9mW2HapuEfcv1igPRgu1ajJHWE16pCUomFko3YtOUw9RY2Mj5s6di88++wwcx+HQoUMYMGAAbrjhBmRlZWHZsmWyjjdr1izMmjWrw+fS0tKwdu3abo9hsVjw9NNP4+mnn+50n5ycHLz++uuyxqYGcqvMODOH4f8dHn6c+EpWKqdM0PIvlLwQ6niIlE64tFkMcPtDquURqZFU3eoLwu0PIt0kX73ZF4woXattEIml9564b/5mgxn/veq/0uNEaHIln1ANRCYAJXKItKkyU7HsXgUPUXG4D2OLN4hWb0DKkeoKnhdQ6xR/T60SgxNRcE+WxiRK7gmFPaz0XvaMeuedd8JoNKKyslISZwTEarA1a9ZQHVxvQG4Okc6gQ8GcAhTMKYDOkHgFTkPSHiJ1kqqlZpYKTwKZKjd4VXISyDAbpL5viXrwmsMGgl7HSd+NWsgVZzToDJgzYg7mjJiTcOuOZjedSqdoDxFttWotkqql60LBkJmahl6G2SC9T7zdAZrcfvhDPDhOvkQJLbQImSU7RwBROXU9RJxRtkH0ySef4PHHH0ffvn1jtg8ePFh22T0jUj2geg5Rkn2bIp2MlTvRAyEeLr+ou6H0zTKSK6HO76CkOi/HcUl7KkiOWXa6UdXSdyCSQKpmx3tieCfrDSMLBV+QRwvla1qTpOo05T0TUr9ClQQnS8JeohNxhs1qwoZTXoYZJoM23a5sGujVkXtAolEEQL2FMy1k/7oulyvGM0RoaGiA2axNwllPRlIhDcWnQsoHedS9VYe6t+rABxNfgTYm2aeKVuJuVzijVqVKy/pHciV6fsgMiP59EjNYyeowUYM5GeSuhoN8EG/tewtv7XsLQT6xCaOZksfOYtRLYSbavf7UTD4mKF12H+IFKX9SLUOvDzGImuMziIgnSav8IUCbvLpG6R6QjFCpen0vaSDbILrgggtilKQ5jgPP83jyySdx4YUXUh1cbyBahTQeL5HgE7B/7n7sn7sfgi/xEvFk48NqqJCSEEGmxaB4/6DIjV8lD5HC4Y/8JNWqtdRdscm8+fuCPsx9ey7mvj0XvmBin5dWUjUQ1dSS4mLBH+ThDntL1WzdoXTZfas3InegnkEkL7G6xinuV6SgAG13SNXIqiZVkzkiCYMofB9qdPkR6AFq1bID7k8++SSmTp2Kb775Bn6/H/feey/27duHpqYmbNy4UYkxntZEq5C6fCHkdteLUwfYp9jDj7XLIVJDhdSpooJtpkW9ME0wxCu+Kpb0PxL2ECUXUk0GLW7+zZSSqgFxEjhU10a14IB4FDkuVrxSaZRWqiafK92kVy0cRUJm8RpEqeQhUjO1osGVuCgjISfdBIOOQ5AX0NDmQ7E9jdbwFEH2GTh8+HDs2bMH48ePx8UXXwyXy4XZs2dj586dGDhwoBJjPO3JkKFCqk/TY+znYzH287HQpyV2AxEEIaJDlODJrtNxkkiZUnlEaiZbSh4iFXKIor1QSoUCpZ5NCXqIGlqT06lKBpuKximBVlI1oExlDVkcZFrUzeki14VLIdFSLRLFIwZRfPctkkNUpOFkbtOk7D55D5EuqquBEtpctJG11CBd5V944QUsXbpUqTH1OjIsBtS1+lSz/t3+ELyBsOBWUhUEZtS0eBUziNQsx40kjyo/CRNDL8NsgDEJEcCuSDapuiEFmlmqefN3JNnpPppkw5UdoWQz4K6I9ka1+YLUvbVKFhd0htyk6pTwEEmLZi1yiJK7B+TbxHlCac06Gsi6GxuNRuzdu7fThqiMxFDb+icneppRL1W5JYLUF6hNmRNdyiFS4WapZtm9Gp6vZJOq6zUNmamfQBrxECX/m0geIoohMzX7fUVj1OskCQclvKdaJIqTpOqaFi9CfPeFKTUtxEOUCiEz9bymUuFNkl7iRNulaIHs5ek111yDl156SYmx9FqsMgyikCuEjfkbsTF/I0Ku7qvSOqLBlbwrFADypQoChQwiD728ju5Qs+w+UmasoEGUZLlrQ6t2VWZq9/cTBEEyiGi0baGlFB6NVgYREJVHpMBkrIXYZL7NDEM4/7E777YgCKh2aqtSDajvNQ2GeOmaSCaHCKDXW1ENZLsH/H4//vnPf2LdunUYN24crFZrzPN//etfqQ2utyB3RRxoSO7GFGnbkeSJrrCHyCmJMqqQVE3K7lXoJq2Oh8gsvZc3EILFKE96X9OkapUTSF3+EAIh0VNAJalaCQ+RBoYDIdNiRG2LTxmDSMVrnKDXcSjJSkNlkxtVTW4phNYRDndASi8o1LDKzKbyNdHsFqv/OC75ayJfBYkWWsg2iPbu3YuzzjoLgNiZPhoWSksMMgGoJboliTImuRomITOlPES0tGHiIVNFD5EaBpE9zQiTQQd/kEd9qw+lOe21wzojGOLRFJ6oNCm7N8sr9TbpTVh5xUrpsVxIE1uTIRIeSobCqBwiQRCo3BdpCUcmgpLeU+laUDk3qiw3HZVNbhxtdGHCgNxO9zse1irKyzDLXlTQhEQRXP4QQryguAxJRJjVlFSzY0DZhse0kW0QffbZZ0qMo1ejeg4R5diwYjlEKvUxA6L1VlTwEKlg6HEchwKbGcebPaiTaRA1uf0QBFHVQYsJWK4wo1FvxIIxCxJ+PxKOykk3UTFeiIfIEwih1Rek0vqENNqlkfQtFyVFS7UKBfbPs+LLQw042ujucr/KJvH5fjnalotH69W5/HTOqa5oaqNngOefzjlEDPqorULaQKFpHxCVVK1U2b1KfcyAWGFG2j2oTkWtvInIykze70NWcjlhrSm1ic4h4uNIek0WmgnVAJBm0kufgZb3VMpxUtmTAigrWqpFDhEAlOWKqR7HGl1d7lfVTAyi+BcUSmA26GDUi9eiGmEz4iHOoWCAFyg8T9AkoRKjbdu24a233kJlZSX8fn/Mc//73/+oDKw3obYQnSTKmHTfprDWTRu90EA0JGSWbVWv7D7EC/AEQgl1iI8Xh0phgoIE9XC0bNsBtF8Nd9eRPMgHsfaHtQCAGYNmyG7w2kxRpZpQYDOj1RtEXYsXgwq6U1vtHkk4UgOPXSScrICHSCM5gfJc0cCpaIjPQyTHw6oEHMchw2xAszugyjxBwsg07r1KzxM0ke0hevPNNzF58mTs378f7777LgKBAPbv349PP/0UdrtdiTGe9mSYxdi0WglzyTZ2JRDRvkBIkFzfNFGz6WOaUS95Q5TOI1LNQ5RgdUeDhm07gFNWw3Hc/H1BH2b9exZm/XtWQq07HAoY3rTbdyhhtMVLJGRG/7rQomEtAJTnRTxEXXmEq1LEIALU7XjfTFOXKzzPBEKCdNxURbZB9Oijj2L58uX44IMPYDKZ8Le//Q0HDhzA3Llz0a9fPyXGeNqj5okORKrMko0Pmw16aWVHO48oxAuSi16N1SPHcaq171DLIJImZdkeIu0qzIDIahhQJ4xMU6WaILVOoRQmaE6FpGoFc4jUrDIDgL7ZadBxokhtV/cuySDKTgGDiEQSVLwmaHgkTQadFOpN9cRq2QbR4cOHcdlllwEAzGYzXC4XOI7DnXfeiX/84x/UB9gbUDtk1kTx5kqsf9qVZtHuebVWj0p39iY4VZoEEk1mrNPYQwSom1cXUalOTQ+RIAhSyEzt0BKgbMGBVjlEZoNeKrc/2knYLBjiJTXrUo2TqgF1i2+kkBml8y1yL0rtPCLZBlFOTg5aW1sBAH369MHevXsBAA6HA2531/FYRseoKbolCALVEl5JhK6N7olOVig2BdtbnEpEgO40CZklaBARZV5NdVdUXCQoUcGVT9FD5PaH4A/3ETudyu69gRA8AVFcVu2ye0CsNAOAo50kVlc2uREICbAYdShJgaakaupz0QyZAVHK+SnevkP2THP++edj3bp1AIC5c+fijjvuwMKFC/GLX/wCF110EfUB9gbUFN1q8wWjROhS10OkVuJxNGQSVqqzN8HhUV6pGoi+CcmblGtJM0sNDSJ1b/70Q2Y0PURNlHWS5EJyiGh7Tsl1puMi3g81KQsnVh+p79ggOhzePiAvQ9WGup2hZj8z2jlrPaV9h+yz8JlnnoHXK94wH3jgARiNRnz11VeYPXs2HnroIeoD7A2o6SEi4QGLUYc0U/I3V6mCgPKJroZWz6lEGrwq9zv4gpHGukobe0QgsNHlhz/Iw2SIb/1TLXX31i5kZjOrk88FKBMykyYACh4i2jpJcomEzOheF9GNXbUwOIYU2gAA39e2dvj8D3VtAEClSpAGWiwSaFU15veQ9h2yDaKcnBzpsU6nw7333ot7772X6qB6Gxmn6K4oeXOgHR6QPESUDaJmDST91cghIpMAp8KqOMdqgtmggy/Io8bpRb/c7hNDeV6QblpahszUrahRIKk6ykOUbKlxE2WdJLlkKpRULZXca9COBACGhg2igzU9wyCK5BApv0iQZB4onXMFPaR9h+w7cmVlZZfPs0oz+cjRXeFMHAY/M1h6LJcm2q7QTGVk2R1aeIgUWglH44xS5lV6VcxxHPpkpeFIgwvHHe64DKImtx+BkACOi9zEtMAmI6napDfhmZnPSI/lInlgKObnEA+R2x9Cm697LaWu0LJtBxBbdk9TR0ZSqdZASgAAzijKBACccHjQ4g20U38+XC8aRAPzU8MgUiuS4A/y0nvQOufye0j7DtkGUXl5eZcXRCiUWAf23ozZoINBxyHIC3D5Ql3ePHVGHfrc0kf8x9W1ympH0L65RjxEdF2hWgi22RQUoCOoXVXTJ1s0iE6EezJ1R004XJZrNccdYlMCOZWXRr0Rt4y/JaH3ib750wyZWc0GZJgNaPMFUdfqS8og0rJtBxC5LkK8ALc/JPXVShanxh4ie7oRxXYLqp1eHKxpxTnlkehHiBdwKBxKG1yYIgaRSpWXZI7QcaDWIqSn9DOTfWbv3Lkz5v9AIICdO3fir3/9K/70pz9RG1hvguM4ZFgMcLgDYXeocivzJsrlu0p5iLTogq2kAB1BbYOIVMeQ8uHuIFVRWuYPAeoVGpAEd5o3f0JBphlt9UHUtniT8jKoqdjeEWlGvbRga/EGqBlEEeFVbT4XAJxRZEO104sD1S0xBlFFQxtc/hDSjPpe5yGKNNU2UfNi08ypUxLZZ/aZZ57Zbtu4ceNQUlKCJ598ErNnz6YysN5Ghlk0iLqbjIWQAMeXDgBA1llGyD1d6XuIROOtxRuENxCi1hFazU73BCUF6AhqN7Pskx02iOL0EFWnQIUZEF1R0/1vEeJD+LLySwDA+f3Oh14X/znoUDCEWWAz40i9K+nFQrPGHiKO45CZZkSTy49WbxDFlBoSODVq2xHN6L5Z+OxgPXYca8Y1k8ql7burnACAkX0yNenn1xFqLRKIR5Lm70Jy6lz+EFy+IDWjmjbUfOJDhgzBtm3baB2u1xGv9c97eey+cDd2X7gbvJeX/T603e+ZaQYptELTS6Rmp3uCKjlEaofMshLzEGmZUA1AllK1N+jFha9ciAtfuRDeoLwVqJLGRqJK4aeiZdsOghLh5IhKtXYG0bjybADA9srmmO3fnhANolF9stQeUqdYVfIQOSg2diVkmA1ID1c1p3JitWyDqKWlJebP6XTiu+++w0MPPYTBgwcrMcZeQdzWPwekD09H+vB0yHYPgX6JMcdxilSaqdnpnqBkE0uCQ4McIgA4GadBRHKIiu3aGkQ2larMaHe6j4ZW+45ICbR2hoMSi4WI1ph2ht6Y0izoOKCqyRMTztlZ5QAAjOqbqdHI2qNWO5smBaougZ6RWC3bb5WVldUuqVoQBJSWluLNN9+kNrDehjVO0S19uh7j940X/0kgqVryENGsqMk044TDo5CHSE0dIuXL7ltU/lzEQ3TS4Y1L0iEVVKoB9TRXaCvyRkNLnDFSAp0CHiKK14bWSdWAKLUxtCgTB6pbsLmiCZefWYImlx97jjsAABMH5Go2tlMhv4HLr7SHiFRdUs6ps5lxrNGd0lpEsg2izz77LOZ/nU6H/Px8DBo0CAZDasYFewLE+neptCKm2qYgg1j+9E70Zpcyq5SuOB1DZkV2C3Qc4A/xaGjzSbH8zogkVWvsIVKpdYcSGkQEWu07UiFkRq4Nmt5TZwokVQPAlCH5OFDdgrV7a3D5mSX48lA9BEFMuC5OgZYdhOjmrjTlD05FqarGntC+Q7YFM2XKFCXG0etRK2FOia7ZtCvN1O50TyC/gdsfQiDEK9JDzaFy9ZxRr0NRpgUnnV4cd3i6NIgEQZCSr7WeCNQrMaavUk0gE0DSSdUa6xAByvT508IL3BGXjirC818cxqff1cHjD2H9gToAwNShBZqO61TINRHkBfiCPLUCllNRapGQaLNpNZFtEK1evTrufS+//HK5h++1xJtUHXKHsP2c7QCAsz8/A3Iuieiu2TRDZqTSjNaJrkWneyBiEAGiYUrzOyJEtytQiz7ZaaJB1OzBWf2yO93P4Q7A5Rd1xPpma2sQ2VRSb29WIIRMIK1TkvEQefyRVi9aGg5KqLhrIb7aEaP62FGak4aqJg/+tuEQ1u6tASAaSqlEulEPjgMEQVwoKGYQuYgBTl+GAkjt9h2yDaIrr7wSHMdBEISY7adu4ziOiTTKgLhDu23cJwDu/W7psRyiu2ZT7dtE2UNEVigZKna6BwCDXod0kx5ufwgt3oAik6TaSdUAUJqTjm1Hm1HZSVdvwvGwdyjfZlbsZhsvctTbk0HJHKLoUuM2XzDmM8ULSXA16rmEXk8L2uHkUFjTCADsKmqNdQTHcbjhvAF4ePU+PP/FYQDAhP45GN03S9NxnYpOxyHDZECrL4g2X1DyuNAmWoeIJpHUitT1EMmebT755BOMGTMGH3/8MRwOB5xOJz7++GOcddZZWLt2LXieB8/zzBiSiRpJpCQ2bKbcNZt2lZmWrnSl84jUTqoGgAF5VgDAkYauDaKqZtHQLtXYOwSI56hRL3qFuvOaGvVGPDHtCTwx7QkY9fK+V4eUn0P/98gwG2AlpcYJeomic+m0aOxKoF123+oNgKyftc4hAoBfTuiHGSMKAQAldgsemz1K4xF1jBrzhFIhWqUagdNE9pJj0aJFeP7553HeeedJ22bMmIH09HTceOONOHDgANUB9hZsKmhMRCdn0ry50vYQadHpnmCzGFDTokzpvSAIqidVA0B52CA62o1BdDxsEPXN7r7nmdJwnOgRaQ6LlXYlBmjSm3DP5HsSeh8lk6oBcRKoaHChrtWHAQkoHpNFDE1NmESIVGDSuT+R68Bq0mvaIoZg0Ovw/K/OxkmnF3kZJpgN2npIO0OOYGmiRLS56FeZAamdQyT7TDx8+DDs9vZ3J7vdjqNHj9IYU69EDdGtSAsAZZLlGtp84HmZcbwOIO0U1GzbQaB9449GTNYWvx81jb3+xCBqdHe5X1WTGDIrzdHeQwSok1jtULgtRrJaRA1t4uSRZ9PYIJJ+CzoTsdqK7fFAmiGnqjEEKO8hCoZ46d5Hv8pMvBaaXH74g/JFhdVAtkF0zjnnYNGiRaiurpa21dTUYPHixRg/fjzVwfUmVHGFKpQslxcOmQV5QVpxJwNJ/LZr5CEClNEiIqtio56jGrLsjvJc0SBqcvkl71tHpJKHCIi/9D7Eh7DtxDZsO7ENIT7+UD0fdb4qVdKebJigsU0cH7nGtMJGuew+FUQZeyJK9zNzKFjQkp1ugiFcHEEM/VRDtkH08ssvo66uDmVlZRg0aBAGDRqEfv36obq6Gi+99JISY+wVqNG4T6nwgFGvk+LNNNyh5KJUIq+jO5TMIYoOl6mZD2I1G6SKp4ouEquPhT1I/XJSwyCKd5HgDXox/p/jMf6f42W17mj1BkEcmkp57AqT9RC5xOsp16qtQUTK7mldFw4NlOhPB5RWcCeLZnuaEQbKBS06HScZ9qmaRyQ7h2jQoEHYs2cP1q1bh++++w6CIGD48OGYNm2apkl/PR01WhU0K5iPUGAzo8nlR32rD8OKkzuWFp3uCUr0bCJoGSYoz7WitsWHioY2jCnNave8P8jjWJNoEA3It6o8uo6J5NUpky9BFgjpJr1iYZJIqXFiE0BDa9hDpHnIjG7ZfSo0du2JKN2+o1lBXS5AvB5qWrwpm0eUUB0nx3GYPn06pk+fDgBwOBzMGEoSyUOkaPWAMjlEgJhH9F1NK5UTXYtO9wSSQ6S0h0htBuRbsaWiCRUNHecRVTa5EeIFpJv0mne6JyidQ6SGAjRp35Goh6gx7CHK09pDFDaIvAEe/iCfdCK0loUTPZkMhRXcI33zFAoh21Jbi0j2Wf3444/jP//5j/T/3LlzkZubiz59+mD37t1UB9ebIDd/f4iHL6iMZEGTgiXGNBv3admqQNkcIu1aFZA8oopOKs2O1LcBEA2nVFnc2BQ2iNQQBkxWnZfkEOVmaOshyogSLaWRWO3QQKD0dEDpXNNmhdp2EPJTvH2HbIPohRdeQGlpKQBg3bp1WLduHT7++GPMnDkT99yTWOkrA7CaooTofMoYRJGkauX6NtGw/MkkkKPBJBDJIVIuqVrN/myEgeGS70O1rR0+TzSKBuTJLw1XCrVWw0q2xEi2f5NUZaZxUrVeFxGGpFGBKRmjGosy9jQyzGJoV6mel0oKlQKpX3ovO2RWXV0tGUQffPAB5s6di+nTp6O8vBwTJkygPsDegl7HSSrJbd6gIjdppRRIgagbP0UPkRbaK5EcotMrZDasJBMA8ENdG3zBULucmWgPUaqgdH8/Ja8HAklmb/MF4fIFJXmNeBAEIWU8RIBYet/mC1JZLBBvKQuZySPujgYJ0qxgFAGIjiScJiGz7OxsVFVVAQDWrFmDadOmARAvXqZOnRxKi24pmVRNK2QmCAIaFfRkdYeUQ6TAb6BlUnWJ3YJMiwFBXsAPdW3tnj9YI3qOBhfY1B5apyh9PSipUk3IMBskiQW5i4VWX1BqtaO1hwiILr2n6SFiBpEcVAuZKZxDdNpUmc2ePRtXX301Bg8ejMbGRsycORMAsGvXLgwaNIj6AHsTGRYD6lp9XZ7snJFD2cNl0uN4EYQozRUFROhoneguf0gS7dJiVZx5mnqIOI7D8JJMbD7ShP0nWzCiJCKuGgjxOBA2iEb2yVR9bJ0Rbw6RUW/Ew1Melh7Hi9Iq1YD4vRdmmnG00Y26Fq8kkhkPDeFrKcNs0Ly3HBDd8Z6Gh0g7rbGejNIdDdTS5TptQmbLly9HeXk5qqqq8MQTTyAjQ8w5qK6uxs0330x9gL2JeE52nUmH/kv6i/+4um7FEI0nEIIvSBq7pq6HqCkcIrAYdUg3JVQEmRRq5BBppc47rDhsEFW3xGz/oa4N/iAPm8WQMhpEQPzaXCa9CUumLpF9fCIAqrTeVYHNgqONbtTKvDaIpzQVwmUA3WtDiybHpwMZSusQhT13tMV7CdELZ54XoNOlRgEHQfaMYzQacffdd7fbvmjRIhrj6dUoebKTnkgmg9jRnTbkRG/zBeH2BxM2ZkglnFZCdFJYwBuEIAhUK6601l4Z1Uf0Cu2sdMRs33dSNJCGF2emTIUZoEJ4QKVqRkmLSGbpfWMbEWVMDYOIVn6dIAhRZfep8dl6CorrELmU9Zqe2tUgNwVCwdFo31WPIUEqzboyiARegGufC659Lggy+oY5ogS3lJj0RLe+eDol4yVqCuuuKNVbqjtIWCDEC3D76ebEae0hGt8/BwCw94Qzpkplz3EHAMSE0VKBeFt38AKPfXX7sK9uH3gh/h5JauldkYIDuddFfYq07SBENLqS8xB5AiEpN4rlEMkjQyWxUqXyN00GneSRTcWwGTOIUoh4VsS8h8e2kduwbeQ28J74b/5NCutLcBxHpdJMKrnXyEOUZtRDH3bj0l6Fad3Qsm92OkrsFgR5IcZLtPGHBgDA+P7ZmoyrM+IVZvQEPBj53EiMfG4kPAFP3Md3qOQhIpVmcsUZJQ9RqhhEUd7TZCDXgVHPKeKtPp0hXjpvgEcgRLdBaogXpFCmkouERBcIasAMohQi3oQ5Y54Rxjx5J6wamis08oiI4aZVmIDjuEhiNcU8Ip4XpONpmUhKvERfHxaNoGqnB4frXdBxwKSBeZqNqyOi29nwMryh8aJ6yEzmdRHRIEqNsBLxnjqTbGsTWRiYUipE2xOIlm2grUXU4glAIL39FNSHSradjZIwgyiFiGdFrLfqMbl+MibXT4beGv/qSmkFUiBKdCvBNgVAJIdIi5J7Aq3QQDSt3qB0s9EykfTCMwoAAB/sqYYgCPjye9EwGt03K+USXDOib/5+ujd/byAEbyActlE4PFtoS6x9R21YzLEwRVqpkEmSeNYSJRI6Vr9ooqdj1Ouk1ATaHmyyQMgwG5JuzdIVNEV8aSP7Uw8YMACNjY3ttjscDgwYMIDKoHorSirzNkl9zJRvU1DfloSHqE17g0gJcUaHR/lGovFw8fBCpBn1qGxyY2eVA+/uPAEAuHBogWZj6gyzQQejXvQg0L4myM3foOMkz6xSJLoiJguLlDGIwp5NR5IeoogoY2p4vnoaSs0TaufUpWL7DtkG0dGjRzsUYPT5fDhx4gSVQfVWlKyqUSNfIuIhSj5kpqmHiHJnb0D7hGpCusmAS0YWAQCuX7UNm440Qq/j8NOz+2g6ro7gOE6xpsek5D4rXfmwDenf1OoNwiMjUb9GMohSI4eIGDAk5JUoWufS9XRsClUjq5VTR7PvJW3iXhqtXr1aerx27VrY7ZGKlFAohA0bNqC8vJzq4HobZKXaVXgg5Alhz8w9AIDRbw9CvL4GNdoUUPEQpUDILNLglaKHKIUmgVt/NAgfflstnRNXj++Hvtmpoz8Ujc1iRLM7QPW3ANRRqSZkWsQKTG+AR12rF2W53YszhnhBmjCKUs1DlGTITOl+Wac7ii0SVPMQnQYG0ZVXXglAXLXNnz8/5jmj0Yjy8nIsW7aM6uB6G9Z4NCZ4wPmFM/w4/kTTSGNX5asHaHiItNReUUKcUY3qjXgZmJ+BVQvOwT+/qsDAfCvunjFU6yF1SrzijHJpUmk1DEQqMCub3Kht8cVlEDW0+cALgI5LnSozcu46PYGkRPUiBR7aXws9EaWuCbU8RAUpnEMUt0HE82ICYv/+/bFt2zbk5aVWRcrpgFInOqBOmwKaOURK9dKJB5o9mwhO8v2nSHfvcwfl4dxBqX8NxxNGNuqNuHvS3dLjeFBrNUwozDSjsskd9yRAErDzbWZJBkJryLnLC+KiLdFqySaF+2Wd7lgVmieUbuxKSOX2HbKzCSsqKtptczgcyMrKojGeXo2S3b0dKripieXf2OZDiBdk38h9wZDUxVlTD1Ea8dSdfjlEPQ1bHEJ0Jr0JT05/UtZxHSpUXUZDJoEaZ7wGUWqFywBRVM9q0sPlD6HZ7U/YIFKj4vV0Rql5Qo20CiAyT7j9IbT5gjHVpFojO6n68ccfx3/+8x/p/zlz5iAnJwd9+vTB7t27qQ6utxGRZaevQqqG9Z9jNYHjxBVko0u+9U+MNr2Ok8JWWmCjJEAXjUNlj8TpQrzijHKRbv4qhW36ZqcBAI43xyccSRKqC1LIIAKiEquTqDRTS//pdEWaJxQLmSl7TVjNBkmQMxmJFiWQbRC98MILKC0tBQCsW7cO69evx5o1azBz5kzcc8891AfYmyA3f5c/hBBFITpvICS1oVDSTW3Q66QeZInkERGV6ux0k6ZN/zIt9A1TB+vunRDxdLznBR5HHUdx1HE07tYdauVLEEjSerwGUV2KVZgRaCRWRxqIMoMoEZSqRpaaHavwu6RqYrVsX1V1dbVkEH3wwQeYO3cupk+fjvLyckyYMIH6AHsT5OYPiPFhWuEV4p1QQ3Ml32ZGQ5svoTyiJhUSv+MhkkNEP2SWKjlEPYV4NFc8AQ/6/62/uN8DbbCauk9aVitfghDxELnj2p/kEKVSyAyINogSvzZS5TrvqSjVz0yNPFNCgc2Co43ulMsjku0hys7ORlVVFQBgzZo1mDZtGgCxg3FH+kSM+DEb9DCHFUJpTsaRE12Zxq7RSJZ/Ih6icJhN65VjJIeIZlI1yyFKhJ6eL0EoDRtEJ5o9EITuvb814esnZUNmCXqIgiE+sjhgIbOEUEqHSKr+U+F3yU/R9h2y3QWzZ8/G1VdfjcGDB6OxsREzZ84EAOzatQuDBg2iPsDeRmaaEfWtPqqTsZqWfzKVZs1Syb22YQIlhBkdnohRyogfpUuM1TK++2SJIbNWXxBOT6Dba7EuVT1EYYO+OUEPUXTuEet0nxgZ8cizyEQQBFUrL1O19F62QbR8+XKUl5ejqqoKTzzxBDIyMgCIobSbb76Z+gB7GzaLAfWtPqqTsRQbVvNETyBZriEF2nYA0TpEp6cwY0/CpkCjXSBaHFCd3yPNpEdehhhOPt7s6dYgqkmxth0EknOVaINXYoja04ww6FkrzURQYpHgCYTgD4r5d2rkEOUnEUlQEtlnpNFoxN13342//e1vGDt2rLR90aJFuOGGG2QP4MSJE/jVr36F3NxcpKenY8yYMdi+fbv0vCAIWLJkCUpKSpCWloapU6di3759Mcfw+Xy47bbbkJeXB6vVissvvxzHjx+P2ae5uRnz5s2D3W6H3W7HvHnz4HA4ZI9XaZSYjNWs6kjGQ0QS7IhRpRVkEnb7QwiE4kvS7Q5nCgkz9iSUuPkHQ7xkYKkZtok3j6jNF5QM6JKs1DKIyPnbnGDIrMnFEqqTRYmkarJAMOo5WE3K91qURHx7esiMsH//flRWVsLvj70wLr/88riP0dzcjMmTJ+PCCy/Exx9/jIKCAhw+fDhG0+iJJ57AX//6V6xatQpDhgzBH//4R1x88cU4ePAgbDYbANEYe//99/Hmm28iNzcXixcvxqxZs7B9+3bo9eKPe/XVV+P48eNYs2YNAODGG2/EvHnz8P777yf6FShCpLEoxXCNigZRMmrVxIgq0LiyJia53RtMesXkDYTgC6++mIdIHkrc/J2eAEgaj5phm77ZadhV5ei20uxE+Hl7mlFK8E8VyPmbaFK1JMrIFgYJY1OguStJV1Cjtx9wGlWZHTlyBD/5yU/w7bffguM4KUGQfIlyEqsff/xxlJaWYuXKldK26H5ogiBgxYoV+N3vfofZs2cDAF555RUUFhbiX//6F37961/D6XTipZdewmuvvSYleL/++usoLS3F+vXrMWPGDBw4cABr1qzB5s2bpUq4F198EZMmTcLBgwcxdGjqtC7ITKPfNkJNzRUaHqJ8jT1EBr0O6SY93P4QWryBpA2iaH2lVBIh6wkocvMP/x42i0HVsE28pffEg0Q8SqlEdpJJ1UyDKHmUWCQ4VA4hF2SmZg6R7LvBHXfcgf79+6O2thbp6enYt28f/u///g/jxo3D559/LutYq1evxrhx4zBnzhwUFBRg7NixePHFF6XnKyoqUFNTg+nTp0vbzGYzpkyZgq+//hoAsH37dgQCgZh9SkpKMHLkSGmfTZs2wW63x8gCTJw4EXa7XdrnVHw+H1paWmL+1CCzG90VzsCh5OYSlNxcAs4QnyWvpjJsdMf7eKppoiEXR36G9mECmqFLKaE6Tfkqv9ONeIQZDToDbh53M24edzMMuu4NTrU1iAjxhsyIwZSKBpFUdp+gB5u17UgeKYzsD4KnpFenZuENEIkkNLsDUu5SKiDbINq0aRMeeeQR5OfnQ6fTQafT4bzzzsNjjz2G22+/Xdaxjhw5gueeew6DBw/G2rVrcdNNN+H222/Hq6++CgCoqakBABQWFsa8rrCwUHqupqYGJpMJ2dnZXe5TUFDQ7v0LCgqkfU7lsccek/KN7Ha7pL2kNN1VOOnMOgz5+xAM+fsQ6Mzx/XyqllOGDSJPIASXP35vIc8LUlK11h4igG7okpXcJ050iXFnN3+zwYy/X/Z3/P2yv8Ns6P7cUTuhmtAvR/QQVTS4utzvhEM0iEhlWioRKbtPLqma5RAlDrkmBAFw+el4idRSqSZkpRlhCIvvJtP7kjayDaJQKCRVluXl5eHkyZMAgLKyMhw8eFDWsXiex1lnnYVHH30UY8eOxa9//WssXLgQzz33XMx+p66qBUHodqV96j4d7d/VcR544AE4nU7pj2gvKU08yrxyUbOc0mo2SEl5cirNmt1+hHgBHAfkZmh/syShSxrVTUylOnGiQ4y0bv5qr4YJAwvE+2ZlkxvBLpL1UzlkRu4hLd5AQmr6TVLFq/bXeE/FYtTDRPTqKM0TzSr0uoxGp+OkaEJtCrXvkG0QjRw5Env27AEATJgwAU888QQ2btyIRx55BAMGDJB1rOLiYgwfPjxm27Bhw1BZWQkAKCoqAoB2Xpy6ujrJa1RUVAS/34/m5uYu96mtrW33/vX19e28TwSz2YzMzMyYPzWwdeMhEgQB/no//PX+uENSkvWv0qosP4GEObJKyEk3wZgC5biRcu/kbzjEQ8R0V+RjNuhg1IuLls7yiARBQL2rHvWu+riuCbVXw4TiTAvSjHoEQgKqusgjSumQWfgcFoTEvKeSt5qpVCcFiSQ4k1AMj0aLRUJJlnh+n3TE185GDWTPPA8++CB4Xlzd/PGPf8SxY8dw/vnn46OPPsJTTz0l61iTJ09u51X6/vvvUVZWBgDo378/ioqKsG7dOul5v9+PL774Aueeey4A4Oyzz4bRaIzZp7q6Gnv37pX2mTRpEpxOJ7Zu3Srts2XLFjidTmmfVKE7lWTezePrgq/xdcHX4N3xxV7VruxIpKSSVKWlQrgMiApdUgiZRUQZ2apYLhwXSUTvLInUHXCj4C8FKPhLAdyB7ltjqK1STdDpOPTPE9uKHK5r63AfQRCkkFq/3NQLmRn0Oqn9TyKl900udi3QgMwTtPS51E6qBoA+UertqYLskpcZM2ZIjwcMGID9+/ejqakJ2dnZshNG77zzTpx77rl49NFHMXfuXGzduhX/+Mc/8I9//AOAeDNctGgRHn30UQwePBiDBw/Go48+ivT0dFx99dUAALvdjuuvvx6LFy9Gbm4ucnJycPfdd2PUqFFS1dmwYcNwySWXYOHChXjhhRcAiGX3s2bNSqkKMyBSVUOr7F7UXBEnErVuQgl5iFKkwoxAs30H0SBiOUSJYbMY0ewOULz5a5fHMrAgA/urW3C4vg3T0N473ejyo9UbBMcB5bnd92TTgiyrEa2+YEKJ1c0sh4gK5F5Ca57QovqvTxYpMujBBhHhhx9+wOHDh3HBBRcgJydHdkURAJxzzjl499138cADD+CRRx5B//79sWLFCvzyl7+U9rn33nvh8Xhw8803o7m5GRMmTMAnn3wiaRABonq2wWDA3Llz4fF4cNFFF2HVqlWSBhEAvPHGG7j99tularTLL78czzzzTKIfXzEiZfcdT8R6qx5ThaniP66ukzOBWEVZtUI2+ZIsu/yQWaoYRN2FLuXAVKqTI7IappQvoaJy+6kMzBeNnCP1HV+7xDvUJysNFqPyAnmJkJVmQhU8CZXeN6lY8Xo6Eym+oZtDpKZwLJGhOJFCITPZBlFjYyPmzp2Lzz77DBzH4dChQxgwYABuuOEGZGVlYdmyZbKON2vWLMyaNavT5zmOw5IlS7BkyZJO97FYLHj66afx9NNPd7pPTk4OXn/9dVlj0wLarQrIiZ6pouaKpDEhI1ku5TxEVMvumUp1MtAMXwJAk0ZJ1QAwIF9MrD5c33HI7Eh4OwmtpSKJdrwPhHjpemIeouTIpOwhUjvPFEjNkJnsGfLOO++E0WhEZWUl0tMjMe6f/exnkgo0I3Ei1U10K2rUPNFL7OFkOWf8JzrxJuVnpIZBRLPsvoUZRElBPGuJ9s86Fa10iICIh6hTgyjsIRoYNpxSEWJIEm9PvBADiuOYtzRZMmkvnDVQECchsxMOT0IRJiWQ7SH65JNPsHbtWvTt2zdm++DBg3Hs2DFqA+utkInYH+ThDYTauc1D3hC+m/cdAOCM5/uhO6d6swZJjJLlL8MVWk9EGVPFQ9RN6FIOLGSWHLQ9RFqEBwgD8jKkMTS2+ZB7ygKAhNJS2UOUa03MIGqOauyq1zGB0mTIpLhI0CLPFIhUUbb5gnB6AimRaC/bQ+RyuWI8Q4SGhgaYzakxmfVkMkwGkNz0DifjEFD/dj3q364HQvGUGIebKap48yfllDVOb9xaJaTKjFSoaQ3N0CWpMrOnaX/B90SIfhONm78gCJqEBwhpJj3Kw9Vj+6vbq99/VyNuG1yYuh6ivLBOWGObPIOI7K+GQOzpTiSpml5IH1BXGsRi1EvnUqokVss2iC644AJJSRoQc3x4nseTTz6JCy+8kOrgeiO6qH5XNCZjLaoHCm1m6HUcAiEhrkozQRCk8FqqdPemGaZxaOiROB3o7uZv0Bkw/8z5mH/m/G5bd7j8IQTCCwmtGoyO7GMHAOw57ozZ7nQHUNUkXgcjiu2qjytecqziwrdRpoeoIVw4kZciYfGeTHcdDeRAFghq5pkSosNmqYDskNmTTz6JqVOn4ptvvoHf78e9996Lffv2oampCRs3blRijL2OTIsRrd4glXCNFgmkBr0ORZkWnHB4cMLhQZG9ayOn2R2ANyBqKnW3r1pkJ9migBDiBel3ZCGzxCD5Ep0Zp2aDGauuXBXXsUgI2WTQIU2jKq5Rfez4YE819p6INYj2VYv/981OS2lVc6Ik3+iS13JBMohszEOULFLlJYUFm6RSrYHHtG92OnYfd6ZMYrVsc3D48OHYs2cPxo8fj4svvhgulwuzZ8/Gzp07MXDgQCXG2OugmdDr0KjEWI7lT5RK8zLMMBtSo9SYuI7bfEEEumiz0B3RvyEziBKDahuVKAE6rRrtjurbsYdo/0kxXDaiRB1V/ERJNGTGPET0oFl2r0WeKYHkm1Z10/BYLRLSISoqKsLSpUtjtlVVVeG6667Dyy+/TGVgvRmaCb1aVJkB4RP9aHwllcQgSpVwGSD+BhwntihwegIJ38RJfD7DbEiJliQ9ke4SSAVBkBSq043pXRo6WoSQT2VkHzs4Tlws1Di9kld0d9hAGlGSuuEyIBIyk5tU3dAq7s8MouShWXavhUo1gYiPHu2m4bFaULtDNzU14ZVXXqF1uF4NzZJKh8pN+wh9ZPSpqXaKFWakXD8V0Os4aRWWTNjMEVVZw0gMezceInfAjYzHMpDxWEa3rTtSwSDKtBgxOpxH9OWhegAAzwv4+ocGAMCE/jmajS0eSMiszReENxCK+3XMQ0SPTIpRBC2vCVJNeeR0M4gY9IiIAiZ/sjdp1MiyRE7ILJxQXZxCHiIgWoBOviIvIeKhYwZRotBsZCnprWj8e5w/OB8A8FXYCDpQ04JGlx/pJj3G9svWcmjdYjMbpIa7chKrIwYRyyFKFrJIaPUF467k7QwtZSiILldVkxv+YOKpCbRgBlEKEskhoqGBo018mMSG4/EQnXSIHiLiVUoVSB5RMh6iSJsINgkkSvTNn6d289f29zh/cB4A4P++r0cgxOP/vhcNo4kDcmEypPZtmeM45JKwmYw8oobwvnkpojXWkyGthYDOmx7Hi5ZCpfk2M6wmPXgBqGzS3kuU2ldeLyWSQ5TciljUXCEVBBolVTd3r0JaHTaailMoZAZEJs1EmlgSWDPL5CEVNYIgGkXJIP0eGhtEZ5dlI99mRrM7gLX7avDOjuMAgIuGFWg6rnghYbOGOCvNBEGQPESpokbfk4mukkw2taJZoygCIBrXkXY22htEcSdVz549u8vnHQ5HsmNhhImIAiZ382/1BRHkieaKuhNA3+w0cJw4hmZ3oEuDgHiRTseQGWtmmTxmgx4Wow7eAI8WTyCpfCwtS4yjMeh1+MU5pXjq0x9w6792AhAT7398Zomm44oXcj3HW2nW5gvCFw6J5LKQGRUy0wzwBEJwegIoTeI4WntN++dZ8e0Jp9TYWEviNojs9q4rH+x2O6655pqkB8Sgl0NE8iXSjHrVO2dbjHqU2NNwwuFBRUMbcqwdJ4oGQzxqw+KNp2XILAWSeE8HMi1GeAO+5G/+LuKx0z6n64YLBuDdXSckMca7pw+Rrv1UhyRGN8XpISLhsnSTHummhIqbGaeQaTGitsWXdGK1liEzABgQziM60kl/PzWJ+8xcuXKlkuNgRGGTejclGx7QrpwSAMrz0sMGkRtnl3VsENW1+hDiBRh0XMpVn0RCZkkkVYdziFJhAu7J2NOMqGtN/uafSh67TIsR79x0Lt7ZcQL986y4ZGSR1kOKm1yZHiJWYUYfWvpcWiZVA5FKsx7lIWKoR5dtI/RA/lX54cddC8s1a5RQTeifZ8XGHxpR0dC55V/VJJZJF2dZUq7hI7lBNCfhIWrSsG/W6URXN3+9To+rhl8lPe6KVMvpKsi04DdTe56gbQ7JIYrXIGplFWa0odHPTOvefgAwMJxD9ENdGwRB0EwwFWAGUUrSlUGkt+gx4q0R4j+uri1qh8Y3/4joVufaMMca3TH7phLEIEqm3FsK0aSAR6In09U1YTFY8Nact7o9hiAIKeUh6snkWeWGzJiHiDY09OpSobffoIIM6HUcmt0B1LR4NS2uYVVmKYiUzJtEqAYAmlyp4QrtSnSrotEVs28qQSVkprGX7nQhk4IUhScQkhJ7mccuOUhidH1bfAZRPSu5pw4NtepU6O1nMeoxuED0Eu090aLJGAjMIEpByInuDfCylGBPRetkOWLkHGt0dVp6fyxsEJWlooco/DuQPCC5CIIghdtSJUTTU+kyjBwn5Lcw6XWwmlKjZ15PpTBTrAitbYnTIGplHiLaSIKlSVwTRFgz12rSNFQ1PNy/b99JZzd7KgsziFIQm9kAkk5zqvUfcoXwOfc5Puc+R8jVtbGkpb4EAJTmpEOv4+D2h1DX2vGNsyIcTuufl67m0OKCeHUSveG0eCMqslp56U4Xusohcvld4JZy4JZycPk790ZGq1RrefM/HSjIFA2bhjYfgnE0P65tEcVXi+2pJa3Rk5E63ichz0JCnlov2EaG+/cxDxGjHTod121Dy3jQWl/CqNehb1ix+kgHoluCIEgeolTMISKGZKId78kEbDWpL3twukHDQ8Tyh+iRZzVDr+MgCPElVteE+xUWZTKDiBZ2CiEzUiWotUE0qq9oEO2qcnQr5KskzCBKUSQNnFNOdl36/2/v3oOjqu/+gb/3ms0uyZJ7AglLuAXEiBiUi31KKxS1WOextVoZGf2NMnU6rVjq08HHzgjTmfbRp5ZOFXthtPWG2Nryq78fVqVWKMpNIDwFQUMhgYQk5J7d3DZ7+T5/7J6zWbJJdjdn95zkvF8zmeLugX7z3bPnfM738/l+v0asaFmBFS0rYLSP/vF1aOBkj8wg8Ax7r9k9gL7BAExGA0pztDdClGUL7XgPJLcWUQfrhxSjSL0E14RSjNFoQGG4Hkga/RlNc/iYYo4QKUZKmY2nqLpjSMpMTZXTnbCajGjr8aKuffQNmlOJAZFGyU/EV92IDQYDrAVWWAvGzvnKJ7uKU10XlGQBAM40DR8K/aw5FCTNLnBocv+moTvedydRWB1ZBJA34PFSol6ig5+HogrDoz3NYwREA76A3PdMmSknW4GFYzvkmcjq1nbZLCZcFx4lOlbXoVo7OO1eo5wK7KPVroEbwDUloZP8TGOMgKgpFBDNL85Oa5sSkWO3oLvfl9RFRyvbREwGcnpgHPUSWtnpfrIozs7A/wBoGSMgagkXXmeYjePadoWiOUfIIiRCyiJoYTuV/1y7AJkWEyqKslRrAwMijRqpZiLoDeJfm/4FAJjz45IRh/iCQSGnCPJUjP6lEaLPmj3wB4IwmyItPhseNZpfot4XYCxOuxVo70suIJLXIOJNYLykAlIlauq4JpQy4p1p1jykoJrF7MqRHrS6+3xJL2iopVHTG2bkqN0Epsy0aqqcMotO1Qi/QOMLjWh8oRHCP3LxWXe/T57hpOYTsSvPAbvVBK8/OGxp9s+aQwHRAg2PEMlT75PY4JU1RMpRpKiaq4YrqijOlFlTd3/U8aQMadLHYCCIvsHklmfRQhZBSxgQaVRkccbkbgDSiZ5lMyPDrN4MJ5PRIE+pPHGpU3691+vH+fDMMy2PEEkXnWRuxKwhUo5ULzHoH742l8lowlfnfhVfnfvVUbfu4OehrHiLqjnlPjUyLSZYwyPuyd4ntFJUrRUMiDRqvE/EWjrRbyoPbex6pDZSLHf8YicCQYHpUzNVXap9LPJq1UnVEHFEQilZGWaYw4tzXT1aZzPbsGfdHuxZtwc288g3Xek7wRE7ZUgzxlrGSJk1hafcFzEgUpTBYIjst9ib3Gr6WkqZaQEDIo1yjnMGgVYW3AKGBEQXIgHRkdp2AMDSWbmqtCleznGkzOSd7nkDHrfoi39y3wl5Y1d+HoqIN2UmjxAxZaa4nHE8sHn9AfR4Q5MU1Kwz1RIGRBo13hGiNnn2gPonepUrB2ajAZe7+uU6Iik4Wlaep2bTxiQFlOOpIVJrpfDJJjJal/hnIYSQAynOMlNGUVYowOnu9426xZA0QsQ1iJTnHMe+l9LokNlokCct6B0DIo0a77YRWkqZOTLMWDEnHwCwu/oyWj1euZ5o+eyJERC1x7Ea79Ui07zV/wwmAymw7Lzqabh3sBeOnzjg+IljxK07+gYDGAyvNq6FUdPJIDvTDJsldAuRVqKO5YocEGk3NT5RjfSdiId0TctReR8zLWFApFFK1RBp5eL/jRumAwD+dLwBO49cQlAAi8qmoixXeytUDyWtz9GeYI5+6LIHXBlZGdJDQqzRuj5fH/p8I69wK30fMlTc1XuyMRgMmD41FOQ0dPbHPGbQH5RTatOmcoRIaXLKLIkaIi09NGsFAyKNmjpkdlMye7tobTrlmmuKkWO34HJXP7b9rQYA8OAKl8qtGpuUW+9I8ILT1e9DeNUDzXwGE13uOFJmcv0Qn4YVJT3Q1HfGDkYbu/oRFIDNYkSBBtL3k41zHLORtfbQrAUMiDRKGiEKBIVc+JaI9p5QUXW+Ri5CmVYTfvzv1yI8UQj/Njcfdy6arm6j4iCNEHX2DcrrOsWjLdz/zkyLJrclmYimOsaRHuAMs5QoC+9BWN8ROyC6FH59Rq6dgWgK5IwyajoWrT00awErqTTKZjEhw2yE1x9EV58PWbbECkG1GP3fcd00zCvKQmNXP26ekw+TUfsXyBy7FQYDIEToohNvgNnmkQJS7fT/RDeui3+4XoKfh7LKckMps/oRUmZDAyJSnrxOWjKbT4dnIjNlFsFHVw0bzwwnrUb/84qy8KWKQlhME+PUMxkN8o04kcLqVo2N0E0G0sU/mSnGWhsxnSykEaKGEVJm0siR1msFJypn5jhmwcr3CH4nJBPjrqRT0o040fqVYFDIM5x4Axg/eaZZ7+gL0A0lj0hksf+VMlpR9VjaWUCaEnINUQdHiNQwvoeEcEDEUVMZU2YaJt2IowIiI+Bc6Qz/OXbKyT3gg18D+5hNFslMvZdqiFhIqpyRFqEzGoxY6Vop/zkW6fPQwrpck4k0QtTW40Wv1w9HRvQt5WJ7X9RxpCxpSY9kiqojm38zIJIwINKwWAGRKdOExfsWh/6jN/aaK/I+Zhnq7mM2WUh1J4mM1Mk3YF5sFCM9DV/9OWRaMrHvwX2j/l3WEKWG025B/hQr2noGcaG1F5WlTvm9YFDgQlsPAGB24RS1mjipTZV3NBhEMChgTKAuU6tlFWpiykzDkq0hknPDvPgrIjJCFH/KrI0pM8VJKTP3gC+hGX9AJN3JFLLyZheEgp1zLZ6o1+s7+zDgC8JqNjJlliLStPugADwDic1Glh4S+NAWwYBIwyI1RIkNh/JEV5a0FlEiizO2sYhXcdLaXEIkvmBpm0fayobfCaXNLZICop6o189dCY8OFUyZEDNKJ6IMswl2aygLkMiDs9cfkL9DBXxokzEg0rBch5QiiIxMBHoD+LjgY3xc8DECvbH3D2qXN3blia4EebXqRGqIOO1ecRaTEVm2UJZ/6MW/d7AXBf9dgIL/Loi5dYcQQv5OsIZIeXMLswBEAiBJTXjEaF4R02WpJJdWJBAQSdcyi8kgr3lHrCHSNCmguXp3b1/b6E/HHRwhUlSiq1ULISIpM96AFZVjt8Iz4B+2WnVbX9uIf8c94IcvEEqx8TuhvDnh+qB/XZUykwKkeUVZaW+TnuRNyUBDZ39iy4J4IiPYXDAzggGRhkkzxIZG/sZMI248fWP4z7HrKOR0TRYv/kqQnsDa4px27/H65Y1EORytrBy7BZc6hj8kjEaq/ZqSYYaN+5gprqI4FPDUtfehu98njzj8s6Er9D4DopTKT6LGUQqIeH2KxpSZhsWaZWYwGuBY6IBjoQOGEfLyLeGTvTCLmykqIdFZZlK6jDdg5UmF1QmlB3o5wyyV8qdkwJUXKpo+Wd8FAOjsHcT51lD68gZXjlpN04VkNqBu5bIgMTEg0jApIOpKcB8tRv/KkupOuvp8GPQHxzy+jVO8UyaZeq52rkGUclUzQkHP8YudAIATl0L/O6vAwWndKSad122JzILlPSImBkQaJs0yCwrAHZ4REBwMonZLLWq31CI4GPvmLEf/PNkVkWO3wGIKjca1xnHR4SKAqSM90SaUHmBNXcpJo0DHL3YAAI6FA6MlHB1KubwkFo7lPSI2BkQaNnRWjTQcKnwCF7dexMWtFyF8sUeNWuWUGU92JRgMBjn9eMU9MObx0jHsf+VJI0SJPA1zhCj1ls3KBQB8UtsJz4APfz/bAgBYWp6nZrN0QZq4kcjWQswixMaASOPyElycscfrR99gaDo+Zzgppyg71JctcQREzeFjip2s4VJavpweGDLRwGDEkmlLsGTakphbd3CV6tSbXTAFswocGAwE8ZN3PsPnVzwwGw1YvaBI7aZNesmkkeWAiPeIKAyINC4n1n5mo5BOdIfVNGxfIUpeUXYouGnujiMgCh9TwoBIcfkx6iUyLZn4ZMMn+GTDJ8i0ZA77O0OnGFNqGAwGrLtpBgDgjaOXAAB3XFcir6RMqSMtC5LIqClTZrExINK43AR3vJfTZdm8GStJCoiueMa+6EgBURE/A8VFUmbxPw1f8fDzSIf7l7mwKLyXWf6UDPzHbfNVbpE+DJ0FG+/kGz4kxMYhBI2LueP9KFrCF38OhSpLDogSSJmVOIePVtD4SOd1R68XgaCIa0uIFnfo4i+lPSk1bBYT/vDIcpxq6MacwinyEgmUWtI9IihCM5LHqpXrHVJWwRGiaBwh0jhpc9DWOEYmhh7HE11ZkRqi0T8HIQRTZimU67DCYAhd/KW6uj5fH2b+YiZm/mIm+nx9UccLIeSHBI6apl6G2YQlM3MZDKWR2WRETjg1Gc9aRFJqzc6yimEYEGlcIQMiTYh3hKirzwdveK2iQo5IKC508Y+eaSaEwMXui7jYfRFCRKcMOvt88rYdHDWlySqRtYh4jxgZAyKNk6Z7S0+5Y2nhyZ4S0gjRWAGRlC7Lc1iRYeYq1amQyLorV4Z8HlYzL3c0OSXynWjmsiAj4hVC46TApoUjRKqS0i3uAT/6w/n3WFhQnXqxZpqNRAqI+H2gySw/gQVLIyl91jhejQGRxklRfIvbOywdEAsXZUyNrAwzMsP7ko02WhcpqGZAlCqJ1NVJDxIMUGkyS2T2ZWMXr1EjYUCkcVIdSr8vgB6vf8zjI8OhPNmVZDAYhqTNRr4RN3VzUcZUk9ID8Vz8pYU0OcOMJjN5nbS4ZsH2A2BAFAsDIo2zW82YEp4JMNYT8YAvIE/PnzaVJ7vSpLRZU3f/iMdckQIijkikjJT+iic9cMXNESKa/BJZFiTy0MaU2dU4524CKMzKQI/XjxaPFy5HJuzX2ENvXLUEi3Si260mODO5QqzSSqdm4iiAy10jB0SN4WCJI0Spk3/VfmYGgwHXFFwj/3koeco9U8g0iUmjPU1xrKTfxJTZiBgQTQAFWRm40NaLFo8Xplkm3PTpTaE3enujjmvqigyFXn1joPErzQ0FovUdIwdEDZ2h98rCx5LyIhvthtdTsdjx6Xc+jXmsdAzXIKLJTHoAG2trIX8gKD8klDCLMAxTZhOAPNNsjOHQxvCXYdpUDoWmQmlOqF8bOvtivh8ICvm9GQyIUiaReolIDREv/jR5SSn6Hq8fngHfiMe19ngRFIDZaEC+g6OmV1M1INqyZQsMBkPUT3Fxsfz+gw8+OOz9ZcuWRf0bXq8X3/ve95Cfnw+Hw4E777wTDQ0NUcd0dnZi/fr1cDqdcDqdWL9+Pbq6utLxKypCeiIeq4Zo6AgRKa8sJxTkSKNAV2t2D8AXELCajLwBp5B0fnf0DsLrH3kJhEBQDJllxos/TV6ODDOybKGEz2h1RNIMs6JsG4xxbHujN6qPEC1cuBBNTU3yz6lTp6Lev+2226Lef+edd6Lef+yxx7B7927s2rULH330EXp6enDHHXcgEIhcKNetW4eTJ0/i3XffxbvvvouTJ09i/fr1afn9lCDNNGvxeBHoC+DowqM4uvAoAn3RN4NGri+RUtII0eXOfgRjbKJ4sb1XPi6ePbYoOVPtFnmRxRa3F32+Pix8YSEWvrAwauuOVo8X/vB+Z5x1SZNdPHVEzXIWgd+HWFSvITKbzVGjQlfLyMgY8f3u7m68+OKLePXVV7F69WoAwGuvvYaysjL87W9/w6233oqzZ8/i3XffxeHDh7F06VIAwI4dO7B8+XJ8/vnnqKioUP6XUljU9h0C6DsTvuhfdU+WZj/xZE+NEqcNJqMBg4EgWjzeYYXT9R2hz4X1Q6llMBhQnG3DpY4+NHUPIHdKBs60ngGAqLW6LneFPo/ibBsDVJr0ip2ZqLnSM2pA1CRP+uBDcyyqjxCdO3cO06ZNQ3l5Ob71rW/hwoULUe/v27cPhYWFmDdvHjZs2ICWlhb5vePHj8Pn82HNmjXya9OmTcO1116LgwcPAgAOHToEp9MpB0MAsGzZMjidTvkYrYsUkQ7AaDNi0YeLsOjDRTDaoj++yOwBnuypYDYZ5aewSx3D64ik11g/lHpyEeko6QEptTk9h98HmvxKpNq6UQMizjAbjaoB0dKlS/HKK6/gvffew44dO9Dc3IwVK1agvb0dAHD77bfj9ddfx9///nc8++yz+OSTT3DLLbfA6w3VBTQ3N8NqtSInJyfq3y0qKkJzc7N8TGFh4bD/78LCQvmYWLxeL9xud9SPWqTZAI1d/YARyPlSDnK+lAODKfqpt5EjRClXnu8AAJxv7Rn2Xl1bKCBy5TEgSrVi+eI/yhII4QeE6ZxkQDpQFEfK7HIn60xHo2rK7Pbbb5f/XFlZieXLl2P27Nl4+eWXsWnTJtx7773y+9deey2WLFkCl8uFPXv24Otf//qI/64QImraeawp6Fcfc7Wf/vSn2Lp1a6K/UkpIF/TewQC6+32YGt7teyjPgA+egdBK1hwhSp25hVk4cK4N/2oZHhDVXPEAAOYUTkl3s3SnRJ5mPPJEAyllxoCI9ED6ToxWVH2xgw9to1E9ZTaUw+FAZWUlzp07F/P9kpISuFwu+f3i4mIMDg6is7Mz6riWlhYUFRXJx1y5cmXYv9Xa2iofE8sTTzyB7u5u+ae+vj7ZX2vcbBaTvBhdfUsfLm+/jMvbLyPoC8rHSMOk2TYzHBmql4ZNWlKwc3VANOgPorYtVFQ9rygr7e3SGyll1jjaIpnSCBFTZqQDxWOMEAkh5DrHGbmOtLVrItFUQOT1enH27FmUlJTEfL+9vR319fXy+1VVVbBYLNi7d698TFNTE06fPo0VK1YAAJYvX47u7m4cPXpUPubIkSPo7u6Wj4klIyMD2dnZUT9qkp5yG1v7cO6753Duu+cgBiMFpNL6N6U5jPxTaaSAqK69F/6gQFaGmcPRaSAtgVA/wppQQCQ9wHW5SA+mOSPrpMXaCLyjdxA9Xj8MhsiMWYqmakD0+OOPY//+/aitrcWRI0dw9913w+1244EHHkBPTw8ef/xxHDp0CHV1ddi3bx++9rWvIT8/H3fddRcAwOl04qGHHsIPfvADfPDBB6iursb999+PyspKedbZggULcNttt2HDhg04fPgwDh8+jA0bNuCOO+6YEDPMJNJT7kjbRlwKr548M58BUSpJAdHlrn70DUY22/28OZwuK5rCVcLTYEaetGp4HwwGA1xOF1xOl9z3Qgi5yL2MF3/SAWkyh2fAj66+4YszSumy4mwbbBZTWts2UaiaW2loaMB9992HtrY2FBQUYNmyZTh8+DBcLhf6+/tx6tQpvPLKK+jq6kJJSQm+/OUv480330RWViQlsW3bNpjNZtxzzz3o7+/HqlWr8Pvf/x4mU+QDf/311/Hoo4/Ks9HuvPNOPP/882n/fcdDHiHqGsCsGO9f6gila1x5HApNpVyHFflTMtDW48XZJg+qXKGCfikgmlfIdFk6SE+47gE/fD4L6h6ri3r/ituLfl8AJqOBo6akC5lWE4qzbWh2D6CuvRc5juha03rOgh2TqgHRrl27RnwvMzMT77333pj/hs1mw3PPPYfnnntuxGNyc3Px2muvJdVGrZADou7YKYKL0ggRi+VS7vqyqfjb2SuovtQpB0QnLoXq2K4rc6rZNN2wW81yYFrf2QenPbrf68KLZE6fmikv4kg02bny7Gh2D+Biex8Wz4iefX2xnQHRWHilmCDkFEF77IConiNEabN4xlQAQPWlLgCALxCU/3zjzFx1GqVDZbmhh4T6GGtC1YUL3Gfm8/tA+iEtCyI9EAwl1T3OKuAs2JEwIJogZuWHTuK6EQKixs7QzIKZDIhS7oYZ0aNCZ5vc6PcFkG0zYw4vNmkjPen+q7UDN+64ETfuuBH9vtBIaW34hlDOEVPSEemB+GKM+4S0LEhFMa9RI+H87AmiNCcTFpMB3sFgzPf9QQGbxShv80Gps6jMCYvJgKbuAZxv7cHB86GFRKtcOdwwMY2ki39tuwfHGo8BAIIi9P3gCBHpkVQyceGqhWP9gSAutIa+E3NZ5zgijhBNEGaTcczRn3lFWbwhp4HdasayWXkAgD3/bMKefzYBAG5ZMPK6VqS8uSMsgTD0tXIGRKQjFcWhYOfzKx4EhmxAXdfeh8FAEHariQuVjoIB0QQyq2D0i/v8Ykb+6XLX4ukAgJ/vrcGpy92wmo24/dqRNykm5UkLYJ5via6XGPAF5EUyF5Sou34YUTq58hywW00Y8EUWigUi6bK5fGgeFQOiCWSsYriKYl780+WO66Zh9pAA9YHlLuRPYboyncrzHTAbDfB4/VGvf97sQVCElkhgCpn0xGQ0yKNEZ5oi+2+eutwNAJjPVfRHxYBoAhlrBIgjROljNRvx+/9zE9Yvc2HTV+bhP26dr3aTdMdqNsasETobvhEsKMniIpmkO9eER0XPNEYCouN1oQkgVTNzYv4dCmFR9QSyqHTqqO8zIEqvslw7fvzv16rdDF2rKMpCTUtb1GtyQMQRU9KhhdNCa3JJs2C9/gBONnQBAJa4GBCNhiNEE4grzw5npgXuTAFDbnQsOzPfjjymbEhnpDWhMoxTkW/PBwAcD98IKku5SCbpz81zQhM+TlzshGfAh9OX3Rj0B5HnsHKSwRgYEE0gBoMBC2ZPxaOP9uHSnjKYHJHtSRj5kx4tLc+DETbMDexC8w9a4PNb8Gk4VbA8PBOQSE9ceQ6U5zvgDwocPN+ODz9rAQDcVJ7LFPIYGBBNMDeEn4gPnY9OE9xYzhWSSX8WlGTBYTXBM+DHZ81uHDrfDiFCU/ILs21qN49IFSvnFQAA/t//NOL/nrwMALiNs2DHxIBogpFO9H/UtMmLzwHA0pl8Gib9MZuMuCn8MPDB2Rb8Pfw0fPOcfDWbRaSqb9xQCgD4//9sQkNnP3LsFty6kAHRWFhUPcFcm5eFp/5gh9cfxDe6P8Lx8OtFTj4Nkz59ZWEO3qh9CD/cDxQOboURGVh7XYnazSJSTWWpE/csKcUfjjUAAJ5cew1sFtMYf4sYEE0wRhhQXmsAYII/IMY8nmiyu3VhEbx/PR3+L4HFM6aypo5077++fh3WXjcNOXYLrhtjhjKFMCCaYAwZBszftQC7PqlHnn34lgVEejP0yXeJKwfb7rmexaOke0ajQS6xoPgYhBAcZoiD2+2G0+lEd3c3srM1sr5Jby8wJbx6dU8P4OCUStKf3sFeTPlp6HvQ80QPHFZ+D4goIt77N4uqiYiISPeYMptggv4g2naHptznr7EzoiUiIlIAA6IJRngFztxzBgDwb1duULk1REREkwMDIiKa8OwWu9pNIKIJjgEREU1oDqsDvf/ZO/aBRESjYAkKERER6R4DIiIiItI9BkRENKEN+AewdudarN25FgP+AbWbQ0QTFGuIiGhCCwQDeOfcO/KfiYiSwREiIiIi0j0GRERERKR7DIiIiIhI9xgQERERke4xICIiIiLd4yyzOAkhAABut1vVdgR6A+hFaFVet8cNk/SG2w0EOMOG9Kd3sBcIz7Z3u90IWPk9IKII6b4t3cdHYhBjHUEAgIaGBpSVlandDCIiIkpCfX09SktLR3yfAVGcgsEgGhsbkZWVBYPBoNi/63a7UVZWhvr6emRnZyv2705G7KvEsL/ix76KH/sqfuyr+KWyr4QQ8Hg8mDZtGozGkSuFmDKLk9FoHDWyHK/s7Gx+YeLEvkoM+yt+7Kv4sa/ix76KX6r6yul0jnkMi6qJiIhI9xgQERERke4xIFJZRkYGnnrqKWRkZKjdFM1jXyWG/RU/9lX82FfxY1/FTwt9xaJqIiIi0j2OEBEREZHuMSAiIiIi3WNARERERLrHgIiIiIh0jwFRGrzwwgsoLy+HzWZDVVUVDhw4MOrx+/fvR1VVFWw2G2bNmoVf//rXaWqp+hLpq6amJqxbtw4VFRUwGo147LHH0tdQDUikr/785z/jK1/5CgoKCpCdnY3ly5fjvffeS2Nr1ZdIf3300Ue4+eabkZeXh8zMTMyfPx/btm1LY2vVleg1S/Lxxx/DbDbj+uuvT20DNSSRvtq3bx8MBsOwn88++yyNLVZPoueV1+vFk08+CZfLhYyMDMyePRsvvfRS6hooKKV27dolLBaL2LFjhzhz5ozYuHGjcDgc4uLFizGPv3DhgrDb7WLjxo3izJkzYseOHcJisYi33norzS1Pv0T7qra2Vjz66KPi5ZdfFtdff73YuHFjehusokT7auPGjeLpp58WR48eFTU1NeKJJ54QFotFnDhxIs0tV0ei/XXixAmxc+dOcfr0aVFbWyteffVVYbfbxW9+85s0tzz9Eu0rSVdXl5g1a5ZYs2aNWLRoUXoaq7JE++rDDz8UAMTnn38umpqa5B+/35/mlqdfMufVnXfeKZYuXSr27t0ramtrxZEjR8THH3+csjYyIEqxm266STzyyCNRr82fP19s3rw55vE//OEPxfz586Ne+/a3vy2WLVuWsjZqRaJ9NdTKlSt1FRCNp68k11xzjdi6davSTdMkJfrrrrvuEvfff7/STdOcZPvq3nvvFT/60Y/EU089pZuAKNG+kgKizs7ONLROWxLtq7/+9a/C6XSK9vb2dDRPCCEEU2YpNDg4iOPHj2PNmjVRr69ZswYHDx6M+XcOHTo07Phbb70Vx44dg8/nS1lb1ZZMX+mVEn0VDAbh8XiQm5ubiiZqihL9VV1djYMHD2LlypWpaKJmJNtXv/vd73D+/Hk89dRTqW6iZoznvFq8eDFKSkqwatUqfPjhh6lspiYk01dvv/02lixZgmeeeQbTp0/HvHnz8Pjjj6O/vz9l7eTmrinU1taGQCCAoqKiqNeLiorQ3Nwc8+80NzfHPN7v96OtrQ0lJSUpa6+akukrvVKir5599ln09vbinnvuSUUTNWU8/VVaWorW1lb4/X5s2bIFDz/8cCqbqrpk+urcuXPYvHkzDhw4ALNZP7eUZPqqpKQEv/3tb1FVVQWv14tXX30Vq1atwr59+/DFL34xHc1WRTJ9deHCBXz00Uew2WzYvXs32tra8J3vfAcdHR0pqyPSz9mrIoPBEPXfQohhr411fKzXJ6NE+0rPku2rN954A1u2bMFf/vIXFBYWpqp5mpNMfx04cAA9PT04fPgwNm/ejDlz5uC+++5LZTM1Id6+CgQCWLduHbZu3Yp58+alq3maksh5VVFRgYqKCvm/ly9fjvr6evzsZz+b1AGRJJG+CgaDMBgMeP311+Wd6n/+85/j7rvvxvbt25GZmal4+xgQpVB+fj5MJtOwCLilpWVYpCwpLi6OebzZbEZeXl7K2qq2ZPpKr8bTV2+++SYeeugh/PGPf8Tq1atT2UzNGE9/lZeXAwAqKytx5coVbNmyZVIHRIn2lcfjwbFjx1BdXY3vfve7AEI3MiEEzGYz3n//fdxyyy1paXu6KXXNWrZsGV577TWlm6cpyfRVSUkJpk+fLgdDALBgwQIIIdDQ0IC5c+cq3k7WEKWQ1WpFVVUV9u7dG/X63r17sWLFiph/Z/ny5cOOf//997FkyRJYLJaUtVVtyfSVXiXbV2+88QYefPBB7Ny5E2vXrk11MzVDqXNLCAGv16t08zQl0b7Kzs7GqVOncPLkSfnnkUceQUVFBU6ePImlS5emq+lpp9R5VV1dPWlLISTJ9NXNN9+MxsZG9PT0yK/V1NTAaDSitLQ0NQ1NW/m2TklTDV988UVx5swZ8dhjjwmHwyHq6uqEEEJs3rxZrF+/Xj5emnb//e9/X5w5c0a8+OKLupt2H29fCSFEdXW1qK6uFlVVVWLdunWiurpafPrpp2o0P60S7audO3cKs9kstm/fHjXdt6urS61fIa0S7a/nn39evP3226KmpkbU1NSIl156SWRnZ4snn3xSrV8hbZL5Hg6lp1lmifbVtm3bxO7du0VNTY04ffq02Lx5swAg/vSnP6n1K6RNon3l8XhEaWmpuPvuu8Wnn34q9u/fL+bOnSsefvjhlLWRAVEabN++XbhcLmG1WsUNN9wg9u/fL7/3wAMPiJUrV0Ydv2/fPrF48WJhtVrFzJkzxa9+9as0t1g9ifYVgGE/LpcrvY1WSSJ9tXLlyph99cADD6S/4SpJpL9++ctfioULFwq73S6ys7PF4sWLxQsvvCACgYAKLU+/RL+HQ+kpIBIisb56+umnxezZs4XNZhM5OTniC1/4gtizZ48KrVZHoufV2bNnxerVq0VmZqYoLS0VmzZtEn19fSlrn0GIcMUuERERkU6xhoiIiIh0jwERERER6R4DIiIiItI9BkRERESkewyIiIiISPcYEBEREZHuMSAiIiIi3WNARERERLrHgIiIiIh0jwERERER6R4DIiLStbfeeguVlZXIzMxEXl4eVq9ejd7eXrWbRURpZla7AUREamlqasJ9992HZ555BnfddRc8Hg8OHDgAbvFIpD/c3JWIdOvEiROoqqpCXV0dXC6X2s0hIhUxZUZEurVo0SKsWrUKlZWV+OY3v4kdO3ags7NT7WYRkQo4QkREuiaEwMGDB/H+++9j9+7daG5uxpEjR1BeXq5204gojRgQERGFBQIBuFwubNq0CZs2bVK7OUSURiyqJiLdOnLkCD744AOsWbMGhYWFOHLkCFpbW7FgwQK1m0ZEacaAiIh0Kzs7G//4xz/wi1/8Am63Gy6XC88++yxuv/12tZtGRGnGlBkRERHpHmeZERERke4xICIiIiLdY0BEREREuseAiIiIiHSPARERERHpHgMiIiIi0j0GRERERKR7DIiIiIhI9xgQERERke4xICIiIiLdY0BEREREuseAiIiIiHTvfwH77mgG47LE4wAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHFCAYAAADv8c1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjRUlEQVR4nO3deVhUZf8G8HuGfR1ANhHEBRUR9xXXfFXUVFwyVAqjt7RS3Fts197ezMo0t7QyzUqxXJIoUdxQZNEE3HdBXEBQYEB2mOf3B6/zawJ1RgcOA/fnuua6mnOeOfM95zo5N895znNkQggBIiIiInooudQFEBERERkChiYiIiIiLTA0EREREWmBoYmIiIhICwxNRERERFpgaCIiIiLSAkMTERERkRYYmoiIiIi0wNBEREREpAWGJiLSqw0bNkAmk1X7ev3115GamgqZTIYNGzbo7TtXr16t0/aaNWumrkkul0OhUKBt27aYPHky9uzZU+1n/rkvVlZWaNu2LRYuXIiCggKNtiEhIbC2tn6SXVLTdd+IqOYYS10AEdVP69evh7e3t8YyNzc3uLi4IC4uDi1bttTbd61evRqOjo4ICQnR+jN9+vTBF198AQC4d+8eLly4gLCwMAwdOhTPPPMMNm/eDBMTE43PjB8/HvPmzVN/Jjo6Gh999BFOnjyJbdu26W1//u5x9o2IagZDExHVCF9fX3Tr1q3adb169Xrk5wsLC2FpaanvstTs7Ow06hg8eDCmT5+OBQsWYOHChXjvvfewePFijc+4uLhU+cy1a9fw888/o7i4GObm5jVWLxFJj5fniKhWVXd5bsGCBZDJZEhMTMT48eNhb2+v7om6evUqJk6cCDc3N5iZmcHFxQWDBg1CcnIygMpLbWfOnEF0dLT60lmzZs0eu74FCxagXbt2WLlyJYqLix/ZXqFQQCaTwcjISOfvetJ9y8vLw+uvv47mzZvD1NQUTZo0wezZs6tcLpTJZAgNDcXatWvRunVrmJmZwcfHB2FhYTrXTNSQsaeJiGpERUUFysvLNZYZGz/8n5xx48Zh4sSJePXVV9U//E8//TQqKirw2WefoWnTprhz5w5iY2ORm5sLANixYwfGjx8PhUKB1atXAwDMzMyeqPZRo0bh008/xV9//YW+ffuqlwsh1Pt0//LcDz/8gIkTJ1a5lKeNJ9m3wsJCDBgwADdu3MA777yDDh064MyZM/jggw9w6tQp7N27FzKZTP1d4eHhOHDgAD766CNYWVlh9erVmDRpEoyNjTF+/PjHPVREDYsgItKj9evXCwDVvsrKykRKSooAINavX6/+zIcffigAiA8++EBjW3fu3BEAxLJlyx76ne3atRMDBgzQukZPT08xYsSIB67/+uuvBQCxZcsW9bIH7dPw4cPFvXv3ND7/wgsvCCsrq4fW8KT7tmjRIiGXy8WxY8c0lm/dulUAEH/++adG7RYWFiIjI0O9rLy8XHh7ewsvL6+Hfj8R/T/2NBFRjdi4cSPatm2rsexRPU3PPPOMxnsHBwe0bNkSn3/+OSoqKjBw4EB07NgRcnnNjiwQQlS7PDAwEG+88QYAoKioCMnJyfjPf/6DYcOGYe/evTr1cD3pvkVERMDX1xedOnXS6NEbOnQoZDIZDh48iOHDh6uXDxo0CC4uLur3RkZGmDBhAhYuXIgbN27A3d1d69qJGiqOaSKiGtG2bVt069ZN4/UojRs31ngvk8mwb98+DB06FJ999hm6dOkCJycnzJw5E/n5+TVVOq5duwag8m6/v3NyclLvS79+/TBjxgwsX74cMTExOk8L8KT7dvv2bZw8eRImJiYaLxsbGwghcOfOHY32rq6uVbZxf9ndu3d1qp2ooWJPExHVGX8fg3Ofp6cn1q1bBwC4ePEifvnlFyxYsAClpaVYs2aN3msQQuD333+HlZWVVkGvQ4cOAIATJ07o/F1Psm+Ojo6wsLDA999//8D1f5eRkVGlzf1ljRo10rl2ooaIoYmIDEbr1q3x3nvvYdu2bUhMTFQvNzMzQ1FRkV6+Y+HChTh79izeeecdraYQuH+nm7Oz8xN9r677NnLkSHzyySdo1KgRmjdv/sjt79u3D7dv31ZfoquoqMCWLVvQsmVLXpoj0hJDExHVWSdPnkRoaCieffZZtGrVCqampti/fz9OnjyJ+fPnq9u1b98eYWFh2LJlC1q0aAFzc3O0b9/+odvOzc1FfHw8AKCgoEA9ueXhw4cRGBiIhQsXVvnM7du31Z8pLi5GcnIyPv74Y9jZ2eHFF1+s1X2bPXs2tm3bhv79+2POnDno0KEDVCoV0tLSsGfPHsybNw89e/ZUb8fR0RH/+te/8P7776vvnjt//jynHSDSAUMTEdVZrq6uaNmyJVavXo3r169DJpOhRYsWWLJkCWbMmKFut3DhQqSnp2PKlCnIz8+Hp6cnUlNTH7rtI0eOwM/PT/1IlCZNmqBHjx5477334O/vX+1ntm7diq1btwIATExM4OHhgYCAALz77rvw9PSs1X2zsrLC4cOH8emnn+Kbb75BSkoKLCws0LRpUwwePLjKXFUBAQFo164d3nvvPaSlpaFly5b4+eefMWHCBJ3qJmrIZOJBt4kQEVG9IJPJMH36dKxcuVLqUogMGu+eIyIiItICQxMRERGRFjimiYionuMoDCL9YE8TERERkRYYmoiIiIi0wNBEREREpAWOadIjlUqFW7duwcbGptrHQRAREVHdI4RAfn4+3NzcHvrQbIYmPbp16xY8PDykLoOIiIgew/Xr1x/6WCGGJj2ysbEBUHnQbW1tJa6GiIiItJGXlwcPDw/17/iDMDTp0f1Lcra2tgxNREREBuZRQ2s4EJyIiIhICwxNRERERFpgaCIiIiLSAsc0ERERkUFTqVQoLS194HoTExMYGRk98fcwNBEREZHBKi0tRUpKClQq1UPb2dnZwdXV9YnmUWRoIiIiIoMkhEB6ejqMjIzg4eFR7cSUQggUFhYiMzMTANC4cePH/j6GJiIiIjJI5eXlKCwshJubGywtLR/YzsLCAgCQmZkJZ2fnx75Ux4HgREREZJAqKioAAKampo9sez9UlZWVPfb3MTQRERGRQdNmnJI+ngnL0ERERESkBYYmIiIiIi0wNBERERFpgaHJAGTmFyP5eq7UZRAREdVJQgi9tHkUhqY6rrisAlM3Hkfg2jjsTL4pdTlERER1xv2pAx42G/h9hYWFACpnB39cnKepjqtQCTham6G0XIVZYcm4eDsf84a0gVz+5HcBEBERGTJjY2NYWloiKysLJiYmj5zc0s7O7okepyIT+uivIgBAXl4eFAoFlEolbG1t9bbdCpXA57svYE30FQDA0HYu+DKwE6zMmHmJiKhh08djVLT9/WZo0qOaCk33bTt+A29vP4XSChXaNrbFdy90QxM7C71/DxERkSF50gf2avv7zTFNBuSZru7YPLUnHK1NcS49D6NXHsHxazlSl0VERCQpuVwOc3PzB76e5JKcxvfoZStUa7p6OmBnaF+0bWyLO/dKMOmbeGxPvCF1WURERPUeQ5MBamJnga2v+sHfxwWlFSrM/eUEPt11HioVr7QSERHVFIYmA2VlZow1z3fF9IEtAQBroq9g6o/Hca+kXOLKiIiI6ieGJgMml8vwxlBvLJvQCabGcuw9dxvjv47FjZxCqUsjIiKqdxia6oExnZtgy9RecLIxw/mMfIxeeQR/pWZLXRYREVG9wtBUT3Ruao+d0/ugnZst7haUIujbBGw9zgHiRERE+sLQVI+42Vng11f9MNzXFaUVKrz+6wks+vMcKjhAnIiI6IkxNNUzlqbGWBXUBTP/5QUAWHvoKqZu/IsDxImIiJ4QQ1M9JJfLMNe/DZZP6gwzYzn2nc/EM6tjcT2bA8SJiIgeF0NTPRbQ0Q1bXvGDs40ZLtzOx+hVR3A0hQPEiYiIHgdDUz3XycMO4aF90b6JAtkFpXjuu3hsOZYmdVlEREQGh6GpAXBVmOOXV/wwokNjlFUIvLXtFP4TcZYDxImIiHQgaWhatGgRunfvDhsbGzg7O2PMmDG4cOGCRpsFCxbA29sbVlZWsLe3x+DBg5GQkKDR5ptvvsFTTz0FW1tbyGQy5ObmVvmunJwcBAcHQ6FQQKFQIDg4uEq7tLQ0jBo1ClZWVnB0dMTMmTMf+tRkQ2JhaoSVkzpj9uBWAIB1MSn494ZjyCsuk7gyIiIiwyBpaIqOjsb06dMRHx+PqKgolJeXw9/fHwUFBeo2rVu3xsqVK3Hq1CnExMSgWbNm8Pf3R1ZWlrpNYWEhhg0bhnfeeeeB3xUUFITk5GRERkYiMjISycnJCA4OVq+vqKjAiBEjUFBQgJiYGISFhWHbtm2YN29ezey8BGQyGWYPbo1VQV1gbiJH9MUsjFsdi2t3Cx79YSIiogZOJoSoM9dosrKy4OzsjOjoaPTv37/aNnl5eVAoFNi7dy8GDRqkse7gwYMYOHAgcnJyYGdnp15+7tw5+Pj4ID4+Hj179gQAxMfHw8/PD+fPn0ebNm2wa9cujBw5EtevX4ebmxsAICwsDCEhIcjMzIStre0j679fm1Kp1Kq9lE7dUOLljcdwO68EdpYm+Pq5rvBr2UjqsoiIiGqdtr/fdWpMk1KpBAA4ODhUu760tBTffPMNFAoFOnbsqPV24+LioFAo1IEJAHr16gWFQoHY2Fh1G19fX3VgAoChQ4eipKQEx48ff5zdqdPauysQHtoXHd0VyC0sQ/C6BGxK4ABxIiKiB6kzoUkIgblz56Jv377w9fXVWBcREQFra2uYm5tj6dKliIqKgqOjo9bbzsjIgLOzc5Xlzs7OyMjIULdxcXHRWG9vbw9TU1N1m38qKSlBXl6exsuQuNiaY8srfhjV0Q3lKoF3dpzCgvAzKK9QSV0aERFRnVNnQlNoaChOnjyJzZs3V1k3cOBAJCcnIzY2FsOGDUNgYCAyMzN12r5MJquyTAihsVybNn+3aNEi9cByhUIBDw8PnWqqC8xNjLB8YifMG9IaALAhNhUvbjgGZSEHiBMREf1dnQhNM2bMQHh4OA4cOAB3d/cq662srODl5YVevXph3bp1MDY2xrp167TevqurK27fvl1leVZWlrp3ydXVtUqPUk5ODsrKyqr0QN339ttvQ6lUql/Xr1/Xuqa6RCaTYcagVljzfBdYmBjh8KU7GLv6CK5m3ZO6NCIiojpD0tAkhEBoaCi2b9+O/fv3o3nz5lp/rqSkROvv8fPzg1KpxNGjR9XLEhISoFQq0bt3b3Wb06dPIz09Xd1mz549MDMzQ9euXavdrpmZGWxtbTVehmyYb2Nsfc0PbgpzXL1TgDGrjiDm0h2pyyIiIqoTJA1N06dPx08//YRNmzbBxsYGGRkZyMjIQFFREQCgoKAA77zzDuLj43Ht2jUkJibi5Zdfxo0bN/Dss8+qt5ORkYHk5GRcvnwZAHDq1CkkJycjO7vykSFt27bFsGHDMGXKFMTHxyM+Ph5TpkzByJEj0aZNGwCAv78/fHx8EBwcjKSkJOzbtw+vv/46pkyZYvBhSBft3BT4LbQPOje1Q15xOV5YfxQb41KlLouIiEh6QkIAqn2tX79eCCFEUVGRGDt2rHBzcxOmpqaicePGIiAgQBw9elRjOx9++OFDtyOEEHfv3hXPPfecsLGxETY2NuK5554TOTk5Gtu5du2aGDFihLCwsBAODg4iNDRUFBcXa70/SqVSABBKpfJxD0mdUVRaLmaHJQnPtyKE51sR4p3tJ0VpeYXUZREREemdtr/fdWqeJkNnSPM0aUMIgTXRV/HZ7vMQAvBr0Qirn+sCeytTqUsjIiLSG4Ocp4nqFplMhteeaolvgrvBytQIcVfvYszqI7icmS91aURERLWOoYkeaYiPC7a+1htN7Cxw7W4hxq6KxcELuk35QEREZOgYmkgrbRvbIjy0D7o3s0d+STn+veEY1sWkgFd3iYiooWBoIq01sjbDTy/3xLNd3aESwH8izuLt7adQWs4ZxImIqP5jaCKdmBkb4bPxHfDeiLaQy4CwY9fx/HcJuHtP+3mziIiIDBFDE+lMJpPh5X4tsO6F7rAxM8bR1GyMXnUEFzI4QJyIiOovhiZ6bAO9nbF9Wm80dbDEjZwijFt9BHvPVn1cDRERUX3A0ERPpJWLDXZO74NeLRxQUFqBKT/+hTXRVzhAnIiI6h2GJnpi9lam+PGlngjq2RRCAJ/uOo95v55AcVmF1KURERHpDUMT6YWJkRz/HeOLhQHtYCSXYXviTQR9G4/M/GKpSyMiItILhibSG5lMhhd6N8OGF7vD1twYiWm5GLPyCE7fVEpdGhER0RNjaCK969fKCb9N74MWjla4pSzGs2visOtUutRlERERPRGGJqoRLZyssWNaH/Rr5Yiisgq89nMilu+7xAHiRERksBiaqMYoLE2wPqQ7XuzTDADwZdRFzNichKJSDhAnIiLDw9BENcrYSI4PR7XDonHtYSyXIeJkOgLXxiFDyQHiRERkWBiaqFZM6tEUP7/cE/aWJjh1U4mAlTFIvp4rdVlERERaY2iiWtOzRSOEh/ZFaxdrZOaXIHBtHHYm35S6LCIiIq0wNFGt8nCwxLbXemNwW2eUlqswKywZn0Weh0rFAeJERFS3MTRRrbMxN8Ha4G547amWAIDVB6/glZ+O415JucSVERERPRhDE0nCSC7DW8O8sXRCR5gayxF19jbGfx2L69mFUpdGRERULYYmktTYzu4Im9oLjtZmOJ+Rj9GrjuBYarbUZREREVXB0ESS69LUHuGhfdDOzRbZBaUI+jYevxy7LnVZREREGhiaqE5ws7PAr6/6YUT7xiirEHhz20n8J+IsyitUUpdGREQEgKGJ6hBLU2OsmNQZswe3AgCsi0nBSz/8hbziMokrIyIiYmiiOkYul2H24NZY/VwXmJvIEX0xC2NXHUHKnQKpSyMiogaOoYnqpKfbN8bWV3ujscIcV7IKMHplDGIu3ZG6LCIiasAYmqjO8m2iwM7QPujc1A55xeV4Yf1R/BCbCiE4ESYREdU+hiaq05xtzLF5Si+M69IEFSqBD8PP4J0dp1FazgHiRERUuxiaqM4zNzHCkmc74p2nvSGTAZuPpuH5dQnILiiVujQiImpAGJrIIMhkMkzt3xLrXugGazNjHE3JRsDKGJzPyJO6NCIiaiAYmsig/MvbBTum9YZnI0vcyCnCM6tjsedMhtRlERFRA8DQRAanlYsNfpvWB34tGqGgtAKv/HQcqw5c5gBxIiKqUQxNZJDsrUyx8aUeCO7lCSGAz3dfwOwtySguq5C6NCIiqqcYmshgmRjJ8Z8xvvh4jC+M5TLsTL6FCWvjkKEslro0IiKqhxiayOA938sTP77UE3aWJjhxQ4mAlTFIvp4rdVlERFTPMDRRveDXshHCp/dFaxdrZOaXIHBtHHYm35S6LCIiqkcYmqjeaNrIEtte643BbZ1RWq7CrLBkLI48D5WKA8SJiOjJMTRRvWJjboK1wd3w2lMtAQBfH7yCqT/+hfziMokrIyIiQ8fQRPWOkVyGt4Z5Y9mETjA1lmPvuUw883Us0u4WSl0aEREZMIYmqrfGdG6CX17xg7ONGS7evoeAVTGIvXJH6rKIiMhAMTRRvdbJww7hoX3RwV2B3MIyBK87ih/jUqUui4iIDBBDE9V7rgpz/PKKH0Z3ckOFSuD9nWfw7o5TKKtQSV0aEREZEIYmahDMTYywbEInvDXMGzIZ8HNCGp7/LgHZBaVSl0ZERAaCoYkaDJlMhteeaonvJneDtZkxElKyEbAyBucz8qQujYiIDABDEzU4g9q6YPu03mjqYIkbOUUYtzoWu89kSF0WERHVcQxN1CC1drHBzul90LtlIxSWVuCVH49jxb5LEIITYRIRUfUYmqjBsrcyxQ//7oEX/DwBAEuiLmLG5iQUlVZIXBkREdVFxo/zIZVKhcuXLyMzMxMqleYdSP3799dLYUS1wcRIjoWjfdHG1RYf7DyNiJPpSL1bgG+Cu8HNzkLq8oiIqA6RCR2vR8THxyMoKAjXrl2rcilDJpOhoqLh/pWel5cHhUIBpVIJW1tbqcshHSVcvYvXfk5EdkEpHK3NsDa4C7p6OkhdFhER1TBtf791vjz36quvolu3bjh9+jSys7ORk5OjfmVnZz9R0URS6tmiEXZO7wNvVxvcuVeCSd8k4Je/rktdFhER1RE69zRZWVnhxIkT8PLyqqmaDBZ7muqHgpJyzPvlBCL/d0fdS32b4+3h3jA24hBAIqL6qMZ6mnr27InLly8/UXFEdZmVmTFWP9cFswa1AgCsi0nBixuOQVlYJnFlREQkJZ0Hgs+YMQPz5s1DRkYG2rdvDxMTE431HTp00FtxRFKRy2WYM6Q1vF1tMPeXEzh86Q5Gr4rBdy90g5ezjdTlERGRBHS+PCeXV+2ckslkEEJwIDgvz9VLZ24pMXXjcdzMLYKNmTGWT+qMgd7OUpdFRER6ou3vt86h6dq1aw9d7+npqcvm6hWGpvrrzr0STPspEUdTsyGTAW8O9carA1pAJpNJXRoRET2hGgtN9GAMTfVbabkKC34/g00JaQCA0Z3csPiZDjA3MZK4MiIiehLa/n4/1uSWV65cwbJly3Du3DnIZDK0bdsWs2bNQsuWLR+7YKK6ztRYjk/GtkdbVxss/P0sdibfQsqdAqwN7orGCk6ESURU3+l899zu3bvh4+ODo0ePokOHDvD19UVCQgLatWuHqKiomqiRqE4J9muGH1/qCXtLE5y8oUTAyiNITMuRuiwiIqphOl+e69y5M4YOHYpPP/1UY/n8+fOxZ88eJCYm6rVAQ8LLcw3L9exCTNn4F85n5MPUSI5PxrXH+K7uUpdFREQ6qrExTebm5jh16hRatWqlsfzixYvo0KEDiouLH6/ieoChqeEpKCnH3F+SsfvMbQCcCJOIyBDV2OSWTk5OSE5OrrI8OTkZzs68DZsaFiszY3z9XFfM5ESYRET1ns4DwadMmYKpU6fi6tWr6N27N2QyGWJiYrB48WLMmzevJmokqtPkchnmDmmNtpwIk4ioXtP58pwQAsuWLcOSJUtw69YtAICbmxveeOMNzJw5s0HPW8PLc3T2Vh6mbPwLN3OLYG1mjK8mdsKgti5Sl0VERA9RK/M05efnAwBsbPjXNMDQRJXu3ivBtJ8TkZBSORHm6/5tMO2plg36DwoiorqsxsY0/Z2NjQ0DE9E/NLI2w08v90RwL08IAXy++wJmbE5CUWnDfcQQEVF9oNWYpi5dumDfvn2wt7dH586dH/oXc0OecoDoPhMjOf4zxhdtG9vig52nEXEyHSl3CvDN5G5oYseJMImIDJFWoWn06NEwMzNT/zcvMxBpJ6hnU3g5W+O1n47jzK08BKyIwdfPd0WP5g5Sl0ZERDris+f0iGOa6EFu5hZh6sa/cOZWHozlMiwc3Q7P9Wy4D7cmIqpLamxMU4sWLXD37t0qy3Nzc9GiRQtdN0fUIDSxs8DWV3tjZIfGKFcJvLvjNN7dcQql5SqpSyMiIi3pHJpSU1NRUVF1QGtJSQlu3Lihl6KI6iMLUyOsmNQZbwxtA5kM+DkhDc+vS8CdeyVSl0ZERFrQenLL8PBw9X/v3r0bCoVC/b6iogL79u1D8+bN9VsdUT0jk8kwfaAXvF1tMCssGUdTsjF65RGsDe4K3yaKR2+AiIgko3VP05gxYzBmzBjIZDK88MIL6vdjxozBxIkTERUVhSVLluj05YsWLUL37t1hY2MDZ2dnjBkzBhcuXNBos2DBAnh7e8PKygr29vYYPHgwEhISNNqUlJRgxowZcHR0hJWVFQICAqr0euXk5CA4OBgKhQIKhQLBwcHIzc3VaJOWloZRo0bBysoKjo6OmDlzJkpLS3XaJyJtDGrrgt+m90ZzRyvczC3C+DWx+P3ELanLIiKih9A6NKlUKqhUKjRt2hSZmZnq9yqVCiUlJbhw4QJGjhyp05dHR0dj+vTpiI+PR1RUFMrLy+Hv74+CggJ1m9atW2PlypU4deoUYmJi0KxZM/j7+yMrK0vdZvbs2dixYwfCwsIQExODe/fuYeTIkRqXEYOCgpCcnIzIyEhERkYiOTkZwcHB6vUVFRUYMWIECgoKEBMTg7CwMGzbto2PhqEa4+Vsg9+m98GA1k4oLlNhxuYkfBZ5HhUq3ptBRFQniTokMzNTABDR0dEPbKNUKgUAsXfvXiGEELm5ucLExESEhYWp29y8eVPI5XIRGRkphBDi7NmzAoCIj49Xt4mLixMAxPnz54UQQvz5559CLpeLmzdvqtts3rxZmJmZCaVSqVX992vTtj2REEKUV6jEJ3+cFZ5vRQjPtyLEi+uPCmVRqdRlERE1GNr+fus8EHzmzJlYvnx5leUrV67E7NmznyjAKZVKAICDQ/Vz2JSWluKbb76BQqFAx44dAQDHjx9HWVkZ/P391e3c3Nzg6+uL2NhYAEBcXBwUCgV69uypbtOrVy8oFAqNNr6+vnBzc1O3GTp0KEpKSnD8+PFq6ykpKUFeXp7Gi0hXRnIZ3n66LZZN6AQzYzn2n8/EmFVHcCXrntSlERHR3+gcmrZt24Y+ffpUWd67d29s3br1sQsRQmDu3Lno27cvfH19NdZFRETA2toa5ubmWLp0KaKiouDo6AgAyMjIgKmpKezt7TU+4+LigoyMDHUbZ2fnKt/p7Oys0cbFRfPBqvb29jA1NVW3+adFixapx0gpFAp4eHg83s4TARjTuQm2vtobjRXmuJpVgDErj+DA+UypyyIiov/ROTTdvXtX4865+2xtbXHnzp3HLiQ0NBQnT57E5s2bq6wbOHAgkpOTERsbi2HDhiEwMBCZmQ//MRFCaMxcXt0s5o/T5u/efvttKJVK9ev69esPrYnoUdq7KxAe2hfdPO2RX1KOf/9wDKsPXobgHLRERJLTOTR5eXkhMjKyyvJdu3Y99uSWM2bMQHh4OA4cOAB3d/cq662srODl5YVevXph3bp1MDY2xrp16wAArq6uKC0tRU5OjsZnMjMz1T1Hrq6uuH37dpXtZmVlabT5Z49STk4OysrKqvRA3WdmZgZbW1uNF9GTcrIxw6YpvRDUsymEAD6L5AN/iYjqAp1D09y5c/Hmm2/iww8/RHR0NKKjo/HBBx9g/vz5mDNnjk7bEkIgNDQU27dvx/79+7We50kIgZKSygkBu3btChMTE0RFRanXp6en4/Tp0+jduzcAwM/PD0qlEkePHlW3SUhIgFKp1Ghz+vRppKenq9vs2bMHZmZm6Nq1q077RfSkTI3l+GRse/x3rC+M5TJEnEzHM1/H4kZOodSlERE1XI8zynz16tWiSZMmQiaTCZlMJpo3by5++OEHnbfz2muvCYVCIQ4ePCjS09PVr8LCQiGEEPfu3RNvv/22iIuLE6mpqeL48ePipZdeEmZmZuL06dPq7bz66qvC3d1d7N27VyQmJop//etfomPHjqK8vFzdZtiwYaJDhw4iLi5OxMXFifbt24uRI0eq15eXlwtfX18xaNAgkZiYKPbu3Svc3d1FaGio1vvDu+eoJiRcvSu6/meP8HwrQnT+aI+Iu3JH6pKIiOoVbX+/n2jKgczMTJGfn//YnwdQ7Wv9+vVCCCGKiorE2LFjhZubmzA1NRWNGzcWAQEB4ujRoxrbKSoqEqGhocLBwUFYWFiIkSNHirS0NI02d+/eFc8995ywsbERNjY24rnnnhM5OTkaba5duyZGjBghLCwshIODgwgNDRXFxcVa7w9DE9WUmzmFYsTyQ8LzrQjR8u0/xA+xKUKlUkldFhFRvaDt77dMCI4w1Rdtn5JM9DiKyyowf9tJ/JZcOXP4hG4e+GhMO5gZG0lcGRGRYdP291vnMU23b99GcHAw3NzcYGxsDCMjI40XEdUMcxMjLJ3QCe887Q25DNjy13VM/CYet/OKpS6NiKhB0PqBvfeFhIQgLS0N77//Pho3bvzA2/GJSP9kMhmm9m8Jb1dbhG5KRFJaLkatiMGa4K7o0tT+0RsgIqLHpvPlORsbGxw+fBidOnWqoZIMFy/PUW1KvVOAqT/+hYu378HUSI6Px/gisDsnWCUi0lWNXZ7z8PDgRHtEdUAzRytsn9YHQ9u5oLRChTe3ncSHO0+jrEIldWlERPWSzqFp2bJlmD9/PlJTU2ugHCLShbWZMb5+rivmDG4NAPgh7hqe/y4Bd++VSFwZEVH9o/PlOXt7exQWFqK8vByWlpYwMTHRWJ+dna3XAg0JL8+RlKLO3sacLcm4V1KOJnYWWBvcFb5Nqj7yiIiINGn7+63zQPBly5Y9SV1EVEOG+Ljgt+m9MWXjcaTcKcAzX8fis/EdMLpTE6lLIyKqFzhPkx6xp4nqAmVRGWaHJeHAhSwAwJR+zfHWMG8YG+l8NZ6IqEHQ9vdb59CUlpb20PVNmzbVZXP1CkMT1RUVKoEvoy5g1YErAIC+Xo5YMakz7K1MJa6MiKjuqbHQJJfLHzo3U0VFw30SO0MT1TV/nEzH67+eQFFZBTwcLPBNcDe0bcxzk4jo72psTFNSUpLG+7KyMiQlJeHLL7/Ef//7X90rJaIaM6JDY7RwssLUH//C9ewijFsdiy+e7YgRHRpLXRoRkcHR25imP/74A59//jkOHjyoj80ZJPY0UV2VU1CKGZuTEHP5DgDgtada4nX/NjCSc0Z/IqIam9zyQVq3bo1jx47pa3NEpEf2VqbY8GJ3TO3fAgDw9cEr+PeGY1AWlklcGRGR4dA5NOXl5Wm8lEolzp8/j/fffx+tWrWqiRqJSA+MjeR45+m2+GpiJ5ibyBF9MQujV8Xg4u18qUsjIjIIOo9psrOzqzIQXAgBDw8PhIWF6a0wIqoZozs1gZezNaZuPI7Uu4UYs+oIljzbEcPbc5wTEdHD6DymKTo6WuO9XC6Hk5MTvLy8YGyscwarVzimiQxJdkEpQjclIvbKXQDA9IEtMXcIxzkRUcOj1zFNXbp0QU5ODoDK0NS9e3cMGDAAAwYMQL9+/eDt7d3gAxORoXGwMsXGf/fAS32bAwBWHbiCl344BmURxzkREVVHq54mCwsLXLp0Ce7u7jAyMkJGRgacnJxqoz6Dwp4mMlS/Jd3EW9tOoqRchWaNLPHN5G5o7WIjdVlERLVCr/M0derUCS+++CL69u0LIQQ+//xzWFtbV9v2gw8+eLyKiUgyYzpXjnN65UeOcyIiehCtepouXLiADz/8EFeuXEFiYiJ8fHyqvRwnk8mQmJhYI4UaAvY0kaG7e68EMzYncZwTETUoNfoYlYyMDDg7Oz9xkfUNQxPVB+UVKizadR7rYlIAAE+1ccJXEzpDYWkicWVERDWjxia3VKlUDExE9ZixkRzvj/TBsgmdYGYsx8ELWQhYFYMLGZzPiYgaNr3NCE5E9cuYzk2w7bXeaGJngWt3CzF29RH8cTJd6rKIiCTD0ERED+TbRIHfZ/RFH69GKCytwPRNiVgceR4VKr08spKIyKAwNBHRQzlYmeKHF3toPLcuZP1R5BaWSlwZEVHtYmgioke6/9y65ZM6w9xEjsOX7mDUyhicvZUndWlERLVG59DUokUL3L17t8ry3NxctGjRQi9FEVHdFNDRDTum9YGHgwWuZxdh3NdHsDP5ptRlERHVCp1DU2pqKioqKqosLykpwc2b/MeTqL5r29gWv4f2Rb9WjiguU2FWWDI+jjiL8gqV1KUREdUorR8YFx4erv7v3bt3Q6FQqN9XVFRg3759aNasmV6LI6K6yc7SFBte7IEley5g9cEr+C4mBWdu5WFlUGc0sjaTujwiohqh9eSWcnllp5RMJsM/P2JiYoJmzZphyZIlGDlypP6rNBCc3JIaol2n0jHv1xMoLK2Am8Ica4K7ooO7ndRlERFpTe+TW6pUKqhUKjRt2hSZmZnq9yqVCiUlJbhw4UKDDkxEDdXw9o2xc3ofNHe0wi1lMcavicOvf12XuiwiIr3TeUxTSkoKHB0dNZbl5ubqqx4iMkCtXGywM7QPBrd1Rmm5Cm9sPYn3fzuN0nKOcyKi+kPn0LR48WJs2bJF/f7ZZ5+Fg4MDmjRpghMnTui1OCIyHLbmJvgmuBvmDG4NmQz4Mf4aJn0bj9t5xVKXRkSkFzqHprVr18LDwwMAEBUVhb179yIyMhLDhw/HG2+8ofcCichwyOUyzBrcCute6AYbc2Mcv5aDkSticCw1W+rSiIiemM6hKT09XR2aIiIiEBgYCH9/f7z55ps4duyY3gskIsPzL28XhIf2RWsXa2Tll2DSN/HYGJda5SYSIiJDonNosre3x/XrlYM8IyMjMXjwYACAEKLa+ZuIqGFq7miFHdP6YESHxihXCXyw8wzm/XoCxWX8d4KIDJPOoWncuHEICgrCkCFDcPfuXQwfPhwAkJycDC8vL70XSESGy8rMGCsndca7T7eFXAZsT7yJZ76OxfXsQqlLIyLSmc6haenSpQgNDYWPjw+ioqJgbW0NoPKy3bRp0/ReIBEZNplMhin9W+Cnl3rCwcoUZ27lYdTKGBy+lCV1aUREOtF6ckt6NE5uSfRwN3OL8NpPx3HyhhJyGfD60DZ4bUBLyGQyqUsjogZM75Nb/t2VK1cwY8YMDB48GEOGDMHMmTNx9erVxy6WiBqGJnYW+OUVPwR2c4dKAJ9FXsBrPyUiv7hM6tKIiB5J59C0e/du+Pj44OjRo+jQoQN8fX2RkJCgvlxHRPQw5iZGWPxMB3wytj1MjGSIPJOBMauO4HLmPalLIyJ6KJ0vz3Xu3BlDhw7Fp59+qrF8/vz52LNnDxITE/VaoCHh5Tki3SSl5eC1nxKRkVcMK1MjLAnsiGG+jaUui4gaGG1/v3UOTebm5jh16hRatWqlsfzixYvo0KEDiosb7uy/DE1EusvKL0HopkQkpFROgPnqgJZ43b81jI0ea/QAEZHOamxMk5OTE5KTk6ssT05OhrOzs66bI6IGzsnGDD+/3BMv920OAFgTfQUvrD+Ku/dKJK6MiEiTsa4fmDJlCqZOnYqrV6+id+/ekMlkiImJweLFizFv3ryaqJGI6jljIzneG+mDjh52eGvbSRy5fBejVsTg6+e7oqOHndTlEREBeIzLc0IILFu2DEuWLMGtW7cAAG5ubnjjjTcwc+bMBn3rMC/PET25i7fz8cqPx5FypwCmRnIsHN0Ok3o0lbosIqrHamxM09/l5+cDAGxsbB53E/UKQxORfuQVl+H1X05gz9nbAIDAbu74aLQvzE2MJK6MiOqjGhvTlJKSgkuXLgGoDEv3A9OlS5eQmpr6eNUSEf2NrbkJ1jzfFW8MbQO5DPjlrxt4dk0cbuTw8StEJB2dQ1NISAhiY2OrLE9ISEBISIg+aiIiglwuw/SBXtj4756wtzTBqZtKjFrBx68QkXR0Dk1JSUno06dPleW9evWq9q46IqIn0beVI36f0Rcd3BXIKSzD5O+PYtWBy1Cp+AQoIqpdOocmmUymHsv0d0qlEhUVFXopiojo79ztLfHLK36Y2N0DQgCf776AqT8eh7KIj18hotqjc2jq168fFi1apBGQKioqsGjRIvTt21evxRER3WduYoRPn+mAxc+0h6mxHHvP3UbAyhicS8+TujQiaiB0vnvu7Nmz6N+/P+zs7NCvXz8AwOHDh5GXl4f9+/fD19e3Rgo1BLx7jqh2nLqhxKs/HcfN3CKYm8ixaFx7jO3sLnVZRGSgauzuOR8fH5w8eRKBgYHIzMxEfn4+Jk+ejPPnzzfowEREtae9uwIRM/qif2snFJepMGfLCXyw8zRKy1VSl0ZE9dgTzdNEmtjTRFS7KlQCX+29iOX7LwMAOje1w+rnuqCxwkLiyojIkNRYTxMRUV1hJJdhrn8bfB/SDbbmxkhKy8XI5TGIvXxH6tKIqB5iaCIig/cvbxdEzOgHn8a2uFtQiufXJWD1wctgRzoR6RNDExHVC00bWWL7tN4Y39UdKgF8Flk5LUFeMaclICL9YGgionrD3MQIn4/vgE/GtoepkRxRZ28jYAWnJSAi/dA5NBUVFaGw8P+f/3Tt2jUsW7YMe/bs0WthRESPQyaTIahnU2x9zQ9N7CyQercQY1cfwfbEG1KXRkQGTufQNHr0aGzcuBEAkJubi549e2LJkiUYPXo0vv76a70XSET0ODq42yFiRl8M+N+0BHN/OYF3d5xCSTmfXEBEj0fn0JSYmKie1HLr1q1wcXHBtWvXsHHjRixfvlzvBRIRPS57K1OsD+mO2YNbQSYDfk5IQ+CaONzIKXz0h4mI/kHn0FRYWAgbGxsAwJ49ezBu3DjI5XL06tUL165d03uBRERPQi6XYfbg1lgf0h12liY4cUOJkStiEH0xS+rSiMjA6ByavLy88Ntvv+H69evYvXs3/P39AQCZmZmc0JGI6qyn2jgjYkZfdHBXILewDCHrj2LZ3otQqTgtARFpR+fQ9MEHH+D1119Hs2bN0KNHD/j5+QGo7HXq3Lmz3gskItIXd3tL/PqqH57r2RRCAMv2XkLIhmPILiiVujQiMgCP9RiVjIwMpKeno2PHjpDLK3PX0aNHYWtrC29vb70XaSj4GBUiw7Ht+A28+9spFJep0MTOAque64JOHnZSl0VEEqjRx6i4urrCxsYGUVFRKCoqAgB07969QQcmIjIsz3R1x2/T+6C5oxVu5hbh2TWx+DEulbOIE9ED6Rya7t69i0GDBqF169Z4+umnkZ6eDgB4+eWXMW/ePL0XSERUU7xdbbEztA+GtXNFWYXA+zvPYPaWZBSUlEtdGhHVQTqHpjlz5sDExARpaWmwtLRUL58wYQIiIyP1WhwRUU2zNTfB1893wXsj2sJILsPO5FsYs+oILmfmS10aEdUxOoemPXv2YPHixXB3d9dY3qpVK045QEQGSSaT4eV+LRA2tRdcbM1wKfMeAlYewe8nbkldGhHVITqHpoKCAo0epvvu3LkDMzMznba1aNEidO/eHTY2NnB2dsaYMWNw4cIF9fqysjK89dZbaN++PaysrODm5obJkyfj1i3Nf8iuXLmCsWPHwsnJCba2tggMDMTt27c12uTk5CA4OBgKhQIKhQLBwcHIzc3VaJOWloZRo0bBysoKjo6OmDlzJkpLeVcNUUPRvZkDImb0Q++WjVBYWoEZm5OwIPwMSstVUpdGRHWAzqGpf//+6seoAJV/oalUKnz++ecYOHCgTtuKjo7G9OnTER8fj6ioKJSXl8Pf3x8FBQUAKifSTExMxPvvv4/ExERs374dFy9eREBAgHobBQUF8Pf3h0wmw/79+3HkyBGUlpZi1KhRUKn+/x+6oKAgJCcnIzIyEpGRkUhOTkZwcLB6fUVFBUaMGIGCggLExMQgLCwM27Zt4zgtogbGycYMP77UE9MHtgQAbIhNReDaONzMLZK4MiKSnNDRmTNnhJOTkxg2bJgwNTUV48ePF23bthUuLi7i8uXLum5OQ2ZmpgAgoqOjH9jm6NGjAoC4du2aEEKI3bt3C7lcLpRKpbpNdna2ACCioqKEEEKcPXtWABDx8fHqNnFxcQKAOH/+vBBCiD///FPI5XJx8+ZNdZvNmzcLMzMzjW0/jFKpFAC0bk9Eddu+cxmiw4LdwvOtCNFx4W5x4PxtqUsiohqg7e+3zj1NPj4+OHnyJHr06IEhQ4agoKAA48aNQ1JSElq2bPlEAU6pVAIAHBwcHtpGJpPBzs4OAFBSUgKZTKZxadDc3BxyuRwxMTEAgLi4OCgUCvTs2VPdplevXlAoFIiNjVW38fX1hZubm7rN0KFDUVJSguPHj1dbS0lJCfLy8jReRFR//MvbRWMW8Rc3HMOSPRdQwVnEiRoknUJTWVkZBg4ciLy8PCxcuBARERH4888/8fHHH6Nx48ZPVIgQAnPnzkXfvn3h6+tbbZvi4mLMnz8fQUFB6smnevXqBSsrK7z11lsoLCxEQUEB3njjDahUKvV0CBkZGXB2dq6yPWdnZ2RkZKjbuLi4aKy3t7eHqampus0/LVq0SD1GSqFQwMPD47H3n4jqJg+HylnEn+9VOYv4iv2XMfn7BNy5VyJ1aURUy3QKTSYmJjh9+jRkMpneCwkNDcXJkyexefPmateXlZVh4sSJUKlUWL16tXq5k5MTfv31V/z++++wtrZWz+jZpUsXGBkZqdtVV7MQQmO5Nm3+7u2334ZSqVS/rl+/rvX+EpHhMDM2wsdj2uOriZ1gYWKEI5fv4umvDuNoSrbUpRFRLdL58tzkyZOxbt06vRYxY8YMhIeH48CBA1WmMgAqA1NgYCBSUlIQFRVVZYpzf39/XLlyBZmZmbhz5w5+/PFH3Lx5E82bNwdQOYP5P++mA4CsrCx175Krq2uVHqWcnByUlZVV6YG6z8zMDLa2thovIqq/RndqgvDQPvBytkZmfgkmfRuPtdFXOIs4UQNhrOsHSktL8d133yEqKgrdunWDlZWVxvovv/xS620JITBjxgzs2LEDBw8eVIecv7sfmC5duoQDBw6gUaNGD9yeo6MjAGD//v3IzMxU32Xn5+cHpVKJo0ePokePHgCAhIQEKJVK9O7dW93mv//9L9LT09WXGvfs2QMzMzN07dpV630iovqtlYsNdk7vg3d3nMJvybewaNd5HEvNwZJnO0JhaSJ1eURUg3R+YO/DphW4f9u/tqZNm4ZNmzZh586daNOmjXq5QqGAhYUFysvL8cwzzyAxMREREREaPT4ODg4wNTUFAKxfvx5t27aFk5MT4uLiMGvWLISEhGDJkiXq9sOHD8etW7ewdu1aAMDUqVPh6emJ33//HUDllAOdOnWCi4sLPv/8c2RnZyMkJARjxozBihUrtNofPrCXqOEQQmDT0TQsDD+L0goVPBwssDqoK9q7K6QujYh0pO3vt86hSZ8eNFZo/fr1CAkJQWpqarW9TwBw4MABPPXUUwCA+fPnY8OGDcjOzkazZs3w6quvYs6cORrbz87OxsyZMxEeHg4ACAgIwMqVK9V34QGVk1tOmzYN+/fvh4WFBYKCgvDFF19oPWknQxNRw3P6phKv/Xwc17OLYGokx/sj2+L5Xp41MvaTiGqGQYSm+oahiahhUhaV4Y1fT2DP2cqxk6M6umHRuPawNtN5BAQRSaBGQ9OxY8fw66+/Ii0trcpjRrZv3657tfUEQxNRwyWEwLqYFHy66zzKVQItnKyw+rku8HblvwVEdZ22v9863z0XFhaGPn364OzZs9ixYwfKyspw9uxZ7N+/HwoFr+UTUcP094f+utqa42pWAcasOoJf/uJUJET1hc6h6ZNPPsHSpUsREREBU1NTfPXVVzh37hwCAwPRtGnTmqiRiMhgdGvmgD9m9kX/1k4oLlPhza0n8fqvJ1BUWiF1aUT0hHQOTVeuXMGIESMAVM5TVFBQAJlMhjlz5uCbb77Re4FERIamkbUZNoR0x+v+rSGXAVuP38CYVUdwOfOe1KUR0RPQOTQ5ODggPz8fANCkSROcPn0aAJCbm4vCwkL9VkdEZKDkchlC/9UKP73cE47WZrhwOx8BK2PwW9JNqUsjosekc2jq168foqKiAACBgYGYNWsWpkyZgkmTJmHQoEF6L5CIyJD1bumIP2f1hV+LRigsrcDsLcl4e/spFJfxch2RodH57rns7GwUFxfDzc0NKpUKX3zxBWJiYuDl5YX3338f9vb2NVVrnce754joQSpUAl/tu4QV+y9BCKBtY1usfq4LmjtaPfrDRFSjOE+TBBiaiOhRDl/KwuywZNwtKIW1mTEWjWuPUR3dpC6LqEGrsdCUlpb20PUN+Q46hiYi0sbtvGLM2JyEoynZAIDnezXFeyN8YG5iJHFlRA1TjYUmuVz+0McDVFQ03Ov0DE1EpK3yChWW7b2ElQcuAwB8/ne5rhkv1xHVOm1/v3We4z8pKUnjfVlZGZKSkvDll1/iv//9r+6VEhE1QMZGcrw+tA26N3fAnC3JOJueh5ErYvDpM+0xsgMv1xHVRXob0/THH3/g888/x8GDB/WxOYPEniYiehwZymLM3JyEo6m8XEckhRp7jMqDtG7dGseOHdPX5oiIGgxXhTk2TemJaU+1BAD8FJ+GcatjkXKnQOLKiOjvdA5NeXl5Gi+lUonz58/j/fffR6tWrWqiRiKies/YSI43h3ljw4vd4WBlirPpeRi1Iga/n7gldWlE9D96GQguhICHhwfCwsLg5+en1wINCS/PEZE+/PNyXVDPpvhgJC/XEdWUGrt7Ljo6WuO9XC6Hk5MTvLy8YGys87jyeoWhiYj0pbxChaV7L2L1wSsQAvB2tcGq57qgpZO11KUR1Tuc3FICDE1EpG+HLmZhzpbKyTAtTY3wydj2GNO5idRlEdUrNRaawsPDtW4bEBCgy6YNHkMTEdWE23nFmBWWhPirlZfrJnTzwIKAdrAw5eU6In2o8ckt//mxfy6TyWQNbqJLhiYiqikVKoHl+y5h+f+eXdfaxRqrgrqglYuN1KURGbwam3Jgz5496NSpE3bt2oXc3FwolUrs2rULXbp0we7du6FSqaBSqRpcYCIiqklGchnmDGmNn1/qCScbM1y8fQ+jVsbgl7+uV/kjlohqhs49Tb6+vlizZg369u2rsfzw4cOYOnUqzp07p9cCDQl7moioNmTll2DuL8k4fOkOAGBs5yb4zxhfWJs17JtxiB5XjfU0XblyBQqFospyhUKB1NRUXTdHREQ6crIxww8v9sAbQ9vASC7DjqSbCFgRgzO3lFKXRlSv6RyaunfvjtmzZyM9PV29LCMjA/PmzUOPHj30WhwREVVPLpdh+kAvhE3thcYKc1y9U4Cxq2OxMS6Vl+uIaojOoen7779HZmYmPD094eXlBS8vLzRt2hTp6elYt25dTdRIREQP0L2ZA/6c2Q+D2zqjtFyFD3aewWs/JUJZVCZ1aUT1zmPN0ySEQFRUFM6fPw8hBHx8fDB48OAqM4U3NBzTRERSEULg+yOp+HTXOZRVCDSxs8DySZ3R1dNe6tKI6rxandwyNzcXdnZ2T7oZg8fQRERSO3kjFzM2J+Ha3UIYyWV43b8NXunfAnJ5w/6jluhhamwg+OLFi7Flyxb1+8DAQDRq1AhNmjTBiRMnHq9aIiLSiw7udoiY0RejOrqhQiWwOPI8Xlh/FFn5JVKXRmTwdA5Na9euhYeHBwAgKioKUVFR2LVrF4YPH4433nhD7wUSEZFubMxNsHxiJyx+pj3MTeQ4fOkOhn91GDH/m6KAiB6PzqEpPT1dHZoiIiIQGBgIf39/vPnmmzh27JjeCyQiIt3JZDJM6N4U4aF90drFGnfulSD4+wR8FnkeZRUqqcsjMkg6hyZ7e3tcv34dABAZGYnBgwcDqByEyFnAiYjqltYuNtg5vS+CejaFEMDqg1cwYW0crmcXSl0akcHROTSNGzcOQUFBGDJkCO7evYvhw4cDAJKTk+Hl5aX3AomI6MlYmBrhk7HtsSqoC2zMjZGYlounlx/GrlPpj/4wEanpHJqWLl2K0NBQ+Pj4ICoqCtbW1gAqL9tNmzZN7wUSEZF+jOjQGH/O7IdOHnbILy7Haz8n4p0dp1BcxqsERNrQy5QDVIlTDhCRISirUOHLqItYE30FQgCtXayxMqgLWrvYSF0akSRqbMoBIiIybCZGcrw1zBsb/90DTjZmuHj7HkatiMHPCdf4CBaih2BoIiJqoPq1csKuWf0woLUTSspVeHfHaUz7ORHKQj6Chag6DE1ERA2Yo7UZ1od0x7tPt4WJkQy7Tmdg+FeHcCw1W+rSiOochiYiogZOLpdhSv8W2PZabzRrZIlbymJMWBuHr/ZeQoWKl+uI7tM5NLVo0QJ3796tsjw3NxctWrTQS1FERFT7OrjbIWJmP4zr3AQqASzdexGTvo3HrdwiqUsjqhN0Dk2pqanVTmJZUlKCmzdv6qUoIiKShrWZMb6c0AlfBnaElakRjqZkY/hXhxF5mnM6ERlr2zA8PFz937t374ZCoVC/r6iowL59+9CsWTO9FkdERNIY18UdXZraY1ZYEk7cUOLVnxIxqUdTfDDSBxamRlKXRyQJredpkssrO6VkMlmVW1JNTEzQrFkzLFmyBCNHjtR/lQaC8zQRUX1TWq7CkqgLWBt9FQDg5WyNFZM6o21j/htH9Ye2v986T27ZvHlzHDt2DI6Ojk9cZH3D0ERE9VXMpTuY80sysvJLYGosx9vDvRHSuxlkMpnUpRE9sRqb3DIlJaVKYMrNzdW5QCIiMhx9WzkiclY/DPJ2Rmm5Cgt/P4t/bziGO/dKpC6NqNboHJoWL16MLVu2qN8/++yzcHBwQJMmTXDixAm9FkdERHVHI2szfPdCNywMaAdTYzkOXMjCsGWHEX0xS+rSiGqFzqFp7dq18PDwAABERUVh7969iIyMxPDhw/HGG2/ovUAiIqo7ZDIZXujdDOGhfdDaxRp37pXghe+P4uOIsygp54N/qX7TOTSlp6erQ1NERAQCAwPh7++PN998E8eOHdN7gUREVPd4u9oiPLQvgnt5AgC+i0nB2FWxuJx5T+LKiGqOzqHJ3t4e169fBwBERkZi8ODBAAAhRLXzNxERUf1kbmKE/4zxxbeTu8He0gRn0/MwcsVhPviX6i2dQ9O4ceMQFBSEIUOG4O7duxg+fDgAIDk5GV5eXnovkIiI6rYhPi6InN0ffb0cUVxW+eDfV348jpyCUqlLI9IrnUPT0qVLERoaCh8fH0RFRcHa2hpA5WW7adOm6b1AIiKq+1xszbHx3z3UD/7dc/Y2hn11CDGX7khdGpHe6DxPEz0Y52kiIgJO31RiVlgSrmQVAACm9m+Bef6tYWbMmcSpbqqxyS3vO3v2LNLS0lBaqtn9GhAQ8DibqxcYmoiIKhWVVuA/f5zFpoQ0AEA7N1t8NbEzvJytJa6MqKoaC01Xr17F2LFjcerUKY1HqtyfFbYhDwZnaCIi0rT7TAbmbzuJnMIymJvI8d4IHzzXsylnEqc6pcZmBJ81axaaN2+O27dvw9LSEmfOnMGhQ4fQrVs3HDx48ElqJiKiemZoO1dEzu6Pfq0qB4m/99tpTNn4F+5yJnEyQDqHpri4OHz00UdwcnKCXC6HXC5H3759sWjRIsycObMmaiQiIgPmYmuOH17sgfdGtIWpkRx7z2Vi6LLDOHghU+rSiHSic2iqqKhQ3zHn6OiIW7duAQA8PT1x4cIF/VZHRET1glwuw8v9WuC36f8/k3jI+mNYEH4GxWUNd1gHGRadQ5Ovry9OnjwJAOjZsyc+++wzHDlyBB999BFatGih9wKJiKj+8HGrnEk8pHczAMCG2FQErIzB2Vt50hZGpAWdQ9N7770HlUoFAPj4449x7do19OvXD3/++SeWL1+u9wKJiKh+MTcxwoKAdlj/Ync4Wpvh4u17GLPqCL49dBUqFWfBobpLL/M0ZWdnw97evsHfDcG754iIdHP3Xgne2nYKe8/dBgD0btkISwI7orHCQuLKqCGpsbvn7rt8+TJ2796NoqIiODg4PO5miIioAWtkbYZvJ3fFJ2Pbw8LECLFX7mLo0kP4/cQtqUsjqkLn0HT37l0MGjQIrVu3xtNPP4309HQAwMsvv4x58+bpvUAiIqrfZDIZgno2xR8z+6KjuwJ5xeWYsTkJc7YkI6+4TOryiNR0Dk1z5syBiYkJ0tLSYGlpqV4+YcIEREZG6rU4IiJqOFo4WWPra70x819ekMuAHUk3MXzZYcRfvSt1aUQAHiM07dmzB4sXL4a7u7vG8latWuHatWt6K4yIiBoeEyM55vq3wa+v+qGpgyVu5hZh0rfxWLTrHErKOTUBSUvn0FRQUKDRw3TfnTt3YGZmppeiiIioYevq6YA/Z/VDYDd3CAGsjb6KMaticfF2vtSlUQOmc2jq378/Nm7cqH4vk8mgUqnw+eefY+DAgXotjoiIGi5rM2N8Nr4j1gZ3hYOVKc6l52Hkihisi0nh1AQkCZ2nHDh79iyeeuopdO3aFfv370dAQADOnDmD7OxsHDlyBC1btqypWus8TjlARFQzMvOL8ebWkzh4IQtA5dQEXzzbEW52nJqAnlyNTTng4+ODkydPokePHhgyZAgKCgowbtw4JCUlNejARERENcfZxhzrQ7rj4zG+/z81wbJD2Jl8U+rSqAHRy+SWAHD9+nV8+OGH+P777/WxOYPEniYiopp3Nese5vxyAieu5wIARnZojI/H+MLO0lTawshg1fjklv+UnZ2NH374QV+bIyIiqlYLJ2tse9UPcwa3hpFchoiT6Ri67BCiL2ZJXRrVc3oLTURERLXF2EiOWYNbYftrvdHCyQq380rwwvdH8cHO0ygq5dQEVDMYmoiIyGB19LDDHzP64QU/TwDAxrhrGLH8MJL/d+mOSJ8YmoiIyKBZmBph4Whf/PhSD7jamuPqnQI883UsvtxzAWUVKqnLo3pE69A0bty4h77mzJmj85cvWrQI3bt3h42NDZydnTFmzBhcuHBBvb6srAxvvfUW2rdvDysrK7i5uWHy5Mm4dUvzQY4ZGRkIDg6Gq6srrKys0KVLF2zdulWjTU5ODoKDg6FQKKBQKBAcHIzc3FyNNmlpaRg1ahSsrKzg6OiImTNnorS0VOf9IiKi2tevlRN2z+6PgI5uqFAJLN9/GWNXH8ElTohJeqJ1aLofNh708vT0xOTJk3X68ujoaEyfPh3x8fGIiopCeXk5/P39UVBQAAAoLCxEYmIi3n//fSQmJmL79u24ePEiAgICNLYTHByMCxcuIDw8HKdOncK4ceMwYcIEJCUlqdsEBQUhOTkZkZGRiIyMRHJyMoKDg9XrKyoqMGLECBQUFCAmJgZhYWHYtm0bH0JMRGRAFJYmWD6pM1YGdYadpQlO38zDiBUx+O7wVU6ISU9O1CGZmZkCgIiOjn5gm6NHjwoA4tq1a+plVlZWYuPGjRrtHBwcxHfffSeEEOLs2bMCgIiPj1evj4uLEwDE+fPnhRBC/Pnnn0Iul4ubN2+q22zevFmYmZkJpVKpVf1KpVIA0Lo9ERHVnAxlkXjh+wTh+VaE8HwrQgSuiRVpdwukLovqIG1/v+vUmCalUgkAcHBweGgbmUwGOzs79bK+fftiy5YtyM7OhkqlQlhYGEpKSvDUU08BAOLi4qBQKNCzZ0/1Z3r16gWFQoHY2Fh1G19fX7i5uanbDB06FCUlJTh+/Hi1tZSUlCAvL0/jRUREdYOLbeWEmP8d6wtLUyMkpGRj2LJD2HIsDUI/UxRSA1NnQpMQAnPnzkXfvn3h6+tbbZvi4mLMnz8fQUFBGpNPbdmyBeXl5WjUqBHMzMzwyiuvYMeOHeoZyjMyMuDs7Fxle87OzsjIyFC3cXFx0Vhvb28PU1NTdZt/WrRokcYlSg8Pj8fadyIiqhkymQzP9fTErln90L2ZPQpKK/DWtlN46Ye/kJlXLHV5ZGDqTGgKDQ3FyZMnsXnz5mrXl5WVYeLEiVCpVFi9erXGuvfeew85OTnYu3cv/vrrL8ydOxfPPvssTp06pW4jk8mqbFMIobFcmzZ/9/bbb0OpVKpf169f12pfiYiodnk2skLYVD+8PdwbpkZy7D+fCf9lh/D7iVuP/jDR/xhLXQAAzJgxA+Hh4Th06BDc3d2rrC8rK0NgYCBSUlKwf/9+jV6mK1euYOXKlTh9+jTatWsHAOjYsSMOHz6MVatWYc2aNXB1dcXt27erbDcrK0vdu+Tq6oqEhASN9Tk5OSgrK6vSA3WfmZkZzMzMHnu/iYio9hjJZXhlQEs81cYZc39JxplbeZixOQmRZzLwn9G+cLDiY1jo4STtaRJCIDQ0FNu3b8f+/fvRvHnzKm3uB6ZLly5h7969aNSokcb6wsJCAIBcrrkrRkZGUKkq5+fw8/ODUqnE0aNH1esTEhKgVCrRu3dvdZvTp08jPT1d3WbPnj0wMzND165d9bPDREQkuTauNtgxrQ9mDmoFI7kMf5xMh//SQ9h7tuof10R/p7cH9j6OadOmYdOmTdi5cyfatGmjXq5QKGBhYYHy8nI888wzSExMREREhEaPj4ODA0xNTVFWVgYfHx80btwYX3zxBRo1aoTffvsNb7zxBiIiIvD0008DAIYPH45bt25h7dq1AICpU6fC09MTv//+O4DKKQc6deoEFxcXfP7558jOzkZISAjGjBmDFStWaLU/fGAvEZFhOXkjF3N/OYHLmfcAAOO7uuODUT6wNTeRuDKqTdr+fksamh40Vmj9+vUICQlBampqtb1PAHDgwAH13XGXLl3C/PnzERMTg3v37sHLywuvv/66xjxM2dnZmDlzJsLDwwEAAQEBWLlypcZdeGlpaZg2bRr2798PCwsLBAUF4YsvvtD6EhxDExGR4Skuq8CSPRfwXUwKhADcFOZYPL4D+rVykro0qiUGEZrqG4YmIiLDdSw1G6//egLX7lYO+3i+V1O8PbwtrMzqxPBfqkHa/n7XmbvniIiIpNS9mQN2zfr/h//+FJ+GYV8dQvzVuxJXRnUFQxMREdH/WJoaY+FoX/z8ck80sbPA9ewiTPwmHgvCz6CotELq8khiDE1ERET/0MfLEZGz+2FSj6YAgA2xqRj+1SH8lZotcWUkJYYmIiKiatiYm2DRuPb44d894GprjtS7hXh2bRw+jjiL4jL2OjVEDE1EREQPMaC1E3bP6Y/xXd0hBPBdTAqe/uowjl/Lkbo0qmUMTURERI+gsDDBF892xPch3eBsY4ardwrw7JpYfPLnOfY6NSAMTURERFr6l7cLouYMwLguTaASwDeHrmLE8sNITGOvU0PA0ERERKQDhaUJvgzshO8md4OTjRmuZBVg/NfsdWoIGJqIiIgew2AfF0TN6Y9xnf+/1+np5RzrVJ8xNBERET0mO0tTfDmhstfJ2cYMV7MKMH5NLP77B++wq48YmoiIiJ5QZa9T5VgnIYBvD6dg+FeHcYzzOtUrDE1ERER6cH+s0/ch3eBqa46UOwUIXBuHBeFnUFhaLnV5pAcMTURERHr0L28X7J7THxO6eUCIytnEhy07jNgrd6QujZ4QQxMREZGeKSxMsHh8B2z8dw80sbNAWnYhgr5NwLs7TiG/uEzq8ugxMTQRERHVkP6tnRA5ux+e71X5DLufE9IwdOkhHLyQKXFl9DgYmoiIiGqQjbkJPh7THpum9ERTB0vcUhYjZP0xzPvlBHILS6Uuj3TA0ERERFQLerd0ROTsfnipb3PIZMC2xBsYsvQQIk9nSF0aaYmhiYiIqJZYmhrj/ZE+2PqqH1o6WSErvwSv/nQc039ORFZ+idTl0SMwNBEREdWyrp4O+GNmP0wf2BJGchn+OJWOIUujsSPpBoQQUpdHD8DQREREJAFzEyO8MdQbO6f3gU9jW+QWlmHOlhN4ccMx3Mwtkro8qgZDExERkYR8myiwM7QP3hjaBqbGchy8kAX/L6PxY1wqVCr2OtUlDE1EREQSMzGSY/pAL/w5sx+6edqjoLQC7+88gwnfxOFy5j2py6P/YWgiIiKqI7ycrfHLK374aHQ7WJka4VhqDp7+6jBW7r+EsgqV1OU1eAxNREREdYhcLsNkv2bYM3cAnmrjhNIKFb7YcxGjVsTgxPVcqctr0BiaiIiI6qAmdhZYH9IdyyZ0gr2lCc5n5GPs6iP4OOIsHwAsEYYmIiKiOkomk2FM5ybYO3cARndyg0oA38WkwH/pIRy6mCV1eQ0OQxMREVEd18jaDF9N7Iz1Id3hpjDHjZwiTP7+KOb+kozsAj6KpbYwNBERERmIgd7O2DN3AEJ6N4NMBmxPvInBX0bjt6SbnBSzFjA0ERERGRBrM2MsCGiHba/1RmsXa2QXlGL2lmSErD+G69mFUpdXrzE0ERERGaAuTe0RMaMf5g1pDVMjOaIvZsF/6SF8d/gqyjk9QY1gaCIiIjJQpsZyzBjUCrtm90PP5g4oKqvAx3+cw5jVR3D6plLq8uodhiYiIiID19LJGpun9MKn49rD1twYp2/mIWBlDD6OOIuCEk5PoC8MTURERPWAXC7DxB5NsXfeAIzs0FhjeoID5zOlLq9eYGgiIiKqR5xtzLEyqAvWv9gdTewscDO3CC9uOIbpmxKRmVcsdXkGjaGJiIioHhrYxhlRc/tjSr/mMJLL8MfJdAz6Mho/xV+DSsXpCR4HQxMREVE9ZWlqjHdH+GDn9D7o4K5AfnE53vvtNMavicWFjHypyzM4DE1ERET1nG8TBXZM64MPR/nAytQIiWm5GLH8MD7ddR5FpRVSl2cwGJqIiIgaACO5DC/2aY698wbA38cF5SqBNdFXMGRpNA5c4EBxbTA0ERERNSCNFRb4ZnI3fDu5m/o5di+uP4bpPyfiNgeKPxRDExERUQM0xMcFUXMH/P9A8VPpGLQkGhuOpKCCA8WrJRN8wp/e5OXlQaFQQKlUwtbWVupyiIiItHLmlhLv7jiN5Ou5AID2TRT4ZGx7tHdXSFtYLdH295s9TURERA1cOzcFtr3WGx+P8YWNuTFO3VRi9KoYLAg/g7ziMqnLqzMYmoiIiAhGchme7+WJffMGYHQnN6gEsCE2FYOXRCP8xC3wwhRDExEREf2Ns405vprYGT+91BPNHa2QmV+CmZuTELzuKFLuFEhdnqQYmoiIiKiKvq0csWtWP8wZ3BqmxnLEXL6DoUsP4cuoiygua5hzOzE0ERERUbXMTYwwa3Ar7JndH/1bO6G0QoXl+y5VPgS4Ac7txNBERERED9XM0Qo/vNgdq5/rAldbc6RlF+LF9cfw6o/HcSu3SOryag1DExERET2STCbD0+0bY++8/5/bKfJMBgYticbXB6+gtFwldYk1jvM06RHnaSIioobifEYe3v/tNI6l5gAAWjpZ4T+jfdHby1HiynTHeZqIiIioxni72uKXV/yw5NmOcLQ2xZWsAgR9l4AZm5OQoayfj2NhaCIiIqLHIpPJ8ExXd+yb9xQm+3lCLgN+P3ELg5YcxLeHrqKson5dsuPlOT3i5TkiImrITt9U4v2dp5GUlgsAaOVsjY9G+8KvZSNpC3sEbX+/GZr0iKGJiIgaOpVKYGviDXy66zyyC0oBAAEd3fDuiLZwsTWXuLrqcUwTERER1Tq5XIbAbh44MO8pBPeqvGQXfuIW/vXFQayNNuy77NjTpEfsaSIiItJ0+qYSH+w8jcT/XbJr6WSFhQG+6Nuq7txlx8tzEmBoIiIiqkqlEtiedBOf7jqHO/cqL9kNa+eK90a2hbu9pcTV8fIcERER1RFyuQzj/3eXXUjvZhoTY36195LBPMuOPU16xJ4mIiKiRzufkYcPd55BQko2AMDd3gLvj/SBv48LZDJZrdfDy3MSYGgiIiLSjhACESfT8d8/ziEjr3IyzH6tHPHhKB94OdvUai0MTRJgaCIiItJNQUk5Vh24jO8Op6C0QgVjuQwhvZth5uBWsDU3qZUaGJokwNBERET0eFLvFODjP85h77nbAABHa1O8OdQb47u6Qy6v2Ut2DE0SYGgiIiJ6MgcvZOKjiLO4mlUAAOjgrsCHo9qhq6d9jX0nQ5MEGJqIiIieXGm5Cj/EpmL5vkvILykHAIzt3ATzh3vXyKzinHKAiIiIDJKpsRxT+rfA/tefwoRuHpDJgB1JNzHwi4OIuXRHsroYmoiIiKhOcrIxw+LxHbBzeh90aWoHCxMjtHdXSFaPsWTfTERERKSFDu522PZab6RlF0JhUTt31FWHPU1ERERU58lkMng2spK0BoYmIiIiIi0wNBERERFpgaGJiIiISAuShqZFixahe/fusLGxgbOzM8aMGYMLFy6o15eVleGtt95C+/btYWVlBTc3N0yePBm3bt1St0lNTYVMJqv29euvv6rb5eTkIDg4GAqFAgqFAsHBwcjNzdWoJy0tDaNGjYKVlRUcHR0xc+ZMlJaW1vhxICIiorpP0tAUHR2N6dOnIz4+HlFRUSgvL4e/vz8KCipnAS0sLERiYiLef/99JCYmYvv27bh48SICAgLU2/Dw8EB6errGa+HChbCyssLw4cPV7YKCgpCcnIzIyEhERkYiOTkZwcHB6vUVFRUYMWIECgoKEBMTg7CwMGzbtg3z5s2rvQNCREREdVadmhE8KysLzs7OiI6ORv/+/attc+zYMfTo0QPXrl1D06ZNq23TuXNndOnSBevWrQMAnDt3Dj4+PoiPj0fPnj0BAPHx8fDz88P58+fRpk0b7Nq1CyNHjsT169fh5uYGAAgLC0NISAgyMzO1muGbM4ITEREZHoOcEVypVAIAHBwcHtpGJpPBzs6u2vXHjx9HcnIyXnrpJfWyuLg4KBQKdWACgF69ekGhUCA2NlbdxtfXVx2YAGDo0KEoKSnB8ePHq/2ukpIS5OXlabyIiIiofqozoUkIgblz56Jv377w9fWttk1xcTHmz5+PoKCgBybBdevWoW3btujdu7d6WUZGBpydnau0dXZ2RkZGhrqNi4uLxnp7e3uYmpqq2/zTokWL1GOkFAoFPDw8tNpXIiIiMjx1JjSFhobi5MmT2Lx5c7Xry8rKMHHiRKhUKqxevbraNkVFRdi0aZNGL9N9MpmsyjIhhMZybdr83dtvvw2lUql+Xb9+vdp2REREZPjqxGNUZsyYgfDwcBw6dAju7u5V1peVlSEwMBApKSnYv3//A3uZtm7disLCQkyePFljuaurK27fvl2lfVZWlrp3ydXVFQkJCRrrc3JyUFZWVqUH6j4zMzOYmZlptY9ERERk2CTtaRJCIDQ0FNu3b8f+/fvRvHnzKm3uB6ZLly5h7969aNSo0QO3t27dOgQEBMDJyUljuZ+fH5RKJY4ePapelpCQAKVSqb6M5+fnh9OnTyM9PV3dZs+ePTAzM0PXrl2fdFeJiIjIwEl699y0adOwadMm7Ny5E23atFEvVygUsLCwQHl5OZ555hkkJiYiIiJCo8fHwcEBpqam6veXL19G69at8eeff2LYsGFVvmv48OG4desW1q5dCwCYOnUqPD098fvvvwOonHKgU6dOcHFxweeff47s7GyEhIRgzJgxWLFihVb7w7vniIiIDI+2v9+ShqYHjRVav349QkJCkJqaWm3vEwAcOHAATz31lPr9O++8gx9//BHXrl2DXF61Ay07OxszZ85EeHg4ACAgIAArV67UuAsvLS0N06ZNw/79+2FhYYGgoCB88cUXWl+CY2giIiIyPAYRmuobpVIJOzs7XL9+naGJiIjIQOTl5cHDwwO5ublQKBQPbFcnBoLXF/n5+QDAqQeIiIgMUH5+/kNDE3ua9EilUuHWrVuwsbF54KXHx3E/AbMH69F4rLTHY6UbHi/t8Vhpj8dKezV5rIQQyM/Ph5ubW7VDfO5jT5MeyeXyaqdM0BdbW1v+T6UlHivt8VjphsdLezxW2uOx0l5NHauH9TDdV2cmtyQiIiKqyxiaiIiIiLTA0GQAzMzM8OGHH3L2cS3wWGmPx0o3PF7a47HSHo+V9urCseJAcCIiIiItsKeJiIiISAsMTURERERaYGgiIiIi0gJDExEREZEWGJoksnr1ajRv3hzm5ubo2rUrDh8+/ND20dHR6Nq1K8zNzdGiRQusWbOmSptt27bBx8cHZmZm8PHxwY4dO2qq/Fql72O1YcMGyGSyKq/i4uKa3I1aocuxSk9PR1BQENq0aQO5XI7Zs2dX247nlXbHiudVpe3bt2PIkCFwcnKCra0t/Pz8sHv37irteF5pd6x4XlWKiYlBnz590KhRI1hYWMDb2xtLly6t0q7GzytBtS4sLEyYmJiIb7/9Vpw9e1bMmjVLWFlZiWvXrlXb/urVq8LS0lLMmjVLnD17Vnz77bfCxMREbN26Vd0mNjZWGBkZiU8++UScO3dOfPLJJ8LY2FjEx8fX1m7ViJo4VuvXrxe2trYiPT1d42XodD1WKSkpYubMmeKHH34QnTp1ErNmzarShudVJW2OFc+rSrNmzRKLFy8WR48eFRcvXhRvv/22MDExEYmJieo2PK8qaXOseF5VSkxMFJs2bRKnT58WKSkp4scffxSWlpZi7dq16ja1cV4xNEmgR48e4tVXX9VY5u3tLebPn19t+zfffFN4e3trLHvllVdEr1691O8DAwPFsGHDNNoMHTpUTJw4UU9VS6MmjtX69euFQqHQe61S0/VY/d2AAQOqDQI8r6p60LHiefVgPj4+YuHCher3PK8e7J/HiufVg40dO1Y8//zz6ve1cV7x8lwtKy0txfHjx+Hv76+x3N/fH7GxsdV+Ji4urkr7oUOH4q+//kJZWdlD2zxom4agpo4VANy7dw+enp5wd3fHyJEjkZSUpP8dqEWPc6y0wfNKNzyvqlKpVMjPz4eDg4N6Gc+r6lV3rACeV9VJSkpCbGwsBgwYoF5WG+cVQ1Mtu3PnDioqKuDi4qKx3MXFBRkZGdV+JiMjo9r25eXluHPnzkPbPGibhqCmjpW3tzc2bNiA8PBwbN68Gebm5ujTpw8uXbpUMztSCx7nWGmD55X2eF5Vb8mSJSgoKEBgYKB6Gc+r6lV3rHheaXJ3d4eZmRm6deuG6dOn4+WXX1avq43zylhvWyKdyGQyjfdCiCrLHtX+n8t13aah0Pex6tWrF3r16qVe36dPH3Tp0gUrVqzA8uXL9VW2JGriHOB5pR2eV1Vt3rwZCxYswM6dO+Hs7KyXbdZ1+j5WPK80HT58GPfu3UN8fDzmz58PLy8vTJo06Ym2qQuGplrm6OgIIyOjKsk3MzOzSkK+z9XVtdr2xsbGaNSo0UPbPGibhqCmjtU/yeVydO/e3aD/cnucY6UNnlePr6GfV1u2bMFLL72EX3/9FYMHD9ZYx/NK08OO1T819POqefPmAID27dvj9u3bWLBggTo01cZ5xctztczU1BRdu3ZFVFSUxvKoqCj07t272s/4+flVab9nzx5069YNJiYmD23zoG0agpo6Vv8khEBycjIaN26sn8Il8DjHShs8rx5fQz6vNm/ejJCQEGzatAkjRoyosp7n1f971LH6p4Z8Xv2TEAIlJSXq97VyXultSDlp7f6tluvWrRNnz54Vs2fPFlZWViI1NVUIIcT8+fNFcHCwuv392+jnzJkjzp49K9atW1flNvojR44IIyMj8emnn4pz586JTz/9tF7dwqvPY7VgwQIRGRkprly5IpKSksSLL74ojI2NRUJCQq3vnz7peqyEECIpKUkkJSWJrl27iqCgIJGUlCTOnDmjXs/z6v896ljxvKq0adMmYWxsLFatWqVxi3xubq66Dc+rStocK55XlVauXCnCw8PFxYsXxcWLF8X3338vbG1txbvvvqtuUxvnFUOTRFatWiU8PT2Fqamp6NKli4iOjlave+GFF8SAAQM02h88eFB07txZmJqaimbNmomvv/66yjZ//fVX0aZNG2FiYiK8vb3Ftm3bano3aoW+j9Xs2bNF06ZNhampqXBychL+/v4iNja2Nnalxul6rABUeXl6emq04XlV6VHHiudVpQEDBlR7rF544QWNbfK80u5Y8byqtHz5ctGuXTthaWkpbG1tRefOncXq1atFRUWFxjZr+rySCfG/UbJERERE9EAc00RERESkBYYmIiIiIi0wNBERERFpgaGJiIiISAsMTURERERaYGgiIiIi0gJDExEREZEWGJqIiIiItMDQRERERKQFhiYiIiIiLTA0ERE9wtatW9G+fXtYWFigUaNGGDx4MAoKCqQui4hqmbHUBRAR1WXp6emYNGkSPvvsM4wdOxb5+fk4fPgw+NhOooaHD+wlInqIxMREdO3aFampqfD09JS6HCKSEC/PERE9RMeOHTFo0CC0b98ezz77LL799lvk5ORIXRYRSYA9TUREjyCEQGxsLPbs2YMdO3YgIyMDCQkJaN68udSlEVEtYmgiItJBRUUFPD09MXfuXMydO1fqcoioFnEgOBHRQyQkJGDfvn3w9/eHs7MzEhISkJWVhbZt20pdGhHVMoYmIqKHsLW1xaFDh7Bs2TLk5eXB09MTS5YswfDhw6UujYhqGS/PEREREWmBd88RERERaYGhiYiIiEgLDE1EREREWmBoIiIiItICQxMRERGRFhiaiIiIiLTA0ERERESkBYYmIiIiIi0wNBERERFpgaGJiIiISAsMTURERERaYGgiIiIi0sL/AWSYqWHiPTI8AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -130,7 +138,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -144,17 +152,17 @@ "plt.figure()\n", "plt.plot(s_space, potential)\n", "plt.xlabel('s')\n", - "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", - "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", - "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "#plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "#plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "#plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.title('First DBI step')\n", "plt.ylabel('Least squares cost function')\n", "plt.legend()\n", "plt.figure()\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", - "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", - "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", - "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "#plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "#plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "#plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", "plt.title('First DBI step')\n", @@ -200,7 +208,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -239,14 +247,28 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 183, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-03-15 18:17:12]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.5|INFO|2024-03-20 10:23:17]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-3. -1. -1. -0. -1. -0. -0. -0.]\n", + " [-1. 1. -0. -1. -0. -1. -0. -0.]\n", + " [-1. -0. 1. -1. -0. -0. -1. -0.]\n", + " [-0. -1. -1. 1. -0. -0. -0. -1.]\n", + " [-1. -0. -0. -0. 1. -1. -1. -0.]\n", + " [-0. -1. -0. -0. -1. 1. -0. -1.]\n", + " [-0. -0. -1. -0. -1. -0. 1. -1.]\n", + " [-0. -0. -0. -1. -0. -1. -1. -3.]]\n" ] } ], @@ -256,7 +278,7 @@ "\n", "# hamiltonian parameters\n", "nqubits = 3\n", - "h = 3.0\n", + "h = 1.0\n", "\n", "# define the hamiltonian\n", "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", @@ -266,27 +288,28 @@ "# define the state\n", "state = 0\n", "# initialize class\n", - "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, state=state)" + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, state=state)\n", + "print(np.real(dbi.h.matrix))" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 175, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "grid_search step: 0.8585872727272726\n", - "hyperopt_search step: 0.3413442272248831\n", - "polynomial_approximation step: 0.028303853122485182\n" + "grid_search step: 0.33334\n", + "hyperopt_search step: 0.33819673200950817\n", + "polynomial_approximation step: 0.10712604100508318\n" ] } ], "source": [ "# generate data for plotting sigma decrease of the first step\n", - "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "d = np.diag(np.linspace(2**nqubits,1,2**nqubits))\n", "s_space = np.linspace(1e-5, 0.9, 1000)\n", "off_diagonal_norm_diff = []\n", "fluctuation = []\n", @@ -309,19 +332,19 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 176, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The minimum for cost function in the tested range is: 0.8585872727272726\n" + "The minimum for cost function in the tested range is: 0.33334\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -331,7 +354,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -365,14 +388,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 177, "metadata": {}, "outputs": [], "source": [ "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", "energy_fluc = [dbi.energy_fluctuation(state=state)]\n", - "iters = 50\n", + "iters = 10\n", "dbi_ = deepcopy(dbi)\n", "for _ in range(iters):\n", " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", @@ -383,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 178, "metadata": {}, "outputs": [ { @@ -392,13 +415,13 @@ "Text(0, 0.5, 'Energy fluctuation')" ] }, - "execution_count": 11, + "execution_count": 178, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -408,7 +431,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -431,41 +454,62 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 179, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\andre\\AppData\\Local\\Temp\\ipykernel_23312\\3703842558.py:14: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " energy[i,j] = dbi_.h.matrix[states[i],states[i]]\n" + ] + } + ], "source": [ - "iters = 10\n", - "columnNorm = np.empty((2**nqubits,iters))\n", + "iters = 30\n", + "states = [0,1,2,3,4,5,6,7]\n", + "energy = np.empty((len(states),iters))\n", + "\n", + "\n", "d = (np.diag(np.linspace(1,2**nqubits,2**nqubits)))\n", - "for i in range(2**nqubits):\n", + "for i in range(len(states)):\n", " dbi_ = deepcopy(dbi)\n", - " dbi_.state = i\n", + " dbi_.state = states[i]\n", " for j in range(iters):\n", " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", - " dbi_(step_poly,d=d)\n", - " columnNorm[i,j] = np.linalg.norm(dbi_.h.matrix[:,i])\n", + " if step_poly is not None:\n", + " dbi_(step_poly,d=d)\n", + " energy[i,j] = dbi_.h.matrix[states[i],states[i]]\n", " " ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 181, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eigenvalues: [-4.00000000e+00 -3.46410162e+00 -8.06606266e-16 3.61709753e-17\n", + " 2.32474753e-15 2.00000000e+00 2.00000000e+00 3.46410162e+00]\n" + ] + }, { "data": { "text/plain": [ "Text(0.5, 0, 'Iterations')" ] }, - "execution_count": 13, + "execution_count": 181, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -476,45 +520,140 @@ ], "source": [ "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n", + "print('Eigenvalues:', eigvals )\n", "plt.figure()\n", - "for i in range(2**nqubits):\n", - " plt.plot(range(iters), columnNorm[i], label='State ' + str(i))\n", - " plt.axhline(y=eigvals[i], color='r', linestyle='--')\n", + "for i in range(len(states)):\n", + " plt.plot(range(iters), energy[i,:],'.', label='State ' + str(states[i]))\n", + "for eigvals in eigvals:\n", + " plt.axhline(y=eigvals, color='r', linestyle='--')\n", "plt.xlabel('Iterations')\n" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradients for finding optimal $D$\n", + "\n", + "An advantage of the least-squares cost function is that one can use gradient descent and the learning is more stable than with the off-diagonal cost function." + ] + }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { - "ename": "ValueError", - "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[20], line 8\u001b[0m\n\u001b[0;32m 5\u001b[0m step \u001b[39m=\u001b[39m \u001b[39m1e-2\u001b[39m\n\u001b[0;32m 6\u001b[0m iterations \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m----> 8\u001b[0m d, loss, grad, diags \u001b[39m=\u001b[39m gradient_ascent(dbi, d,step, iterations)\n\u001b[0;32m 10\u001b[0m n \u001b[39m=\u001b[39m \u001b[39m3\u001b[39m\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:253\u001b[0m, in \u001b[0;36mgradient_ascent\u001b[1;34m(dbi_object, d, step, iterations)\u001b[0m\n\u001b[0;32m 250\u001b[0m diagonals[:,\u001b[39m0\u001b[39m] \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mdiag(d)\n\u001b[0;32m 252\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(iterations):\n\u001b[1;32m--> 253\u001b[0m grad[i,:] \u001b[39m=\u001b[39m gradientDiagonal(dbi_object, d, H)\n\u001b[0;32m 254\u001b[0m \u001b[39mfor\u001b[39;00m j \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[0;32m 255\u001b[0m d[j,j] \u001b[39m=\u001b[39m d[j,j] \u001b[39m+\u001b[39m step\u001b[39m*\u001b[39mgrad[i,j] \u001b[39m# note the plus sign as we maximize the potential\u001b[39;00m\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:237\u001b[0m, in \u001b[0;36mgradientDiagonal\u001b[1;34m(dbi_object, d, H)\u001b[0m\n\u001b[0;32m 235\u001b[0m grad \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(\u001b[39mlen\u001b[39m(d))\n\u001b[0;32m 236\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[1;32m--> 237\u001b[0m derivative \u001b[39m=\u001b[39m dpolynomial_diDiagonal(dbi_object,d,H,i)\n\u001b[0;32m 238\u001b[0m grad[i] \u001b[39m=\u001b[39m derivative\u001b[39m-\u001b[39md[i,i]\n\u001b[0;32m 239\u001b[0m \u001b[39mreturn\u001b[39;00m grad\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:224\u001b[0m, in \u001b[0;36mdpolynomial_diDiagonal\u001b[1;34m(dbi_object, d, H, i)\u001b[0m\n\u001b[0;32m 220\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdpolynomial_diDiagonal\u001b[39m(dbi_object, d,H,i):\n\u001b[0;32m 221\u001b[0m \u001b[39m# Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz)\u001b[39;00m\n\u001b[0;32m 222\u001b[0m \u001b[39m# Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation\u001b[39;00m\n\u001b[0;32m 223\u001b[0m derivative \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m--> 224\u001b[0m s \u001b[39m=\u001b[39m polynomial_step(dbi_object, d, H, i)\n\u001b[0;32m 225\u001b[0m A \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(d\u001b[39m.\u001b[39mshape)\n\u001b[0;32m 226\u001b[0m Gamma_list \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mgenerate_Gamma_list(\u001b[39m4\u001b[39m, d)\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:127\u001b[0m, in \u001b[0;36mpolynomial_step\u001b[1;34m(dbi_object, n, n_max, d, coef, cost)\u001b[0m\n\u001b[0;32m 124\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 125\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m--> 127\u001b[0m \u001b[39mif\u001b[39;00m n \u001b[39m>\u001b[39;49m n_max:\n\u001b[0;32m 128\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 129\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mNo solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 130\u001b[0m )\n\u001b[0;32m 131\u001b[0m \u001b[39mif\u001b[39;00m coef \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", - "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" - ] + "data": { + "text/plain": [ + "Text(0, 0.5, 'Diagonal elements')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGwCAYAAABcnuQpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3xUZdqGrymZ1EnvvdN7h4QOYkVFEEVcu66KZde27vqtrrsq69p7xS4ogmBXSkISeu8hIT2TXieZTD/fH2dIQp8JhIC+1+/HH3M45T2TZM497/s8962QJElCIBAIBAKB4AJF2dMDEAgEAoFAIDgThJgRCAQCgUBwQSPEjEAgEAgEggsaIWYEAoFAIBBc0AgxIxAIBAKB4IJGiBmBQCAQCAQXNELMCAQCgUAguKBR9/QAuhu73Y5Op0Or1aJQKHp6OAKBQCAQCJxAkiT0ej2RkZEolaeee/ndixmdTkdMTExPD0MgEAgEAkEXKC0tJTo6+pT7/O7FjFarBeQ3w9fXt4dHIxAIBAKBwBmam5uJiYlpf46fit+9mDmytOTr6yvEjEAgEAgEFxjOlIiIAmCBQCAQCAQXNELMCAQCgUAguKARYkYgEAgEAsEFjRAzAoFAIBAILmiEmBEIBAKBQHBBI8SMQCAQCASCCxohZgQCgUAgEFzQCDEjEAgEAoHggkaIGYFAIBAIBBc0QswIBAKBQCC4oBFiRiAQCAQCwQWNEDMCgUAgEAguaISY6Sp2O+T9BpLU0yMRCAQCgeAPjRAzXWXnZ/D5NfDx5VC1v6dHIxAIBALBHxYhZrqKqQXUHlCUBW+nwY+PQFtDT49KIBAIBII/HELMdJUxd8M9m6HP5SDZYPM78Now2PYR2G09PTqBQCAQCP4wCDFzJgTEwbWfwfxvIbgXGOrgu/vhvUlQsrGnRycQCAQCwR8CIWbOBkmT4M85cNEz4O4LFbvgw4vgm9uhWdfToxMIBAKB4HeNEDNnC5UbjLkHFmyHIfMBBez5Cl4bDuv+BxZjT49QIBAIBILfJULMnG18QmDm63DHWogeCZZWWPM0vDkKDnwvWrkFAoFAIDjLCDHTXUQOgVt/haveBW0ENBTBknnw6ZVQfaCnRycQCAQCwe8GIWa6E4UCBl0L926F9IdA5Q4FGfDWOPjxYTDU9/QIBQKBQCC44BFipotIksT2Eid9Zdx9YMoTcM8m6H2Zo5X7XXhtKGx+D2zW7h2sQCAQCAS/Y4SY6SIrd+m4+s313P35NiqbnCzuDUyAuZ/DjSshtJ9ssvfjQ7Lp3uG13TtggUAgEAh+pwgx00VK6gwoFfDjnkqmvJDB+1kFWG125w5OnAB3roNLXwDPQKg5INfSfHkd1B3u1nELBAKBQPB7QyFJv+/2mubmZvz8/GhqasLX1/esnnufrol/fLuXHSWNAPSJ8OXfV/ZnWFyA8ydpa4CMhbDlPbBbQekGo++C8Q+Dh99ZHa9AIBAIBBcKrjy/hZg5Q+x2iSVbS3nup4M0tVkAuHZ4DI9e3JtAb43zJ6o5BL88Dvm/ya+9gmHyP2DojaBUnfVxCwQCgUBwPiPETCe6W8wcoa7FxHM/HeTrbWUA+Hu58diM3swZHoNSqXD+RHm/yaKm9pD8Oqy/7CycOKEbRi0QCAQCwfmJEDOdOFdi5ghbi+r5x7d7OVipB2BIrD9Pz+xP/ygXloxsFtj6Iax9BoyN8rZel8D0f0NQ0tkftEAgEAgE5xlCzHTiXIsZAKvNzscbinnpt0O0mKwoFXDD6Dj+Oq0Xfl5uzp/IUA+ZC+X2bckm19OMulOup/H077bxCwQCgUDQ07jy/O7Rbqa33nqLgQMH4uvri6+vL2PGjOGnn35q/39JknjyySeJjIzE09OTiRMnsm/fvh4csXOoVUpuTUtg9V8ncMWgSOwSfLKhmMkvZPD11lLsdif1o1cgXLwQ7t4AydPAboENr8OrQ4Q/jUAgEAgEDnpUzERHR/Pcc8+xdetWtm7dyuTJk5k5c2a7YPnvf//Liy++yOuvv86WLVsIDw9n2rRp6PX6nhy204T5evDqdUP48vbRpIT6UNdq5uGlu5n9zgb2ljc5f6KQXnDDUrjhGwjpDW31Dn+acXKNjUAgEAgEf2DOu2WmwMBAnn/+eW655RYiIyN54IEHePTRRwEwmUyEhYWxcOFC7rzzTqfO113LTJIkUdRmJsHL3an9LTY7i3IKeWVVHq1mG0oFzBsVx1+np+Lv5ULXk80K2z+CNf+RRQ1A0hS5niasr+s3IhAIBALBecgFs8zUGZvNxuLFi2ltbWXMmDEUFhZSWVnJ9OnT2/dxd3dnwoQJrF+//qTnMZlMNDc3H/WvO/i5tolxmw5w7/5iCgym0+7vplJyx/gkVv91Ipc7lp4+3VjM5BcyWby5xPmlJ5UaRtwG9+2AsQvkOprDq+VZmu8fhJaaM7wzgUAgEAguLHpczOzZswcfHx/c3d256667WL58OX379qWyshKAsLCwo/YPCwtr/78T8eyzz+Ln59f+LyYmplvGvaXJgB1YWtVA+uYD3H+ghOK204uacD8PXnMsPaWG+VDfauaxZXu46s0cdpY2Oj8AT395NubezdDncpDscgfUq0Mg+yWwOBmxIBAIBALBBU6PLzOZzWZKSkpobGzkm2++4f333yczM5PGxkbGjRuHTqcjIiKiff/bb7+d0tJSfv755xOez2QyYTJ1iIrm5mZiYmK6pZtpl97A/wor+a1Onv1RK+Da8EDujwsj1vP0y08Wm52P1xfx8qo8WkxyMe+c4dE8MqM3wT7OLV+1U5QDv/wNKnbJr/1iYdqT0O9qOb1bIBAIBIILiAu6NXvq1KkkJSXx6KOPkpSUxPbt2xkyZEj7/8+cORN/f38+/vhjp853Llqztze38nxhJWvr5cJktQKuiwji/rgwoj1OXw9TrTey8KdcvtkuG+5pPdQ8ODWV+WPicFO5MHlmt8Oer2DVU6DXyduiR8JF/4GYkS7fl0AgEAgEPcUFWTNzBEmSMJlMJCQkEB4ezm+/dXTrmM1mMjMzGTt2bA+O8HiG+nrz5aAkvhuawvgAH6wSfKqrY8zGAzySW0q50XzK40O1HrwwZxDf/HksA6L80But/Ov7/VzyShY5+bXOD0SphEFzYcE2mPR3cPOCss3wwTT4+iZoKDqj+xQIBAKB4HykR2dmHn/8cS6++GJiYmLQ6/UsXryY5557jp9//plp06axcOFCnn32WRYtWkRKSgrPPPMMGRkZ5ObmotVqnbpGT5jmbWps4fnCSrIbWwDQKBRcHxnEgthQok4zU2OzS3y1tZTnf8mlvlUWQTP6hfP3S/sQE+jl2kCaK2Dtf2DHZ4AEKo1supf+kDDdEwgEAsF5zQWzzHTrrbeyevVqKioq8PPzY+DAgTz66KNMmzYNkGdpnnrqKd555x0aGhoYNWoUb7zxBv3793f6Gj0hZo6wvqGF/xVVsr4LoqbJYOGlVYf4dGMxNruEu1rJneMTuWtiEl4atWsDqdwDv/4DCjLk156BMPExGH4LqFxwJBYIBAKB4BxxwYiZc0FPipkj5DToeaGo6ihRc11EIPfFhZ1W1ORW6nnqu32sP1wHQISfB49d3JsrBkWicKWwV5Igf5UsamoOytsCk2Dav6D3paJIWCAQCATnFULMdOJ8EDNHyGnQ87+iSjY0tgLg1knUnKpQWJIkftlXyb9/OEBZQxsAw+MC+Ofl/RgQ7UKAJcimezs+kUMsWx2eNLFj5Tbv6GFdui+BQCAQCM42Qsx0ojvFjMlUhbt72Ol3PIZjZ2rcFArmOkRNzClEjdFi4/2sAt5Ye5g2iw2FAq4ZGs3DM3oRqvVwcfB6yH5ZznqyOjxp+l8DU/4PAuJcvieBQCAQCM4mQsx0orvETH19Djt33Upc7G3Ex9+DSuXp8jnWN7TwQlElOQ5Rc8Sn5r64MOJO4VNT2WTkuZ8O8O1Ouf3aW6Pi3skp3JIWj7ta5dogmsphzb9h15ccXST8V/AMcPmeBAKBQCA4Gwgx04nuEjO5h56irOwTADw8YuiV+k+Cgyd16VwbG2VRk9XQIWpmhwdyX2zYKbOftpc08NR3+9nlcA6ODfTi8Ut6c1G/cNfqaQAqdsv1NIWZ8mvPABj/iBydoHYhO0ogEAgEgrOAEDOd6M6gydra38g99BQmkxyvEBpyMSmp/8DDPbxL59zc2MILRVVkNsjme0rg6rAAHogPI9nrxMtIdrvE8h3lLPz5INV62fl4VEIgT1zWl/5RLtbTtBcJPwE1B+RtAfEw5Z/Q7ypRJCwQCASCc4YQM53o7gJgq7WVwsJXKC37CEmyoVJ5k5jwANHRN6JUuthC7WBrUysvFlWyxuEorACuDPXn/vgwenufeDmr1WTlrYzDvJdVgMlqR6GA2cOieeiiLtTT2Kyw83O5SLjFkYMVNVwuEo4b06V7EggEAoHAFYSY6cS56mbS6w9wMPcJmpt3AODj04fevf6Fn9/QLp9zR7OBl4sr+aW2I/n70hA/HowLo7/2xAZ65Y1tLPzpICt3ddTT/HliErelJ+Lh5mI9jbkV1r8OOa+ARe7AotelMPVJCEntyi0JBAKBQOAUQsx04ly2ZkuSHZ1uCfmHn8dqbQIgMvJakpMewc3Nv8vn3as38FJxFT/UNLVvmx7ky4Px4QzxPbGo2VbcwL++76inifTz4NGu+NMA6Ksg8znY9jFINlCoYNifYOLfwCe0q7clEAgEAsFJEWKmEz3hM2M215Gf/xwVlcsAcHMLJDnpUSIirkah6Hoc1oGWNl4prmJFdSNHfmiTArU8GBfGSH+f4/a32yW+261j4U8H0TXJ7deDY/x54rI+DIsLdH0ANblyiGXuD/JrN28Ydx+MuRfcj7++QCAQCARdRYiZTvSkaV5Dw2ZyD/0fra15APj5DaVXr6fR+vQ+o/PmtRp5pbiK5dUN2Bw/vbH+PvwlPoxx/j7HzbwYLTY+yC7kzbX5tJptAFwyIJxHZ/QmLsjb9QEU5cBvT0D5Nvm1dyhM+hsMuRFUXasTEggEAoGgM0LMdKKnHYDtdgulZR9RWPgqNpsBhUJFdPSNJCbcj1rtXFjmyShqM/F6cTVLKuuxOH6Mw329uD8ujKlBvseJmmq9kZd+O8SSLaXYJXBTKbhxTDwLJifj7+Vi+7Ukwf5v5ZmahkJ5W1CKXE8j4hEEAoFAcIYIMdOJ7hQzRqMRDw/nOoWMRh2H8v5DTc3PAGg0oaQk/42wsMtdr2E5hnKjmTdKqvm8og6TXf5xDvDx5P64MC4J8UN5zPkPVjbzzI8HWXdIjjPw83RjweRk5o+Jc910z2qGbR/JNTUGOT+KmFEw7WmIHXVG9yUQCASCPy5CzHSiu8RMcXExX3zxBWPHjmX06NG4u5/c3K4zdXWZ5B56kra2EgAC/EeT2utJfLxTznhMVSYLb5dW87GuDoPNDkCKlzv3xYVxVWgAauXRoibzUA3P/niAg5VyC3hMoCePzujNpQMiXBdYxma562nDG2CV86PofZnsUSM6nwQCgUDgIkLMdKK7xMzKlSvZvn07AN7e3kyYMIGhQ4eiVp++ZsRmM1FS8i5FxW9ht5tQKNTExNxMQvwC1Oou1LAcQ73FynulNXxQXkOzVRY1sR4a7o0N5dqIQNyVHUXINrvE0m2lvPDroXbTvcEx/jx+SR9GJnShSLi5AjKehR2fgmSXO5+GzocJj4FvxBnfm0AgEAj+GAgx04nuEjN2u519+/axZs0aGhoaAAgICGDSpEn0798fpfL0XUttbaUcyvs3tbWrAHB3Dycl+XFCQy8546UngGarjY/Ka3mntIY6ixWAcI0bf44N4YbIILxVHUtKBrOV99YV8s66wxgcRcLT+obx6IzeJId2oVOp+iCsfgpyf5Rfqz1hzN0w7n7wcNGZWCAQCAR/OISY6UT3OwBb2b59O5mZmbS2ysZyYWFhTJ06leTkZKdESW3tGg4depo2o2PpKWAsvVL/ibd38lkZo8Fm53NdHW+WVlNhsgAQ6Kbi9ugQbokKxs+tYzapWm/k5VV5LNlSis0uoVIquHZEDA9MSSHU10UnYYDiDbDqn1C6SX7tGQjjH4YRt4LauaU5gUAgEPzxEGKmE+eqm8lsNrNx40ZycnIwmeTlmri4OKZOnUpMTMxpj7fZTBSXvEvxcUtP96JWnx0PF5PdztLKBl4rqaKozQyAj0rJzVHB3BETQojGrX3f/Go9C3/O5bf9VQB4uqm4PT2B28cnovVwO+H5T4okwcEf5Jma2kPyNr9YmPwPGDAbnJjFEggEAsEfCyFmOnGuW7MNBgNZWVls3rwZm01erunVqxdTpkwhNPT0brltbSWOpafVALhrwkhOfuysdD0dwWqX+L6mkVeKqzjQKpvpeSgVXBcRxN2xocR4dLRpbymq55kfD7CjpBGAIG8NCyYnc/2oODRqF0XIkcynjGdBXyFvCxsAU/8JyVNFO7dAIBAI2hFiphM95TPT1NRERkYGO3fu5MhbPGjQICZOnEhAQMBpj6+tXcuhvH+1dz35+4+kV+qT+Pj0OmtjtEsSv9U180pxFdubDQCoFXBVWAALYsNI9ZaXlSRJ4pd9lfz351wKauWltNhAL/46PZXLB0aiVLooQswG2PQ2ZL8MJkdEQ1waTHsKooefrdsTCAQCwQWMEDOd6GnTvJqaGtasWcOBAwcAUCqVjBgxgvT0dHx8Tr18JHc9vefoejKiUKiIippHYsKDuLmdvXuRJImcxhZeK64ms0Hfvv3iYD8WxIUy1FfusLLY7Hy1tZSXV+VR4+h86hfpyyMzejM+Jdj1mSNDPWS9AJvfBZu87CXauQUCgUAAQswcRU+LmSOUlZWxevVqCgtlt1yNRsOYMWMYM2bMaY332trKyct/pt1wT856epiIiGvOKOvpROxoNvBacRU/1naEWqb5+3BfXBjpAXJUgsFs5YOsQt5ZV0CLSe6SGpMYxKMX92ZwjL/rF20slZeedn3paOdWwpAb5HZuv6izdGcCgUAguJAQYqYT3SlmJKsdhQt1I5IkUVBQwKpVq6iokGtGPD09SU9PZ8SIEbi5nbqwtr4+h9xD/8JgyAfAVzuQ1NR/4uc3uMv3cDIOtRp5vaSKZVUNWB2/IYO0niyIDePiED9UCgX1rWbeWJvPpxuKMTtM+mb0C+ehi1JJDu1CVEP1AVj9r07t3B4w8g5IexC8uuB5IxAIBIILFiFmOtFdYsZcpqf2o334To3De0Q4CpXzSyySJLF//37WrFlDXZ0cAeDr68vEiRMZNGgQKtXJIwXsdgtlZZ9QUPgqNlsLABHhs0hKfgR3TfCZ3dQJKDOaebu0ms91dbQ5ohKSPN25JzaUa8ID0CiVlDUYeOm3PJbtKEOSQKmAWUOjeWBaKlH+nq5ftGQjrHoSSjbIr939IO1+GHUXaM7cVFAgEAgE5z9CzHSiu8RM/Ve5GLZXA6AO9cLvkgQ8egW4VDdis9nYtWsXGRkZNDc3AxAUFMTkyZPp27fvKc9lMtVw+PB/qahcBoBK5UNiwn1ER89HqXQxNNIJas1WPiir4cPyWpqscpdWhLsbd0SHMD8yCB+1ikNVev73Sy6/Otq5NSolN4yO4+5JSQT7uOgpI0mQ96scZFm9T97mEwYTHoGhfwKVi+3hAoFAILigEGKmE90lZiSrnZZNFehXl2A3yHUj7sn++F2aiCbCtdkDi8XCli1byMrKoq1NzjWKiIhgypQpJCUlnVLUNDXtIPfQU+j1ewDw8kokNeUfBAVN6OKdnZoWq41PdXW8U1pDpVk24PNTq7g5Kphbo4MJ0bixvaSB//58kI0F9QB4a1TcmpbAbeMT8XXVo8Zugz1LYe1/oLFY3haQIHvU9LtaeNQIBALB7xQhZjrR3QXAdoOF5rWltKzXgU0CBXgNC8NvehwqX9dmI4xGIxs2bGDDhg2YzXJ3T3x8PFOnTiU6Ovqkx0mSnYqKpeQffh6LRRYQwcFTSEl+HC+v+C7f26kw2e18U9nAGyXVHG6TO5s8lAquDQ/k7thQYj00ZOXV8r9fc9ldJhcT+3m6cdeEJP40Ng4vzekzrI7CaobtH0PmQmiV074JGwBT/g9SpgmPGoFAIPidIcRMJ85VN5O1ro2mn4to21MLgMJNic/4aLTjo1G6n7wG5kS0tLSQnZ3Nli1bXDLes1r1FBa+RmnZx0iSFYXCjdiYm4mPv+esuQgfi02S+Lm2ideKq9mpl71qlMDlof7cGxtKfx9PftlXyf9+PUR+tVzjE+zjzr2TkrhuVCzuatfeG0wtsPEtWP8qmOSlOWLHysZ7saPP4p0JBAKBoCcRYqYT57o121TcTNOPhZiL5Qet0scN3+lxeA9zrUgYoLGxkYyMDHbt2tVuvDdw4EAmTZp0SuO91tbD5OX9m7r6dQBoNCEkJT1ERPjVZ72V+whHvGreKKlmbX2HV82EAC33xoYyxs+bFTt1vLz6EKX18lJapJ8H901JYdawaNxULo7LUA/ZL8keNVbZxZiUi+Tlp4iBZ+u2BAKBQNBDCDHTiZ7wmZEkiba9dTT9XIitTn7QdrVIGE5svDds2DDGjx+PVnviFmhJkqirW8uhvH/T1ibXmsit3E/g5zf0DO7u9OxraeONkmpWVDdgc/x2DdR6ck9sKNP8fVm2vYzX1uRR1SwvT8UHeXH/1BSuGBSFylU34WadvPS0/VOQ5Fks+s+CSX+HoKSzeFcCgUAgOJcIMdOJnjTNk6x2WjZWoF/TqUg4yQ+/SxLRRLm+7FNeXs7q1aspKCgAwM3NjVGjRjFu3Dg8PU/cAm23mygt+4TCwtfbW7nDw2aSlPQwHh4RXbwz5yhuM/FuaQ1fVHS0dcd5aLgrNpSZQX4s21LKWxmHqWuV64OSQ314cGoqF/cPdz0ioe6wXCS89xv5tUIFQ+fD+EeE8Z5AIBBcgAgx04nzwQHYbrDQnFFKS06nIuHBofheFIfa/9TuvyeisLCQVatWUV5eDoCHhwfjxo1j1KhRaDQnbss2mWspOPwCuoqvAQml0oO4uDuJi70dlaoLXjAuUGe2sqi8lg/La6i3yLMngW4qbokK4dpgf1ZuLePddQU0tcndUb3DtTw4LZXpfcNcj0io2A1rnpbbugFU7jDydtl4z/vs+/AIBAKBoHsQYqYT3eoAbLejcKE12FpvpOnXItp2Orpx1Ap8xkXhOzEGpadr3T2SJJGbm8uaNWuorpb9bry9vZkwYQJDhw5FrT7x+Zqb93Ao72mamrYB4O4eQXLSI2c1lftkGGx2FlfU8XZpDSVGeTbGU6lgbkQQN4QE8Nu2cj7IKkTviEjoH+XLg1NTmdw71PWxFW+Q3YRL1suvNT4w5h75n4ff2bwtgUAgEHQDQsx0orvETG1JEStffJYxs6+n95h0l0SNuUxP04+FmArklmWllxrt5Fh8Rke4FI8AYLfb2bNnD2vXrqWxsREAf39/Jk6cyMCBA1GeYFySJFFd/QP5+QsxmnQA+PkOISX1Cfx8B7l0/a5gtUt8X9PIm6XV7NbLxcBK4NIQf+aHBLB5ZyWLcgppNcuzOIOi/XhgWioTU0NcEzWSBIdXy6KmYpe8zTMAxj0gxyRovM7ujQkEAoHgrCHETCe6S8z89MaL7F+3BoCQ2HjGzb2RxKEjnH7YSpKEMbeBph8LsVbLLc2qQA/8LorDc0AIChdrRqxWK9u3b2fdunW0tMi1MSEhIUyePJnevXufcFw2m5GSkvcpKn4bu10WFeHhV5KU+FC319PAyTugxvh7Mz8ogNx9NXyyvpg2x9LU4Bh/HpiawoSuiJoDK2HNv6H2kLzNJwzSH4JhfwK1i+7EAoFAIOh2hJjpRLdlMxnb2P7jSras/AZzmyxGIlP7kHbdjcT0HeD0eSSbhGFbFU2/FWPXy0svblE+cudTkr/r4zKb2bx5M9nZ2RiNcidVZGRku5vwiTCZqjh8+H/t0QhKpQdxsXcQF3c7KtW5mb040NLGm6XVLO8UbJni5c784AAqD9TzxaZijBY5zLLLosZmhT1fyQndjSXyNr9YmPgoDJwLKheN/AQCgUDQbQgx04nuLgBua9GzZeU37PjpO6xmR6vxoKGkzb2RsMRkp89jN9toyS5Hn1mGZJJnIjx6BeB3cQJu4a6HK7a1tbF+/Xo2btyIxSIX1iYkJDB58mRiYmJOeExz824O5f2HpqatALi7h5OU+FfCw6/sNn+aY9EZzbxXVsOnujpaHEncoRo1cwP8aTvcxNebS44SNfdPSWFiLxdFzRE34XX/g5ZKeVtQMkz8m4hIEAgEgvMEIWY6ca66mVrq69i4bAl71vyC3eHamzpqHGOvvYGgqBOLhxNhazHTvLqE1k2VYHd0Pg0JxXd6PGp/15dDWlpayMrKYuvWrUe5CU+ePJmwsLDj9pckieqan+R6GmMZAFrtAFJS/k6A/wiXr99Vmq02PtPV8V5ZDRUmWYx5KpVc5a9FXdjCym1l7aJmULQf901Jcb1Q2NIGW96HrBehTY6BILQfTP479LpERCQIBAJBDyLETCfOdWt2Y1UlG77+nP3ZGSBJKBRK+k6YzNhrrsc35ORRBMdirW2j6ZeOeATUCnzGRuE7MRqll+uJ0Y2NjWRmZrJz5852N+EBAwYwadIkAgMDj9vfZjNRWvYRRUVvtvvThITMIDnpEby84ly+flcx2+2sqG7k7dJq9rXIy2ZKYIqPNwFlbfy2XddeU9M/ypcFk1OY1ifMNZ8ak94RkfBaR0RC5FBZ1CRNEaJGIBAIegAhZjrRUz4ztSVF5Hz1GflbNgKgVKkZNO1iRl01B2//k0cRHIu5VE/jj4WYC+XOJ4WHGt9JMfiMjUDh5mKuEbKb8Nq1a9m/f788LqWSoUOHMn78+BO+P2ZzLQUFL1OuWwLYUSjciIm+kfj4e3BzO3ctzpIkkd3QwpulRxcLD9G4E11pImdXJQZH91PvcC0LJqe4br5nqJcFzaa3wSLXQRE7Ro5IiE87m7cjEAgEgtMgxEwneto0ryI/l+zFn1KyZycAand3hl58BSMun4WHj3MuwO2dTz8VYq1ydD75afCdFofX0DCXO58AdDoda9asIT8/Xx6XWs3IkSMZN24c3t7H1+i0tOSSl/8s9fVZjv39SUxYQFTU9SiVJzbq6y4OtLTxTmkNy6oaMDt+fWOVKlKrLezYW02ro+YoOdSHeyclc9nACNSuZD+11Mi5T1veB5tcB0XiRJj0D4g5d0ttAoFA8EfmghEzzz77LMuWLePgwYN4enoyduxYFi5cSK9evdr3uemmm/j444+POm7UqFFs3LjRqWv0tJg5QsneXWR/+QkV+bkAuHt5M+KKWQy5+HI0Hs458Ep2CcOOapp/LcbWJD9k1WFe+F0Uj0efwC6Z3hUVFbF69WpKS0sB0Gg0jB07ltGjR+Phcbw7cV1dJnn5z9LamgeAp2c8ycmPEBI8vdtN946lymThw/JaPi6vpdEqCxg/SUG/Wit5+2vRG2XzvbggL+6emMRVQ6LRuOLj06yDdc/D9k/ALp+LlItg0uMQOfgs341AIBAIOnPBiJkZM2Ywd+5cRowYgdVq5e9//zt79uxh//797bMDN910E1VVVSxatKj9OI1Gc8I6jxPRrQ7AkuTSA1ySJA5v3UTOkk+pLZXDH738/Bl15WwGTr0Y9UmiCI47j8VOywYdzWtLkdrkh6wmzhe/i+Nxj3d96UeSJPLy8lizZg2VlXJ3j5eXF2lpaYwYMQI3t6NrdOx2K7qKrygoeBmLpQ4Af/+RpCT/DV/fc59Y3WqzsaSinvfKaihsc7S3WyX61dvQ5dbTbJALiCP9PLhzQhLXjojBw5UluoYiyHwedn3ZEWbZ+zJZ1IT1O8t3IxAIBAK4gMTMsdTU1BAaGkpmZibjx48HZDHT2NjIt99+69Q5TCYTJpOp/XVzczMxMTFnXcw017bx87t7SZudQmSKv0vH2u02ctdnsf6rz2msqgBAGxTCmGuuo9+EKShVzj1o7W1W9Jml6LN1YJU7ezz6BOI3Ix63MNfbue12O/v372ft2rXU1ckiRavVMmHCBIYMGYLqmHFZrXqKi9+lpPQD7Hb5PQ8Lu4KkxL/i6Rnt8vXPFJsk8VttM2+XVrOxqdUxSDvJdVaa8xppbpVFTbCPhlvTErlhdCxaDxeKqesOQ8ZzsEfOtwIF9LtKbukOST3r9yMQCAR/ZC5YMZOfn09KSgp79uyhf//+gCxmvv32WzQaDf7+/kyYMIH//Oc/hIaeuDPoySef5Kmnnjpu+9kWM799uI9Dm6sA6JseydirknB3scvIZrWyL2MVG775kpZ6WTwEREQydvY8erkQkWBrMsnt3Fsq25+xXkNC8Z0WhzrA9SBLm83Grl27yMjIoLlZ7u4JCAhg0qRJ9O/f/7iIBKNRx+GCF6isXAFIKBQaYmL+RHzc3bi59czS3o5mA++WVrOyphGbBNgkwqpNUKinyWFO6Ouh5qZxCdw8Np4AbxfqfqoPysZ7+7+VXyuUMGA2THgUgk5sTCgQCAQC17ggxYwkScycOZOGhgaysrLaty9ZsgQfHx/i4uIoLCzkiSeewGq1sm3bNtzdj/ddOVczM8ZWCxuWH2Z/tpxt5OWrIf3aVJKGumjgBljMJnb9+iObv/2aNr0sHroSkWCpNtD8SxFt+2RhhEqBz5hItJNiUHm73s5ttVrZunUrWVlZtLbKMx2hoaFMnjyZXr16HTcuvX4fefnP0tCwAZCLhBMS7iU6at45LxI+QrnRzAdltXxWUUuz1Q52CW21Ea+iVpocdUeebiquGxnL7eMTiPBzIUG8cg+sfRZyf5BfK1Qw6DoY/xAEJnTD3QgEAsEfhwtSzNxzzz388MMPZGdnEx198iWKiooK4uLiWLx4MVdfffVpz9vdBcDlhxrI+DyXRkeXUfzAYMbPTUUb6PqMiLnNwLYfV7D1u+XtEQkRKb1Im/snYvs7X4tiLtXT9FNHkKXCXYU2PQqf9CiU7q5b9ptMJjZt2kROTk67UIyKimLKlCkkJiYeta8kSdTVZZB/eGFHkbBHLElJDxEaesk5LxI+QovVxuLKet4rraHYaAZJwq3aSECJgeZ62b/GTaXgqiFR3DUhicQQ5zrNACjfLi8/5f0iv1aqYfD1MP5h8I/thrsRCASC3z8XnJhZsGAB3377LevWrSMh4fTfaFNSUrjtttt49NFHT7vvuehmslpsbPupmO0/F2O3S7i5qxh9ZSL9J0S75nPioE3fzJbvlh0VkRDbfxBpc28kIqXXaY6WkSQJU14jTT8XYtHJsypKbze0k2PwGeV6OjfIEQk5OTls2rTpqIiEKVOmHCdA7XYrFRVLKSh8GbO5BgBf30EkJ//tnDoJH4tNkvi1tol3SmvkuhpJQllnIqDEQGuNHLapUMCMfuHcNSGJQTH+zp+8bCusfUZO6gZQusGQG+SZGr9zX0MkEAgEFzIXjJiRJIkFCxawfPlyMjIySElJOe0xdXV1REVF8e6773LjjTeedv9z2ZpdV95CxucHqSyQl4pC432ZdENvgqNd+JbfiZaGejYt/4rdq37GbpO7lpKGj2LcnBsIiXNuGUOyS7TtraX512KstfLDWuXvLnvUDAntkkeNXq8nKyuLbdu2nTYiwWptpaT0A0pK3sNmk2ebgoOnkpz0MN7ezmdXdQe79AbeK63h22o53FLRaEJbbMBcaWjfZ1xyEHdNSCItOdj5WaWSjbKoKcyUX6s0MPRGSPsL+EV1w50IBALB748LRszcfffdfPHFF6xYseIobxk/Pz88PT1paWnhySefZNasWURERFBUVMTjjz9OSUkJBw4cQKvVnvYa59pnRrJL7MsqZ8Pyw5iNNpRKBYOnxTLi0njUGtcdewGaqqvYsPRL9q9bgyTZQaGg15h0xs6eR2Ckcw9HyWandWsVzatLsDfLBbDqUC/8psfh0S+oS8s/jY2NZGRksGvXrqMiEiZOnEhQUNBR+5pMNRQWvoKu4iskyQYoiYycQ2LC/bi7Ox/z0B1Umix8VF7LJ7pa6i02FC0WPIpaQGfgyF9H/yhf7hyfxMX9w5034CvKkQuFixw1YCp3GPYnSHsQfCO752YEAoHgd8IFI2ZO9gBdtGgRN910E21tbVx55ZXs2LGDxsZGIiIimDRpEk8//fRJk5+PpadM81oaTGR9dYiCHY4llhBPJl7fi5g+zvnjnIi68lLWf/0FhzbID0eFUkm/CVMZc81cfIOdEwSSxUbL+gqaMzo8atyifWTjvRTnYxY6c2xEgkKhaI9I8PM72vemtfUwhw8/T03tbwAolZ7Ext5CXOztqNWnF6fdicFm55uqet4rreWQwQhtVtRFLWjKDdht8p9JTKAnt6cnMntYDJ7OitPCLFnUFOfIr1XuMOwmh6iJ6J6bEQgEggucC0bMnAt62gG4YGcN6xYforVRrn3pNSqccdck46ntendPdVEBOUs+pWD7FgBUajUDp13MqCudz32yt1nRryujJbscyZE+7Z7kh+9F8bjHdu19qqioYM2aNeTlyYW/KpWKESNGkJ6eflxEQmPjVvLyn6O5eQcAbm6BJMTf0yPxCMciSRLrGlp4t7SG1fXNYLahKm3FvaQVu1l+rwK9NcwfHceNY+II8nEizVySoHCdLGpK5G4vVO4w/GYY94AQNQKBQHAMQsx0oqfFDIC5zcrGlQXsySgDCTy83Rg7K5neY8LPqLtHd+gA2Ys/pXTfbsCR+zTjcoZfMQtPH+dmOWx6M/q1pbRsqgDH7INH3yD8psfhFu668R5ASUkJq1evprhYdjnWaDSMHj2aMWPG4OnZ0fosSRI1Nb9yuOB5DIZCQO58Skz6C2Ghl6JQuF6kfLbJNxj5oKyWJZX1GMxWVOUGNMUtSAa5VshdreSaYdHcnp5IfLAT75ckybU0a5+FUkckh9oDht0MaQ+ANrz7bkYgEAguIISY6UR3iRlLVRUVf3uc0EcexqN3b6eOqSxsIuOzXOrKWwCI6uXPxOt74x/mdUZjKd6zk5zFnx6V+zT8sqsYeskVaDydO7e1wUjzqhIM26vajfc8B4XgNzUOdbAL3isOJEni8OHDrF69mooK2eXYw8ODcePGMWrUKDSdohvsdgu6iq8pLHy1vfNJq+1HctKjBAaOc/na3UGTxcoXFfV8UF5DWZsZZZURdaEeZbPc1aVQwPS+YdwxPpFhcU4sJUoSFGTILd1HiZqbxEyNQCAQIMTMUXSXmNE9+hhNK1aASkXgDTcQvGABKp/TfzO32ezsWlXKlu8LsVrsqNRKhl0cx9CL4lB1oV36CJIkcXjbZjn3qaQIAE+tLyOvnM2g6ZfgpnFiKQSH8d5vxbTtqZU3KMF7eDjaybGo/Z07x7HjOnDgAGvXrqWmRhYq3t7ejB8/nmHDhqFWd/je2GwGSko+oLjkfWw2WfAFBqSRlPwwvtr+Ll+7O7DaJX6pa+L9sho2NLSgaDCjLtKjqukwahwa68/t6YlM7xeO6nTdYicSNe01NQ+IQmGBQPCHRYiZTnTfzEw1Vc89i/6nnwFQh4UR9vjjaKdPc2rpqKmmjcwvcyndXw9AQLgXE2/oTWSy/xmNS7Lbyd2QxfqvP6ehQnYn9gkMYvTV19J/0jRUauecgM3lLTT/WoQxt0HeoFbgMyoC7cQYVF2o97Hb7ezevZuMjAwaGxsBuWtt4sSJDBw48KjcJ7O5jqKiNykr/xxJkmc+wkIvIzHxQby84l2+dnexV2/gg/JallU1YG42oypqQV1hALmshthAL24ZF8/s4TF4n86s8IioyVx4dE3N0BvlQmHR0i0QCP5gCDHTie6umWnJyqLyX09jKS0FwHvCeML/8Q80TnRbSZJE3pYqsr/Oo00vP7T7jotgzNXJeHQhfqAzdpuNfZmr2bD0S/R18oyIX2gYY665nj7pE1EqnevEMRU10fRLMeZCh5uwmxKfcVFox0ehdDGLCuSIhB07dpCZmUlLizz7EhQUxKRJk+jbt+9RuU9tbaUUFLxEZdUK+doKNZGR15IQvwB39xCXr91d1JqtfK6r4yNdLRXNRtQlrahKW1E4Cqu1HmquHxXLTWPjTx+X0F4o/ByUrJe3qTQwZL4savyd6+ITCASCCx0hZjpxLgqA7UYjde++S+1774PFgsLdneC77iTw1ltRak4/i2FstbBhWT77c+TaEk+tG2mzU0gZEXbG9v9Wi4Xdq35m0/IlGJoaAQiMimHcnHmkjBzrVJilJEmY8htp+rUYS6keAIWHCm16ND5pkV2KSDCbzWzZsoXs7Gza2mQzv/DwcCZPnkxKSspR963X7+fw4eepq18HONq5Y24mLu6OHm/n7ozFLvFjbSMflNWyuV6PSteGqqgFpUFugVcrFVwyIIJb0xJO7ywsSbI/TcZzHS3dSjcYMk823wuI696bEQgEgh5GiJlOnMtuJlNBIZVP/wvDBrn2QRMXR9j/PYHPOOeKWHV5jWR8fpAGhwNtTJ8AJlzfC7+QMysQBrAYjez45Xu2rFiKsVWeEQmNT2Lc3BtIGDzcKdEkSRLGA/U0/1qExTFGpZca7cQYvEdHoOyCKaDRaGTjxo2sX78es1k284uOjmbKlCnHRVs0NGwk//DzNDfvBOQgy/j4u4iOmo9K5XoWVneyS2/gg7Iavq1swFotixpVg7n9/4fFBXBrWgLT+4ad3oSvKFtefiqUxRxKNQyaC+l/hcDEUx8rEAgEFyhCzHTinDsASxLNP/5I1XPPYauRi2i1F88g7LHHcDvG6v9E2Cx2tv9azLafirFZ7ajclAy/JJ4h02LPqED4CCZDK1u//5ZtP3yLxSjPiET26kvatTcQ08+5MEvJLtG2p4bm30raIxKUWjd8J8XiPTK8S7lPBoOB7OxsNm/ejNUqz2QkJiYyefLko3KfJEmipvZXDh9+EYMhHwB393ASEu4jInwWSqXrs0TdSY3Zwue6Oj7W1VFZ04q6uAVlRRsKx19dlL8nfxobx7XDY/E73bJd8QZZ1BSslV8rVDBwjixqgk8fBSIQCAQXEkLMdKKnfGZsej01r75Gw+efg92O0suL4HvvJXD+DSjcTl9r0lhlIPPLXMoOygW4ARHeTJzX64wLhI9gaG5i84ql7PrlB6wWecYgdsBg0q6d73yYpU3CsKOa5tXF2Brkbh6VnzvayTF4Dw9D4aztfyf0ej3r1q1j27Zt2O1yzcmJcp8kyUZF5XIKCl7GZJKX57y8EkhM/AuhITPOC4+azljsEj/VNvFhWQ0bq5uPq6vxdFMxa1gUN41NIDn0NFlepVtg3X8h71f5tUIJ/a6WAy1D+3TznQgEAsG5QYiZTvS0aZ5x/34qn/oXbbt2AeCekkzYE0/gPXLkaY+VJIlDm6vIWXr2C4SP0FJfx8ZlS9iz5tf2MMvEYSMZN+cGQuOdW8KQrHLuk35NCTZH7pMq0APfybFymKXK9bqfhoYGMjMzj8p96t+/P5MmTToq98lmM1Gu+4KiojexWOTOMK22H0mJfyUwcPwZ1xx1B3v1Bj4sr2WZrh5LeSuq4haULdb2/5+QGsJNY+OZkBpy6tT18u2w7nnI/bFjW58rYPzDEOHcLJtAIBCcrwgx04meFjMgt0s3LV9O9f9ewNYgz7T4Xn45oQ8/hFvo6TOVTlQgPG5WMqmjzsxBuDNN1ZVsWLq4I8wS5DDLOfMIjIw+zdEyksVOy6YK9Bml2Ftk8aUO9sR3aiyeA0O6lNB9otynIUOGMH78ePz9/dv3s1r1lJQuoqTkg3aPGn//USQl/RV/v2EuX/dc0OAw4ltUVoNO1yKLmhojR96l+CAv/jQ2nmuGRaP1OIV4rdgF6/4HB1Z2bEu9WBY10efnvQsEAsHpEGKmE90lZhqMDTyz6RnuG3ofMVrn2mVtjY1Uv/QyjV99BZKE0tub4AX3EjhvnlNLT7r8RjI+z6WhohWAqF4BTLy+1xk7CHfmuDBLhZK+EyYzZtZ1+IWevuYHwG620bqhAn1mKfYjnTyhXrKo6R/cJVFzotyn4cOHk56ejo9Px7KM2VxPcfHblJV/it0uzxIFBU0iKfGvaLXn5xKMTZJYVdfMB2U1ZJU3oippRVXeisIq/2l6aVTMHhbN/DHxp16CqtoPWf+DvcuQbZyBpMmyqIkb2/03IhAIBGcRIWY60V1i5v9y/o/l+cvxUHlw75B7mddnHmoni0/b9uyl8umnMe6WM5XcU1IIe+IfTi092ax2dq4qYcsPRdgsdpRqBcMuimPojDjUbq53E52MY8MslSo1A6ZcxOir5uATGHSao2XsJistOTr068qRjI6E7nBvfKfF4tE3qEuzSiUlJaxZs4aioiL5fG5ujBo1inHjxh2V+2Q06igsep2KiqVIkpyjJBvvPYCXV8KJTn1ekNdq5KPyWhaX1WIsbUFV0oqytWMJKj0lmBvHxDO5d+jJ3YVr8yDrRdi9BBz3TlyaXFOTOFHOXhAIBILzHCFmOtFdYqa4uZinNjzFlkr5Yd83qC9PjnmSPkHOffuX7HYav/mGmhdexOZwxPW99FJCH3nYqa6nppo21i3OpWSfXCfiH+bFhOtSie7tRC6QC+gOHSRnyaeU7JVrftRuGgbPuIwRV8zCy9fPqXPY26zos8vlhG6T/HB1i/TGd2ocHn0CXRY1kiRRUFDAmjVrKC8vB8Dd3Z2xY8cyevRo3N07YhcMhkIKCl6mqvp7ABQKFRHhs0hIWICHx/kbFdBitfF1VQMflFZTUNYsi5rqjiWoKH9Pbhgdx7UjYgj0PomXUUMRZL8EOz4Hu8Vx4HB5pib1IiFqBALBeY0QM53ozpoZSZJYnr+c/239H3qzHpVCxY39buTPg/6Mp9q5cEZrQwM1r7xC4xJ56Unh5UXI3X8m8MYbUZzGcE+SJPK3VZP9VR4GR+Ft6qgwxs1KwcvX9ciBU1GydzfZSz6h4tBBADSengy95EqGX3Yl7l7OpWvbDRb0WeW05OiQzA5RE+0ji5peAV0SNbm5uaxZs4bq6moAvLy8SEtLY8SIEbh1WrrT6/dzuOBF6urktmaFQkNU1HXEx9+NuybYpeueSyRJIqexhUXltfxcUofiyBKURf6z1aiVXD4wkhvHxJ3ciK+pHHJege0fg9UobwsbAOl/gb4zwUk3aIFAIDiXCDHTiXNRAFzbVsuzm57l12K5VTbaJ5onxjzB2Ejn6xTa9u2j6ul/07ZzJwCahATCHn8cn/S00x5rarOyaUUBezLLQAJ3LzWjr0yiX1pkl+pTToYkSRTu3ErO4s+oLjoMgIe3D8OvmMXQGZfj5uGccZ2t1ULLujJa1uuQHK3JmhgtvlNjcU91XdTY7Xb27dvH2rVrqa8/0tGkZfz48QwZMuSoMMvGpm0cPvwCjY2bANlNOCbmJuJib8fNzbmZpp5CZzTzia6OT0traCzVy7M1jtRugIHRftwwOo4rBkXicaIlx5Zq2PAGbHkfzHKRNEEpckzCwDmgOjsdcgKBQHA2EGKmE+eym2lNyRr+s+k/VBvkWYLLEi/j4REPE+jh3NKPZLfTtHKl3PVUKxvu+UyZQthjjzqV9VRV1EzG5wepLZUfVGEJvkyc14vg6LNr+S9JEnmb17P+q8+pKysBwMvPn1FXzmbg1ItROxHhAGBrMaNfV0brhooOUROrxXdqHO4p/i6LGpvNxq5du8jMzKSpSc6S8vf3bw+zPJL7JEkSDQ3rOVzwAs3NjuUztZbYmFuJibkZtfo0Pi89jMlu54eaJj4srWFbaSPqkhaUlR1GfL6ebswZFs280XEkBJ9g1sxQD5vfhY1vgbFR3uYXC+PugyE3gJtzs4oCgUDQnQgx04lz3ZrdamnltR2v8cWBL5CQ8HP346/D/sqVyVc6/XC26fXUvvEm9Z99BlYrCo2GwFtvIfiOO1B6nvpBY7fZ2ZNZzqaVBViMNhRKBQMnRzPysgQ0HmfXHddut3EwZx3rv/6cpqpKAHyCghlz9Vz6TZyKSu3c9Wx6M/rMMlo2VoDVIWrifOWZmmTXRY3VamXbtm1kZWW1h1kGBwczadIk+vTpc5Soqa1dTUHBi7S05gLg5hZAXNydREfdgEp1/j/U9+oNfFRex9KSWiylLajKWlG22dr/Py05mBtGxzKlTxhux5oYmvSw5QN5tqZVFuB4h8LYe2H4LeB+/uReCQSCPx5CzHSip3xm9tTs4akNT5HbID8kh4UN4/9G/x+J/s5n6Zjy86n8z3/as57UERGEPfwQ2osvPu0DvqXBRPbXhzi8XU7M9glwJ21OComDQ866kZzNamVfxio2LFtMS508o+QXFs7Ya66nd9oEpxO6bXoz+oxSWjZVnhVRYzab2bx5Mzk5OUeFWU6aNInU1NT280mSnarqHygsfAWDoVC+riaU+Pi7iYqcg1LpftJrnC80Wax8VdnAorIaikqbUZW2oKwxtRcMh/m6c+2IWOaOiCHS/xiRZmmDHZ/JdTVNcvo7Hv4w6k4YdRd4nd2icoFAIHAGIWY60ZOmeRa7hc/2f8Zbu96izdqGWqnmlv63cPuA2/FQO1dfIkkS+t9+o/q5hVh0OgC8hg8n7B9/x6N379MeX7y3jnWLc2mulQs/4/oHMX5uKr7BZ3/WwWo2s3vVT2z69usuJ3QD2JrN6DPPnqg5WZjl5MmTSUzsEJd2u5XKyuUUFr2G0Sh3SXm4RxKfcC8R4VejVJ7/NSV2SSK7QS4Y/qW0DmVpK6pyAwqz/D4qFTC5dyjXj4plQuox7d1WM+z5Wu6AqpP9fHDzhuE3w5h7wPf87f4SCAS/P4SY6cT54ACsa9HxzKZnyCzLBCBGG8PfR/2dcVHOpWkD2I1G6j74gLr33kcyGkGpxH/ObELuvx91QMApj7WYbWz7qYgdv5Zgt0mo3ZQMO4vhlcddz2hk+8/fsXXlN0cndF97AwlDnEvohlOImimxXaqpMRgM5OTksGnTpvYwy/j4eKZMmUJMp5oku92MTvc1RUVvYDJXAeDpGUtC/H2Eh1+BQnFhdP+UG818pqvj0/Ja6kv1qMpaUdV3JHdH+nswd0Qsc4bHEO7XSVzbbXDgO8h6ASplLyRUGhh0HYy7H4KSzvGdCASCPyJCzHSi28SMoR4ynpU7QZz4xipJEqtLVvPs5mfbC4Snx03nkRGPEObtnLMugEWno+r559H/9DMASl9fQu69l4Dr5p7WRbi+opV1X+ZSfqgRgIBwL8Zf14voXqcWQ13F2NrCth9WHJXQHZHSi3HXziduwGCnz3NCUXMGhcJ6vZ6srCy2bduGzSbXl6SkpDB58mQiIiI6rmszUl7+BUXFb7XnPnl5JZOYcB+hoRefd2GWJ8Nst/NjTRMf62rZWNYoi5pyQ7vDsEqpkGdrRsYyPjWkY7ZGkiB/NWS/CMU58jaFEvpeKf/ei/wngUDQjQgx04luEzO//gPWvwZqTxh9F4x7ADz9T3tYi7mFN3a+wRcHv8Au2fF28+bewfcyt/dcpx2EAVo3b6bqmWcxHXT4viQlEfbYY6dt5T5ReGV3edMcwdDcxNbvlrHj5++xmuV07Zh+Axl37XyiejkfMXBCUROjRTsltks+NY2Njaxbt44dO3a0h1n26dOHSZMmEdopM8tqbaWs7FOKS97FapW7pHx8epOYcD/BwdPOyzDLk3GwtY2Py+v4qryONl0r6rJWlA2dZmv8PJg9PIY5I2KI6lxbU7JRdhXO+6VjW/I02atGRCUIBIJuQIiZTnSbmCnZCL/9E0rl4lw8/OUP9pF3ONXaerD+IE9veJrdtfI0fu/A3vx91N8ZHDrY6SFINhuNS7+h5uWX2wMsfSZOJPSRR3BPPLVlv7HVwqYVBezNKgcJNJ5qRs9MpN/4qFMnNZ8BLQ31bP72a3av+gmbY5knYfAwxl07n7DEZKfPY2t2tHRv6mjpdov2wXdKLB69XXcUrqurIyMjgz179rRvGzhwIBMmTDgqoftEYZZabX8SEx4gKGjiBSVqWqw2vqlq4OPyWg5UOZagdIZ2Mz6FQk7vnjsilil9Qjs6oSr3QPbLsG8ZOAJJiRktz9SkTAcn66IEAoHgdAgx04lurZmRJDj0M6x6CmoOyNu0kTDxMRg8D1SnnmmxS3a+yfuGl7e9TLO5GYCrkq/igWEPOO1NA2BrbpZbuT//HKxWUKsJnDeP4HvuRnWae64qbCbzy1xqSvQAhMZpmXB9L0Ljuq++qLm2mo3LlrB37W9IdvmBmDJyLGNnX09wbLzT57HpHaJmYydRE+kti5ouZD9VVVWxdu1aDjpmu06W0G2xNFJS8j6lZR9jsxkA8PUdQmLC/QQGpl1QokaSJLY2G/iovJbvKhqwVhpkYdNptibYx51rhkVz7YiYDt+a+gLIeRV2fg42x74hfSDtAeg/SxjwCQSCM0aImU6ckwJgu00O9Vv7TEdra1AKTP6HbBd/modbvbGel7e9zPL85QD4any5f+j9zEqZhcoFq3lTQQHVC/9LS6ZcaKwKCCDkvgX4z56N4hSeL3a7xN7McjatOIzZaAMF9B8fxeiZibh7dd9DqaFSx4alX3IgO0MWhgoFvceOZ+zs6wmIiHL6PLYWM/qsclo36JAcXTtuEd5oJ8fi2S/IZRdknU7HmjVryM/PB+SE7mHDhpGeno5W2+G9YjbXUVzyHmVln2K3y91ifn7DSEx4gMDAC2/ppdZsZXFFHZ/o6iitM3TM1jjeU4CRCYHMHRHDxf0j8NSoQF8JG9+ELR+CWRbE+MXAmHth6HzQOBd1IRAIBMcixEwnzmk3k8UIWz+ErP+BoU7eFjkEpvwfJE46rajZWb2Tf2/8d7s3Td+gvjw+6nEGhQxyaRgtWdlUPfcc5sNy5IB7SjKhjz6GT9qpu6dam0zkLM0nb4ujg0frxrhZyaSOCu/W2Ya6shLWf/U5hzbJRaYKpZJ+E6Yw+uq5+IU6Xxxta7XQkl0uxyQ4Ai3VYV74To7Bc0CIy6Lm2IRutVrNyJEjGTduHN7eHQ9pk6mG4pJ3KC//HLtdnqXw9x9FYsIDBAScPgn9fMMuSWTU6/lYV8tv1U1QY0RV3oqqxtS+j9ZdzeWDI7l2eAwDo/1QGJvk3/2Nb0Kr7G2EZ6C87DryDvB2LmldIBAIjtCtYubnn3/Gx8eHtDS50PSNN97gvffeo2/fvrzxxhsEnKZN+FzTI63ZxmbZVXXD6x0ZOPHpMOWfEDPilIda7VaW5C7h9R2v02KRj70y+UoeGPoAQZ7OPxAkq5WGxUuofe01bA5rf+8J4wl79FHcE09t3Fd2sJ7MLw/RWCUvoUSm+DPhul4ERnbvt+yqwsOs/+ozCrbLSeRKlZoBUy5i9FVz8Al0/t7tBouc0r1eh2R0iJoQT7STY/EaGIJC5ZqoOZLQXVZWBoBGo2H06NGMGTMGz06OzCZTFUXFb1FevgRJkkVNQMBYEhPux99/uEvXPF8oM5r5XFfH5xV1VDebUJW3oi43oOjkMtw7XMvs4TFcOTiSIHc77PwC1r8qp3YDuHnBkPmyV01AXM/ciEAguODoVjEzYMAAFi5cyCWXXMKePXsYMWIEf/nLX1izZg19+vRh0aJFZzT4s02P+sy01speHVve76gr6HWJvPwU1u+Uh9a21fLytpdZcXgFAFo3LfcMuYdre13rUteTramJ2jff6qinUakImDuX4HvvOaU/jc1qZ+eqErb+UITVYkepVDBoagzDL4k/67EIx6I7dJCcrz6jZM9OANRuGgZNv4SRM6/By8/f6fPY26y0rNehzy5HapMLjlVBHvhOjMFrSCgKFzx2JEkiLy+PNWvWUFkpRzd4eHgwduxYRo0ahbt7h0uw0aijqOhNdBVLkSS5YywwMJ3EhPvx8xvi9DXPJyx2iZ9qm/i4vJacBj3KerM8W1NlBLv8EeKmUjCldxizh0czITkQde53sgHfEa8ahQr6Xy171YQP6MG7EQgEFwLdKmZ8fHzYu3cv8fHxPPnkk+zdu5elS5eyfft2LrnkkvYP+vOF88E0j8ZSyHxO/sYq2QEFDLgGJv7ttAZkO6t38symZzhQLxcYJ/sn8/ioxxkRfuoZnmMxFxVR9fz/aFm9GgClVkvwXXcRMP8GlKcIhmyubSPrqzyKdjuCLwPcSZudQuKQsx+LcCyl+3aTveQzdLn7AXBz92DIxZcz/PKr8fRxPjfIbrTSsrGClqwy7K0OUePvjnZiNN7Dw10SNXa7nYMHD7J27VpqauTlFC8vL9LS0hgxYgRunbx+2trKKSp+g4qKb5Ak+bpBQRNISLgfP1/Xlg7PJ/JajXyqq2NJZT1NbRZUFQZ5tqZTgneI1p2rh0Qxe1gUyS3bIOdlKMjoOEnyVFnUxKefdvlVIBD8MelWMRMYGEh2djZ9+/YlLS2NG2+8kTvuuIOioiL69u2LwWA4o8Gfbc4LMXOEmkOw9j+w/1v5tUIFQ+bBhEfBL/qkh9nsNr7J+4ZXd7xKk0leMroo/iIeGv4Q4d7hLg2hdeNGqhb+F9MBWRy5RUcT+tBf0V500SnFSdHuWtYtOYS+Ti50je0XSPq1qfiHerl0fVeRJImiXdvJWfIZVQWyxb7G04vhl13F0Etm4u7l/PXtZhutGyvQryvD3iI/eJW+GrTjo/EeGY5S43yxtd1uZ+/evWRkZFBfLxvq+fj4MH78eIYOHYq6U8F1W1sphUVvUFm5DEmSl2eCgiaRmHA/vr4X7gyFwWZnZXUDH5fXsUNvQKG3oCpvRVPRhr1T0fCgGH9mD4tmZmgN2m1vyL//R9q6IwbLoqbPFaft/hMIBH8sulXMXHHFFZjNZsaNG8fTTz9NYWEhUVFR/Prrr9x7770cOnTojAZ/tukuMdNmtvH62jzunJCEr4eLHT8Vu2DNvyHvV/m1SgPDb5V9anxCT3pYk6mJ13e8zleHvsIu2fFQeXDLgFu4qd9NeKqdz1qSbDaavl1BzcsvY3XMLngOGULYo4/gOXjwSY+zmm1s+7mY7b8WY7dKqNRKhlwUy7CL4lC7IAS6giRJHN62mfVLPqWmpAgADx8tI66YxZCLLsPNw7msKwDJYqN1cyX6zDJszfLyn9LHDW16FN6jI1C6u7CMZ7Oxa9cuMjMzaXLUJvn5+TFhwgQGDRqEStXxvhgMxRQVvUFF5XJAfpgHB08hIX7BBS1qAHbrDXxSXsc3VQ20WW0oa4xodAYUNUaOfMJo1Eqm9w1jXi87oyq+QLnzC7DKztD4x8kdUEPmiQ4ogUAAdLOYKSkp4e6776a0tJT77ruPW2+9FYAHH3wQm83Gq6++2vWRdwPdJWae+fEA764rIMzXnX9fOYBpfZ3vummnZCOsfhqKs+XXbl5y58e4+0+ZVJxbn8uzm59lW9U2ACK8I/jL8L9wUdypZ1eOxd7aSt0HH1K3aBGSI1Vae/EMQv/6VzTRJ58paqwysG7JIUr3yzMSvsEepM9JJX5gsNPX7iqS3c6hTTms/+pz6nVyQa6Xnz8jZ85m4LQZuGmcT7iWrHZat1WhzyjF1iB36ig81WjHReIzNhKlC23pVquV7du3k5WVhV4vtygHBAQwceJEBgwYgLKTmZzBUEhh0etUVq6kQ9RMJTHhPrTaU9dSne80W20sraznE10dB1uNYLKhqjDgXWHE3NzhXROqdef6/t7coPqV4H0fQZv8u4RnIIy4Tf478AnpmZsQCATnBaI1uxPdJWY2HK7jb8t2U1QnL6tdOjCCJy/vR4jW+YcpIPurFGTIMzXlW+VtGq3c+THmbvDwO8lhEr8U/8ILW1+gslWuUxoaOpTHRj5GnyDnIwIALFVV1Lz6Kk3LloMkoXBzI2DePILvuhNVJ7O4Y69fsKOG7K/zaHEIgfiBwaTPSemWRO5jsdttHMzOZP3SL2iqku/fJyCQUVddS//J01GfJqeqM5LNjmFnDfq1pVhrZVGncFfhMyYCn7QoVD7OxzxYLBa2bt1KdnY2ra2tAAQHBzNx4kT69u17vKgpfJ3Kqt+fqJEkiS1NrXyiq2NldSNmux2F3oKnrg11ZRtmU0c31LBIDQ+FbmVkxZeomorljSp3GHwdjFkAwc67QwsEgt8P3SpmVCoVFRUVR2XXgGwJHxoa2h7cd77QnTUzRouNl1Yd4v2sQmx2CX8vN/5xaV9mDY1yvThWkuDQL7D237JlPMhCZuwCGHUXuJ+44LXN2sZHez/iw70fYrQZUaDgqpSrWDBkAcGers2UGHNzqV74X1rXrwdA6edH8J13EnDDvJMWCZuNVrb+WMSuVaXY7RIqNyXDZsQxZHosarfuT5e2Wa3sy1zNxm8Wo6+Tl8y0wSGMvnou/SZMQXUKs8BjkewSbXtq0a8twVIpi1SFmxLvkeH4jI9G7ee8UDWbzWzevJmcnBzaHLNeYWFhTJw4kd69ex/1+9Haepiiojccokb+cwwJnkZCwn1otX2dvub5Sp3ZypLKej7V1VLYZga7hLLGSHCNiZYKA3ZHN5RGKfFgdC7XWb7Fv8HRAYVC7gAcuwBiR4tiYYHgD0S3ihmlUkllZeVxYkan05GUlNT+wX2+cC4KgPeWN/HI0t3sr5AjCdJTgvnPlQOIDepCcazdDgdWyoncNbKtPl5B8tLTiNtOWk9Q0VLBS9te4qein+RD1F7cPvB25vedj7vKtdmilqxsqp9/HpOj/sktKoqQBx/E95KLUZwke6de18q6JbmU5zYC4BviyfhrU4nrf27M0qwWC3vW/MKm5V/R2iAvWfiHRTDmmuvonTYBpQtOypJdwniwnuY1JVjKHD5BKgXew8LQTohGHeT8zJPRaGTjxo1s2LABk0mewYqIiGDSpEmkpKQcJ2oKi16nquo7fo+ixi5JZDe08LGulp9rm7BJgNmGttqEX7WJ2pojzQMSEz3yeUT7K331OR0niBoui5o+l4MLP0+BQHBh0i1i5kgtzIMPPsjTTz+Nj49P+//ZbDbWrVtHUVERO3bsOIOhn33OVTeTxWbnvawCXlmVh8lqx8NNyV+mpXLLuATUqi6E79ltsHeZLGrqZSdfvEPkdO7ht4DmxEJpZ/VOFm5eyN66vQBE+UTxwLAHXK6naS8SfuUVrNXVAHj060foww/hPXr0iY+RJPK3VpO9NA9Dk1wfkTAomLTZ52bpCcBiNrHr1x/ZvGIpbc1yQW5gZDRjZl9Pr9FpJxVjJ0KSJEx5jTSvLcFcKAtVFOA1KATtpBjcwpwvVDUYDGzYsIGNGzdiscidVNHR0UyaNInExMRjRE0+hUVvHCVqfi/LT0eoNFn4sqKOz3R1lJvk90PRYiG+3kpbaQuNLfLvT5KinPu9fuUSeyZqhxEh/nEw+m4YcgO4+5zsEgKB4AKnW8RMQoKcwlxcXEx0dPRRXRoajYb4+Hj+9a9/MWrUqDMY+tnnXLdmF9a28viyPWwokOMM+kX6snDWQPpHnbj25bTYrLDnK8hc2OGo6hMmpxQPuxncju/isUt2fij4gZe3v0y1QRYig0MG8/CIhxkYMtCly9vb2qj/+GPq3nsfu6MGxHt8OqF/fQiPXqknPMZstLLl+0J2rynrkaUneQxt7Pj5e7Z+twxji1yQGxwbz9jZ15M8YozLy4Cmoiaa15RiOtTQvs2jXxC+k2LQRDvvedPa2kpOTg6bN2/G6kgOj42NZfLkycTHxx+zb75jpuZ7OouahIQF+Gr7uzT+8xWbJLG6rplPdHWsrmuW71KSCNRbia6zUlrURJvZRjBNzFf/xs1uq/CVHMLSw0/+Gxh1J/hG9uRtCASCbqBbl5kmTZrEsmXLzrvYgpPREz4zkiTx9bYy/vPDAZraLCgVcPO4BP4yLRVvF9p+j8JmgV1fwrrnobFE3qaNkEXN0D+dUNQYLAY+3vcxi/Ytos3RAntJwiXcP/R+In1c+/C31tdT++ZbNCxeLDsJKxT4zZxJyH0LcIs88bnqdC1kLT5E+aFGQF56Sp+TQvyA7u96OoLJYGD7jyvY+v1yzG3yMkZofBJj58wjcegIl0WNuUyPfm0pbfvq2re5p/jLoibBz+nz6fV6srOz2bp1a3udWUJCApMnTyYmJuaofTtmar7n99bS3ZmSNhNfVNTzeUUdNWZZ6ClsdgYYFLjp2jhQ3IBGMjFLlcVt6h9JUMiF35JSjaL/LHm2JnJwD96BQCA4m1ww3UzPPvssy5Yt4+DBg3h6ejJ27FgWLlxIr1692veRJImnnnqKd999l4aGBkaNGsUbb7xBv37OTbf3pGlejd7Ev77fz3e7dABE+Xvy9JX9mNy7C23cR7CaYefnckzCkYRubQSk/QWG3nhCUVPVWsVrO15j5eGVSEholBpu6HsDtw24Da3G+VkFAHNxMdUvvYz+558BUGg0BNxwA8F33H7CzqcTLT2dy66nIxhbWtj6/XK2/7QSi1EWduHJqYybPY+4QUNdFjWWqlb0GWUYdlUf0Rdo4nzRTorBo1eA0+dramoiKyuL7du3Y7fLJ0pOTmbSpElERR2dHN5RKPwdRy4qm+/dh6+vazNu5zNmu51fapv5uLyW7MaW9u0RkoIBLVBd1EyurpEpyh3crv6BUcqD7ftIcWkoxt4LKReBC0uKAoHg/KNbxYzNZuOjjz5i9erVVFdXt38AH2HNmjVOn2vGjBnMnTuXESNGYLVa+fvf/86ePXvYv39/eyrxwoUL+c9//sNHH31Eamoq//73v1m3bh25ublotad/EJ8PDsAZudX849u9lDXID9FLB0Twf5f3JczXeaO347CaZFGz7gVolv1WOmZqbgS344XCgboD/G/r/9hcuRkAf3d/7hp0F3NS5+Cmcs34r233bqqf/x+GLY5QSK2WoNtvJ3D+DSg9j7/2iZaehl4Ux9Dpsd1uuNcZQ3MTW79bxo5fvsfqKMiN7NWXcXPmEdvf9YgBa10b+nVltG6tQq5oBbcIb7STYvDsH+x0UndDQwPr1q1j586dHPmTTE1NZdKkSURERBy1b2trAUXFbxzlUxMUNIGE+Pvw8xvs8j2czxw2OKITKuppsDpCQxWQ5uZBaK2ZbQdqCWzax63qH7lMuRG1Qn4/TL4JaMbdjUKY8AkEFyzdKmbuvfdePvroIy699FIiIiKO+wb60ksvuT5iBzU1NYSGhpKZmcn48eORJInIyEgeeOABHn30UQBMJhNhYWEsXLiQO++887Tn7DYHYJudT3S13BgZjKcTBb4Gs5VXVuXxfrbcxq11V/PwjF7MGxWHyskH3gk5kajxCZe7n4bffJyokSSJrPIsXtj6AgVNBQDEamN5YNgDTI2d6lqRsCTRmpVF9f9eaO98UoeGEnzPPfjPuhrFCdqij+t6CvYgbXYK8QODuz3rqTOtjQ1sWbmUXb/+hNUizxjF9B3A2DnziO7jej2KrdmEPruc1o0VSA4rf3WwJ9oJ0S6FWtbX15OZmcnu3bvbRU2fPn2YOHEiYWFHz+jJ5ntvUFm5giOiRg60vA8/v6Eu38P5jNFm5/uaRj7R1bG5qbV9e5yHG5MVHpjKWti7dx9XW3/ketVqfBXykqJRrcU86EZ8x999ysgQgUBw/tGtYiY4OJhPPvmESy655IwGeSLy8/NJSUlhz5499O/fn4KCApKSkti+fTtDhnSkDc+cORN/f38+/vjj485hMpnaW2BBfjNiYmLOuph5qaiShYWVxHho+GdSJJeGOFcvsU/XxOPL97KrtBGAQdF+/OeqAV0vED7CEVGT9WLH8pN3KIy7z9H9dPS3U6vdyrK8Zbyx8w3qjXIr88CQgfx12F8ZGubag1Cy2Wj+/ntqXnkVi05eUtPExxPywANoL5p+3PsiSRL526rJWZpPa6P8s4rrH0Ta7BT8w7o36+lYWurr2PTt1+xZ/TO2IwW5AwYzdvY8onq5Zj4IYGu10LpBhz5H15HU7afBJ921/Kfa2loyMzPZs2dP+7Z+/foxYcKE42wRDIYiiorepLLq2/bsp8CANBISFuDvP9zlezjfOdDSxqe6Or6urEdvk0WcRqFgRqCWAUYlBbllBBz6mvmKn0hQVgFgQ0lJ+HQCp9yPX8rYnhy+QCBwkm4VM5GRkWRkZJCaeuJOlq4iSRIzZ86koaGBrKwsANavX8+4ceMoLy8nslOR6R133EFxcTG//PLLced58skneeqpp47bfrbFzPfVjfxffjk6R1vpOH8f/p0SRR+f09eB2OwSX2wq5r8/56I3WVEq4KaxCfxleio+XS0QPoLVDLu+kGtqjhQKewXJ/hwjbjvOfK/V0spH+z7i430ftxcJT4qZxAPDHiDRL9GlS9vNZhoXL6b2rbexNchdPx79+xP6lwfxHnv8A8RstLLtpyJ2rirFbpNQqhUMmRrLsIvjcXM/tz4izbU1bP72K/as+Q27TRYh8YOGMnb2PCJSep3m6OOxm6y0bqpEn1WOXe/If/JS4zMuCp8xEU5HJVRXV5ORkcH+/fvbtw0YMIAJEyYQHHx0IbXBUExx8dtUVC5rT+kOCBhDQvx9BASMdPkezndabTZWVMmzNTv1HQG3KV7uzA0JQFttoHbLSsbULGGMsuP9y9f0oWHgbfSdPA9vr3NXtyUQCFyjW8XMCy+8QEFBAa+//vpZXRa45557+OGHH8jOzibakQt0RMzodLqj6gZuv/12SktL+dlRhNqZczUzA/KH6evF1bxZWo3JLqEE/hQVzMMJ4QS6nV6UVDcb+df3+/l+dwUAYb7u/PPyflzcP/zM39sj3U9ZL3S0dHsGyB0fo+48LiahxlDDm7veZFneMuySHaVCyVXJV/HnQX8mzNu1gmVbSyv1ixbJmU+OFHWv0aMJ/cuDeA48vlC1scpA1pJDlDiynnwC3Bl3TQpJQ0PO6dITQFN1FZuWL2FvxiokRz1Y4tARjJ09j7BE12312/Of1pVhcySOKzQqvEeHo02LQuXrnKFhZWUlGRkZHDwoF7sqFIp2URMUdLQxYVtbKUXFb1FR8U27qPH3H0VCwgIC/Eef8/f0XLBLb+DTI0GXjp+bp1LBzNAALvP1oXnXJnx3vU+6MQN3hfyeVEhBbAm5Gr9xtzFmQCoaJ5cCBQLBuaFbxcxVV13F2rVrCQwMpF+/frgdk4GzbNkylwe8YMECvv32W9atW9fuZwN0aZnpWM5FAXBJm4mnDuv4oUY2afNXq3goIZw/RQbj5kQ9zLpDNTyxYi/FjpynCakh/GtmP+KCzkLhos0Ke5fKLd11+fI2dz8YdQeM+jN4H/0gLGgs4OXtL7O2dK28q8qdeX3mcUv/W/Bzd20pzFpXR+0779D45WIkh1GcdtpUQu67D/eUlKP2lSSJwl21ZH+Vh75efuhH9Qpg/LWpBEae+wLOxsoKNi5bwv51a5Ak+eGYNHwUY665nrCEJJfPJ9kk2vbWoF9bhqXSUfNxxFV4fDRqJzu7dDodGRkZ7en0CoWCQYMGMX78eAIDjw4nbWsrp7jkbXS6r5Ek+f338xtOQsICAgPG/S5FTbPVxjdVDXxSXsuBVmP79v4+nsyPDGKksZGGjHfoXbqEQOS/1zZJww+KdMpS/8To0WmMjA9EeSZ1bAKB4KzQrWLm5ptvPuX/L1q0yOlzSZLEggULWL58ORkZGaSc4AEXGRnJgw8+yCOPPALImTehoaE9XgB8IrIb9PxfXjn7HR+iKV7u/Cs5iklBp7+u0WLjzYzDvJ1xGLPNjkat5J6Jydw5IRGPs2E0Z7fBvuWw7n9Qc0De5uYNI26Rw/y0R8++7KjewUvbXmJHtezo7Kvx5dYBt3Jd7+vwVLs2NW8pL6fm9TdoWrFCjmtQKPC74nKC770XzTGeKlazje2/FLP91xJsFjtKpYIBk6IZcVkC7p5nuATXBRoqytn4zWIOZGe2i5rkEaMZc831hMa7tgwH8u+0MbcBfUYp5qIOV2HPAcFoJ8SgiXLO0ba8vJyMjAzy8vIAOWbkiKg51gPKaNRRVPwOOt1XSA4XXT/fIbKoCRz/uxQ1kiSxrdnAx7paVlY3YnLkP3mrlMwKC2B+iDd+O5fjtuVtItoOtR+XY+vHt+6XEzD4Mq4YEku/SN/f5fsjEFwIXDA+M3fffTdffPEFK1asOMpbxs/PD09He+/ChQt59tlnWbRoESkpKTzzzDNkZGSct63ZNknic10dzxVWUG+RizGnBfnyz+RIkr1O34pdUNPCEyv2kpMvm7LFB3nx1Mz+TEgNOTsDtNsh9wd5pqZil7xN7QFD5svFwv6x7btKkkRmWSavbH+F/EZ5VifEM4S7Bt3FVSlX4aZ0rZ3blJ9Pzauvof/1V8d11fhfM4vgP/8Zt2M6dZpr28j+Oo/CXbUAePpqGHtVEr1GhTvd7nw2qdeVsWHplxxcv04OBQVSRo5lzOzrCYmN79I5TUVN6DPKMB6sb9/mnhqA78Ropw34ysrKWLt2LYcPy5EXSqWSIUOGkJ6ejv8xvj9GUyUlxe9RrvsSu11eivXVDiQhYQFBQZN+tw/tBouVryvr+URXR76hYwl6iNaLGyMDmdl2EEPGawSW/orS0RVWag/hY9t0NvtfwuQhqVwxKJLEEBGdIBCcS7pdzFitVjIyMjh8+DDXX389Wq0WnU6Hr6/vUZlNp+NkH56LFi3ipptuAjpM8955552jTPP693eufbanfGaaLFZeLKrig/IarJLsjXFLVAh/iQ/D/zT1NJIk8d3uCv79/X6q9fKH78X9w3nisr5E+p+lgkVJgvxVkPlfKJN9Z1CqYeC1sldNcMcsmc1u44fCH3hjxxvoWuVupVhtLPcOuZeL4i9CqXCt1qBtz15qXnmF1uxsABTu7gRcdx1Bd9yO+pilkpJ9dWR9lUdjlbwEF5bgy/i5qYTG9YxnUF1ZCRuWfknuxux2UZM6ahxjrrmO4C6KGnNFK/qMUtp21xxJLUATq0U7IQaPPoFOibeSkhIyMjIoKJDb7ZVKJUOHDiU9PR0/v6OXB02mGkpK3qOs/AvsdrnoW+vTj/iEewgJnobCxZ/nhYIkSaxvbOFTXR0/1DRhcfz8fNVKZocFcrOPgfi9nyFt+Qg3i7wEZZDc+dY2jo9sF6GJ7MfMQVFcNiiCCD9ROCwQdDfdKmaKi4uZMWMGJSUlmEwmDh06RGJiIg888ABGo5G33377jAZ/tulp07x8g5Gn8nX8VicvKQSoVTycEM6NkcGoT/OQ0hstvLwqj4/WF2GzS3hpVCyYnMKtaQlnr1hRkqAoSy4ULshwbFRA3ytkV+FO9vBmm5mvD33Nu7vfbW/nTg1IZcGQBUyInuDyN3vDli1Uv/wKbdu2yVf18iLwxvkE3XILqk4/K5vVzq41pWz9oQiLySYPb2wEo69MwlOrOZO77zK1JUVs+GYxhzbKggyFgtTRaYyZNZfgmLgundNa14Y+q5zWrZVglf8s1aGeaMfH4DU4xCmvmuLiYjIyMigsLARApVIxdOhQ0tLSjhM1ZnMtJSUfUlb+KTabLBZ9vHsRH38PoaEzUCh+v8nUNWYLSyrq+VRXR7HR3L59lJ83N4V4cVnVbyg3vY3qyJIssMHWl49s01ktDWNYfAhXDI7kkv4RBHj3zO+gQPB7p1vFzJVXXolWq+WDDz4gKCiIXbt2kZiYSGZmJrfddlv7Gv75Qk+LmSNk1Dfzz3wduZ3qaf6ZHMWUQO1pRcCBimae+HYvW4vldufEEG+euqIf6SlnaenpCGVbZVGT+2PHtqQpkP5XiBsLjnEaLAY+3f8pH+37iBaLbDc/MHggC4YuYHTEiRO1T4YkSbRmZ1Pz8isY9+0DQOnrS9DNNxEw/0ZUPh3Fv62NJtYvy+fQZtk7ROOpZuTlCQyYEIWyK8nkZ4GakiI2Lv2SQ5ty5A0KBb1GpzHmmusIio499cEnwaY305Kjo2WDDskkL1W2e9WMCEfpRNt6UVERGRkZFBUVycerVAwbNoy0tLTj/g7M5npKSxdRWvYJNpv88/TySiIh/h5CQy9FqTz3tUrnCrskkdXQwsfltfxS13TExJkAtYo54QHcYcslatdHSAd/QOHw8CmXgvjcOpXFtkk0K/0YnxrCFYMimdY3rOvZawKB4Di63TQvJyeHXr16odVq28VMUVERffv2xWAwnP4k55DuEjN2u5WqqhWEhc10+sPeapf4tKKO5zvV00wI0PJkcuRp/WkkSWL5jnKe+fEAtS3yN8lLBoTz90v7EnW2lp6OULUPsl+Wu6AcRa/EjJKXnzpl3jSZmli0dxGfH/gco00WaSPCR3Dv4HtdN96TJPSrVlH76quY8uT6HJW/P0G330bA9dcfFZGgy28ka8khakvlB29gpDfp16YS3avnwk9rigvZ8M2X5G1aL29wiJrRZzBTYzdaad1UgT67HLte7kZSeKrxGRuJz9hIVN6nr1kqLCwkIyOD4uJi4NSixmJporTsY0pLF2G1yjOJnp5xxMfdTXj4TJQu1khdaFSaLHxZUcdnujrKHf5RIHtI3eFrYmrB16h2fAIGuZ7NgpqVttF8ap3OTikJDzcVU/qEccWgSCb2CsFd/fud2RIIzgXdKmYCAwPJzs6mb9++R4mZ7OxsZs2aRVVV1RkN/mzTXWKmpORD8vL/g49PX3r3esol+/gmi5WXi6t4v6wWiyT708yLDOKRhHBCNKd+YDS1WXjpt0N8sqEIuwSebirumZTEbelnqeupM/WFsP5V2PE52ByFkyF9IO0B6D8LHHlOtW21vLf7Pb4+9DUWu8NEMHIc9w65l/7BrkUDSDYbzT/9TO3rr2M+MqsQHEzwHbfjP2cOSg+5iNpul9ifrWPTigKMrfI1k4aGMHZWMr5BPVfPUF1UwMZvFpO3uUPUnOnyk2Sx07qjipZ15Vhr5RoXhZsSr+FhaNOjUQeeurBckqR2UVNSIhspnkrUWK16yso+paT0QywWh/mhRzRxcXcSGTELpdI5b5wLFZsksaaumU90dayuaz6SI0qwm5p5od7c3pRF8I5FoNvefkyuMon3TVNYaRuLCQ1aDzUX9w/nikFRjEkKOrPIEoHgD0q3iplrr70WPz8/3n33XbRaLbt37yYkJISZM2cSGxvrUmv2uaC7xExFxTccyvsPVqtcKBgZMYekpIfRaAJPc2QHRW0mnu7kT+OtUnJfbBh3xIScNu9pv66ZJ1fuY3ORXLsSF+TFPy/ve2aJ3CdDXwkb34ItH4BZL2/zi4Ex98LQ+e1RCRUtFby7512+zfsWq8OsbWL0RO4efDd9glyLBpCsVpq++57aN97AUiZnTqlDQgi68078Z1+D0l1+oBpbLWxeWcDedeVIEj0WYHksJxQ1o8bJoqaLhcKSXaJtXy36zDIsZY40aSV4DgyR27ojTu3H47qoaaVc9wUlJe9jNstdZe7u4cTF3k5k5FxUqjMISr1AKDOa+aKiji909VSaO2ZrJgRoWaAuZeyhL1DuWw42eba0TaVlmTSJd9smUiyFAxDs485lAyO4fFAkQ2P9f7ddYwLB2aZbxYxOp2PSpEmoVCry8vIYPnw4eXl5BAcHs27duuNyY3qa7qyZMZvryD/8XyoqlgKgVvuTnPQQkZFzXCqe3NjYwpP5unZL9ih3N/6WGMHVYQEoT/HBJ0kSK3fpeObHA1Q1yzMnk3uH8sRlfUkI7gajubZG2PqhLGxaq+VtngEw8g4YeWe7AV+pvpS3d73N9wXfY3csU02Omczdg++mV6Br0QCSxULjsuXUvvM2Vp3slKwOCyP4rjvxmzULpUYuvqwtayFrySF0eY0AaAM9GDsruUdchDtz3PITcvfT6Guu63JLtyRJmA43oc8sxeS4X5DburUTonFPPHVbt6uixmYzotMtprjkPUymSgA0mmBiY28jKvJ61Orffyq11S7xW10Tn+jqyKjXH2k6I1Sj5tYABTdW/UjAzk+gqaT9mEM+I3mzdSLftQ3Ahvx5EB3gyeWDIpk5OJLe4T1XwycQXAh0e2t2W1sbX375Jdu3b8dutzN06FDmzZvX7g1zPnEuCoAbG7eSe+iftLTIVvNa7QB69XoKP99BTp/DLkksr2rgmYKK9vX6gVpP/pkUybiAU/vptJisvLYmjw+zC7HYJNxUCm5NS+TeyclnnvV0IixGOf8p51VokLtmUHvCkBtgzD0QKLs4FzYV8s7ud/ix4Eckx8f/tLhp3DnwTpdFjd1spmnZMmrffgdrpfxAVUdEEHznHfhdfTVKjaY9wHL9N/m0NMjiLqqXP+lzUgly0oyuu6gpLmTjN4s7CoWRfWpGz5rbJfO9I5jLW9BnltK2p7a9rdst2gfthBg8+wWdsq37ZKLmZN1PdrsJXcU3FBe/jdFYLl/LLYCYmJuJib4Rtfr0vk+/B4rbTHyuq+PLynpqzPIMpAKYFODFX827GXJoMcr8VRz5gRg9w1njfQnPVY+kxNzxGZQa5sMVgyK5YlAUsUHnNmBVILgQuGBM884F56qbyW63Ulb+KQUFLzs6QhRERswmKekhNJqg0x5/hDabnffKani1uIoWRyLw9CBf/pEUSar3qaf1D9e08K/v9pN5qAaAUK07j13cmysHR3WPPbvdBge+g5yXQSc7BaNQQt+ZMPY+iJLriA43HubtXW/zS9Ev7aJmauxU7hp0V5dETeNXX1P37rtYq+XZIVnU3In/1Veh0GiwmG1s/7mYHb/JLsIKBfQfH8XIKxLxcKJotjupKSnqEDWOP73kEaMZffXcLmU/HaGjrbsKrPLvjTrYE5/0KLyHhqFwO/mypeuixkJl5QqKit+krU0uLFartURH/4nYmJtwc+u5QuxzicUu8XNtE5/qalnX0NK+PVzjxl0+rczTrUS7+3Nok5eCJaWayvDJLLZP5e3SaByNagAMjvHnikGRXDYoglDt73/5TiBwhm4XM+Xl5eTk5FBdXY3dbj/q/+677z5XT9etnOvWbJOphsOH/0tFpZxRpVb7kZj4IFGR17nU4lpjtvBiURWf6GqxSaBSwLyIIB6KDyfU/eQPZEmSWHOwmn99v78962lIrD//vLwfg2P8z+jeTnFRKFwnFwvnr+rYHp8ui5rkqaBUkteQxzu73+HXol/bRc2U2CncNeguegf2dumSdpOJxq+XHi9q7ri9ffmpubaN9d/kc3iHLO7cvdWMujyRfumRPdbKfYTa0mI2LltC7oasdlGTOGwkY2ZdR3hSymmOPjm2FjMt63W0bKhAapNnDZQ+bviMi8Rn1KnTuo+ImszMzKO6n4YMGUJaWtpxjsJ2u5Xq6h8oLHoTg8HRgabyIipqHrExt+LufpatA85jCg0mPquoY3FFPXUWx/sOXOTvzoOGjQw4uBhF6cb2/W0BCewNu4q3m0bzS5EVR9oCSgWMSQpi5qAoLuofjp/n77uDTCA4Fd0qZhYtWsRdd92FRqMhKCjoqLV5hULR7kB6vtBTPjPy0tNTtLTsB8DHpzepKf9HQMAol86TbzDy78M6fq6VW2W9VErujgnlzzEheJ+i9dNktfFBdiGvr8nHYJa/Al4zLJpHLupFqG83fvOr3AvrX5Pbuu3yhzohveXlpwFzwM2D/IZ83tn9zlEzNROjJ3LnoDtd7n6ym0wdMzU1smhRh4cTdPtt+F8jFwqX5TaQteQQ9To54DEw0pv0OSlE93a+WLu7qCsrZdPyJRzMWdee/ZQweBijZ80lMtW1ounO2E02WrdU0pJdjq1RXnJTaFR4jwzHJy0Ktf+pO5KOiJojPjVHYhLS0tKOy36SJDs1Nb9SWPRG+++7UulOZOQc4mLvwMMjssv3caFhstv5qaaJT3V15DR2zNZEuLuxwKOGOWUr8Nn7dUchvUqDMfkSMnwu5d2SSLaXNrUfo1EpmdhLNueb0jsMzx4saBcIeoJuFTMxMTHcdddd/O1vf0OpPP9tz3vSNE+SbJSXf8nhghfbu57CQi8jOflRlz/gNza28K/DOrY3y7MtIRo1D8eHc31E0CmdhKuajSz8+SDLtss1Dt4aFfdOTuHmcfFnv5W7M01lcqHwto87Pri9Q+Vi4RG3glcghxsPt4uaI4XC46LGcdfAuxgcOtily7WLmvfe65ipCQsj6NZb8Z8zG9w07MvSsem7AkytsshKHBLCuFnJ+DqZWN2d1OvK2bR8CQeyM5Acs52xAwYz5uq5RPd1TeB1RrLZadvt6IA6ktatVOA1KATthGjcwk9dvHus+Z5SqWTw4MGkpaUdl9ItSRJ1dRkUFr1Bc7O87KhQuBERfhVxcXfi5RXf5fu4EDlsMPKZro4llfXtvlJK4GI/NQ/qs+mXuxjFkeVZgKBkGvvM4xtbOl/tbyO3St/+X94aFdP7hXPFoEjSUoJx6+GZRYHgXNCtYiYoKIjNmzeTlJR0RoM8V5wPDsAWSwOHC16kvPxLQEKp9CQ+7k5iY293qb1VkiS+q2nimQIdRW1yK2iylzuPJ0ZwcfCpO1h2lDTw5Hf72VXaCEBMoCd/v6QPF/UL795uH2MTbP9EFjbNsqBC7QmDr4fRd0NwMoVNhby/531+KPgBm8NldWT4SO4YeAcjw0e6ND67yUTj0qXUvfd+e6GwKjiYoFtuIWDutZglNzZ/Vyi3ctslVGolg6fGMHRGHBqPnndvbaysYNO3X7N/3WrsNvm9iO7Tn9FXzyV2wKAu/6wkScKU1yh3QB3u+PbvbAdUcXExmZmZ7TOvCoWCQYMGkZ6eTlDQ0TVhkiTR0LCBoqI3aGg8srSiJCzsMuLj/oyPT2qX7uFC5WSzNeEaNx7QVHBN+Qp89i8D85F2ezfoczklCbNZXBPPyt2VlDW0tR8X4OXGJQMimDk4iuFxAd1TDycQnAd0q5h55JFHCAwM5LHHHjujQZ4rus8B2E5eXh6pqalOP2D0+n3kHvoXTU1bAfDwiCI5+W+Ehsxw6SFlttv5RFfHi0WV7d/4Rvh680RSBCP9T961Y7dLfLuznIU/H2xv5R6VEMgTl/Wlf5TfSY87K9gssG+5vARVuduxUQG9LpaXoOLGUaov4/2977Myf2W7T83AkIHcMeAOxkePd03UmM00LVtO3bvvYtHJ4ZiqgAACb76ZgOuvo7EJsr/Oo+ygbArn5adhzFVJ9BrZM6ncx9JUXcWWlUvZs+Y37Db5vYhI6cXoWXNJGDz8jASouUyPfl3Z0R1QUT5ox0fj2T8Yherk5y4pKSEzM7M9pVuhUDBgwADS09MJCTm+RqaxaRtFRW9SV5fRvi0keBrx8Xfj6zuwy/dwoXKi2RoFcLFWyYMtOfQ7tARl59magHikIfPZG3oZ3xyy8f1uXbsDOECknweXD4rkisGR9I3wFR42gt8V3SpmbDYbl112GW1tbQwYMAA3t6ML1F588UXXR9yNdJeY2bp1K99//z2xsbHMmDGDyEjnlo0kSaKq+nvy859r9+zw9x9FasoTaLWu1UjorTbeKKnmndJq2hwVhBcF+/K3xAh6e5986cRgtvJ2xmHeWVeAySp3+8weFs1D07u5ngYcwZbZsOENOPRTx/bwgbKo6Xc1FcY6Fu1bxLK8ZZgczsO9Anpx64BbmR43HZXS+eUxyWKhaeVKat9+B0tpKSBnPwXOn0/ADfMoKbaSszSP5lo5jiE03pf0OSmEJ3azuHMSfV0tW1Z+w57Vv2C1yA+xsMRkRl01h+Tho1GcwVKvta4NfXY5hq1VSBZ5aUsV6IF2XCReI8JRnqJGo6ysjMzMzKOy2Pr37096ejphYccbNzbr91JU9BY1Nb9wREEFBqYTH3c3AQEju3wPFypHZms+09WR3Wm2Jkyj5n5NFbN1K9HuXwYmuVYOhQpSL8I2+AbWK4eyYnc1v+ytRG+yth+bHOrDTIewiQv6/Xv/CH7/dKuYefrpp/nnP/9Jr169CAsLO64AeM2aNV0bdTfRXWJm48aNrFq1CqtV/jAZPHgwU6ZMQat1zmvDZmujuPhdikvewW43AQoiI+eQmPgX3DXBLo2l0mThhaJKvqiowybJ6/JzwgN5OCGcKI+TJ/qWN7bx3E8H+W6XPHPhpVFx98RuikY4EbV5sPFN2PklWB3T6D7hMPI2GHYLtUqJT/Z9wpLcJRiscq1QrDaWm/vfzBVJV6BROZ9WLFmtNH3/PXXvvIvZkSit9PIiYN71+M2bz75dbWz90ZHKDaSOCmPMlcn4BJwf1v2tjQ1s/X45u379EYtJFl5B0bGMuvpaeo1JQ+mCwDsWW6uF1g1ysKXdUU+k9FLjPToCnzGRqE6RTK7T6cjMzCQ3N7d9W58+fRg/fjwRERHH30drPkXFb1FV9R2SY0nRz2848fF/JijQ9eT13wMFBlP7bM2RTiiA6Vo1Dxo2Mijva5SdOqHwCYfB12EacD1ra3xZuaucVQeqMVs7OksHxfgzU7R6Cy5wulXMBAQE8NJLL3HTTTedyRjPGd1ZM9PU1MSqVavYs2cPABqNhvT0dEaPHn3cjNXJaGsrJ//wQqqrfwBApfIhIf5uYmJucjkDJ6/VyHOFFe3xCO5KBTdHBXNfXBiBbievB9lW3MDT3+9np6OeJtLPg0cv7s3lAyPPzXq8oR62LYLN74FedvlF7QED58CoP9PkH8UXB7/g8wOf02SS7y3UM5T5fedzTeo1+GicN8STbDb0v/1G7VtvY3I8gBXu7vjPno3nnPls3djKwQ0VIIFaI0cjDJ4Wi9t50kliaG5ix08r2f7Td5jbZIEXEBHJiJnX0Dd9Eip111t57WYbhu1V6LPKsdXJggm1Au+hYfikR+EWcnJjt8rKStatW8f+/fvbt6WmpjJ+/Hiio6OP27+trZTiknfR6ZYiSfKMk9anH3HxfyY0ZLpLDtq/F8x2O7/UNvOZro7Mho7i3yA3Nfd4NnB95Q/47/saDLUdB8WNgyE30Jx4Cb/mtbBiZzk5+bVHtXqPTQrmisGRXNRPtHoLLiy6VcyEh4eTlZVFSkrXvTDOJeeiALi0tJSff/6Z8nK5wNXf35+pU6fSr18/p79pNjZu5VDev9HrZWHk6RFLUvIjLtfTAGxrauXfBTo2NMrdK1qVkrtjQ7kj+uTt3EeiERb+dBBdk/wgGxTtx98v7cvIhHPUwmw1w/5v5dmaznUDCRNg9J8xxKexNH85H+//mGqD3LGk1WiZ22su1/e5nmBP52e0JEmiZe1aat9+B+NuRw2Pmxt+V1yOdPmNbMpqocJRKOsT4M7Yq5NJHh563swcGFtb2PnLD2z7cQVGvbwUoQ0OYcTlV9N/8nTcNF2fUZIzoOpoWVeGudTxUFWAR58gtOOj0MSdvDajurqadevWsW/fPo58tCQlJTF+/Hji4o4P2jSZqigp+YBy3ZfYbLI48/JKIC72LsLDr0CpdH727fdEcZuJLyvq+bKijipzx2xNuq+GB007GVXwDarDazpS7TVa6H8VDL6BGv9B/LCngpW7dGwvaWw/VqNSMql3CDMHRzG5d+i5mX0VCM6AbhUzzz77LBUVFbz66qtnNMhzxblzALazZ88eVq1ahV4vPwBiYmKYMWMGUVFRTp1DkuxUVn5L/uHnMZvlh7Wf3zBSUv7uUjSCfC6J1fV6ni3Qsa9FFifBbmoejA9jfmQQmpPUWhgtsj/Nm2vzaXX401zUL4zHLu7TPXlPJx48lG6SO6AOrOz4wA6Ih5F3YB4wmx8qcvhw74cUNRcB4K5yZ2bSTP7U70/E+sa6cCkJw4YN1L79DobNm+WNSiU+06ejnzSfLZvaaKmX63bCE/1Im51CWML5k6ljNrax+7ef2Pr9clobjxQz+zPs0isZNO0S3L26bpMvSRLmomb068owHqhv366J1eKTHn3KuITa2lqysrLYvXt3u6iJi4tjwoQJJCQkHCeGLJYGSks/prTsk3YbA3f3COJibyMy8lpUqp5vn+8JrHaJVXXNfFZRx5pOCd5+ahW3+Bi5uW4VofsWQ0NRx0FBKXK34KC5lFj8+W63jm93lJNX3VGb4+Ou5qJ+4cwcHMnYpCDUotVbcB7SrWLmqquuYs2aNQQFBdGvX7/jllOWLVvm+oi7kXPdmm02m1m/fj05OTlYLI6MpYEDmTJlynG28CfDam2lpOR9ikvexW6XhUhY2BUkJT6Ep6dzwugIdkliRXUjzxVUUGyUp/NjPDQ8nBDOrLAAVCf5hl2jN/HSqkMs3lyCXQI3lYJ5o+K4b0oKgd7n8NtyY4m8/LT9EzA2ytvcvGHwddhH3MbaNh0f7P2APbXyjJYCBVPjpnJTv5sYGOJat4xh+w7q3nmHlszM9m0e4ydSMeIG9uyxYDXLj5Jeo8IZfWXSeVNPA2A1m9mbsYotK5fSXCMLYXdvb4bMuJwhMy7Hy/fMCpot1QZasspp3V4FNvkjQxXogTY9Cq9hYSctFq6vrycnJ4cdO3a0u4VHR0czfvx4UlJSjhM1VmsL5bovKSn5ALNZNkF0cwskJuYmoqPm4+Z2/gjJc43OaGZxZT1fVNRRZuxI8B7i48EDisNMLvkOtwMrwCLPcKFQQuIkGHw9Uq9LOFhnZcVOHd/t0lHe2NHqHeyj4bKBcvjl4BiR6i04f+hWMXPzzTef8v8XLVrkyum6nZ7ymWlqamL16tXsdixhqNVqxo4dy7hx43B3d+4haDRWUFDwYns0glKpISb6ZuLj/+xyqJ/ZbueLinpeLKqk2jFtnerlwWOJ4af0qMmr0vPMjwdYmys/WLQeau6ZlMxNY7vZdO9YzK2w+yvY9A7UHOjYnjgRacQdbPULYtH+T8gqz2r/r6GhQ7mp301MiJmAUuH8N09jbi51775H808/geMBrBiWRtGA6zhcJO9zPtbTANisVg7mZLL526+p15UBoHZ3Z+CUGQy/7Cq0Qa4Vlx93fr2Zlg06WjdWYDd0KhYeFYHP2JMXCzc1NZGTk8P27dvbi+bDw8NJT0+nT58+xxlw2mwmKiq/obj4XYxGuQtNpfIhKuo6YmNuwd099Izu40LGLkmsa9Dzma6OX2qbsTg+wj2VSmYHqLlLv56E3KUoSjZ0HOTuJy9DDboee9QItpc2smKnjh/2VFDf2tHqHRvoxczBsrBJDv1jBIcKzl9E0GQneto0r7y8nF9++aU9wM/Hx4fJkyczePBgpx2Um/V7yct7hsbGTYCcVJwQv4CoqOtRKl0r6DPY7HxQVsMbJdU0WuVlpMFaLx5LDGdCgPakoiYnv5b//HCA/RVyfUaUvycPXZTKzEHdFGJ5MiQJCjNh07uQ+yPtRin+cTDiNvITx/HR4eX8UPgDVkecQrxvPPP7zueKpCvwUDvf2WEuLqbugw9pWr4cyTHL1tY3jfxec6hpkAWMT4A7o69MInVE2HnhT3MEyW4nf8tGNn37FVUFcm6SUqWm7/jJjLhiFoGRrs3wHYvdbMOwzVEsXO8oFlYp8BoSijY9CrewEy9J6vV6NmzYwJYtW9pnLoODg0lPT6d///6oVEcLQzn/6UeKi9+mpVUu2FYqNUSEzyI29rY/nKvwsdSarSytrOfzijryDKb27cle7tzl3cJVuh/x3vsVNJd1HBSYBIOug4FzsPjGkJ1Xy4qd5fy6v6o9+gSgb4QvMwdHcvmgSCL9/5jLfIKepdvFjNVqJSMjg8OHD3P99dej1WrR6XT4+vri4+N8Z8m5oKfFDMi1BwcOHOC3336joUGuawgLC2P69OlOOylLkkRt3Rry8xdiMMiGZZ6e8SQnPUxIyEUuTw03Way8VVrDu2U1GBzp3KP9vPlbYgSjTmK8Z7dLLN9Rzv9+zaXCUSTcL9KXxy7uTXpKD4QKNhTDlvePXoJSe8CAa6gaMIvPG3ayNHcpeotcwxTgHsDc3nOZ02uOS8XClupqGj75hIYvF2NvbUUC6lInczhhJq0muUssNN6XtGuSiUj2P7v3eIZIkkTx7h1sWv4VZQf2yhsVClJHjmXklbPPKKkbOhULZ5VhLunowPHoFYBPejTuSSee9TMYDGzatIlNmzZhNMq/S/7+/qSlpTF48GDU6qO77+SohLUUFb9FU9N2x1YloaEziIu7E19t1yMffg9IksTWZgOf6epYWd1Im2NGUa2A6YFa7rbnMrRgBcoD34GltePAuDQYdC30nYlB6c2qA9Ws3FlORm4NVnvHo2FkQiBXDo7ikgHh+Hv9MYuyBeeebhUzxcXFzJgxg5KSEkwmE4cOHSIxMZEHHngAo9HI22+/fUaDP9t0l5iRJAlzYTPuLpirWa1WNm/eTGZmJiaT/C0qOTmZ6dOnExrq3LS53W5FV/EVBQUvY7HUAeDrO4Tk5EcJ8B/h8n3UmC28WlzFx+V1mB2/CpMCtTyWGMEg7YmLR40WGx/mFPLW2sPtpl3pKcE8dnFv+kX2gNmc2QB7voYt70Hlno7t0SNoHXojy9ysfJa7BF2r7KfjpnTjssTLmN93PikBznfl2ZqbaVi8hPqPP8ZWV4dN6UZ58sUURU/FapdnFJKHhTLmqqTzIu/pWMpzD7B5xdcUbNvcvi1u4BBGXDGL2P5dj0o4gqnYUSy8v67DWTjCG5/x0XgNDEZxgiJTo9HIli1b2LBhAwaDXOuh1WoZO3Ysw4YNQ6M5/sHZ2LiVouK3qatb274tMCCNuLg7CAgY+4ev+dBbbayobuSLirr2LDeQDfnmBblzU/N6Qg98IyfdH/lBqT2g1yUw8FpInkKDUeLHvRWs2Kljc2FH8bebSsGE1BCuGBzF1D6heGl6PgJE8PulW8XMlVdeiVar5YMPPiAoKIhdu3aRmJhIZmYmt91221GOoOcD3SVmWrdV0fD1ITwHBuM/MxmVt/PLPQaDgczMTLZs2YLdbkehUDB06FAmTpzotOme1driKBJ+H7tdLuYLDp5KUtJD+Hi73jZfbjTzUlEVX1bWHanv5JJgPx5OCKePz4kfzPWtZl5bk8dnG4ux2CQUCrhycBR/mZZKTGDXu2i6jCRB6WbY/C7sXwF2R5GkVxDWITewKiKVT4t/Ynft7vZDRkeMZn7f+aRFpTldV2M3mWha/i11iz7EUlyCSeNLYdJMdGGjAAUqtZJBU2IYNiMOjef592FfU1LElhVLObh+XXuoZVhiCiOvvIbkEaPPyIAPwFLbRkt2OYZtnZyFfTX4jIvEe2QEyhO8J2azme3bt5OTk9PeDejp6cno0aMZOXIknp7H/w7qWw5SXPwO1dU/tBvwabX9iYu9g9DQGX9Ir5pjOdDSxuKKer6u6ohPAHkW9hatkRm6X9HsWQy1hzoO8gqC/rNkYRM1DF2T8f/Z++/wuO7zzB/+TO+9AINeiQ6CvYoSKYnqlCW523HsJI53f9l1drOb3exmnU2ySa7dTWIn2byxk9hJ7MSxLcnqlaQosXewggUgesf03ue8fxxgBkOCEhskSOZ9Xec6gzNnzjkzOOX+Ps/93A+vnJngldMT+TQziCab21tLeLKr/G7zy7tYFCwqmbHb7Rw8eJCmpiYMBkOezAwNDdHa2pofXS0VLBaZCe8dJfj2EORAalBgeWYZmuab82Pxer3s2rWLS5cuAaBQKNi0aRMbN25ccES6EJLJGQYH/4qJyWdnb+hSXK5nqKv9TdTqax1YPwiDsSR/PjTFz6f9CIh9Y3Y4zfznmlIadQvrTUa8Mf7v25d47axoeKeUSfmlDdX8xtaGD7fyaT7C03DqR3DiHwsNLpFA43ZON9/PP4cvs3vknXy37mpjNV9s/iJPNjyJTnFjJeiiAd9uvN//Ponz5wnryrnS8Ax+SxMAGoOCtU/U0brJhXQJ3uiDM9OceO1Fzu/ZmW+VYHGVsfrxp2ndsg35DZ6D10M2miZ6dJLIoQlyEZFYSpQydGtK0G8qR2699nzKZDKcOXOGAwcO5FOySqWSNWvWsGHDhgXT2PH4GCOj32di4rl89Z9GU0VV1ddxlT59U81cP6lI5XLs9IT4yaSPd32FEm+dTMoOh4lflY7TNvAykvM/h6i78EFrHXR8VjSwtNXTNx3mlTMTvHx6ghFf4V5v0Sp4rFNsfrmq6m7zy7u4M1hUMmO1Wjlw4ACtra1FZObAgQM888wzTE9P39bB32kspmYmNRrG9+xlMm4xMqJdXYL58TqkN9l9eXh4mJ07d+ZN9/R6PVu3bqWrq+saQeT1EI320z/wZ7jdOwGQSlVUVHyFmup/g0JhvqnjAbgcTfBng1O86g6I2wOeLrHwn2pKqdUuXI11dizA/37zEof6xfSXQSXn39xXz9c21Xx04ehsBnrfErU1A4W0BKYqxjuf4ScaKS8MvZXX1egVep5qfIovNH2BSmPlDe1CEARix47j/YcfENm7D6+tnSv1TxPTij2KrC4tmz7dSFWb7QO29NEgFgxw6q1XOf326ySioheJ1mRm5SM7WL79UdS629PBCZkcsdMzhPePk5meKxsGTbsd/eZyVNXXXpfZbJaenh4OHDjAzIxYai6Xy1mxYgUbN27EYrFc85lUysvY2D8zOvbPZDIBYLasu+KXqaj48i1dB59ETCZTPDfl5yeTXgbjhUqmeo2Kz5cY+VL8LNaLP4dLrxfKvAHKVkLHZ6D9aQR9CadGA7xyeuKa5pflZo3Y/HJ5GS2u6xcV3MVdfBAWlcx87nOfw2Qy8Xd/93cYDAbOnj2Lw+HgySefpKqq6heuNFtIZwm+PUzk4DgIIDOrsHxmGep6881tRxDo6elh9+7dBAIBABwOBw8++OCCfhzXQzB4iiv9/5dAQNRFyOVGqqt+ncrKX0Ymu/nUT08kzp8OTvKWRwwvyyRi36f/UF1CteZaUiMIAvv7PPzvNy/lQ9IOg4pv3t/I59dUfrShaM8VsW3CqX8pCIalcmJNj/BK+TJ+7D7GUGgYEP1qtlRs4YvNX2RD2YYb/v0Tvb34/uEf8b/xJuOO9QzWPEpGIZKBymYzmz6zDFv50hLJzyEVj3Fuz05OvP4SEa9oma9Qa+i8/yFWPvokRvvtibwFQSDZFyC8f4xkXyC/XDThK0fTem3H7rnu9Pv27cuT/blO3Zs3b15Qa5bNxpiYeI6R0R+QSIifkcm0uFyfoaryV9Borm2v8IsIQRA4Gozyk0kfr7oD+UIAKXCv1cCX7Cq2uw+gPP8c9L8Ls6k8JFKo3SISm5YnyCgMHB7w8tKpCd7umSIyr/llo1PPk11l7FheTpXtI0g938XHGotKZiYmJti6dSsymYy+vj5Wr15NX18fdrudffv23bCQ9cPCh1XNlOgP4H++l6xfFPbqNrgwPVL7vp2HF0Imk+H48ePs3bs3X+VRXV3N9u3bb8JJWMDrfY/+/j/Nl7MqlXZqav4d5WWfuyWL+NOhGH82NMVur0hQ5BL4XKmV36wuoWoBUpPLCbx6doI/23mZUZ8Yuaq2aflP25t4vMP10Yah03FRU3P8BzBWEMPmrLUcbH6AfxUCHJg6ml9ea6rl802fZ0f9jhvuA5Wensb/L//CzHOvMGDbzFj5vQhSORIEmlbbWP+ZFnSmpWO6Nx/ZTIbLh/Zx/JWf4xkVyZ1UJqNp4xbWPPE0jura295Heioqduw+NVMw4bOo0G8qR7e65JropiAIDA0NsX//fgYGBvLLm5qa2Lx5M5WV10bR8mXdI39PJCL2jJJIZDgdj1BV/fVf+Aqo+YhmsrziDvCzSR9HgoVqJ5NcxqecZr5szNE+8haSc88XXTPIlNC4XdTYLHuYhETFu5dmePn0BHsuFze/XFElNr98rLMMh2Fpnvt3sbSw6KXZ8Xicn/zkJ3R3d5PL5Vi5ciVf+tKXFhTpfdT4MEuzc8kMwTcGiR6dAkBmU2P9zDJUNTdf4ROPxzlw4ABHjhwhmxVHRG1tbWzbtg2b7cbSFYKQZXr6NfoHvpM3HlOrK6ir/U1KS5+8JYHkyWCUPx2c4r3ZRnhyCXzBZeOb1SVULtChO5XJ8ZNjI/y/PX35UHSry8hvP9TEfU2Ojz4EPXVejNac+RmkZkuLZUqGmh7kpxYbL7mPE50tZdXKtTxR/wRfaP4C9eYbK6nPRqIEf/48o//6Kpf1G3A7VgAgl2RYvtHGqs91LSnTvfkQBIGh0yc5/uoLjPYURNPVnStY88QzVHXcfgXUQiZ8EpUM3ZpS9BvLFtTVjI+Pc+DAAS5eLJgn1tTUsHnzZurr6685JkEQ8PkPMjL89/j8B/LLLeb1VFX9GjbbvUhuwlTxk47BWJKfTfl4dsrHRLLgNNyoVfHZUiufUwVx9r4iVhC6LxU+qNBB86MisanfRigj5a3zU7x6ZuKa5pebGuw8sbyMh9tLMarvNr+8i4Vx1zRvHj4Kn5lErx//z3vJBlMgAf2mcozbq286SgMQCAR49913OXPmDABSqZTVq1ezZcuWG/b0yeVSTEw8y+DQX+ct4rXaBurr/uMtedQAHAtE+LOhKfb5RY2FQiLh8y7rdUlNNJnhBwcG+ft9A/ly7jU1Fv7Lw82sqfmQGlm+H5IROP9zOPEPMHk6vzhirePV+jX8NDnBQHg4v3xN6Ro+1/Q5tlVtQ3EDxoVCJkN41y76/vktLrCckLEGALUQY9VGA51fvmdJioTnMNXfx4lXX6D3yEGEWdG0o6qG1U88TdPGe26rWzeI6dpo9wyRA+N5Ddp8XY2y6lrthdvt5uDBg5w9ezbfKqG0tJTNmzfT2tq6oCllOHyRkZHvMz3zGoIgnodabQNVVb9CacmnkMnuRgzmkBUEDvoj/GzKxxvuAPFZNjKXhvpsqZVHsmOoL7wA558XW4/MQW2C5ieg/WmovZeZWIbXz4ql3qdHA/nVlHIpW5sc7Fhezv0td5tf3kUx7jiZeeWVV2545zt27LjhdT8MfFSmeblEhsBrA8ROiIJouV2D5dONtxSlAZiammL37t1cuSK6uSqVSjZu3MiGDRtuuD1CNhtjdPRHDI/8Xb6Zn8HQRl3db2Gz3ntLpOboLKnZP0tq5BL4fKmNb1Y7F0w/+aMpvru3nx8eGiI5G4Le2uTgP21vor38I/CoWQgTp6H7h3D2uXy0RpDKOdZwDz816NjjP5+vgrJr7DzT+AyfXvZpSnWlH7hpQRCIdZ/i3D/spidaS0ItRtkMqRnWrFXR9NVHkKqXbvVNcGaKk2+8zPk9u0gnxTSo3mpjxcNP0Hn/w6hv0zRTyAkk+vxEDowX6WoUlQYMm8vQtF/rVxMMBjl8+DAnT57MuwpbLBY2btxIV1fXNf3jABKJCUbHfsj4+E/JZmcJucJGRcUvUVH+RZTKpSnW/qgQymR5bSbAz6Z8HJ2XhjLIpDzhNPPZEgtrIxeR9rwI51+AyFThw1obtOyAtqegZjPD/gSvzlZEzW9+qVPK2N5Wyo6uMjY33C31votFIDM3arsvkUjyKZGlgo/aATh+yYf/hT5yoduP0gAMDAywe/duJiZEAzidTseWLVtYtWrVNa6p10M6HWJk9AeMjv4j2ax4YzKZVlJX+x+xWjfe0nEdCUT486tIzWdnNTULCYWnggn+ak8fPzs+SnZ2xPdYh4v/+OAyGpxLRCCbjEDPC3DyhzB+Ir94ylLJ81Ud/Dw5jicplg9LJVK2VGzhM8s+w6ayTchuwKslNjjMib99l4seBxm5mKK1By+zcjnUfO1pFCUli/O97gASkQhndr/JqbdeJeoXTdUUKjXtWx9k5SM7MJfevC3A1cjrak7PQGZWV2NSot9Yhm5NKVJtMUmJxWIcO3aMo0ePEo+L0R2dTsf69etZvXr1gmnwTCbMxMSzjIz+I8mkaC0glaooLX2KqsqvodPdnkPyJxFD8STPzqah5je8rFIr+XSphc84TNR6usVI54WXIeYtfFjnhFaR2AiV67k0E1uw+aVFq+DRDhc7lpexpsZ6t9T7FxR300zzsFhkJp1MkE4mb6gbcS4+G6U5OS9K80wjqtpbi0TkcjkuXLjAnj178PnEB4nFYmHr1q20t7ffMPlMpbwMD/8tY+P/Qi4nCpfN5nXU1/0WZvPqWzq2Y4EIfz40zd5ZTY1MAs+UWPjN6hLqtddGHIY8Ub6zu5dXzkwgCGI+/emVFfzm/Y0fjfHe9TDdI7ZNOPPTfCVUGgl76tbwrF7DsfBgftUyXRlPNz7N041P49B+cAVQZMrH4e/tp29SiyCRgZDDNX2E5bVxyr76WTTLly/Wt7ptZNJpLh/ax8nXXsQ9MiQulEhoWL2eVY89SXlz2+3raiIpokcmiRyZLPjVKKRoV5Wg31SGwlF8nswZ8B06dIhQSBSsK5VKVq9ezfr16xe8D+RyaWbcbzEy8gPC4YKLtM12L5WVv4LVsumj13ctMeRmq6GenfLx6kyASLYg9l1t1PLpUis77HqsY4fEaM3FVwtVhAD6Emh9Elo/Ra5yPafGgrwy2/xyfqm3y6Tm8U4XTywvo6P8+k1x7+KThw+NzCQSCdRLOCQOi0dmLh54jzf/+tuUNTVTv2od9avXYS17/5LPa6I0G8owPlSDVHVrUZpsNkt3dzd79+4lEhEjIiUlJTzwwAM0NDTc8EWfTM4wNPxdxsd/iiCINxGrZTN1db+JybTylo7tRDDKnw9N8a5PJDVS4KlZUrNsAfO9S1Mh/nxnL7suiIRPIZPwuTWV/LutjZSaltA5lk6IN+VTP5q1gxcxoLfxfFUbL6fdhDJitEsmkXFvxb08s+yZG4rW+CfDHPj7Y4xMiP83aTZJ1eg7LDNN4vzyFzA+tB3JbRrZLRYEQWDk/BlOvvYig6dP5peX1DWw6tEnWbZh8x3Q1eSInZkhcmCC9FQh1aFutqLfVIaqwVx0zmezWc6fP8/BgwfzXjVSqZTOzk42bty4YOWlIAgEgycZGf0Bbvcu5uz+dbpGKiu/RmnJk3dN+BZALJvjLU+Q56Z87PWF86Z8ComEB2xGnimx8KBFg2poH/S8CBdfg2SwsAF9KbQ8AW2fIlO+jsNDoofNWz1ThBOFUu9au44nOl3suNvV+xcCi0pmstksf/Inf8L3vvc9pqen872ZvvWtb1FTU8Ov/uqv3tbB32ksFpnZ9+N/5PgrPy9aZnGVU7dqLfWr1lK2rAXZAmmfXDxD4PWClkZmVWN5uhH1bTQoTKVSHDlyhIMHD+Z7PlVVVfHAAw9QVVV1w9tJJCYYGvobJiafy4sjrdZ7qKv9TUymFbd0bN2hKN8ZmmbXbEm3BHjcYeY/1JTQtkCbhFMjfr69q5f9faLPiVIu5ZfWV/Nv76vHrl9i4kzfoOhZc/pfISym/RISCbvKmnjOZOJUfDK/aqmulKcanuKphqdw6d8/BTN5JcCBfznHzJQYhVCmQtQOvk5Fphfb5z+L5XOfQ26/8UaZHza8YyN0v/EKF/btyTsL6y1Wlm9/jM4HHr6haOb7QRAEkgNBIgfGSVzyFdoLlWjRbyxDu8JZlMYVBIG+vj4OHjzI8HBBxL1s2TI2bdpEVVXVdZphDjE69iMmJ5/Pp2MVCivlZZ+jvOLLqFUfrJH6RcR0Ms2L036en/ZzPlJIHZnkMnY4zTxTYmGtXoF0YK9IbC69XkxsdE6R2LTuIFG+gb1X/LxyZoJ3Lk6TSBeiPy0uI08sd/FEZ9nSiuLexR3DopKZP/zDP+SHP/whf/iHf8jXv/51zp8/T11dHc8++yzf+c53OHz48G0d/J3GYmpmQp4ZBk4e58qJI4z2nCOXLYwgVDodNctXUb9yDTVdq9AYived6PXjf6GPbGDWl2ZtKaZHa2/aPXg+YrEYBw4c4NixY2Qy4rEsW7aMbdu2UVp64zfeeHyUoaG/YXLqhTypsVm3UFv7zVsmNWfDMf5iaJo3PIWb1nabkf9QU8JK47XtA44MePn2zl6ODYlpNI1Cxi9vrOEbW+qwfFQtEq6HbEZ0Fz71z3DpjXxPqH6Vhucr23hVEiGYEZ1UJUjYWLaRpxufZmvlVhSyhaMVgiDQ3+3m8M97CflEQqCNTlE/8DL20EVMDz+M9UtfRL389sujFwuxUJCzu97k9M7XiQZEbZFcoaR5832sfHQHjqqa295HxhMncmiC6IlphJSo15Nq5ejWlqLbUIb8Ki+fsbExDh48WFTWXV5ezqZNm2hubl4wRZtOh5iYfJax0R+SSIqkVSKR43Q+QmXFVzGZum77e3xScTES5/lpPy9M+5mcV+ZdoVbwtNPCM6VWmlRSGHhP1Ndceq04FaWxQvNj0PopouUb2d3r55XTE+ztLe7q3VVp5onlZTze6aLEeDdy9knBopKZhoYG/vZv/5b777+/qJ3BpUuX2LBhQ76fylLBhyUATsZiDJ3pZqD7GAOnTpAIFxqySSRSXI1N1K5YTe2K1Thr6pBIJOQSGYJvDRE9Io7gZUYl5qca0LTcXiVFKBRi7969dHd3M/fvbW9vZ+vWrTfsUQMQj48wOPQ3TE29kG/kZ7XeQ23tv8dsWnVLx3YxEuevhqd5eSaQD0XfazHwzWonG836ogfznJvwn++8zJkxkQTplDJ+ZXMtv7a5DpN2CfpTRL2i/8apf4FpUXuRlMBuaxkv2Es5lvLkV7WoLDxe/zifavgUyyzLFtxcNpOjZ/8Ex18bIBEViaUpcIWGgRcxhYZQt7dj+dKXMD76CNIbrGr7sJHNpLl8aD/db77C9MCV/PKq9k5WPLyDulVrbru5ZS6RIXp8msih8bxxJdLZ0u5N15Z2ezweDh8+zOnTp/NFC1arlQ0bNrB8+fIFe6Plchk8nt2Mjv4TgeDx/HKjsYvKiq/gdD5yS4aUvwjICgKHAxGem/LzurtYX9Ou1/B0iYWnSsy45BIY3CsSm4uvQbzQsRuVCZoegZYnCJTdw1uXg7x6doLD/d68h41EAmtrrDy+vIxH20uxLbVo7l3cFBaVzGg0Gi5dukR1dXURmblw4QJr167NazeWCj6KaqZcLstkX69IbLqP45kTRs5CZ7FSs3wltV2rqO5YgWQmg//nfWS8s03yljswP1GHTH97N0aPx8O7775LT08PIFabrVixgnvvvReT6cZD/bHYMEPD3y0mNZZN1NZ+85aFwv2xBP9veIbnp31zhSqsMer4ZrWTB2zGa0jNnkszfHtXLz0TIkk0qOX86uZafmVz7dI13Zo8K6agzj2br+gYlct50VXPy2opM5mC7qPV1sqnGj7Fo7WPYlJd+79JxTN07xzmzO5RMrOhdof3DHVXXkIXn0FmNmP+9DOYP/95lBVL065fEAQmLl+k+42X6Tt2OO9XY3SUsOKhx2jfuv3OlHZf9BI5OEFyoBAFVFToxRRUpwOJvBB9iUQiHDt2jGPHjuUdt7VaLWvWrGHt2rXodAs3HQ2Hexgd/Sempl/L68yUSjvlZV+kvPwLqFRLywl9KSGezbHLG+Ln0z72eMOkZx9BEmCDWc8zJRYec5gwS4Hhg7PE5lWIzhQ2otBB44PQ8gRu17280RvllTMTnBwuDKZlUgkb62080VnGQ22lS3Pwcxfvi0UlM6tXr+Y//If/wJe//OUiMvMHf/AH7N69m/3799/Wwd9pfNSl2QAhj5uh0ycZOHWCkXOn8/4cMC9q076KykwjwvkYCCDVyTE/UY9m+e275E5OTrJnzx76+voAkMlkrF69mnvuueeGjfdg4fST2byO2prfwGLZeEvHORJP8jejbn4y6SU5O7xq06v591UlPOE0I7uK1LzdM81f7O7l0pQoLDaq5fzaPXV8bVMNhqVKajIp6HsbTv9EnOcyZIBDOj0vldbyrhAhM0sSFVIFWyu38mTDk2ws24hcWpx2jPiTHHttgEuHJhEEkCBQHuim+sLzqFIhkEjQ33svli9+Ad3mzUhusLLtw0bIPcPpXW9w7p23SURm3aRVKlo3b6Xr4cfvSAoqNREhcmiiqLRbqlegW+dCv86FzFgYLKRSKU6dOsXhw4fzvdHkcjnLly9nw4YN2K+jUUqlPIyP/5Tx8X8lmRJ1cBKJAqfjISoqfgmTadWSTQMuBfjSGV6dCfDitL+ojYJSImGbzcCnnBa2201oJQKMHhVJzcVXITha2IhMCXVboeUJJl1bea0vxatnJzg7No/MyiRsaXTw+HIXD7SULN17xV0UYVHJzKuvvsov/dIv8d/+23/jD//wD/mDP/gDLl++zI9+9CNee+01Hnzwwds6+DuNpUBm5iOTTjN+sYfB0ycYOtONd2yk6P1SUy1rnY+hyYgjQnWTBfNTDcjNt58HHhkZ4Z133smLIBUKBevWrWPjxo1otTcuoIvHxxge/h4Tk88jCGIe3GRcQU3tv7tl873pZJrvjc7wwwlvvuFdnUbFb1Q5+XSpBdW8h3IuJ/DG+Un+cndf3nTLpFHw9Xtq+eWNS5jUAEQ9Yhrq9L/ClNgiwC+V8rrZzotWO73ZQmTTprbxWN1j7KjfQZO1qWgz3okIR14aYOismLaSywRqU+dxHfon5FmRLCsqK7F8/nOYnn4a+QJdppcC0qkklw7s5dSbrxRKu4GK1nZWPPQ49avXLyikvxlkIymix6eIHp4kG5ot+ZVJ0HTY0W8sQ1VVuC9ks1kuXrzIoUOH8l5OIPaA2rBhA9XV1Que37lcGrf7bUbHfkgw2J1frte3UlHxZUpLdiCTLb12L0sJo4kUL83qay5GCwM+rUzKI3YTn3KauddqQCmRwES3mIa6+Ap4C6lLJFKo2ggtTzBaspWXB6W8dnYyP/iBguvwY51l3N/sRKe6vfPrLhYPi16a/fbbb/Mnf/InnDx5Mt+b6fd+7/fYvn37TW1n3759/Omf/iknT55kcnKSF198kU996lP597/61a/ywx/+sOgz69at48iRIze8j6VGZq5GyD3D0Jluhs50M3L+DMlYFClSmkzraLNsRCaRk5VkyXYqcD3eicZwe+WIgiAwMDDAnj178l2IVSoVGzZsYP369TdVap9ITDA88ndMTPyMXE58SBgMbdRU/384HNtvqd+NL53hH8Y8/GDMjT8jRitcKgXfqHDwS2U2dPKCtiKbE3j93CR/ubuXfves+d/HhdSA6F1z5qciuQlPIgCXlApesZfxukaJf9b7B2CZZRk76nfwaO2jRd41E31+Dr3Qz/SgmH5Ta6Q0qQewvfP3EAoAIFEqMT7yMObPfx5NV9eSjBQIgsD4xR5Ovf0afccOIcy2J9BbbXTe/zAd9z+E3nJ7bS+EbI54j5iCSg0XNG0LpaAEQWB4eJjDhw9z+fLl/LplZWVs2LCB1tZWZLKFdT7hcA9jY//C1PTLef8mudyIy/UMFeVfQqu9/Uadn3RcjMR5cdrPizMBRhMFzxmLXMZjDjOfKjGzwaxHBuC+PBuxeSU/QMjD1QUtjzPs2MrPRw28dnaSAc+8sn6FlG3NTh7vLGNrkxPNEu2T9ouKj41p3ptvvsnBgwdZuXIlzzzzzIJkZnp6mn/8x3/ML1MqlVitN35TW+pkZj5y2SyTV3oZOtPN8LlTRIc8rLZtx6EWOwJ7EhMMai9g76ijqn05ZU0tKJS3JnATBIHLly+zZ8+evAeHWq1m06ZNrF279oZbJIDoUzMy8n3Gxv+VXE4sxdRqG6ip/jeUlDyBVHrzI59oJsu/THr57oibqZQY/THLZXyt3M6vVjiwKwvbzOYEXjs7wV++08fAPFLza5tr+eVNNUtXUzOHXFYUPZ75mXhDTsdIA/u1Gl5xVLBXmiYzK5eWSqSsd63nsbrHuL/qfnQKHYIgMHjaw+GX+glMi1VTBquKDpcX03s/IjmrmQJQNTVh/txnMe3Ygew29SmLhbDXw9ndb3L2nbeJBQOA2LW7ce1Guh567I4Y8aXGwmIK6ow737VbqlegW1sqpqDmVUHNiYXPnDmTrxI0Go2sW7eOVatWXXcAkE4HmJh8jrGxH+cbvYKoNysv/xJ2+/23dG38IkEQBE6GYrw47ecVdwB3qlAxWqKU84TTzKecFlYZteI54R8WS70vvQbDh8jX7QNY6xCaH2fIvpXnp0t49dwMI75Y/m2NQsb9LU4e73RxX9PdPlFLAR8bMjMfEolkQTITCAR46aWXbnm7i0VmspkcEqlkUW22k7Eoo+fPEjwwgm3ajlyiJCdkuRg8yoXAISRyKWWNzVS2dVLZ1oGrsemmjcnm3ITfe+89PB4xZaHVatm8eTOrV69esKrjekilfIyO/RNjYz8ikxHDump1BdVVX8fl+vQtmY0lczmen/LzNyMz9MfFUa5GKuELLhv/ptJR1P9pjtT81Tt9+UiNUS3nVzbX8rVNtZg0S5zUgNhC4fIbYsRm4F0QcgSlUt7W63jV5uI0hfC7Wqbmvsr7eKzuMdGUDxkXD01y7LVBYkFxNGsr17OyS4ru4AuE33oTYVbkKtFqMT32KObPfg5NR/tH8lU/CJl0mr4jBzi98w0megul1PbKajoffITWe7ahuon06ELIRlJEj00RPTIvBSUFTZuYglLWFMTo0WiUEydOcOzYMaJR8fxSKpWsWLGCdevWXXeQJQg5vL59jI/9GI/3XeYesCplCWVln6Ws7HOo1bff/uGTjqwgcMgf4aUZP6+7gwQyhdY55SoFTzotPFliplOvEf9nETf0vimSm/53IVuIdKJzICx7hGHHVp711/HKeR9j/oInjk4p4/6WEh7tcHFfk+MusfmI8IkiMy+99BJKpRKz2cy9997LH//xHy/o3DmHZDKZN44D8ceorKy842Tm0uFJ9v60F0eFHnulAUeVHkeVAYtLh2wRGqRlgkk8z10gc0XUVESyQY7NvI573ohPrlRRtqyZytYOKlrbKW1oQr5Ak72FkMvlOHfuHO+9916+vF6n03HPPfewatWqBZv1XfdYM2HGxn7MyOgPSKfF0kql0k5lxdeoqPgScvnNp8qygsCb7iB/NTLN2bB405FJYIfDzG9UOWk3FB5qc6Tm/+25wpVZTY1BJedrm2r4lc21mLUfk/LZ8LTY3+bcszBxChCroV4zmnjDbGVIKJznJpWJB6sf5JGaR+i0dNHz3gTdb4+Qiosj2bJGM2sfLEFzeg/+Z39G6kp//rPq1lbMn/0sxscfW7LRmunBfs7sfJ2LB/aSSYnfW6FS07L5PpZvfxRnTd1tbV/I5ohf8BI5NEFqcF4KqlSHboOryIgvnU5z7tw5Dh8+jNstdqGXSCQ0Nzezfv3665rwgag3G5/4CRMTz5FOz/UskmK3b6O8/AvYrPcgkdx9cH4QUrkce31hXp4J8KYnSHReqXeNRskOh5kdTjNtc8QmGYYr74gRm96dxSZ9Ch1CwzZGHdt4PtLKzy/EivpE3SU2Hx0+MWTmZz/7GXq9nurqagYHB/nWt75FJpPh5MmT102D/P7v/z5/8Ad/cM3yO01mDjzbx5k9o9csl8ol2Mr02Cv02CtFomMv16PU3Jlwcvy8B//L/eTC4igy4UrTmz3F0MVu4qFg0bpyhRLXsmYqWtqoaGnH1diEQvX+0ZFsNsuZM2fYt29fvqrDYDCwefNmVq5ceVOkJpuNMzH5HCPDf583G5PJ9FSUf4nKyq/eUvmqIAgc8Ef465GZfP8ngPssBv5dtZNN87xqsjmBN89P8v/eucLlaXFdnVLGVzbW8Gubaz9eHhSeK6K25tyz4BtAAC4olbxmsvCWwYBHKOgKnBon22u280DJQyRO6Dj37jjZ2Q7lNZ121u2oRTt1Gf/PniX89tsIKfGzEq0W46OPYPnMZ1B3di5JbU0iGuHCvj2c2fkGvomx/HJXQxOdDzxM08Z7PvAc/yCkJqNED08QOzWDMFsGL1HL0K0qQbehDIVdFPIKgkB/fz+HDx+mv79ADsvKyli/fj2tra3Xbf6ay6Vwu3cyNv6vBAJH88vVqjLKyj6Lq+wzdx2GbxDxbI49vhAvTQfY7Q0Sn2emV69RscNp5gmnmRadWjynMymx5PvS6+IULgi9kcgQqjcwXrKVl2PL+XGvlIlgIRqqU8rY1lLCYx2ld1NRHwI+MWTmakxOTlJdXc1Pf/pTnn766QXX+bAiM7mcQGAqhns0jHs0jGckjHs0kh8JXw2jXY2tfJbkVBiwVegw2jRIbiFNlUtkCL45SPToFCCWcZserSNmjzF2qYexC+cZvXDuGnIjlckoqWugvLlNnJparnEmnkMmk+H06dPs27cv36zPYDBwzz33sHLlyhvu0A1ipcf09KsMDf8tsZhYeSCRKHG5nqK66uu3LIg8F47xNyMzRQZ8nXoN/7bKyRMOM/LZ3zaXE3i7Z4q/2nOFi5Pid9EoZHxpXRW/vqUO58fJMVQQxEqOcz8XO3qHJ8kCx9Uq3jTb2KVVExYK52CZroyHHI9T3buK6e4EggBIYNnaEtY+XodOniD0yiv4n32O1LwHsqqxEfNnPoNpxxPIzOYP/Wt+EARBYOzCOU7vepMrxw7n3bdVWh0t92xl+QMPY7/N8u5cLE305AyRIxNkvYUHmmqZBf16F+pma/76nZmZ4ciRI5w5cyZvwqfX61m7di2rVq26rl8NQDTaz/jET5icfIFMRrxmJRIZNttWyss+h9W65a625gYRzWbZ5QnxykyAd3yhvN0DQINWxROzEZvmOWIjCGLU8/Ibonv3TE/R9gRnK9OlW3kjtYJ/GLQwFiw8W7RKGduanfmIjVZ59390p/GJJTMAjY2N/Nqv/Rr/9b/+1xva7ocpABYEgbA3IZKb0QiesQie0TARf3LB9eUqGbYyHbYyHdZyvTgv06M13lgaJDkcwv9CH5lZ0aeq3oT5qUYUdg2CIOAbH2Ps4vn8FPF5r9mGtbyS8uZWypa1ULasBYurrGhEnslkOHXqFPv3779tUiMIOTyePQyP/O288lUJDsdDVFd9/ZZt4YfjSf521M1PJn3EZ6tgKtQKvlHh5Isua74CShAEdl+c4f/t6ct7UKjkUj6/ppJfv7eecvPHrHQ2lxVFjueeE4XDcT8p4KBWw5tmO++p5cSFgq6gWbqcLRNPIx00AyCVSWjdXMbqR2vQGpXEu7sJPPscobfeQpgdEEiUSgwPPID508+gXb9+SfrWRAN+zr+3m3PvvEVwZjq/3LWsmc77H6Zpw+bbitYIOYFEn5/ooQkSvf68plRmVqFb50K3piRvcDmnqzl+/HjeQFQul9PZ2cm6desoKSm57n6y2SRu91uMj/+kyGFYpSrF5XqGMtdn0Ggqb/l7/KIhnMmyyxvilRk/7/rC1xCbxx1ixKZ1jtgA+IdEUnP5DfHamnf9CPoSvGVb2SOs4nsjlQwEC6kttULK1iYnj3S42NbsRH+33PuO4I6Tmd/6rd+64Z1/+9vfvuF1iw7kBsiM1+ulvLycv/u7v+MrX/nKDW13KVQzJaJpPGMRvGMRPGNhvONRfJNRsvOaps2HxqDAWqbD6tLPzsVJrb82xSNkc4T3jxPaPQKZHMglGO+rxHBfZZHTqSAIhNzTjF3sYfzyBcYvXcA3fm2aTGMwUtbUgquxmbLGJkrrl6FQq8lkMnR3d7N//37CYTFlc6vpJ4BA4ARDw9/D6303v8xsWkN19a9js913y2Xd/zTu4QdjHrzpWet/uYyvlNn41QoHpSpF/rfY2+vm/+25kncMlUslPLOygn97Xz019uuPopcssmmxv835n4v+G6kwcYmEAxo1b1kc7FPJSMzemO2RCrZMfBqnV4yIyRVSOrdVsGJ7NWqdgmwoRPC11wg89zzJeT2MFOXlmJ5+CvNTT6EoK/sovuX7QsjlGD53mrO736L/5FFysxESlVZH8+b76Ni2nZLa+tvaR8YbJ3J0itiJKXKx2QjYnGfNehfKalEwnMlk6Onp4ciRI0xOFhqO1tbWsm7dOpYtW7ZgH6g5RKNXmJh4lsmpF0inC662FstGylyfweHYfrd7900gnMmy0xPkFXeA964iNrUaJY87zDzunCceBoj7oW+XSGz6dkOqkNYW5BrCZZs4IFvD300t47S/kLJWyqVsaXTwSHspD7SWfDwKD5Yo7jiZ2bp16w3tWCKRsGfPnhs7SkQr8StXxLTDihUr+Pa3v83WrVuxWq1YrVZ+//d/n2eeeQaXy8XQ0BD//b//d0ZGRrh48SKGG/RbWQpkZiHksjmC7jje8Sje8Qje8Qi+iShBT7yomnA+NEYlVpcWS6lIbiylWiwuHVqjkqwvgf+lKyT7AgDI7RrMn2p4327csVCQicsXmei9yPjli0wP9JFNp4vWkUilOKpqcTU24WpswlFbz9DkNAcOHsxHavR6PZs3b75poTBAJHKZkZHvMzX9at6AT6ttoKrqVygt+RQy2c3rWuLZHM9N+fjeqJuB2QoohUTCUyVm/m2lkxZ9QfNweMDLX++5wqF+MWollcDjnWX8xtYGmkpvz9PnI0M6AVd2iR2JL78F6SgxiYT9GjU7LQ72q2TEhSxlwQbWjjxOaUQkNTIVrNxeQ9f9VSjVcgRBINFzgcDPnyf02uvkZkksEgm6DRswPf00hgfuR3oT3kQfFvLRmj1vE5yeyi931tbTse0hWjbfi0p766RVSGeJnfUQOTxBeqxgdCgv0aJfPysYnv0NR0ZGOHr0KBcvXsz3SrNYLKxdu5auri40mutHBHO5JG7PO0yM/wyf/0BhP3IjJSU7KHN9GoOhfUnqm5Yq5iI2r84E2HNVKqpSreQxh4nHHWZWGrVI537XTAqGD8DlN8UpWDwQjDm6OKlaxw+9Lez2OxCbM4iDpI0Ndh5pL2V7a8nHS6e3BPCxSTO99957CxKlX/7lX+a73/0un/rUpzh16hSBQACXy8XWrVv5X//rf1FZeeOh1qVKZq6HdDKLbzKKbyI6bx4h4ls4VQWg1MhFYuPUUCKTYBoIIEmIo1LtCiemR2uRGT44dZVJp5kZ7Gfi8gUm+y4z0XdpwdSUSqfDWbeMnK2EkWCE2Gy5r16vZ+PGjTdd0g2QSE4xOvpPjI//hOysC65CYaOy4pcoL/8SSuXNG6blBIGdnhDfG50pskq/12LgG5UOtloLzQdPDvv5/717hT2XCv1fHmwt4Te2NtBVab7pfS8ZpGLQt1PU1/TuhEyc2GzEZpfFwT6lHIevibWjj2OLidGWnCqF6x4VDz+6Fv3sAz8XjxPetYvA8z8nduxYfvNSoxHjY49ifuop1B0dS+6hKuRyjJw/y7k9b3Pl+GGysz4xcqWKZes20r5tOxUtt0cGUmNhIkcmiZ9xFwTDShnaFQ5061woy8QKsUAgwPHjxzl58mS+D5RCoaCrq4u1a9ficDiuuw8QK6EmJ3/O5OTzeUE9gF7XhMv1aUpLd6BULtx24S4WRiSTZbc3xGvuAO94w/k0NYhmnY/YTTzqMLHepM9r8BAEmDoHvW+JxGaiu2ibaX05PfoNPBtq43lfHSnEAZ5UAmtrrTzS7mJ7Wwku08csrf0R4GNDZj4MfNzIzPWQSmTwT8XwT0bxT4kkxz8VI+SJc/V/UA60aKTUKqVIJBKyEghUGJG1WTGV6DA5NRgs6hsSH4e9HiZ6LzF55TJTVy4zPdCfL40FEJCQNtvIOMvJysSLVqVUsm7tGjZuvuemHIVBLOsen/gZo6P/RDIphuelUjUu19NUVnwNne7WSnC7g1G+O+rmdXdBLLxMq+YblQ6eLrGgmS2n75kI8jfv9vPG+cn877qpwcb/d18DG+ttS+5hfVNIRWeJzYt5YpOUwBG1mt1mJwORNbSObsecEKvMYsog0c5hVm6pZ0vVPZjVZnEzo6MEX3yJwEsvkpkopFCU9fWYPvUkph07ULyPNuSjQiwU5OL+9zi35+2iNiLmEhftWx+k9d5tGKy3TgZysTTR7hmiRyfJuAulvcoqA7p1LrSddiQKGalUirNnz3L06NF8aTdAfX09a9eupbGx8X1TUIKQxec/zMTEs3g8u/Lu2xKJHJvtPspcz2Cz3Xe3g/dNIpbN8a4vxOvuIDs9waLO3laFjIftJh51mLnHoi9qr0JoUuy5dvktMdWbKfzvc3ItQ6a1vJpYzr94m3Bjzr/XVWnm4fZSHm4r/Ximtj8ELDqZOX78OM899xwjIyOkUqmi91544YWb3dyi4pNCZq6HbDpHYCYmEp2pKIHpGIHpGP7pGLp0juUaKeZZ7Yw/k+NMPEswCzKFFJNDg8mhwezUYnJqMM7+rbeor2sGmM1k8IwOM3XlMlP9fUz19+EdHSEnCGRMVpJ2F4JSJDCSXJZStZLWxgYqGpdRUteA1nhj3bpzuTQzM28yMvoDwuHz+eU221aqKr92W40tfzDm4ceT3vzNyqqQ8ctldr5Wbsc5q6vpd0f43nv9vHhqnMxsGHp5pZl/e28921tLFtUs8UPBHLG58Ar0vg3pKGngpErD/txjMP0o2pTYzymk8tJdsRNdW4at1fdxX+V9VBurEXI5YkeOEHjhRcK7d+cN+ZBK0W3ciOnJJ8U01PukUT4KCILAZN8lzr+7i0uH9pNOiA8fiURKzfIVtN33APWr19+wR9NC208OBIkenSTe4807DEvUcnQrnejWlaIomXVuHhzk6NGjRS0TLBYLa9asYcWKFe+bggJIp4NMT7/K5OTPCYULVv4KhZWSksdxlT6FwbD0ImZLHclcjn2+MG94grztCeJLF4TAepmUB2xGHnWY2WY1oJ/XYoVUDAb3iWZ9vW9DeLJouzPGNvZkV/DP/lZ6ctXMpaOaSgw81F7KQ20ltLqMd/9fs1hUMvPTn/6Ur3zlK2zfvp1du3axfft2+vr6mJqa4qmnnipqPbAUsFhkRshmQSpdsiedIAjEQin8E1HiJ6ZQXfIhzQoIwFAqx8V4lvR1/vNSuQSjTYPRLpIbo109OxcnharYWyGViDMz2J8nN4NjE/jlKnKq2RtxNovSP4PCN43RbMZZUzdvqsfocF73dxQEgUDgGCOj/4DH8w5zgiK9vpnKiq9SUrLjlnQ1oUyWH094+f6Ym/GkqNVRSCR8qsTMNyoceRO+MX+M7+8f5KfHR0jMphAanHr+zb317FhehlK+9Kp7bhrpOPTvgZ6XxBtwMkhGkPNO6lH6wk8jyYgENKCe4UTFW/Tbu6k2VXNvxb3cW3kvXc4upLEk4bfeIvDiS8RPnsxvWqrVYnj4YUw7dqBdu2bJVUOlEwkuHznA+Xd3Mn7pQn65WqenefO9tN37ACV1Dbd8nWfDKaInpokemyQ7r6pRWWMUozXtNiQKGX6/n+PHj9Pd3Z1PQc1VQa1ZswaX64MdgiORy0xOvcDU1MukUoWIj07XSGnJpygt3YFavfSE20sdmZzA4UCENzxB3nQH8+1VAFRSCfdYDDxiN7HdbsShnEeABQEmz4jXVO+beePLOcRUTo7IV/PTQCv7s63EEQeBlVYN21tLeaitlFXVFmQf94HTbWBRyUxnZyff+MY3+I3f+A0MBgNnzpyhtraWb3zjG7hcrgUN6z5KLBaZCb7+OjP/+/+g6epCs2IFmq4u1G2tSG+ip9GHiWw4RfD1AWKnZx1LNXKyK5wE9EqC7jhBT5zgTJyQJ04u+/6nhMagyBMbg02N0abOvzZY1MgUUuKRMEf37+fk2bOE47Mj9lwORcCN0juFNDPvhqDT4aiqxVFTi6O6Fmd1HbaKKuRX6W5isUFGx37IxMTz+R5QCoWV8vIvUFH+5Vsy4cvkBN7wBPm70RlOhAp9WtabdPx6pYOH7CZkEgmeSJJ/OjjEDw8PEU7Muuqa1PzqPXV8fk3lJ6fzbiYljiwvvgyXXicdDXM+9ggnok+TyonXj08zyYnKNxmwngWJgEFhYEPZBrZUbGFT+SaM7hjBl18h+PLLpMcKxnZylwvT449j2vEEqsbGj+obXhf+qQl63nuHnn3vEPF68sttFVW0btlG6z1b0Vttt7RtISeQ7PMTOTpF4pKXuVynRDMXrXGhcGpJpVKcO3eOY8eOMT1dKDOvrKxk7dq1tLS0fKAdQi6Xwec/wNTki7g9u/LNLkGCxbyO0tKncDofuiUn7l905ASB06EYr88Sm7kCAxBjLGtNOh62m3jEYaJGc9WzIDwlEpu+nWJ7hXRBx5eVKrmoWs7PI+3synQxJoj6KbteyQMtJWxvK2Fjvf0XzqRvUcmMTqejp6eHmpoa7HY77777Lh0dHVy8eJFt27YVlSEuBSwWmZn64z/B/8//XLRMolCgbm1F07UczfLlqDuXoygvW1LRm0R/gMDLV8jMiGRAWW3E/GR9XqSYywlEfAlCnjhBd3zeXFyWjC1sCpiHBHRGJQabSG70FhURZugdPYPHL96cJRIJDrUClX+G0MhQ3vCsaDNSKRZXOY6qGhzVtdirqrFX1mB0OMlkQkxM/IzRsR/ldTUSiYIS56NUVP4yJuPyW/ptuoNR/m7MzWvuAJnZq6JSreRXyu180WXFpJATTqT58dERfnBgEHdYvJGZtQq+sqGGr26swar7BOkUshkYPQIXXyN1YRdnJ7s4HX2SpCCeK2ntJEerd3Le1D0XLQegzdbGPRX3sMm1kYaRDOFXXiX01luFaihA1dKC6YknMD726JLT1+RyWUbOnaFn7ztcOXaYTHpOkyKlevkKWrdso2H1ulv2rskGk2K05vgU2cC8aE21Ed3aUjQddiQKKSMjIxw7doyLFy+SmxWm6nQ6Vq1axapVqzCZPjhlm06HmHG/ydTUy0VOw1KpCrv9fkpLnsRm23JXX3MLEASBy7EEb7mDvOEJ5tuszKFZp+Zhu4mH7CaWGzSFyigQKw6HD4g6m763ITBS9NkpZQ1vpjp5K7mck0IjGeTolDLubXKwvbWUrU1OTNpPfsn3opKZyspK3njjDTo6Oli+fDm/8zu/wxe+8AUOHz7Mww8/TDAY/OCNfIhYLDKTi8dJ9PQQO3WK+OkzxE+dIuvzXbOezG5H09mJprMDdUcHmvZ2ZDdwE1pMCJkckYMThN4ZRkjlQAL6DWUYH6xG+gFtFxLRNGFvgqA7TtibIOSdnXvEeeY63jkCAmllgJhuhLSqcI449JXU2MpQCTES4UnCnjF8E8MkIuEFt6PUaLBVVGGvqsFWUY7aOU00u4tw9Ex+HaOxi8qKX8bpfPiWbtITiRT/NO7hnye8+Geb2WllUj5bauVXy+006tQk0llePDXO3+7tZ8grRnTUCimfXV3J1++po9J6ew0QlxxmQ+bJs29y5lCEM+71pARRtKhTDhCp2su+shEupouvAaPSyIayDWy2r2Vlv4Dk7f1E9u2DOQsAiQTt2rUYH38M4/btH/m1cTWSsSiXDx+gZ+87TFwupKGUGg2N6zbRtmWbWA11C+mzvBnf1dEatQxtlxPd2lKUZXpCoRDd3d2cOHEib8QnkUhoampizZo11NXV3dCAKR4fZ3r6ZSanXiIWK7g9y+UmnM5HKC3Zgdm85pY8nu4CxhIp3vYEecsT5HAgkh8QAZQqFWy3G3nIbmLz1QJiQQD3pdl01NviAEIo3EfjUj0H6eSNRCfv5brwYUQulbCuzsqDLSU82Fb68TP8vEEsKpn54he/yOrVq/mt3/ot/viP/5i//Mu/5Mknn2TXrl2sXLnyF1YALAgC6ZER4mfOED9zlviZMyQuXYLMtVEHZXU16vZ21B3taNrbUbe0IH0fu/PFQiaYJPjaAPFzYkhdqldgergW7UrnLbVZEASBeDhN2JfIE52IN0HYnyTsTRDxJ0jGMqQVQWK6UVLqwoNPmbCijVaiSJsQBAG1NolCFUCCj2x6mmR0hlhwCiGXXXDf5moppSsiqJxjSCTiOgq5jfKKL1JR/gVUqpsf/ceyOV6Y9vP9MTeXogU7+/ssBn61ws79NiOCAG+dn+J7e/s5Ny6SNKkEHuss4xtb6mgvX1oP5zuFxGgvp185xdkeE+mcSBid8j6WmZ6l3zXNIZuLQ9kg4WzxaLXeVM8Wwwru6ZVh299Dsvt0/j2JQoHunnswPvYohq1bkd5mR+w7Df/UBBf2vcvF/XuKnIYNNgctm++l5Z6t2Curb2nb2VCS6MlposenyfoK55qiXI9uTQna5U4EpYRLly5x7NgxhoeH8+vYbDZWr179gZ41cxAEgXCkh+mpV5iafpVUqmBHoFKVUuJ8jJLSHRj0bUsqqvxxQiCdYbc3xFueIO/6wkWNMHUyKfdZDWy3mXjAZsR2dRuEuF9sitm3UzTtixfukwISLssaeSPRyZ5cFz1CDQJS2sqMPNhawgMtJbSVfXIExItKZnw+H4lEgrKyMnK5HH/2Z3/GgQMHaGho4Fvf+hYWi+W2Dv5O46OsZsolEiQuXCRx/hzxs+eInztLenjk2hUlEpR1dahbW1G3tYrz1tYPrYNxos9P4JX+fDmpssqA+ckGlOV3fv+peIawP0HEl2RsZJxzvSeZCowwJ+xVpI1oIpUok1YkFF+QgpBFyPkRsh5yWS8IXsh5yaYD+c/LNRlsLX7srQEUOpFICjkJQqQBveJBnKX3YKuowuhwIJXeWP5ZEAQOBiJ8f8zN255Q3tOwWq3ka+V2Pu+yYpLLONzv5Xv7BtjXWxBfbmqw8Y0t9dzTaP/E3GDmIx5Jcfr1y5zdP00mI442nYo+1uh/Srmymx6DmYOljRxUSemJTZOjcFNXSBVskbewvU9DzZERJAMFIzKJVoth61aMjz2KbvNmpDfpW7SYEASB8csXuLBvD72HD5CMFbQPjpo6WjffR9OmLbdU5i3kBJL9AaLHp4oroRRSNO12dGtKUNaacLvdHD9+nDNnzuQrSuVyOe3t7axevZry8vIbOt8EIYvff4Sp6Vdxu98ikylERLXaWkqcj+MseQy9bulpnD4uSOZyHPRHeMsTZKcnVCQglgKrTToetBnZbjexTKsq/r/lsjB+UiQ2vW/D1NmibfulFnanO9mT7eJAroMwWspMah6YJTbr62wf6yKFuz4z87DUSrMzfj+J8z0kes4TP3+exPkeMlNTC66rqKpC3dyMuqUZVUsL6uZm5CUli/JQFDI5IocmCO0eQUhlRe3LmlKMD9Ug0y1ubtbr9XLo0CFOnz6db9Jntdhpq+/Coa8mHkoTCSSJzpvma3cEIY2Q9SFkveRy4hzBjbF6DHubD72rEB2Ie1R4LlgI9NvQGFyYHGWYXeXYKysoqa3GWVON6n0iAsPxJP847uEnkz6CsykojVTKp0stfK3cTqteQ89EkL/dO8Dr5ybJzpZ1t7iM/PqWWh7vLEMh+/jeXK6HeDjFqZ0jnNs7RiYlEhanaog1mh9TrTqBRAJBqYyj5W0csjg5lPYxmfAUbaPZp+XJIRvtp/2opgP55VKDAcP992N89BF0GzYgucWS6cVAJpVi4NRxLu5/l4HuEwX9l0RCZWsHLZvvo3HdRtS6mx8YZKNpYt0zRI9PkZkpiNPlNjXa1SXoVpaQUcO5c+c4fvx4kWDY5XKxatUqOjo6UN1gUUI2m8Tn28vU9Kt4PO/MEw6LxnzOkscocT6GVltz09/lLkQIgsDZSJy3Z4nN+Uhx5LJarWS73ch2m4l1Zh3Kq9OXocnZiM1O0dMmVXCfziLjpNDEO5nlvJvroleoQK9ScO8yB/e3ONna5MTyMdP0LTqZyeVyXLlyhZmZmbwwbQ5btmy52c0tKpYamVkIGbebxIUL+Sne01NkRjYfMpMJVXMz6uYmVMuaUC1bhqqh/o55eWRDSQJvDBKfV/Vk2l6Nbq0LiWxxIwuhUIgjR45w4sSJ/GjTZDKxYcMGVq5cWeQqnE5liQWTRAMposFZkhNMictm55FAjGTEjcp0CUvjEcx1/UjlIgHJJqX4ek14LlhIBopv9lKZDoXGjlrvQGcpwWArxVxahrWsDL1Fi0avRNDKeCse5R8nvVycl4Jab9LxtQo7j9rNTAXi/MPBQX52fJRYStyvy6Tma5tq+PzaKozqpfNQvlOIhVKc2jXC+XmkxmGJsMb8MjWx55nj4QIwYqnkSHkLR1RyjkVGCKVCs28K1E/CA5eVrL+UQzdPJCszmdA/+ADGhx5Gt37dkiI28UiY3sP7uXjgvaIyb5lcTu2K1TRvupe6lWtuWjgsCAKp0TDRY1PEz3rEwQaABNTLLGhXl6ButjI+NcHx48fp6enJDwqUSiWdnZ2sWrXqhsq755DJRPB43mF6+jW8vv35ViMABkMbTudjlDgfQaOpuqnvchfFGE2k2OUJsssb4qA/Qmre41g/l46ym9hmNWK/Oh2VScHIITEV1fs2ePuK3p7Czp5MJ+/llnMw105comF1tZX7W5zc31JCvUO35KPFi0pmjhw5whe/+EWGh4e5+qMSiSR/ES0VfBzIzELI+P0kL10S01SXLpG4eIHU4BAs9PtKJCirqkRi09iAqrERVUMDypqaW77ZJweDBF7pJz0phtAVpTpMT9Shrjff+pe6QcTjcU6cOMGRI0eIRsX9azQa1qxZw9q1a9HfRPotk8oSC6WIhVKE/DP4Q68Qzb6EIC3YwUennXh6SvH3yyEXf5+tAVIjUqkZicyCRGpGrrYyVVPB8QY7Z60ycrP3Bqsg4XGphmcMRkwqGa/2u/np2XG8UZGk6VVyPr+mkq9trv1EivdioRSnd49wbu84meRsg8syFatbRqlLvoBkaC9kCiQwK1dzsXo1x+yVHBPidPsvEs/EkQgCTWOw8UKOjZclGKOFwZPUZMLwwP0YH34Y3bp1SJZQKirknuHiwb1cOvAentGCvkWh1tCwZj3Nm7ZQ3bEC2U10nQfIJbPEz3mInpgiNRTKL5dq5Wi7nGhXl5AxSzl9+jQnTpzAN68ooby8nFWrVtHe3n5T7UbS6SBu906mZ17H7z+EMK+TtMHQgdP5yF1icwcQzWTZ6w+z0xPiHV8Id6oQfZYAK4xaHrAZedBmpH1+Q8w5+Abhym4xajO4v8iJOI2cY9km3sst571cF31COTU2Hfe3lHB/s5PVNdYlmY5aVDLT1dXFsmXL+IM/+ANcLtc1P+iNlAt+mPi4kpmFkEsmSV65QvLSZRKXL5G83Euyt5es37/wB+RyVLU1KOvqUdXXo6yvE0lOdfUNNQcUcgLRo5MEdw4jxMULS9Nhx/RoLXLL4jcXTKfTnD59mkOHDuGf/Y5yuZyuri42bNiAzXaLnh9CDp/vAGPj/4LH8y5zZSQKhQOL/nGE0Fr8Ywn8kxOEPZNE/NMkIm5ymev3xwIIG8o427KOM82tRLUiQZHkBJrHkqzuT1E+k+aSMssJdRaPVNynFFil1/GYy0KL04Baq0Ctk6PSKVDrFKi08vxc+jFMT8UjKU7vGuXce2OkZ0mNtUzH6u0u6s0XkV6Z9d24qnFf2t7I2erVHNMbOZF0c9p9lnQmSeuIwIZLAmsvC5hj8z5g0GHcdj/Ghx5Ct2nTkvJ7co8McengXi4d3EfIXUgFqfUGGtdtpGnDPVS2ddywhmsOaXeM2MkZot3T5EIFJ3aFS4d2VQma5XZG3OOcPHmyqLxbpVLlozWlpaU3tc9UyofbvZOZmTfw+Q/DPA2UQd+G0/kITufDaLW1N7XduyhGThA4HY6xyxNitzfEuavSUaVKBffbDNxvM7LFcpULMYhGmEMHxKjNlV3gGyh6e1ywszdbiNpIVQa2LHOwrdnJfU2OJdMQc9F9Zs6cOUNDQ8NtHeSHhU8SmVkIgiCQ9XpJ9vaS6O0VyU5fH6kr/eSi0YU/JJGgKC9HWVeLqrYWZW0dypoalLU1yJ3XuvFmo2lCu4aJHp0U8wNyKYZ7KzDcW4FUufgmTrlcjosXL3Lw4EEmJgoRlZaWFjZu3HhTjUevRiIxwfjET5mYeHaea6oEm+1eysu+MNvjRux+HAsG8E9NEJicwD85gXd8nMDUJMGZSTKpeVEGqYzeujZOta1l3FWTX27z++i6PED7gIcZqYOTOhsj8xxDKzJSVifl1KelSLk2/KtQy4rIjUpbPFdr5SjnL9cUXss+4lFXIpLmzJ5Rzu4ZJTXbBNVcomXVI9U0rnYi814W/Tb6dsPIYZg3+kehI1mzmbPlrRxXKTkZ6ufs9GnqhxKsvyiwrlfAPO9Uz6gVsGElrseexnLf/cj0S6PvzVwbhUsH93H58H5iwUD+Pa3JzLL1m2hafw9lzS03RWzmSrxjJ6aJXyiIhpFKUDdZ0K0qIVup4vS5M5w8eTI/MAAoKyvLR2tuVFszh1TKO0ts3sQfOFIUsdHpluF0PIzT+TA63bIln85Y6phMpnjHG2a3N8g+f4TYvOoohUTCOpOO+21GttmM14qIAbz9BWIzdKAoKppGzvHsMvbmlvNebjm9VNJVaWFbk5Otzc6PtDpqUcnMtm3b+C//5b/w8MMP39ZBflhYLDKzc2gn3z3zXdpsbbTaWmm1tdJkbUIjXxopA0EQyExOkuzvJ3mln9RAP8n+AZL9/eTexwtIotWirK4Wp6oqlNVVKKuqUFRVI2S1BF8bIDkgfl5mUmJ6pBbNcseHcrILgsDw8DAHDx6kr6+QH66srGTjxo00NTW9b4O+90Mul8bt2c34+I/x+w/nl6tUpZS5PktZ2WeuawU/R3QC01MEpiYITE8SmJokMD3J5WSWozWtXFjWRVohPizk6RQtV87RdeEosmCS0+YV9Grryc36e1iFNOtI0ZVTIknqSKdunzDKldIikiOSHjkqjbhMqZEXv6cpvK/UyO5YVCgZS3P23THOvDOaF3EbbGpWPlRNywYXMoUU4gFR3Ni3UwybR6aLN2JfRqp+Kz0lDZyQZuiePkOk+yRdPTHWXhawz7MoysgleDsqUG7dQsNjn8NZvjSqcnK5LGMXznPp0D76jh4q8lXSWawFYrOs+aY8bHKxNLEzbqLdM6RHC9uUauVoljvQrnAylnbT3d1dFK1RKpW0t7ezcuXKG66Emo9Uyofbs0skNv7DCEIhRaLR1OB0PITDsR2jsfOuj81tIpHNcTgQYY9PjNoMxov7I1aoFWyzGrnfZmSzWY/u6qhNKgbDBwul3/7BorenBAt7s8vzURut0cbWZgf3NTnZ1GBH/yG6nS8qmXnxxRf5H//jf/Dbv/3bdHR0oLhKk9HZ2XnzR7yIWCwy8+cn/px/6vmnomUyiYxaUy2ttlZarC00W5tptjajV344JdY3AkEQyPp8pAYHSQ4MkBoYJDk4QHpomNTY2MKanFlI1GqUlRUoajYi0a8GQUw1yZ0KzDsaUDfcesfhm8XMzAyHDh3i7Nmz+Ruy1Wpl/fr1dHV13ZQm4GrEYoOMT/yUyckXSOdN4KTYbFsoL/scNttWpNIb1yIlY1FGJyZ4ftLHC0kYmddLqnRmnOUXjlE5eIWL2mbOG1pJysTfVZlN0ha+yLrcIOVWPTqzA63RjkpvQ6GxIFeYkcpMpJMCyVhmdkqTmJ2nYpl8FOR2oVDJrkN6riVDc9GiuWVKjfyaxpypRIbze8c5vXuEeFgUl+pMSroerKLtnvJC/69cDqbPzY4q34HRo8VRG7kaqjeRrd9Kr6OB7qSHkePvoj14lo6eKK55GdicBAar1fjXNqK/fxutHVtpMDcgu8n0zp1GNpNh5NxpLh8+wJXjh4tKvfVWG43rNrJs/WbKl7XcFLFJT0eJds8QOzVTlIaSOzRoVzoRluk5P3SR7u5uvF5v/n2n08nKlSvp7OxEewteP+l0EI/nHWbcb+Pz7ct39QZxcOCwP4jD8SBm89qbuo7uYmEMxJLs9gbZ4w1zOBghmSs80pUSCevMOrZZjWy1GWjSqheO2lx5R4zaXKW1yQhSTgkN7Mt2sje3nEvSOtbWOrivycHWZid19sUVES8qmVlo5CuRSBAE4RdKAOyJezjnPscF3wUueC/Q4+nBm/AuuG6VoSpPbJqtzbTYWrBrPrwH/41CSKdJjY2RGhwiNTJMemSE1PAIqeFh0hMT4oNlDlIFyoYHUS57BIlcfDhnpk8ixM+gKDWjKCubN7lQuFxIjXc+XBkOhzl69CgnTpzIN+hTq9WsXr2atWvX3tb/PJdLMuPeycT4T/EHjuSXK5VOylzP4HJ9Bq325kzSBEHgWDDKDye8vDYTyFcv6CQC27IxNkyPcHEwzJ6wGS9iekQi5KiPDtAVOktpcro4ASWRoLfaMDmcmBwlGJ2l4mtnCSZnKVqzlUxKEMlNPEsyliYZnyU+0QypxOzreJpkLEMqlsm/n4pn8jqX24VSLSukwOYIj06BQiUl5I4z2R8iNavLUmpkNG9w0XFfBUabujgqFA/A4F4xYnPlHQiNF+/IWA712xDqtzHqaOTi+SOEdu3EcqyP8olizdOIA84sUxJa24xz1UaWl3TR4ejAqrbeke98K8ik0wyfPcXlw/vpP3GUVLwgDNJbrDSu20Tjuo2UN7feuE9STiB5JUC0e5pEjxdhnku3staEdoUDtznGqfNnuHDhAplZo0+ZTEZLSwsrVqygtrb2lqKemUwEr3cvM+638XrfI5stEDW53ITdvhWHfTs22z3IZEvLJPHjiGg2yyF/hHd8Yd7xhhhNFEdtylUKtlqN3Gc1cI9Fj0lxVZQlnRArpK68I15j7ktFb3sFAwdyHezNdrI/14na6mJrk1j2vb7OhuYOyw4WlczMd55cCNXVt+aAuVj4MB2AZ2IzXPRdFCevOJ+KLuwhY1PbaLY2s8y6jGZLM03WJqqN1cilS7NhoZBKkZ6cJDUySnpsdHY+Rmraj0SzEoVrtbheJkmq7y1SV3ZBtvhCkmq1yF0uFKWlyF2lKEpKkZeWiH87S1CUOJGaTLdEeJLJJKdPn+bIkSN5TYBUKqW9vZ0NGzbcVFnqQojFBpmYeJaJyefnRWvAYtlAmeuzOBwP3XT3bk8qw8+mfPzzhIeheaHi1UYtX3RZMfsz/Gh/P0eGAvn3alVJNsnHqQlcIuqeIpN8f1GyVCbDYLNjdJRgcpZgdDgxOUvFuaMEvcX6vqP9bDZHOp7Nk505kjOf8CSjaZKzpCgVy5CYWx5L58uzbwcKtQyNXoHqKnG0WivHLBnGEj2CwX8ItecYktz830MC5SuhfhvUb8OXMTPw5vMk392P+eIY0nmHFtDByQYJJxsk+DsqaSpbTqejk057J03WJpSyD79SSiQ23fQePsCVq4iN1mSmce0GGtduoqK1/YaronKJDPHzHmLdM/l0MQByKZoWK9I2I72JMbpPdRf51pjNZrq6uujq6sJsNt/S98lmk/j9B3G7d+H27C66jqRSJVbLZuyOB7Db70elXHqDvY8bBEGgP57kXW+YPb4QhwLFURuZBFYbddxnNXCf1UinQYPs6ntvYFQkNf3vIAzsRZIMFb19IVfN3lwn+3KdlHXcx59/Ye0d/Q53TfPm4aMWAPsSPi75LhVNQ8EhBK792ZVSJfXmepqsTSyzLGOZZRmNlsaPdKR4o4hfmCT45hAZ95xpWBIhforMyBHSk5PXr7i6ChKVCnlJCXKnA4XTidzhQD43t9uR2e3IHQ5kZvOCpCeXy3H58mUOHTrE6GihQqa6upoNGzawbNmyW9bViNtP4fbsZmLiWXy+A+Sdh+UmSkt3UOb6DAZD281tUxA44I/wwwkPb3uC+Z4uRrmUZ0qsbJap2HtqgpdOT5DKzBrSGVR8eX01T7WYkEf9BGemCM5ME3RPE3LPEJyZIuR2L9jEcz5kcjkGu6OI4BidJbPRnVK0poV/5xtFNpPLp7/yBKgoHZYhFROJUiKWIRFNEfWnSMTSLHCJvP93IUmZ8gJVqlNUqs5gkxe7bWckWsLG1cQdm0hZVpEbmyF6fDeSk93I5pHJlAzOV0vobhCnoEVJs7WZDnsH7fZ2OuwdVBmrkH6I2o9MOs3IudP0HjlI/4kjJKIFszS13kD96nU0rt1IdecK5Ddox5AJJIiddhPrniky5ZNq5ajbbYSq4PxUL+fOnSM5jzTX1dWxYsUKmpubr5EZ3CgEIUsg2I3HvYsZ904SifnVbBJMxi7s9gew27eh0zXeFRDfAcSyOY4EIrzrC/GeL0xfrHggZFXIuMdimCU3Blyqqwh8Ng1jx8WUb/87MHmm6O2Riieo+rV/uaPHvOhkpr+/n7/4i7/g4sWLSCQSWlpa+M3f/E3q6+tv+aAXCx81mVkIsXSMK4ErXPZf5rLvMpd8l+jz9xHLxBZc366x02hupNEyO5kbqTPXLRmx8RwEQSB+1k3wzaF8N2BFpQHzY7UoSpSkp6bITE6SnpwiPT1FZnJKXDY9TWZ6muzNNCmVy5FbrcjsNuR2O3KbHbnNisxqy8+nEegeHuZCf3/eE8lisbBu3Tq6urpQ30B5+vshHh9ncurnTE48RyJZqLLS61spc32a0tInUSjMN7XNmWSan035+JcJL8PzQsQrDFqeMhsJDQb52bHRfMdupVzKjuVlfHVjzTV9oIRcjojfJxKceUQn5J4mODNNyONGyL1/5ESuUGKYS1s5nLMRntJ8lEdjWJxKByEnMHDWTfebw8wMzwpZJVBSY8TVYEaukJKIpklE0ySjaeKRNImI+PdcNEgn9VKhPEOV6jQVyjNoZcWjynDWxlhyOaOJdqIzBkzBYazuM6gixeniETucapDQXS+ltxyyMgkGpYF2Wzvt9vY8wXFoHXf8d1gI2UyG0Z6z9B49yJXjR4iHCteNUqOhtms1jes2Utu1CqXmg1M3giCQnogSOzVD7MwMuXDBIE9mVqHstDCiD3B28AKDgwWxqEqloqOjg66urlsSDc/ffzTai9uzG7d7F+HwuaL3Neoq7I77sdu2YTavuauzuUMYTaR41ysSm/3+MOFs8b2gSafmPouBe60G1pv1aK8uAoi4YeBduPIOQv87CPf/PtKVX76jx7ioZObtt99mx44ddHV1sWnTJgRB4NChQ5w5c4ZXX32VBx988LYO/k5jKZKZhZATcoyHx+n193LZf5lefy99/j5Gw6MLRnEkSKg0VNJgbqDeXE+jpZF6cz21xloUso/2YhfSWcIHxgm/O5Z3K9V02DE9XIPcdn0ClkskyMzMiJPbnZ+nZ2bIejziMreHbCBwU8cT02i40tpCf00NqdmRpEIQaJbJWG42Y7XZkJnNyExmcW42ITOZkOr1N9zfxuc7xMTkc7jduxAEkYRIJEocjgdwlT6N1XoP0ptIIc5Fa3404eGtedEanUzKkzYTVaEs756c4MxY4UG2utrCL2+s4eH20htqmZDLZon4vFdFc2byEZ6I14sgvD/ZUag1s/qcEkxzqaxZsmNylqBU3x7hFgSBySsBTr41zEhPIS1R2Wpl5fYqypss1/yPMqlsgdxE0sQjKeLhJFJ3D1r3QUzhI1hSZ5CRLvqcJ13DWLKdaV812akkFs8lTKFBJPOuv5hSyrka6G6A03US/IbCvq1yO83GFtod7ayoWE6Hox2TanF9t3LZLOOXeug7dpi+Y4eI+ApETKZQUN3RRcOaDdSvXofW+MHHMtcbKnZqhniPF2GeZkpeoiXdpKaXCc5ePk9w3uDDbrfT1dVFZ2fnbd9nE8kpPJ49eDzv4PcfKhIQy2R6bLYt2O33Y7fdi0KxtHoBflyRzgmcCkV51xdmrz/M6VCM+Ve+UiJhjUlMSW2xGujQa5AW9ZDKicL8O/zsWVQys2LFCh566CH+9//+30XLf+d3foedO3fS3d1980e8iPi4kJnrYS6K0+fvoy/QxxX/FfoCffgSvgXXl0lkVBmr8iSn3lxPvameamP1h573z4ZToj/N8SkxZSCToN9QhnFbJVLtrZ/0QipFxusl4/GS8XrIzr7O+nxkfD7xb59P/Nvvh7T40MrIZAzV1NC7bBlh0+y5IAiUjU+wrK8X5/RMsbhWJkNmNCIzGpGaTIXXRgMyowmZ0YDUYCzMDXqyWvBmDjAVeoNItCCeUylLKC39FC7X0+h0N+fR5E6leXbKz79OeOmPF0LDzTo190lUTPX62N0zTWY2H15iVPHlddV8fm0VDsOtm19lMxnCXk8+kiNOs4THPU3Uv/A5OB8ao6lAdEpK88Jkk7MUo92BVHbjgkH3aJhTbw9z5eQMc3ctZ7WBFdurqeuy31z5eDou+tn0v4sw8B6Sqxr4CRI5IXU7M9kOfMM6MkMzGCbOo0hHitabsmo5UyvjaGOMS5ViKfh8WDJOqiR1NKiaaDK30O5ow+mworeq0BqVdzSqJeRyTF7p5crxw1w5fhj/ZCFaKJFIKWtqoXHtBhrWrMfk/GCzPCGdJX7JR+yUm8RlX8G/BlBU6HFXpbkcH+Fi36W8aFgikVBfX8/y5ctvKw01h0wmis9/AI/7HTzed4t0NiDFZFqB3bYVm30rel3T3XTUHYI/neGAP8JeX5h3fSHGk8XE36qQscksRm3useip1iyOyd6ikhm1Ws25c+dobCz2a+jt7aWzszNfUbJU8HEnM9eDJ+6hP9CfJzpzryNX3WznIJPIqDRUUmeqo85cl5/XGmvRKha3iiA9FSXw+gDJvgAg9nsybqtCv8GFZJHN3ARBIBeJFIhOIEDG52dwaorTPi8j86rvTPE4y4ZHqO7rQ3Y9w8GbQLpGSnyzlFhXgpy2MM5RB6xYfE2Y4+2otA6kOj1SvR6pXodMP/daj1SnQ6bT5W36BUHgSDDKjye8vOYOkJglL0qJhPt0WiyTCQ6encITEUeyCpmExzpcfGVjDSsqb0/7suD3SyXFtNUc0XFP57U7oZnpIl3HQpBIpRhn9Toi0SnFnJ+7UF+nbUXIE+f0rhEuHpokM1uZY7SrWX5/FS0bXYWy7ptB1AOD+0R/m4F3IXBVd3uFDqFyA9FcE8FBgeipXrJ9F2He7TMjVzDmcnCuUs6Rhhh9ZX64+jcXJFjiTuzRSkri1dTIGqjXN2CzmjHY1Bjtaow2DUa7Bo1BcVupG+/YCH3HDnHl+BFmBvuL3rdX1dCweh31q9dTUtfwgfvJxdLEe7zEzrhJ9gcKeiYJUK1lxB7kgm+AsYmx/GdUKhVtbW10dXVRWVl52+efIOQIhc6IURvvHiKR4koblcqF3XYfNvtWrJYNd6uj7hAEQWAgnmSvL8w+f5gD/giRq1JS1Wolv1ph59crnXd034tKZiorK/n2t7/NZz7zmaLlzz77LP/5P/9nRkZGrvPJjwafVDKzEARBYDo2TX+gX5yC4nwgMEA4Hb7u51w6F7WmWupMddSaavOTTW27ow/AxGUfgTcGyUyL2iCZVY3p4Ro0HfaPbETl8Xg4duwYp0+fzje3VKlUdHV2sqpxGSYJZINBsqEQ2WCIXChINhgiGw6TC82bh0JkI2Fy4Qi5cPFvLcgEEh0CsfVZkm0CzD1r06A+J0F7VIbqggRJduHfQKJUXkNwohYrby9r4+XqZVwymPPrlqbTLJ+OMDWe5HKgQNTaXXq+srGWHV3lqBUfjq9KMhYVSc70lEhy3HOvReKTTaff9/MqnS5PbMwlIuERX7vQ22wko1nOvjfG+ffGSUTTs5+R03FvBR33VaA13kYk0jcoEpvBvSLJiV1lu6CxknGuJxoqIzoYJ3LiHFlPcRdwHA4CTXVcqtRyxBXjgnKYgOSqdQCJIMEcL8ERqcIRrcQRqcQWK0cjV2O0i8TGZNdgdKgxObSYHBoMNvVNuTqH3DNcOXGEK8ePMHbxfJFWSm+1Ub9qHQ2r11HR1vmBAuJsOEXsrJv4GTepkXnnuhTi1XL6dW4uTF8hFC5olCwWC8uXL6ezsxOr9c4UNCQSE3i87+H1vIvPf4hcrjCQlkiUWCzrsNnuxW67D42m5m7U5g4hnRNbLcyRm5OhKFkB/mttKf+x5ubaY3wQFpXM/OEf/iHf+c53+J3f+R02btyIRCLhwIED/J//83/4T//pP/E//sf/uK2Dv9NYNDLTtxv2/V+ouQdqNkPlOlAuzZGAIAi4426R2AQHGAgM0B/sZzA4eN10FYBBYaDWVEuNqUacG2uoMdZQZay65ZSVkBWInZwmuGsoLzRUVhowPVqLqvaj6+uVSCQ4ffo0x44dK2rO19jYyNq1a6mvr7/hKighlyMXEUlNNhIlFwmLpCccIRmbwis5hk93hoSm8GCTJuToe81oT6mR92cRIlGEG4xy9lbW8ObG+9i9dhMRbSGa0Xz2Erp+H72qMtKzuWxDKsbDnvPsCPdRqcyJBMlgmI0KGZAa9MgMBqTzXxsMYnpNL/4tucnmiNf7jaIBP4GZqTzZCcwRnelJooH3r36TyeUYHSWYS0oxOspJJSuYGtIQDwuz70tZtq6ErvursJbdZjuDXA5membJzT4YPgSp4qiToHeR1Kwk6rEQ6fMRP3sBIVVsTaBqaUG2pouJFgdnS9OcDlzmov8C3vRCBEeKJVaCI1qFI1KJI1qFLVqGXBD/jxKJ6JxscmgwObWYnVpMTg1mpxaDXY3sfVJu8XCIwVMnuHLiCEOnu0knC+eZQq2hZvkK6leto3bF6g/U2WT8CeJnPcTOukmPF34TQQbe8jR9yil6pwdJzyOulZWVdHZ20tbWdkumfAshm03g9x/G692Lx/suicRY0fsadRU2273YbPdisaxHJltaxRMfZ4QzWQ4HIizTqam5w+mmRSUzgiDwF3/xF/z5n/95vk9OWVkZv/3bv803v/nNJcd+F43MvP27cPivC39LFVCxWiQ21Zugci0ol0ZPmPdDIBFgIDjAYHBQnEKDDAQGmIhOkLuO+FMqkeLSuagx1eQJTrWxmlpTLU6t84ZKVnPJLJH9Y4T3jSHMVp+oW6yYHqlF4fzoSGEul6O/v5+jR49y5cqV/HKLxcKaNWvo6uq6YzfgcPgiU1MvMjX9yry+UKDV1lFa8iQl9sdQZS3kolGRFEWj5KIRkShFo2QjEXKRaP7veDzOHouTl6sbOVFWhTD7f9CGItSe6MMX1eBXGgDRiG/V9GUeGzrMmqmLyG6iDlqq1YoaIoNhnn7IiMxkRGo0ikJqkykvpJ6bpEbjDTvYphMJkeDMkpvA9FRhPjN9nZJzCVJFA3L1aqTygq+QyZGmYbWO+q5yzK4yFMrbvOFm0zDeLRKbwb2iK/FVnko5XRUxoY3ojJbopSmSV4ot41Eo0CzvRLd+A6muZfSVSbgQ6qXH23NdA06pIMORLsMWqsAWqshHcGRCMbmUSiUYHRrMJVrMJVosJVrMpVospVo0+uJBSCaVYqTnDP0njtJ/8liRDkoikeJa1kz9qrXUr1qLtfz9U0VpT5z4WTfxsx7SU4U0bVqWY6I0Sp90kmHPWL6yUCqVsmzZMjo7O1m2bBnyO0CSYba9SGwAj/ddvN73CAROIAgFMiWVKjGb12GzbsFm24JWW7/knlt3IeJD85kJz4bTDQbDrW5i0bFoZCYwAgN7xaZdQ/uvdSKVyqFshUhsqjdB1TpQL62O4u+HZDbJSGiEweAgQ6EhcR4cYig0dF1dDoBKpqLKWCVGcAxVVBurqTZWU2WsWjBtlQ2lCL0zKxLOARLQrSnF+EAVMuNH27nV6/Vy/PhxTp06lffZkMvldHR0sGbNGsrKFu7VdLPI5TL4/QeZnHoJt3tnUbjcZFpNaemTlDgfuanKjdFEimcnffxsysfIXIm3IFDmT6EfiTAyXdhHqSLLU7owTzCNJRYUI0mh8GxkaTbCFA4jxOPX2dsNQioVSY95tmrMYkFmsSC3WmZfW5FZLWLJvdWK3GpFugBxzOWyRLzeoh5YhddTpBNxJLIy5OpVSBUFPUgu4yab7Eatd2MtLcFc6sJcWobFVYaltAxTqevWiE46DqPHCuRmvLu45QKQUdcRTTUSnVQQvThOZqq435REo0G7YgXatWvRrl1LsM7BxVlyc8EruowvFEWVIadMWkVZqhprsBLDdAmmUOk1BGcOap0CS6lIbqwuHZZSHRaXFoNFDQhMD1yhv/sY/ceP4B4ZKvqsucRF3co11K1cS0VrGzL59dNR6ZkY8XNixGYurQwQlaYYdgbpy43jDhUIm0qlorW1lc7OTqqrq2/LC+pqZDKRfNTG691bZKMAoFaVYbVuxmrbgtWyEYXi43Of/qTjrmnePHwomhlBAP+QSGqGDopNvIKjV60kgZJ2qN4I1RugagMY7mx+8cOAIAh4E14Gg4MMh4YZCg6J89AQY+ExMsL1Tdr0Cj1VxiqqDdVUGitFkjNLeHRBJaG3h0lcEG9wEoUU/eZysTO3+qN1RU6lUpw7d45jx44VuaKWl5ezZs0a2trabrtqYw6ZTBi3eydTUy/j8x9iTmkpkSiw2bZQWrIDu/3+Gw6T5wSBw4EIP53y8dpMkPisVkISzVDjSRMcChFLiP8zuVTCQ+2lfGldFRvqriWeQjpdpBXKBkPkwqKWKBuapycKhciGgmQDQbLBALlAkFxsYQ+lD4JErUZusyGz2ZDbbMjts6/toomi3GEX53Y7Up3umqaf04MzjF2GsN8GiOeRkIuSSZ4hmzwLQvFxGWwOLK5ZklNahtlVjsVVhrmk9H0f3kVIhmHkiEhuhvaL5mLzopyCAGllA9F4LbFJKdGLY2R9xWk1iVYrkps1a9CuXYO6rY3ptE9snTJLcHq8PQSSgWt2r5AqqNHUUSWppzRRjcVfjnLCSsx3fY2SXCXDWqrF4tJhnZ0Uqhgzg2cZ6D7GaM9ZspnCta3UaKjuXEHdijXUrliNznx9oj1HbOLn3KSnCr+3TxZhyOqnLz1OOFGI5BgMBtrb2+no6MDlct3Zii9BIBbrx+vdh9e3j0DgaFHpN0gxGZdjtW3BZt2MwdB5U5YKd3Fnseil2QudXBKJBLVaTUNDA1/96lfZunXrzR31IuEjEwD7h0VSM3RQ7HXhG7h2HUuNSGqq1kPlerAvgzs4IvmwkcllmIhMMBQaYiQ0wlBIJDojoREmo5ML+uXMwaAwUGmsZH26i21XurB5Z7UfGhmmbVXoN5QteuXTB0EQBEZHRzl27BgXLlzIN7hUq9WsWLGCVatWYbffORv2RHKK6elXmZp6hUjkQn65TKbH4XiQ0pIdWCwbb/hmG8lkedUd4GeTPo4EZx8eWQHtTALTZBy/uxB5qbPr+OK6Kp5ZWYFFd/sl/blUimwgUDz5A2T9fnEK+Mn4/LPl9D6yXh/CB7RquBpSrbbgGD03lThROJ1kzU6ujCnpORkkGhQf6hKJgNboRSJcIOy5SPJ9KtgkEilGpxOLqxzLXDTHVY7FVY7Bbn//PknxgFgGPrgfhvbB1Hnm2xsLAqSk9UTjNcQmJcQujZENFhv8SdRqNF1daNesRrtqNZrlnUjUaiajk/nU1BzBCaWKPwtixHSZuYk6dSMVQi3OSBVqt5XgVILAdIxcduFrU66SYXXpMDvlkBsh7LnMVP8Z4qFA0XoldY3UrVxN3Yo1YnXUde5jaXeM+HkP8XMe0hPi7y0gMCkNMGTy0Z+eIJkpkAubzUZHRwft7e139NqaQzYbxx84is+7H69vP7FYcdWXXG7AYtmI1boZm3UzGk3VHT+Gu7g+FpXM/Lf/9t/47ne/S0dHB2vXrkUQBE6cOMHZs2f56le/yoULF3jnnXd44YUXePLJJ2/ri9wJLJlqpvCUeEMbPiTOr7qhAaA2i1qbynXiVL7yY6G7uREks0nGwmMMhYYYDY0yHBZJznBomOlYccgdATZElvPVmSepSonRK58qxNHGXiLNAhXGSioNlVQZqijRlnwkXY8jkQinTp3ixIkTReZhtbW1rF69mqampjumAQCIRPuYnnqZqelXSCQKKU2FwkqJ8zFKSh7HZFqJ5AYt9ofjSZ6d8vHclD+fhpKEUpgmE2THo6RnS56VcimPtpfyxXXVrKm51qBusSAIAkIsRsbnI+PxiCRnzlfI4yXj8RRNwg1GfnISKd7aexh1bSGgKERGHZYsy9qVmKulRNMJ/NNT+KcmCExO4J8cLxLJXg2ZQoG5xIW1rKKI5FjKyhd2SI75xHvAXIp6AXKTpJ5YoorYpIxY7zjZwFXu2AoFmrY2tKtXoVm1Cu2KFcjMZgRBYCwyJkZvPIUozkKpYY1cQ4u1hVZrKzWKBlzJGtQ+M4HJOL7JKP6phUmOIAgoVF4U8hGS0SvEAleJbY0martWUbtiNTWdK69bYp/xxomf9xI77yE9KkoWsuQYlXoZ1HsYykyTzRXSdS6Xi/b2dtra2m65P9QHIZGYwOvdh89/EJ/vIJlM8e+uUVdhtW7CYt10NyX1IWBRyczXv/51qqqq+Na3vlW0/I/+6I8YHh7m7//+7/mf//N/8vrrr3PixImbP/o7jCVDZq5GIij2uRg5Ik5jJ4parwMgkUFpO1SsFUlOxRoxmvMJE6slMgnGwmOMhEcYDY8yHBpmNDzKeGiMtvFqvuR+DHvGDMCQaoJ/crzMUf05kIgh9XJ9OZWGSioMFVQaKvNTub4ctfz2WhZ8EHK5HH19fZw4cYK+vr78cp1Ox4oVK1i5cuUdK0UF0WsjGOxmevo1pmdeLzIRU6vKcJY8RmnJE+j1rTdEPHKzXbyfnfLxykxA9I/I5JBNxjFMxEkECtGRBqeeL6yt4ukV5XckWnMnkY1EybhnyMy4C+7RMzNkZqZJT8++nppCmFdVEzTUMFZxHzOOlQizhFiV8FM+dYDq7BW0JSaU5eXIXC6yNitRtZIIAqFYFP+MmMYKTE0UpV+uhlqnzxMbi6sca1k5lrIKLKVlyGf9g4j5xEHO8MHrkpsU1cSStcRmFMR6p8h4rhUIqxob0KxYiWblCrQrV6KY9XbJCTlGw6P0eHro8fZw3nOeS75LC7ZP0Sv0tNpaabO30WJppYp6lD4j/sko3okovokowZnYfHsdhFyUbHqQXHoQITuMMC9tI5FIcC1rprZrNbVdq3DW1C0YtckEkyTOe4j3eEkOBkGAFBmGpW4GNG7Gsp6iyG5lZSXt7e20trYummZTELKEwufxeffj8x0gGDqFUJRGl2A0dOSJjcm06qabzd7F+2NRyYzJZOLkyZM0NBS7mF65coVVq1YRDAa5dOkSa9asyQuEP0osWTJzNbJpmDorCglHjojz8MS162ntIqmpWC1OZStBvYS/120ilU0x7h8jdGgM44kcipT40OnXj/F9+wuc1lx63887tU4q9MUkZ24yqW6tQ/f1EAgE6O7upru7m0ikMBKuq6tj1apVdzxak8ul8fsPMTX9Cm73brLZwj612jpKnI/hLHkMva7xfbZSQCybY6cnyHNTft7zh8jmBCTBNIrxKPKpOLnZngpKuZSH20r5/NpK1tfakEo/HuRaEATRNHFqtifY1BTpySlCEz4GfFaGpQ2k5GIkVJpL45w5ScX4Xozhq7yzpFLkJSUoKyqQlZeTctiI67VEZBJCqQRBnxff5Dhhj3uBo5iFRILR7hTJzSzZsboqsJSVY9DKkYwcniU3B8T7wtWaG0k5sXQjMa+a+ICX1Mj4NbuQ2e1oV3SJBKerC3VbK1KV+LDN5rIMh4bz5KbH28Ml3yWS2WtTexaVhVZ7K+22dtpsbTSbWpAHdXjGIngnInjHInjHI8TDaQQhSy4zQW6O3OSKSZdSa6SytYtl69dSu2IVGv21RCQbSZG46CPe4yVxxQ8ZgTgphmQzDChmmKRYX1RTU0NbWxutra3odIsXyc5kImJKyncAn+/gNSkpqVSF2bR6ltxswGBoQyL58KPGnyQsKpkpKSnhT//0T/nKV75StPxHP/oRv/3bv8309DQXLlxgy5YteK42kfoI8LEhMwshOCaSmrHjYvnn5FnIXS3ik4ham4rVUL5KTE0520C+tEbOdwK5eIbw3jEiB8cRZtMg1GmYWZtmQDvOaHi0aIqm39/FV6/Q5yM6FYaKPOmpMFTg0rmQ36LwL5vNcvnyZU6ePEl/f+GGp9Pp6OrqYsWKFXc8/5/NJvB632N6+jU83j3kcoWHkk63jBLno5SUPI5WW3tD23On0rw47ef5KT9nI/F8tEYxFoVQ4Rystmn53JpKPr2yAqdxcaNgi41MOkvf8SnO7R7BPVGIkloUIaqTF3CMHSE3PvKBWh6pVouiqgppZQVJp52oTkNELiOcShDwe/FPjr+vPkeuUolRHFc51vIKbA4LTpkbY7QX2dhRmDgFueJoUEbqIC60EPMbiY+EifcOwlURI4lCgbq1Fc2KFWi6utB0LUdRWki1ZXIZ+gP9RQSn199LJndt5MmpddJma8s32myztaFIavCMhfGORfGMh0WSMzZFJjVALj1ELj0CRf2wJGjNlZTWd1C3ajXL1nei0RVHNnLJDIlev0hsLvkQElmiJBiQzTAon2FGUkgDSSSSPLFpaWlZVGIDoqbN7zs0m5I6RCo1U/S+XG7CYlmHxbIBq2Xj3RLwW8Cikpk/+qM/4k/+5E/4+te/zpo1a5BIJBw7dozvf//7/Pf//t/53d/9Xb7zne/wxhtvsGvXrtv6IncCH2syczXSCZg6J5KbseMwfuJa23UAmQpKO0RiU7ZSLBG3N8JHoC1ZDGRDKUJ7Rogem4JZS39Nhx3jg9V5jxpBEPAn/YyFx4oIzlh4jLHwGDPxmffbBXKJHJfeVURw5s91ihu7Ufr9frq7uzl16lRRtKa6uppVq1bR0tJyxyqh5pDJRHB7djMz/Tpe3/4ijw29vpUS56M4nY+g1dbc0PYuRxO8MO3n59M+xhJpJMEUsjExWjPXAVMmlbC1ycnn1lSytcmB/Gb6JC0xCILA9GCIs++O0d89k9eNqPUKWja6aG7XoI7OkB4bJz02Smp0jPToKKnRUTLT00UtDq6GRK1GUVWJUFlJ3GEjptMSkQqEEjH8nhmC01Pkstnrfl5vs+ModVJjz+CSe7CkhlD5LyK52udGbiQhbScWcRCfSBPvHb6mYgpAXlKCprMTTddyNJ2dqNvaisrhU9kUvf5eznvO5wnOQHBgQQ+qKkMVbfY2OuwdtNvbabY2oxRU+KaieMcizAwFGLt8Hu/oRdLxAYTsVYNdiQqVrg5bZQtV7SuoaKnCUWnIOzkLmRzJwSDxC14SF7xkgynCkjiD0hkGZNN4pIVMwByxaW1tpaWlBf11dDt3CmLn7z78/kP4/Ifx+48URUoBlEoHFssGLJb1WMzr0Wiq7pKbD8Cil2b/+Mc/5q//+q+5fPkyAE1NTfz7f//v+eIXvwhAPB7PVzd91FgsMvPe5RmeOzFGtU1LjU1H1ezcaVB9uGH3yIzoazF+QtTdTJyCRODa9RQ6cC0XiU1ZF7i6wNbw8a6e8sYJ7R4hdnpGlBhIQLvCifGBauTW9z/3EpkE45HxPMEZDY8yFhHn4+FxUrnU+37eqrZSoa+4RqdTaajErrm2PUM2m6W3t5fu7m6uXLmSNw5Tq9V0dHSwcuVKXC7XQru6LaTTQdzuXUzPvIbffwhhnv+JwdCG0zFHbKo/cFs5QeBoMMoL035enQkQSKSRTceRjcWQBgq/l8Og4pmVFXxmdQX1jsV9iCw2YqEUFw5O0LNvnIh/NiIjgapWG+33llPdXpxmyyWTpMfHSY2MkB4ZITUySmp4mNTIMOmxcXgfoiI1GpHXVpMuLyNmNRNVq4jkMgTCIfxTE8RDwQU/J5PkKDckqXdmqdAEseYmkOeKBcuCVEVa10k8WUnMLSc+OEOyr//a45HJUDU2igRneSfq9g5UDfVI5jUEjaVj+cqpOZIzFikWAYvHJaPeXE+HvSNPcurN9cglcsK+BKM9I/R3n2Tqylki3isIVx2zRGpDqqhGa2rA1diCs9aGo9KAs9qA1qQkMxkjcdFL/IKX9ESUkCTOoHSaQdnMNcSmqqoqT2w+jEFtLpchHD6P338Yv/8wgeCJomgpiL2krLPkxmxej0ZTvujH9XHDXZ+ZeVgsMvOXu/v4zu7ea5arFVKqrFqqrDqqbVqqbdrZv7WUWzSo5IscHREEsQx84pRIciZOiT4XC6VclHoo7RRJztxkXwayj5evQno6SnCeRw1SCbo1JRi3VSEz3bwgLyfkmInNFBOd8Fie7Czk7TEfapk6n7qaq7qaIzouvYtYOMapU6c4depUUSVUaWkpK1eupKOjA43mztutp1I+3J5dzEy/gT9wuJjY6NtwOh/B6Xz4hlJRyVyOd71hfj7tZ5c3SDKUQjYeQzYRQ5IqjNpXV1v47OpKHu10oVd9vM6r+chlcwyd83J+3zijFwqia71VReumMlo3laEzv/+5JqTTpCcmRHIzNExqaCg/pScnrx/RkUpRVFRAdTWJUicxk46IVEowESPgniYwPVkUzZEg4FBHKdcEqdAGqdBH0EqLH6SCRErO2kqSJmIBA4nxGPELvWRmro1YSrRaNK2tqDs60HS0o+7oQFFRUUTYA4lAgdx4RYLjiV8rM1DJVDRbm4sITpWhCiGXY+TcBS4ePspYzxlC7iGKqz1lSOVlSBXVSOXVaM3lOKuMOKoMOKoM2MwqZFNREpd8JPsDhHKxBYkNiOLhlpYWWlpasFhu3IjydpDLJQkGT8+SmyMEQ6eLIqYAanWlmJYyr8diWYdafWdMOT/OuEtm5mGxyMz58SBHB30Me6MMeWMMe6OM+eNkc+8TYpaAy6im0qoVJ4uWSqsm/3rRojq5LHh6RWIzcQomTovpqqurpwDkaihpmyU5neLc2bpk+07NR2o0THDnUL47N3IJ+nUuDPdVIjPcOQ1ROBW+JpozR3gmo5PXbQMB4mjVpXNRZayiQl+BPWYnN5bDO+IlN9uJViaT0dzczIoVK6irq7ujbqhzSKW8uN07mZl5E3/gSBGx0eubcToexuF8+IbEw+FMljc9QV6c9rPPG0KYSSAbjyJ1J5k7mzVKGY+2u/j0qgrW1Vo/NqLhhRCYidGzf4JLhybzDS4lUgk1HTbatpRT1WJFcpPfL5dIkBoeITU4SGpokNTgIMmhIVL9A+Qi15ZVz0HmsKOorSNdWS5Gc1QKwtk0fq8b/8Q48XAIELAo45RrQpRrg1RoQ5iV15aap9VOkvpOMkItSa+MxMAkifM9Cxoeysxm1O3tqNvb0LS3o25rQ15amic4c01vezw9eXLT4+lZsOGtQWmg3SZqbzrsHXQ4OtBlVYyeP8NA90kGz3QTC1xVvSXRIJVXIVVUIZNXI5EZUesUOKr0OMv1OJVSdKEU2aEgwWiIIambQdkMM9Li6FZpaSktLS00NzfjdDo/tLRPNhsjEOyeJTdHCYfPFl2DMJ/crP2FjdwsKpnJZrN85zvf4dlnn2VkZCTfaXgO85v0LQV8mJqZdDbHuD/OsC/GiDfKsDfGsC/GqC/GiC9GLHX9EDOAUial3KKhIj9pKTeLr8stGpwGNbI79RDIZsDbJxKbyTNixcTkWUgtUIEmkYKtUSwTL2kXCU5pO+hLlmSZeHIgSHDnEKkh0TxMopCi21iGYUsFMt2d1adcjXQ2zUR04hox8hz5WahaBECZVVIVqaIh2oAuWdDjKLVKGtsa2bhmI+XOxbmZicRm1yyxKY7YaLUNOJ0P4XQ8dEPl3u5UmldmArw8E+DYdAjZRAzZeAxprCAiLTNr+PSqCj69soIq29InyddDJp2lv9tNz/5xJq8UHpIGm5qWjS5aNrrQW24v1S4IAlmPh+TAIKmBfnHe309yYIDM1NR1PyczmVA2NkBNzaw2R0OYHAGfF9/EKGnPMC51gHJtiApNCIc6wtW3lhRKQqoaErJGculSJBEFmSuDJC9dKipxz+/TZkPd1ponN+q2NuQlJYV2EkKOkdAI5zzn6PH2cM5zjkveSwumdEt1pXmC025rpzxtwX3xMkNnTzHac5Z04uqUlAWpokokOPJKJFLxd1fp5FSXailTyzDE0sT9QYZlboakbialAQRJ4fFnNVtobhWJTUVFxaIMIq6HTCZCMHgSv/8I/sBRwuHz15IbVRlmy1os5nWYzWt+ITqBLyqZ+b3f+z2+//3v81u/9Vt861vf4nd/93cZGhripZde4vd+7/f45je/eVsHf6exVATAgiDgjaYY9sYY84sEZ9QXZ9QvEp3JYOJ9ozoACpmEUpOacrOGcrOWcrOacouGMvPsZNKgUd5GGiuXA/8gTJ4WIzdT50SCE72OWFZrF6M4Je2zRKcN7E2g+Oi1UoIgkOwLENw1MEpwlAAApl1JREFUnDfkkihl6DeXYdhcjlS7uKRmIeSEHO6YO09w5nx1RsOjjIRGRGMzAcwpMzXhGiqjlShzhYhSUBskU5rBVm2jyia2hagyiimsO+Wnk077cbvfYcb9Fj7fgaJQuEZdhcO5HafjIYzGrg806BtNpHhlJsCLUz56xoIisZmKI8kUzvNV1RY+s6qCRztdGNUf/v/kTsE7EeHCgQkuH5kiOUvcJBKobrfRsqmMmg4b0jssis5GoqQGB0he6ReJzpV+kleukB4bu27KSmY2o2poQN5QT9JVQtygJyQRiHgnkE6fRh/uo1TuwaUJo5QVP0xzAnjSRnyScpK5KiRpO8pwBtnYOJmh4QX1QHMER93Sirq1FXVbK4ry8vxDOJ1L0+fvy2tvznnO0R/ov8YtXIKEWlOtSG4sbVSGjQhDXkZ7zjF1pRchlytaW6FxIVCBRFaJVF6GRCKeWyoJVOgUlOvlqNJxxnAzKHUzIfWRlRS2odNoWdbcRHNzM3V1dXdcpP9BKJCbo/gDxwiHz13lcQNKpROzeQ1m8xos5rXodI03bJr5ccGikpn6+nr+6q/+isceewyDwcDp06fzy44cOcK//uu/3tbB32ksFTLzQchkc0yFEnmCM+6PM+aPMx6IMeaP3xDZAbDqlLhM6llyI85LZ+cuk5oSoxrFzd5Uw1MFcjN9Xpx7rxR5X+QhkYnC4pJWsUS8pBWcLWCu+UjExoIgkLjkI7RrOG+fLlHJxL5Pm8uRapaGjkMQBALJACPhEUZCs+aB/mH8o36U00psURuS2aRNVpJlXDvOiH6EGc0MSMSR7FxTz7ku5jXGGsr0ZbfskJzJhPF49jDjfguvd19RA0yl0onD8SBOx0OYzWuRSt//Zt8fS/DyTICfT3gZHAqK0RpvIQ2lkEl5oNXJZ1dVsrnRfvPn6BJBJpWl/5SbCwf+/+z9aZAkaXrfB/78PuLO+66sysqsq6vvmZ6T4gAEVxA5ILSkCFIUyaVWJEWzpZHUckEYP8gIEwQSRjPtylYyGmUyDSCt1pYSxAMiBYAEyZkBMHd3T3VX15GVlfedGXd4hN++H9wjMiIzso7uOrvz3/3ae7hHZERURPgvnud5n2eb7ba7EzCzKpe+MMaVL41TGHu6W4ZD28ZdXsa5fx/n3hLOUty8jY3TIWd4CH1+HvXiPNG5aayMQWBvIu69j16+RcFbJy2ddEvXPZXtVpZtK4vnjaOGBbItD/2wiLCzG/9AOiYxl0O/fDmGm6tX0a9eQZ2d7QQZW54VBxgfxtabm4c32bZO5txSRIUrA1e4lrnE+WoBfbNJZXGF0nZvMLIgyqQK5xCVGZzWKAijCIKEAAzKAiOywJAWUZGKrEoHrIuHeMIRmCmSzIULF7h89QoLCwtPfct3P/m+RbX2PpXy96lUfki1doMo6rVoyXKOfP5t8rm3yec/TyZz7aGfyxddTxVmUqkUt2/fZmZmhvHxcf7Fv/gXvPnmmywvL/PGG2/0BDS+CHpZYOZh8oOQvbrDVrnFdqXFVqWVQE6rs2Y9xI0FIArxbpOxXAw7Yzmd8ZzOWC6GnbFsDDzqw+oguU04uBPDzd5Hcdv9sP9OKgDFhOHLMdwMX4kBZ+QKZMafiasqiiLsj4rUfmetU+xO0GUyX5kg/ZXJ517M8mHaPNjke+99j6VbS9jVI6hwJIe11Brr6XWqahWOvZSKqHSKec7mZpnNznI+d57zufPktEdPxR4ETYrFb7N/8FscHv7bnm2nspxjaOhrDA//YQYH/sADi2BGUcQdKwabf7x2wNZKAjbW0a/OtKHws69P8CffmuL65JNNbPgsVd61uP37O9z53g6t+pGFa3wux+UvjXPxrRHUZ/i+C1stnOVl3ARunMV7OPfu4W33Sc6ZSJmeRltYQJu/iDqdI2QboXIb5fADzNY64jELih8K7NkZtlsZdhoZ6mWdtK8zGApkGk2UYgmhjwVHMAz0hQW0K5djK86Vy2gLC4jJjthiq9hxTbUBp+qcvNZklAyvGZe5VB8htxtiL+/QLPduSZdVnfz4RVRzFs8bp17KQASGACOKwLAMvlZlSzpkTTrAEnpdw1PDE1y6foVLly8xPDz8XN6fQWBTq92gUvkBlcoPqVTfIwx7YVMUDXK518nn3iaXf5tc9g1k+eUqj/NUYebSpUv8j//j/8g777zDV7/6Vf7IH/kj/MIv/AL/6B/9I/7qX/2r7PeJhn+e+rTAzMMURRG1ls92NQab7arNdqXFTjLeqbbYrdp4pxSU65YgwGBKZawLbsayOqNt8EnGGU3u/SBHEdR3YO8W7H901B8swimxIui5GHKGL8dwM3wphp3M2FOBnCiMaH10SO131vH3jkHNl18cS81piqKI7e1tbty4wc2bN2l2BWfqOR0mYD+3z4qzwnpt/YFbzAtaoQM2nZY9/1BrThg6lMrf5WD/tzk4/J2ekgqiqDMw8BVGhv8wQ0M/gaKcvlskiiJuNlr8s70y//jePvsr1dgN1bUbaqRg8CffnOQ/eHOKc4Mv1xdxW4EfsvZhkdvf2WbtZrFjHJFVkbk3R7j8xXEm5/OPHTT8xB5fw8JduhcDzr0YcOzFewSnJD0VFAV1bg59YZbUOR0900Cwl5EOP0RyTwJG1dXYaWXYaWXZsdK0qirppkfe8Sn4Iam6hdivJIQool44j375Sgw3ly+jX76MPDgYF32tb3RcUzcPb3K7dPtkTFoE58NRrjenGTlQYL2M3+y96GupNMPnLpMqXABhklopRXW3SUEUGFZAVZuU1EPWxUOKx3ZGZfU0C/MLXH7tKrOzs080w/fjKAw96o1bCdz8iErlR/h+peccQZBIp68kcPMW+dzbaNrIc3m8j6qnCjO/8Au/QDab5W//7b/Nr//6r/On//SfZnZ2lvX1df7G3/gb/L2/9/ce+b6+/e1v8/f//t/n3XffZWdnh3/yT/4JP/uzP9s5HkURv/iLv8h/99/9d5TLZd555x3+2//2v+XatWuP/Dc+KzDzKArDiEPLYbdqs1O12a3abFdb7FRsdmvxfLdq4wan78bplqlKjGZ1RjIaY4kLK25aB4CGMxq6mGwX37+VtNuxVad4H6JTrElaDoYXEri5HMfiDC9AbuaJuKuiMKL14SG1f72Gvx9/uQm6ROYrky8F1AD4vs/S0hI3btxgcXGRoOsX7+zsLK9cf4WBcwPsOrus1FZYra6yWovbrnV68KgqqpzLneNC7sJRy19gNjuLKvXuCouigErlXQ4O/yUHB/8K2+428Yvk859jePinGB76QxjG9Kl/M4oibtQTsPloh9JqDXHfRuhyrZ4bT/MfvjnN//n1SYYzL2cNHKvicOd7O9z57i6VvSMQzQzqXHpnjEtfGCM/8mIERfulUmy9WVyMISfp++1uApByWVLXJknNahi5BkqwhVBfQTjmjg4ikX07zXYzzU4ry3YzTWiJZFtu0hxyjofq9a95JQ8PxxacS5fRLl9Cv3wZdXYWXwi5X7nfgZubhzdZqiz17i6MYKCucM2aZLqcRttuEbm9f8fIZJm4fI386DyKPoNVS1FZa6CVbTKqi60V2ZaK7IjlnjgbGYnJwgRXXr/K1TeuPecYzRDLWqJS/RHVyrtUqj869tmMpevT5HNvJXDz1gsXd/NMt2Z/73vf4zvf+Q4XL17kZ37mZx7rtr/5m7/J7//+7/Pmm2/yx//4Hz8BM7/yK7/Cf/lf/pf86q/+KgsLC/zSL/0S3/72t7l79+4jFxc7g5nHUxRFlCyX3ZrNXi2Gnr1qAjs1pzOutk7uZjhNeVNhNKMzkkDOSCaBnZTATLTFiL1CrnEf+fAuHNyF0v3+8TgAsgFDFxO4uRRnNh66BINzID/+Be4Iatbx99uWGon0lyfJfHniuQQKfxy1Wi1u3brFjRs3WF8/ygotSRILCwtcv36d+fn5TiBj02vGYFNdZaW2wkp1heXqMmvVtVOtOaIgMpWe4kL+AnO5OebycTufO48hG0RRRKNxh4ODf8nB4b+i0bjdc/t06hJDw3+I4aE/RCZz/VTzfBRFfNBo8b9tFvmnH2xTXq/3xNcgwPx0jj/z1jT//qsT5IyX49+oW+0sw7e/u8PSD/dw7SMQHbuQ49IXxrj41gj6U95997iKwhBvezsGm6TZdxdxV1f7BgCLSkT6Up70BQ0910KJthH9kzsmHTHNQTDIZk1nvaKy20ohugLZltMBnIztknK8455UAARNQ5ufj+Hm0mX0y5fQLl3CMWRul273WHC2Gkd1rIQQBmsqEyWTudoA2YMIwev97tEzWaavvMLY/FXM3CxuK0d9qYq/XcXxD6moh2xIRVpC7+cmJ2SZGJxi/vWrvPL2JdTnHOBu2ztUqzHYVCrv0mjcAXqfqyxnyGXfIJd7k1zuTbLZ15Dl55f48qXMMyMIQg/MRFHExMQEf/2v/3X+1t/6WwA4jsPo6Ci/8iu/wl/+y3+57/04joPTVTulVqsxPT39xGHmh1WL/2n7kC/m03wxn+acrr60vv2Po5YbsFezO9CzV7PZrTrs1232aw579djK4/iPZuUBKJgKo1md8bTANe2QeXGLc8EGo84qeWsFvbaCcJrbRBDjiuJDC3EA8tBCAjoLYA4+1GUVhRGtmwnUtN1PmkT6S3FMzdPe0v0kVS6X+fDDD/nwww85ODgqdqhpGleuXOH69evMzs4iSSddSUEYsG1ts1I9ApzlyjL3q/ep99u2T7zTZCI9wcX8Rebyc1zMX+Ri/iLjmkqt/G0ODv4V1eqPeraaauooQ8M/ydDQT1LIf/HUasNtV9T/snbIP7uxTWW9hlg9AmlBFLg8m+c/emuKn31lgtRLmJjPdwOWbxxw93u7bNwqddxQoiwwe32IS58f49wrg0jKi/OL+bhCx8G9fx/7bhfkLN4lODjuqopQ0gHmOKTO6xgFG0U4RDh2UY0QcMwpyuIYu3aWlUOB1V0H0Q/J2DHcZG2XTAI58imbI+SJ8SMLzqXLaJcWaIyk+ah8u2O9uXl4k7ITx9UIIQxVNcaKGpPlFCNlFfGYgUhPpZm8co2pK68wMnuZyB+gcrNEaXWDw9YuB9Ih+0KtJ35NiWQGokGG85Ocu3aJc5fHGZxMIz0sNvEpyvfrVKs/TgDnXWq1HxMEx61uIun05QRu3iCfexNdn35m17onDjO/8Ru/wU//9E+jKAq/8Ru/8cBzH9c603kgx2BmeXmZubk53nvvPd54443OeX/sj/0x8vk8v/Zrv9b3fv7O3/k7/OIv/uKJ9ScNM7+yvMP/c22vMx9TFb6QT/GFfJp3cikupXTEzxDc9FM7jmev3gYeh72azX4y3q8f9Y8SyyMRMC3s86q2x6vaHgvSNjPhFmPeGnrwgKKSej4Gm8H52KozOB/PBy6csObEMTVF6v96HW832f2kiqS+ME7mq1NPNPne01YURezt7fHBBx9w8+ZNarVa51gqleLq1au88sorTE9PPzSnRhRFFO0iS5UllivLLFeXuV+5z3J1mZLdP7eUKIhMZ6a5mL/IQnaCObVF1lvGrr1HGB59aUqSycDAVxke+kkGB/8gqjp46mO4Y9n8z0t7/PMPdiit1XoChwVJ4PJsgT/z1hR/4voEuvLy1SKzqg6LP9jj7vd2KG4dvac1U2buzREWPj/KxMXnF1/zuIpdVYs4d+/GoHP3Ls7SUk+xTkGK0PMexqCLOSVhDLrI0snPcyQb+AOXqBvnOAiG2KqqbO41KG9toVkWmS4LTrblYpzipkLT0C5exLh6BW3hEtrCAqWpDB95a9w8iC04t0u3afktxBAGqypjRZ2xks5oWUcOel97RTeYvHSFqSuvMHnlGmlzgr0f7bCyuMhuc4cdoYgj9D6WTJAi4w+QMcYYPT/L2IUCI+cyFMZTSM9pJ18Y+jSsO1Sr73WabZ+sxq4og+RyifUm+wbZ7PUHBv1/Ej1xmBFFkd3dXUZGRh74pScIQo/f/nF0HGa+853v8OUvf5mtrS0mJo7SOv+lv/SXWFtb47d/+7f73s+zssy8V7P47cMa3600eL/WxDv2MuZlic/lUryTS/FOPs2rGQPtJa6D9DQVRRGVpsde26pTs9mvOxzUj8Zt8HH7WnoiRqgwJ24zJ2xzQdhhTtjmorjDuHB4YsdF51aCSJSbQRi6iDB4MbboJC1KT2DfrVD7N+t4W8nOHVkk/fkx0n9gCvkhqetfNIVhyPr6Ojdv3uSjjz6i1ToKgsxms1y7do1r164x2ZUD5FFVskvcr9xnqbLU6ZcqS313mwAYosyXB4Z4LQXj7COH3RluBXK5Nxga/EmGhn4i8eH3fzxLVotfu7vLv/hgh8O1GmKrK6W/JDA/m+dPvjHJn3l1EkN9+Sw2h5sNFr+/y+IP97AqXVXQ8xrznxtl4XOjDE2nXzqLcOT7uOvrCeDcxblzF3vxLv72TuccSQswBmPAMYZ8jCEPUepzbTEGiCbewClcpiKNs2tn2d+vUtzapLa2gnpYItNyydixuypju0inXPKEwUG0S5dIvXINZWGe/QmDW2aFm+XbfHj4IffK9wgCn8FaDDejJY3Rso7q936vS4rC2NwCU1euMXn5GkMD51h/f417dxfZtHY4pNdqI0cihSCP6RbAGyA9Mszo+Twj5zIMn8tQGEs9t4zZtrObgM37VKvvU69/dGJLeBxYfJmJ8Z9jaurPPNG//6lwM7VhZnt7u6cA31/8i3+RjY0Nfuu3fuuR7vdZxMy0gpD3ahbfrVh8v9rgR9UmrWP5FTRR4PWMyedzKT6XS/F2LsWA8vJ9wT5PtS093Rad/brTcWsddFl7Wl78xafhcl7Y5YKQgI64w3lhhwvCDlmhTzmHRL6oYaXP4eUuEMlfINh7Bb+UJKaTBFJvjpL5d6aQh57OL5KnqSAIWF5e5ubNm9y5c6cH/vP5PNeuXePq1atMTEx87Atl25Jzr3yP+5X73KvcY6m8xL3KPVo9ZTQippSIVwyfV02YUHp/wWr6JMNDP8nQ4E9QKHweUewPkRsth2/c2uGff7DN3loNwe4Fm9lzOf79Vyf4j9+YIq29PC5DiAP3txfLLP5gj/vvH+C2jl6j/KjJxbdHmH9rlIGJl3O3V1tBrZbE4MSA4ywuYt+7R9RsAhFqxscY9NAH3Lgv+Ahin8tXdgom3yCaeBMnv8BhMEDxoEJxa4PSxgbN+/eQdvZiS47tkGm5mKdYcSJZRpyaRL90GeP6VfYnTG4VLG74a9ws3mStskq+LjNaSuCmpGO4xyyCgsDQzDmmLr/C1OVrZNPjbC5uc2/5PhvWzolYGzPUGAgKaG6BoJXDkQyGp9NxLapzcaHN/Ij5XKxzQeBQb9zswE2t+j6OG3sozp//a1w4/2ST5n4qYObjupmO63kEAHth7Of/fqXB96sWP6haFPt8WOZNjbdzKT6XTfFWLsW8qX3mXVNPQlEU0XD8Dui043ja8NN2dYX1fUbdDc53ACeGnhlhH0UIjt0nOOGr1IOfwwlfi9cIsbM7WBdspAszZCcvMzI8+smyMD9jeZ7H/fv3uXnzJnfv3sXrSlP/pMCmW2EUst3Y5l75HkuVJe6V77FYXmS1tkoQBeSlkGt6wDUjYF4PUbr+ZIiCmHqF0eGfYm7iZzH00b5/Y99x+R8+2uZ//2CHzdVqD9ggCkxMZfj3ro/zl9+cZjj1clnYAi9k7aMiiz/YY/XDQ4KuYNXByRQX3xrl4lsj5EdfjB1Rn1RRGOJtbmLfuYNzdxFnMXZXeevrCGKElvcwBjz0QRdjwEPN+v3D4wbmYOKNuE2+iZufp3RQpri1QXFrg8rKfZzFRYStHTJNh4z94FicMJVCmj2HfHme6oVBloY8fmTs8UH1Do39fUbLMdyMlDWyzZPwbAwWmLl8nalL11CVYXa3DlnZWmO7ddCzQwqgEKbJ+3lUp4Bv56gHIrIuMTyd6cDNyEyW3LDxXADHtrepVt8nnb5EKnXxid73U4OZMAz51V/9Vf7xP/7HrK6uIggC58+f50/8iT/Bn/2zf/YTfdmdFgD8N/7G3+Dnf/7nAXBdl5GRkQcGAB/Xi7CbKYoillsOP0jA5odVi6XmybwrOVnizazJW9kUb+dM3siY5M6sN09VTddPQOfIqnNQaxAU15ArK6Qbqwza60yG25wXd5mgiBddpu7/Sezwc5370cXvkZH/V+rCDhvCOPvKJFVjhlbmHNHAHOrIRQYKg53cPcMZ7cnV2XpCcl2XpaUlPvroIxYXF3vAJpfLcfXqVa5cufJU6ta4gctydZl75XsdwFku32Yw2ueaEXDVCMlJvV9Vh2GKljpPtvAlLoz+BAuFS5hK70W87vl849Y2/+TGNiurFWh2gY0AA2Mp/uCVUf7K2zPMD7xclg235bPywSFLP9pj/VaJsCvubHAqzcU3Rz5VYNOt0LKwFxd7AMe5exfsGvqAhz7gYQy46AMeavqkeypCgMF5hMk3E8h5Hcau46NQ3tlKrDjrVO/cxl1cRNjeId20H7ijKhIEwqFBotkp6heG2ZxW+XGmwvvN+8h7TUYSt1ShpiAeuwdRVxm8cJ7Zy6+jKMMcFuusH2xx4FZ6zhMigeEwS94voLh5XDtDLYjDp1VdiquIn8syklQTf16A86T0VGAmiiK+/vWv83/8H/8Hr732GpcvXyaKIm7fvs2HH37Iz/zMz/BP/+k/fawH2mg0WFpaAuCNN97gv/qv/iu+9rWvMTAwwMzMDL/yK7/C3/27f5dvfOMbzM/P88u//Mt885vf/FRszS66Pu/WLH6UAM6NepNWn18B86bGGwngvJk1uZwyUF7iN+fLqpYbxJadUpXGziLBwT2M3QOG98cxnAsIxBd3TfyAjPTraOJ7J34h7kd5VqIxVsMx1hijpE/RzJwnzM8yVCjEO7m6sjKPZvXnFsTqui737t3jo48+4t69ez1gk8lkuHz5MleuXOHcuXN9d0U9KZXsEvfK97hbvMN26fsIzQ8YYZ8ZtfcCVQ/gji2zL4wip17j4uB1LhUucWngEqNmXOzQCQL+0eI+/78fb3LnfpmwcfScIiA9qPP5hSH+47em+erUwFN7Tk9DtuWxcuOAez/aZ/NOmajru2RwMs3cm8NceGOYgfHUSxdj86iKoghvazuGm7Yl584dgt0V9IKbAE7splLMk7F3ESIU5mDmLYTxBHBGXwEtTeD7VPd3KW6uU1y+T+PDD3Hv30fc3iHVtMm2HNRT8nOFioI7Pkx9ZoCdGYPbBZs7zi5KOWSkrDFc0VCC3h8HkQD62CDDc5fJZ85TabhsVfao+b2B0VIkMhrmyQd5FCeH66Sp+AJtP4BqyAxPpxPIeb4WnI+jpwIz3/jGN/hrf+2v8c/+2T/ja1/7Ws+xf/Nv/g0/+7M/y3/z3/w3/Lk/9+ce+YF+85vfPHFfAH/+z/95fvVXf7WTNO8f/sN/2JM075VXXnnkv/GiwsxxeWHELavFj6oW79aavFezWG2d3IZsiALXM7HV5o2syetZ8zO3LfxFk3fQpP7NTZrv73XSNkRmjSjzA5Tw35JtrZE6lo3zuHaiAdaiUVbCMVajuK1EY9SNKQq5HOM5nfG8znhSdmI8ZzCRj8FHk58u8Hiex9LSErdu3eLu3bu47tH70jAMLl2KC/LNzc09k4J8XuixfPg+Kzv/O1b1+6S81R63YBDBqiNyy5a4ZUs0xTyXC1e4NHCJywOXuTRwidnsLP9yrcr/9P4m7y8Vccu9llI5rXB1rsB/cH2Cn7syjvoS1YqyGx7LNw64/+4+G8fAJj9qMvdGDDbDM5nPxPdG2GziLC31xOJ4q7dQ5WIHbvSCdwrgCESZGYTptxCm34bx12Dsepy5HAjDgOr+Hocb65RvfYT10U28+8tIu3ukrRYpx0U65QrrpE1qEzn2Jk3uF0I2QguhJTBc0UnbJy3ykamgz8wwMHgRL1DZrZdohb3vWyWSGA3zDFJAbeVwnBQlH5yux9C24AzNZDoWnOcVg/MwPRWY+cN/+A/zEz/xE/zCL/xC3+O//Mu/zLe+9a1Tdxk9L70sMNNPh67PezWL92tN3q1Z/LjepNZnN09BlngtE4PN6xmTVzMG45rymfiiepHkVxwav7uJ9YNdoiSWQRrUyXx1itQ1DaG2AsVlwuJ93P17BIf3UaorqMdMyce1HQ2wmkDOcjTeAZ2NaAQXhaG02oGb8ZzBZLuKej6usD6U1p7Ybgjf91leXub27dvcvXu3p5yCoijMzc1x+fJlFhYWMM1n494IQ5dK9V02d3+Tw+I3idze7aQVX+C2LXLblli0JexIQBEVLuYvdgAniOb41rLGD5cqVPeaCN3fiqrI1HSW/9OVUf7iG9OMvURxNnbDY+WDA+6/f8DG7RJhV8XydEHj/OvDXHh9mImLuSde1ftFVhRF+Ht78Y6qBHD85Q8Q6/fR8zZ6wTsVcAACfQzGXkOc+wLC+Gsw/jqkjlIKRGFI9WCfw9VlKj9+n+ZHH+GvriLvHZBu2qduGw9Fgdpgiu2JFOt5iX0pQHQVcg0VKer9DIcChGMFMsNziHKOstPECXuTmbbhZkQokGKAVt2g5ETUjz0tpR2Dk8ThDE9nyI+Zz20XVVtPBWbGxsb4rd/6LV5//fW+x99//31++qd/mt3d09OkPw+9zDBzXGESe/N+rcl7tSbv15rcarRw+/wTDqsyryVg0+7H1DPAeRYKLI/Gd7axvrtN2Iy/tMS0QvrLE6TfGT+ZVbhZiss9FO/H2Y+L94mSXnBqff5C8ncige1oKHZddVlzVqIxNqNhfOJfd6okMp7XmcgZTBZi2JksGEwl/XjOeHhh0X5/PwhYX1/nzp073Llzp6fIrCAIzMzMdKw2AwPPzm3Tam1SLH6LYvGblMrf7SnAF0aw7incbMJtW2LbE+L4iUST6Umm0q9TbHyO1Z0s5V0PugAgEiA3YvLO/BB/7rUpvjp9eu2pF01uy2f15iHL7x2w9lERv6sGlpaSmX1liPOvDTF9deCZFsB8kRS6Lu7SUicex7t3A+HgJqpc7AQbK6n+6UcCqUA0eBnx/OcRz78TW3Gykz0JO8MwoHZwwOHdW1TefZfW7TuE6+uoB0XSLfvUgOOGIbM5lmF7QKOkCEi+iub1/htFgJc2kUcnUcxhrCDAO1YuRo5ERsIcYxQoqEMIQZbdss+hE3L8WcmqyNBUbLkZnoldVc86D85TgRlVVVlbW+vZJt2t7e1tzp8/37PN80XQ04KZWu0D9vb+Odnc6+Syr6Np488FFNww5LZl8+Nakx/Xm9yoNbnbtOmXg25IkXk1Y/BqxuSVtMH1jMHMmYvqqSl0A6wf7NL4vS2CJE+IoEqkPj9G+isTyHn9wXcQRdAsngAdikvxmts49aYBItvCKEv+KCvdFp1wjG0G4/iARIIAY9nYijNVMJgeMJkqGEwVTKYLJuN5HeUhX2BRFLG7u8udO3e4ffv2iYKzw8PDLCwssLCw8EhJ+p6UgsChUvkBxdK3KBa/RbO53HPcF0y2owI/bnh8v1rHCo/9+o1khPAniVqfp1nMEDWPpX9PKczP5vijV8f4s69MkH1Jtn37bsDG7RLLNw5ZvXGIbR39ohdlgalLA5x/dZBz14fIDDzkffoZkF8sdraNe3dvwNb7iM1V9GwLLe+hZfsDTohBkD6PMPk64sJXEKffinNZSb0gEoYBlZ1tDn/8PrX338NZvAcbm2ilMuYpAcdNRWJzOMVuwaCqKQihghgdfa4iINQMvIEBlNwoniDjHcu0LEYCQ1GWsTDPiD5EShuk5kisH9rU7JPPSZJFBidTDM1kOpacwckU8lPawflUYEaSJHZ3dxkeHu57fG9vj4mJiY+dNO9p6WnBzMrK/5vllf9XZ66pownYvEY2+3qSFfH57CJoBSG3Gi3erzf5oN7kg3qLRcumn8E0J0u8kjZ4JW1wLRP386Z+FmT8BBUFIc0PDml8awNvN3HLiGC+Okz6D0yhTnyM2idRBI39I8Dp9An4+Kfn0PEElT0phpvb3gj3gjFWwnFWonEOycLxnRYCjOcMpgcMpgsm0wMmMwNH/VD6JBCXy2Xu3r3L3bt3WVtbI+zKu2QYBvPz8ywsLDA3N4dhPLtcPa3WRmK1+RblyveOpW8XEPXzVKVJ7jkqP6wUuVddxg9j61oUgRdewbW/TFibharc644SBQbHUnxxfpA//+oUb0/kXoofCmEQsrtcZfnGISs3Dqkd9L53BqfSzF4fZPb6ECOz2efuenhR1En+t7iIc+cG0coPEcp3UYQD9IKHlvXpV7MxiiR8ZYJo6DLihXeQLn0VYSwOND6uwPcpr65Q/OH3qd+4gbu0hLizi1GpnQg4DoG6oXKQMdgrGFR1FTiC6wgIVZ0glYH8MIGWwhdOXv4LYYrRMM+oPMBQZoRISXHQDFjbbdLqAziCKDAwbnL1KxO8+rXTi8l+HD0VmBFFkZ/+6Z9G0/r7ix3H4bd+67c+MzBTKv0++we/Ra16g4Z1p6fuTCyRdHqBbPY1ctnXyWZfI5W6iCA8n90pzSDkdqPFjXqTm40WN+stblv2iczFAKogsJDSuZY2uJbWuZo2uJY2KJxtE/9EiqIIZ7FM/dubOPePXDLaxTyZr06iLRSezMUvDKG+c9KS04ad8PQioY6U5kCdYl2YZNEf4UZrmEU/dl016f8L3VAkZgZMZgZjuDnX6VNMFQx812FpaYnFxUXu3buHbdud2wqCwPT0NAsLC8zPzzMyMvLMACAMHSqVdymVfpdi8Vs0rLs9xyUpTT7/BQLjEltBjtv1Q+6W73K3dJeaWyMIc7ju1/CaV6GSQ3B6P0uiIXJ+KsUfuzbFf/TqFAPmi18KI4oiyrtNVm4csPZhkd3lKt1fEXpaYebaAOdeGWTm6uALVwjzRVDQsHCX7mHf/ojg3ncRdj9Eaq2hmg30vI+onPzOjSIIyMdWnPFXkS5/FWn+S5Cd6FtXznMcijc/pPyD72N9dBN/eQV5/wDDatKdR9CTRCqGRtXU2M8Z1AyNMLkGRUCkqARmhiiVJ0hn8fvsTDQjjdEwx0iUYzw7QiY7jCVI7DZcNnaa2MmuwM9//Tyf+yPnn8yLmOipwMxf+At/4ZH++De+8Y1HOu9Z6VnEzARBk1rtJrXa+1RrN6jVbuA4J2OHJMkkk7lONvsq2exrZDOvoutPJhnZx5Ebhty1bG42WnyUAM5HjRb1U7YYjmsKVxLIuZo2uJzSuXhmxflYcjfr1L+9SevmYWcHlDxqkvnKJOYbIwhPqwBd4EN1Iwadw6UEeJbiVtmAU0o/ALT0UQ61aTbFCRb9MT5oDfMja4iNaJiQ/o9XEgUm8jqzgynODZqcKxgUqBOUttjfWqV42FuIMJvNcvHiRebn5zl//jy6/uxcHI6zR7H0u5SKv0up/Pt4XrnnuGHMMDDwFQYKX8FVz7NU3+ZO6Q6L5UVuFxe5Xx3Cs98hqE0hVMUeq00EqLmICxPw9UsFfu76VYZTL368Tavhsn6zyMoHRTZuFXuqewsCjJ7PdeBmeDrzQu6IeREURRH+/j7O3Tt4t75LtPYjhMo9lGgXLdt/qzhAEKj48hhRYQHx3NtIr3wN6dwbJ2rKteXUqhx8/3tU3nuX1q3bRBsbqIclNDcGjgiwFZmKGQNO2dSpmhph4vYNJZnASBOaGaJ0Hk/VjhtqkSKRoSgTW2+kAuPDY0iZDKlXhhh6q38iy4+rlzID8NPS8woAtp1datUb1Go/plq7Qb1+k6BPMURFGUzg5lWyCeicVmjvWSiKItZtl1uNFjcbLW41bD5qtFi3+1erVgSBOVPjSkrnSgI4l1I607p6ls34EeSXbRq/vx3vgHLjC4WYVkh/cYLUO2NI6Wf4a96zobxyBDfFpRh4ivfi2J1TFIkqzcw5DrUZNsRJFv0xftwa4bu1Agfe6S4kQYALGbhkNhgKSojWIYRHF0tRFJmenubixYvMzc0xNjb2zGJtoiigXv+IUun3KJZ+j2r1XaKoeweKSC77Wgw3A18hm32NVuCyWF7kbukuP9xf4/c3THZLI4SVLKJ1rCq0GCFnLSaGKnz5XMRXL8xwefAS57LnkMUX0wIaBCF7y1XWbhZZu1nsKYQJsdVm+soAM9cGmL4yQCr38uz6el6KfB93bQ331o8IFn8fdj9Eaq6hqFW0zCluqlDAC7KExgzR6DWki19AfvUnEQem+1pxAOrraxx+5/ep3biBe+8ewtY2erWGFEZEgKUpVE0tseLoVA2VSBSJBIFATxGYaTDz+IZJ2Cd+LhMavD5zlZ/8T77+RF+fM5jp0ouymymKAizrPrXEclOrf0CjcffYF2QsXZ8km3mVbPZ6Ysm5jiw/WpLAp6W6H3C70eKWZXOr0eJ2w+a21aJxihXHlEQumTHYdLeJsy3jfRW2/DhY+DtbBNUEHGWR1JsjpL8yiTLynLO4NkuJy+peAjlJX7wPwelB/4E5jJW5wIE2w5o4yW1vnHetIX5YTlF3et87EiFjYp1JscKUVCUrHMuhoRmcO3+ea5fmmZube6afZ99vUC5/j1L59yiVfv9EILEkpSjk36Ew8CUGCl/uFMgMwoCV2jr/y/1lfvtek409maAIgnsMbqQQMXOAZtxibrTGqxNDLAzMM1+YZz4/z4j57Nxvj6p6yWb9oyLrt0ps3i71WG0gTtY3fXWA6SsFxi/mUV6iMh/PW2GzibN4C//mtwlXf4hYXkTyd9DMJpLW/5IdeDIeQ4SZCwiTryFd+jLK9X8Hwej/OQl9n/KNH1P6wfexbt7EX15G2ttHb8bxlQ1dpWpqVBM3VV1XCUSRUNUJjRSBkSYyc/iqEtefMlX+bz//t5/o63AGM116UWCmn4LAodG4Ra32AbX6B9RqH9Js3u97rmmej8Emc51M9jqZ9FVk+fmmX4+iiE3H43ajxR3L5najxV3L5l7T6RuLA5CRRBZSetxMvTOe1JQzSw5xsHDrw0Pqv7eFt3m0W0lbKJD58gTafOHFMuWHQey2altwDu/B4WIMOvWdU28WyQZB4QLV9AV2lWnuRxN86Izxg9oAi0WPlheQEWwmxBqTYpVxsYZyrGaNr2YwhyaYOXee65cusjBReGZ1sWx7u2O1KZe/i+eVeo6r6jADhS9RKHyJgYEvoesTnWO7tsuv3VnnX9zZYX3bISq5CP6xz4vsI6a2kfWbyMYShVyT+cIc8/kYcBYKC8zl58ioz/dHTlttq836rRIbt0rsr9d7PJaiLDA+l2P6ygBTlwYYPpc5CyT+GPJLJbyb38O/822i7Q8R68soHKKm3FOCjcFzDAJ5lCg/jzD9BtLVr6Jc+SKC3D/eyatWOfzed6i8+y727duE6xuoxRKiH/QATs3QqBkqgawQGClMzeev/oP/5Yk+3zOY6dKLDDP95Pt1avWb1GsfUKvfpFb7ANve7HOmgGnOkc2+QibzSgw5mavPbQdVt7wwYqXlcMeyuWvFgHPXsllpORz/zm7LEEXmTY35lM68qXHR1JlP6Zw3VNRn5Fp4kRRFEe5ajfrvbmHfKnYuDPKwQfrLE5hvjiK+6L907dqRFefwbtLfi+N0gv5uSxCICudw8hcpGrOsSzPc8cb5kTXI1mEdqbHHmFBjSLB6LOphJHAQpbDUAYyBCSYmJ7k4luXicJq5kTSDqaeXgiCKQhqNO5RKsdWmUv0RYWj3nGMY5xK4+SKFwhc6ruQgini30uAfLe7xu0tFdnbqiGUX4XhuBclHNDeR9dtI5iqSvokgBoynxrmYv8jFwkXm8/PM5ee4kLuALj/f7dSthsvmnTIbt0ps3C7ROJZhWTVkJubzTF0qMHW5wMDEp7fMwtNWFEX4W2t4N75JuPx92L+F1NpAUcrI2iklFnwBz00TqBNEg5cQzr2F/MofRJm7jtAnCDiKIpqrKxS/8x1qP/4x7tI9hO0d5Gqdpq5SMzSEawv8of/+//NEn9sZzHTpZYOZfnLdIrX6h9RrN+O+frNvgDGIpFJzZDLXOoCTTl957hacttww5H7T4V7TYdGyWWzGkLP8AEuOJMCsrjGXAM5FU+OiqTFn6gyqL2ZswZOWX2zR+O4O1g93iZzYlC/oMqnPjZL+4gTyy5YHJPChstYFOYtwsBiP7erpt8uMEw5dopa+wIowxY1ajtVyiNMoowW924n9SGQ/TLMTZtgNs/h6nrmRDBdH0lwciQFnfiTNRM544haCMHSoVt+nVPp9SuXvUq9/cGK3Yzp9OQab/BfI5z+PosTfTWXP598Wa/yze/v8YLlE46CJWOljuRFCRGMT2biPZKwhmWsIUvwaiILIVHqKufxcDDr5i8zl55jNzaJJzz6OJYoiqvstNm7HYLO1WMFt9brXjYzCxHyByYU8k5cKFMbMM7j5hIrCEG/pA/wPv0m4+kOE0iKyt4OiNRBPqbHgOyKelyPQp2D4EuK5t5Cvfw3l/CWEPj8qQ8eh+uP3KX3/+2TefJORr3z1iT6HM5jp0qcBZvrJcQ6o14/gpl67iePu9TkzseBkXulATiZz5bnH4HTLDyNWbYd7iYtq0bJZajosNe1TY3IgLuMwZ2pcSEDnghFDz6yhYXwKU7OHto/1oz0a390mKCa//AXQrwyS/tIE2tzLkdfkVLVz5xzehYM25CT9A1xWmIOUC6+yKMxzp5lnsxbi+b3w4EUie2GG3TDDXpjhMDKJEDFVqQM48yMZ5kfSzI+mmSqYT6yque/XqVR+SKn8Hcql75zYAg4imcw1CoUvUMi/Qz7/OWQ5TRRFLDYd/s1hld9cPuSDtTJB2YktN+7Jz4Vp1kBfJtSWEI11RPUAoWtLlSiIzGRmmMvPxS0391wgJwwjDjfqbN4ps3m3zM69Cr7X+3yMrMrExTwT83kmF/Jxgcwzt9QTUeQ6eLe+i3/720QbP0as3kcK9lC01mnxw3gtCc/PExpTMHwZYfYtlOt/EGV2vi/kPCmdwUyXnhbMbG9vs7KywsDAQKc9iyJ7D5Lj7CeAc/MhgJPE4KSvdQHONRQl94wf8YMVRRG7rsc9Kwab+00nsezYbDmn50oRgAlNYc7UOG/EsHM+AZ0ZXXvpt5JHYYR9t0TjO9s49yqddXnEJP2lccw3RhG1F9wF9biyq7H15uDOEewc3IHK+olTI+CAQVaUS6zI86y5eVrHqhIHSOyHKXaCNtykCLq2l2uyyNxwmoXRNPOjMeQsjGaYHvjkkOO6h5TL36dc+R7l8ndpNld6jguCRCbzSgw2hXfI595CljPYQcgPqxb/tlTjd9ZL3N+qIVRcxIqLaPXZSKCGDObryMYGdfFDXGWxY73pliiITGemuZC70HFTXchf4Hz2PKby9N3WgR+yt1pje7HM5t0Ku8tVgmNwo6VkxudiuJm4mGdoJv1M0+p/FhS16ng3v01w9ztE2x8gVpeRowNk9fQAf9eS8YI8oT6F+NrPkPq5//sTfUxnMNOlpwUzv/u7v8u//tf/umctm832wE13U9XnkzCrbcHphpz+LirQ9WkymWtkM23IuYaqDj3jR/xoagYhKy0nAZwYdJaTedU/PXGjJMCUpnYA57yhMWuonDc1ZvSXLz7H22/S+M42zff2iJJf64ImkXprlNQXx1GGn38M1VOVax1ZcA7uxP3+bSiv0g40CoF9hlhlmlUmWWOGFscsEYKIp+c5iDIsWjrbnonLSTemJotcTMBmfjTNpdEMC6MZJvMf311lO7uUy9+jXP4elfL3adnHAU0km3mFfOHzFPLvkMu9jaJkOXA9fq/c4FulOt/crbC/b8VgU3ERqh5Cnzo/Y3mR0YEWemoXR15kz3+XxgMquo+nxrmQu8D53Hku5C/EoJO7QEF/ejlyAi+Bm3tlthZjuPGPWaJkVWTsQo7xuRzjc3lGL2Q/s/WknraiehHvo28R3PsebH+IUF9Fjg6Rld64N0v9Eqm//ZtP9G+fwUyXnhbM3Llzh5s3b1IqlSgWiw+tSZVOpykUCj2A054bhvFM3QOue0i9fot6/SNq9Zs06rf6fIHG0tTRDthkMlfJZF55bnWoHkVRFFHyApZbsTVnJYGclZbDctOlFZ7uthKBSV2N4cbQOJeAzqyhMaurpOQX19oR2j7Wu3tY393BPzz69a1dzJP+4jj65UEE6cX8N3sq8lox5OzfgYPbR315jZCIfYZYZ5I1JlljigYn48rSaZMwPcqBUGDJ0rlV8nFOiWA3VYn50QwLI2kujcWAc2ksw0hGe+zPim1vUy5/l3LlB1TKP+jz2RRIp69QyH+efP7z5PNvoygD3G85fKtU53fLdX6vWMeqODHcVF2EqovYPAn5iiRwccRgciggmykTaWuUglus1u9Tsksnzm+roBU4nzvfaW3gGU+NI4lP9nMSBCEHa3W2lyrsLFXZWargNHstUYIQl10Yn8szNpdl7EKOzID+wn5PfRoU1fbxb/0uwb3vEu3cRHj1Z9H/3f/0if6NM5jp0rOImYmiiGazSalU6ttardPr5ADouk6hUOi0NugUCgVyudwzSRTmeVXqjRhwYkvOrSSXxsm3hyznyWaukc5cJZOOAcc0ZxH67Q18gRRFEXuuz3LTYbV1BDmrLYeVlkvzAfE5EBfqbMPNOUPlnKFxTo/nI6r8QnxxRmGEs1Sh8Z1t7Lulzj+flFNJfX6c1OfGkLIvflr9pya3Gbup9m/H7eAO0d5tSrU660ywxiTrTFLipOUhrcBIIY2UH+dAn2a5ZbJ40GT5wMI95b2TM5TYejN2ZMW5NJYh/xilDWx7OwGb71Ou/IBWa/XEOaY5Rz7/Nvnc5+KYG3WCDxstvlWu87vlBj+qWriOj1j1OnCj1DzCPrE3mixydSLLwqjOUKGFZuxhifdZqy2zUl1h29o+9bFqksa57Lkj0MmeZzY3y2x29om5rKIworRjsbNUYed+lZ37VepF+8R5qZzK2IUcoxdyjF3IMTyTRlZe3B8kZzqpM5jp0osQANxqtXrgplwud/p6vf7A24qiSD6f74Gd7vY00737vkWjcbsDN/XGLSzrXt9Ef5Jkkk5fia03SSxOKnURUXw5LpxRFHHg+gncuKx2Qc5ay6H8ANcVgCEKTOsx5MzoatJrzCTz9HOw6vglG+sH8S6osB1TIQoY1wZJvTOGNpd/IQDshZBdi91U+7dg/zaNnUXWd8tsuBk2GGebUUJ6/w1FQsYMn8nBNOmhCeq5eRbdQZYOLe7u1lktNgn6uHoARjIal8YyCehkuDyWYX4k80h5chxnn0rlBzHgVH6IZS2eOEfTxsjn3iaXf5t8/nOI+hw/qtn8XgI3H9SbhFGEYAex1abqkbZ8goqL550EHFUWuTKW4epEjvlRnUKuQaRusW2tslyNIWettob3gLpfo+Yo53Pnmc3OMpub7YDOWGoM8RP+EGqUHXbuxy6p3ftVDjcahMdee1ESGJpKM3ohx+hsltHzWXLDz9YqfqbH0xnMdOlFgJkHyXVdKpVKB266QadSqTy0cOdxq043+ORyOWT5yfqRg8DBshZjC05iyWk07pzIqwEgCCrp1HxswUmsOC/SVvHHUdXzWbVjyFlruay3XNbsGHy2bLdvRfJuDSgS03ov4MzoKjOGyqSmoj/FYMbID2l+eIj1vR3ctVpnXR4ySH1+DPOtUaSzgoH91TiA/Vt4O7fYXltkY7fEZh02ohGsPq4pE5tJw2ZywGR0fBKG5lmSZrlVDFncrXN3r85mub+lVhDg3IDJwmgMN23ImR1MIT/g/eF5ZSqVd6lUf0il8kPq9Y9O/OCQpDS53Bvkc2+Ry78N5iv8sB524OaOlXx+owihGVtwRuwIreFTKbaw3ZPfQ5IoMDec4up4livjWS6PpSlkLSrBJivVlU5bra0+0GWlSzoz2Rlms7Mdq8657Dlmc7Nk1Y/3ne25AQdr9RhulqvsrtRo1U7mNtJSMqOzWUZms3F/Lov5WbZcvmA6g5kuvegw8yCFYUi9Xu8Bne7WbDYfeh/ZbLYDOPl8vmeczWafiAsrDH2arZUYbJJYnHrjFr5f63O2gGnOkk5fjeNw0jHoPM96VJ9UXhix5RwBzlrLjYHHdtiwXUrewyvJj6oyM7rGtKEyrcdtSleY1p8s7Lg7Ftb3d2i+t9+pBYUkYFwfIv35MdTzL/n27mehMCSqrFFZ/jEby3fY2j1gsxaw62cJOGlZKVBhQmkwkdeYnJggP3OJLfUCHzYHuLNnsbhX585unZLVP5GgKonMjaRjwElA59JYhvFc/5iQIGhSrd2gWvkRlcqPqNbeP1EXThAk0ukr5HJvksu9iW++wXvNFL9XafCdSoOlZlcMYBQhNgPOeTBkR4RVl+2DJuVTHu9IRuPyeJYr4xmujme5PJZlMOuz2VjrwM1qdZXV2irr9XX88KSlt60BfaADOW3Amc3OMp2ZRpUeHTqiKKJetNldqbK3UmNvpcbhRoPAP/kzJDOgMzKbYeRclpFzGYbPZdGMs+Di56EzmOnSywwzD5PjOFQqlR7Aac8rlQqed7rJF2IXVjab7QGd7pbJZD427ERRhG1vJu6pj6jXb9Go3zp1q7imjcWWm44V5xq6PvmpuLDW/YB122W95SS9y4btxmP74bE6ACOqnACO2umn2sCjPX5wcuj4NH98gPWDXbyto7IJ8rBB6nNjmG+OPNsil58C+a0Gu3d/xNbyLbZ2dtmquBS9fm7giCFKjAslJrIiE6MjjM0u0Bq4zJ1whlsluJtYcRb36jT7WEUAMrrMpSQGJwacLJdGM+TMXitbGPpY1l0q1XepVt6lUv1R3x2NmjpKNvcG+dyb2MYbfOBP8b2qw3cqDZZbvRschCjisqxy3hdJN31aZYelvQarRYt+VxRFEpgbTnNlPBu715LHPJSW2bF2WK2tdlxVbdg5aB2c+lqLgsh4apzZ7Cwz2ZkYdJLxRGrikYKQAz/kcLPB3kqN/bUa+6s1ynvNvoXj86MmwzMZhmcyjCS9egY4T11nMNOlTzPMPEhRFGFZVgdsuiGn3cIH7OyBGHZyuVwHbrrHbdiR+qS+fpCOdlIdQU6/gEYAWc6RSV8h0xVsbJoXEF/QqsIfR+3dVx24aTlsOh4bCfBs2A/egdVWQZaYTOBmKrHmTOkqk7rClKYypMqn1r5yN+tYP9il+eP9zvZuJAHj6iCpz42hXcyfJSz7mGq1Wmwv32F76UO2t7bYKjepef0+MwngsM+Y7jE+VGB8ehZt8jq7xkVutga4u2d1AGf5wMI/JR5nLKt3YKEdcHxxJI3eFfxq29tUq+/FgFN9l0bjzoksxYKgkslcJZd9nZb5FrejBX5oqXy3Yp2AG4DLKZ23UwbTnoDa8Nk6tLi9U+fubp2G09/6ktXlnt1fC0mQ9EBKxfKsGG4SK85aba3TGl6j7/0BKKLCVGYqtuZkznVcWDPZGUbMkQfG57gtPwabtXqn7xdcDJAbMWLAmc50ej195q59kjqDmS59VmHmYWq7sLrhpht6arXaQ2FHEASy2WwHcvr1j5JI0PcbNBp3uuJw2oHGJy1LoqiRTl/usuJcI526hCS9ZCn9H1HdsLOZwM2m7bLpJL3tPTCvTluqIDChK0xqMeDEvcqEpjCRAI8ZRLG15oe7PUUupbxG6u1RzLdHkfOfztf5WarRaLC9ucnO8kdsb6yyXaxTP6VUVY4q4xwwJlYYL5iMTUyQnbqKN3KNFfE8d8oRd3ZjYLi7W2er0j8eRxRgdijV46paGM1wbjCFJAoEQZNa7UOq1fep1t6nWn3vRPFMAEUZJJd7Hcf8HHeF63zgjvC9Wlyi5LjOGypfyKf5fNZkVpBplG3u7ta5vVtncbfO8qF1aoD0UFqLExaOxEkLY8hJkzdVoiiiaBdZrcZuqjbgrFZX2ahv4Ian1f2K43Oms9MdyJnJzHQsO8PGcF9LcKvusr9e52CtzsF6nf31Go1S/1Qc6QGNoakMw9NphhLISRcef3v+mWKdwUyXnhbMeLsW7lYDQRERZPHBvSKCLL5Ub+jTYKdarXb6hwUnA5im2QGbbshpN9PsX4MlDB0sa6nXTdW4c8L3HyupSdUGnCQe50XLaPy0VPeDBGxcthzvaGx7bDkuu4730ABlgKwsMqHFgPNaE95Zspi9V0duW2uEOG9N6u0xjKuD8fv6TE9EjUaDnZ0ddtaX2Vm/z85+kUqr/+dLx2aMfcY4ZNSMGBsdZnh6AXniOvX8ZRbtPHf2GizuxrE4d/fqVJr9Xc6aLDI/GicBbLusLo1lGM1oOM4m1eqPE7h5n0bjdt+djKY5R5D+HPelz3MzPMd7TY1bDeeEt2ZUlfl8Ls07+RTv5FLM6SqrB03u7tVYTB7v4n6djdLpqSyG0lqn5MTFkTQXh9NcHE0znI6BIQgDdpu7rNXWWK8dgc56fZ3N+iZBdPp3liEbHbiZycSAM52Z5lz2HEPGUM/3VKvhcrje4GCjzv5anYONOrWD/o9bM2WGptMMTWUYmkozOJVmYCyFdPb5eajOYKZLTwtmat/coPZbq491mzbYxE06OVe71rvGoiIiqF3H1Xguqu1zu449I3dAGIY0Go0O3BwHnWq1iuue/gupLVmWe+Aml8t1rD3tcTt7chSFtFprnW3icU6cW3hese996/pkAjjXOrupNG3spYLKJyEvjNhxYtDZ7gKeLdtj23HZdk637mhBxNf2fP7YlsfnSkfntBSBe3NpDq7m0acyTOgq47rCuKq80MkFXya1Wi12d3fZ3d5md/0eOzs7HNYd+hkzBEKGKDHGAaNyg5GBLKMTM2Snr8H4dQ70C9wtutxNAGcxcVfZfbZhQ3/3z/ywihzeSwDnx9RqN7DtzZOPRVAg9Rrr2h/gDlf4wB3iQys6UUw2LYm8nU3x+XyKz+dSvJE1SUkSluNzb7/Bvb069/YbLO7VubfXONXq1H687RpbnWKiw701trzQY7ux3QGd9fp6B3i2rW3C6HTkN2SjAzbTmeke6Bk2hxEFEaflU9ysc7De4HCjzsFGg/KOdWKLOIAoChTGTQan0gxOphmajCHHzD696u4vo85gpktPC2aaN/ax3t0n8kIiP4Skj3r6gEf6SfwkJYuIahfgtKGne66151J8bs9cSuZiz3mPC0lRFNFqtTpg027dsNNonO737pZhGD2Q091ns1k0rUWrtdjjprLtjb73pSgDnR1U6STQ+GVI+Pe01fCDDuxsO7FFZzuBnR3HY8vxKNR9vr7l8Ue3Pcbso6+NpbTIP59Q+M0JmaImkpVFxtTYwjOmKYwnbayrH1ROj+E50+nyfZ+Dg4MYcjZW2N1aY69Ywz4lM7GOzSiHjFBiJCMxOjLKyMw8+tSrBCOvsOGYHTfV4l5sxVl5gPtnOKNxqauUw8Vhn1F9Ga/1EbX6DWq1D/C88snHLWTZMX+CJflz3Apm+MA2aRzjZ0mAa2mDz+dSMeTkUkzoR0HoluOztN+IQWe/ztJeg6WDBuulZt+gY4jz41wYSnFhOMXccAw4F4ZTXBhOk9aOYu+8wGOzsclGfaNjzdmob7BeW38o6OiSzlRmqgdypjPTTGemGVFHqe7bHG40ONysc7jRoLjVOJHBuHNfKYXBqRSDE2kGJlIMTsb9Z7VUwxnMdOl5x8xEQQI2nRYcAY/bNe86HrbX3a7buCGRGxB6cR+3o9v3i8B/kupYgDTpCJa0LvjpHncDU99zYitSEAbUarUTwFOtVjvrj2LdAUilUj2Ak8lIGEYRWd4mjNZwnSWarfsnghyhnfDvcpLsL4acdGoeUXx2lYRfdEVRRNUP2HY8dlou9v0KuZslppYbyMn3fAB8b0jiX0wofGtExnlA+QRFEBjVZMbUI8gZVZM+AZ4xVXkuyQZfNkVRRK1WY29vj93tLfY377O3t89h3SGi/79BlhojFBlRbEYKGUYmphiafQV16jWc7DnuH9rc2++FnAe5fybzBgujcWHOy8MWU+lV0uI9mtaH1OsfnXAPh4hsiwusaH+AReEat7wxdv2TF+xJTeHtXIrP5VK8lU1xLa2fqJ9mewErhxb39hvc329w/6DB0n6DlUMLp8/W67ZGsxoXho7gpg09xyumd4NOt0Vno77BVmPrga4rWZSZTE924GYmM8NUeorhcAK1kqG67VDcblDcbFDZOx3KskM6A23AmUgxMJGmMGp+6l1VZzDTpecNM89CURTF0NMNOG5I6AZETnA0d7ogyA3i48k5oXsESUfnPV3LkpBYhU5AUBuEFBFXDmhENo2gRcNvUnct6o5F3W5QbzaoWfVHit0BSKVUhoZc8vkapnmIrOwCG8BJYBIEhVTqYseKk8m8Qjp9GVlOP9kX4SVX2PJpfnBA89093PWjbNahKrI/n+XuhRQ3BmV2XZ9dx2PH9Th0/Udm75QkMqYeAc6IKnfmo6rSAaIz19ZJeZ7H4eEh+3t77G3cZ397nf1SjZpz2qsfUaDKsFBhJC0xPDjA8NQFhubeQJ28jhVpsduna9v44l6dvVr/YFhBgOmCycKoyfXRGnP5DQa1ZaTgLlbjNmHYC0dFBrknXGdFeYe7LLDs5QiOwZguCryaMXkra/J2AjhjWv9NBkEYsVVucf+wDTkW9w8aLB9YHDZOr6WnSiIzgybnh1JcGEpxvt2GU53YnM5rHHrsNnY7gcgb9Q0265us12PYeVBGZAGB0dRoB3SmjBlGnClS9UHEkkFj16W4ZdHsk+wPQBAF8iMGA+MpBtqAM26SHzGR5E8H5JzBTJc+CzDztBRFEfjRERS1AchpA1AbhkJCx0/AKYEmpxeK2muRGzxRK1JEhI2HJdhYgkNTdrEkF0t0sLCxsGmELYJTzcQhplkjlS6RTpXJZMqk0iVkud+XnYCmTZPNXiObvf6pSPj3JOUdNGm+v0/zvX2CytHrJ+U1zNdHMN8YRhlN4YURe67HnuOx43jsuh67zlHbS+b1R8i/01ZKEhlVE9hJQGdYlTvQM6LJjKgKBVn6zMcktFotDg4OYrhZu8f+3g77NZumf9oFMIEcxWY4qzM8MsrwzAJD82+hDZ6j0vLiAN4uwFnca5yaBDDOdKzz5kSdK8PbTKbWSIv3CdxFwi4Ljo3GMhe5J1xhWXyDu9F56tFJa+mkpvBmNsVbWZM3sybXMybGQ5JMVlseywnYLB/GVpzlA+uh1pyUKnF+OMX5oTTnB01mh1KcG4xhp2AqPe+tIAzYb+7HFp16bNHZqG2wUY9b039w0tOclmMqPcU5ZY5J7wIDzTHUapawKFPfc3FPCRAXRYFcAjmF8RSFcZOB8RT5ERP5EcplvEg6g5kuncHMi6WOFck5ZgVqw5ETEjn+kaXoFCjqBqnolKRinb9JhIOPJdg0BQer3TiaNwUHR/A7t9A0i3S6RDpdikEnXUbT+n/5BG4G7EkkdwY9uEBauEROO0fGTKNo6oN3u8ldu91k4WhNEkESXsr8LlEY4a5Wsd7bp/XhIZFz9O+jjKcw3xjBfG0YKfdgN57lB+wlFp024Oy6Hvud3mfX9bAeA3oUQWBEjcFmRJUZVmRGZJkRRWZEkhiWJYYliSFBREOAMCIKorgP4z4eE/dRBEEEUbIWJedE8etAlKxFyY8DjuZHL9ixB9n9Ty4I8VyIUyHE4+R9IQBiMhaFo/eLKCBIQvweEoX4fSWJkPTt9xiy0HPxbTQaHOztsb96i4PNFQ6KJfYbPq3w9HiNrGAxpAUM51MMjU0wPHOZobnXSWXzFC23E7zb6fdP31klCiGvjjV4c3yfC/lNhvQ11HCJKKx2XqZdxrnHJe6xwH3xFTaicUJ6wUUW4GrK4PUEbt7Mprhoao8UoxWGEVuVFqtFqwM4y4cWK4cNtsqtvsHXnddClzmfwM3sUIrZBHZmB0+CThRFlOxSB2yOtweVfwBQBIULyiXOB5cYdWbIWsNIlRReUSA4zfImQHZQjwFnLEVhLIGcURP9BS1ncgYzXTqDmU+/orDbzRb0gNCRO637eNfcOYpDch2HhtPEcps0/BZWYNOM7CPYUaqImR3MdDGBnDKGUaPfd6TnqViNAVqNQbz6KFF9AqU5ghEZmJGKEakYqJiRhhGp6CgI/eIb2hcjOYGb5GLUvmB11qSui5kkIogkvdB1wePoQpjMBSEZty+SSd8+l04nHF1kT7smnLhAR4R+iL/fwttu4B+2es6R8hryiIE8aMTPqQcCIgjpAMTxvntshSEHIhxIEftixIEMRQkOZDiU4VCFoiJQUR4PDDNexKATMuhGDDpJcyOGnLAzHnQi8m7Up4jBS6JugO6301KVsEWPsrNJpbVK2T6g5DQ59EQa0ek5h3TBY8iIGCpkGRqdYOjcVYYmZ8nn85RbAff2eyHn3n6dcl/IiShoFd4Y3+fq8B4zmS3yyipStAOAjc59LrLEPEsscF9YoEr+xL2kJZHXMiZvZE1ez5i8njWZ1JTHstI5fsBGqcnKYZOVwwYrh01WDy1WixY71f6J9drK6nLHinNuwOTcoBlDz6DJcOZkHpqm1+y4rDbqG52YnY36BjuNHfw+W+STl4uUm+Ocf4mZ4CJDziSpxgBiRSeyT7dWGRmlAziFsRhwCmMm6QEd8Tn+oDqDmS6dwcyZPomiIDoK0k5AyKpbNGp16o0G9cY+DWcRJ1wikDaQ1C0UvYgonrQWBIGE1RigYRVoNAawGgNYVp4okhAQMCIFI4EbAxU9UuJxMm+PdRREPh0+8WcpV4CSJnCoCRyqIsVk3OmTtaIm4D3GF7gYQSGAIR8GAxgKYDAUGAoEhsOj8VAkkI1A5AgeH6gwajPhkTUniuIg0agb6I6gjyCM4T6ILUZxH8bvYz+MrUhPSA4WDXGFmrhDVaxSFnyKaFSEDKcRr0hIXooY0E0KmVEGhmYZGhhkaHgYW9W4bzks1VoslZvcP4iDevvFtxhyk+nMNpcG97g8uMtEapOMvA54FBniPvMsMc995lnlAo5wEryGFInXMilezxq8ljF5LWMyekr8zcPUcgPWSharh01WixZriWVnrdh8KOgYisRMB3BMZhLgmRkwmSwYKMdcZn7os2vtstnY7MBOOxh5s75Jze1TEy8Cw8tQaI0yaI8z6c8xaI+TahQQm6dbSCVZJDdiUBg1yY+a5MfivjBqoplP35pzBjNdOoOZMz1rhaFDo7FIqXSDSuVDGtYtHGcZOPmlFoUiVjOXwE2BRmMQyyoQBA/+ojA0A7O7KTqGqse9rGMoOoasYco6mqgihkLiCumyfrTdIG13Sc9Fk9416B13PweSS1f3xbljxTmy6AhdFqDQ9QkObfxii9Dq+pUpCsiDOsqoiTxiHqUF6LYuiQKC2HbDHZ8fuVn69+LRfUld611/o71za8/1OXA9Dlyffddjz/E58DwOnHi+7/oUvUcPZobYzTWsygx3ubpGkviejusr6Z9GUHPbLdbZZelHR6kkenZWtgH+2G7K7g0EzrH4OccntH2icBtLXKEm7FIV61SEgKJgcMgAPqe/r/UoIhcp5MI82ShHXslQ0LMIRpotSWCViNXAZ8XxWGk57LR6LTmiEDBqHjCV3uZCfpuLA3uMm5uoUpktpllOLDjLzLHBOULh5Os7qgi8nk3zaibFqxmDVz8B4LRlewHrpSMrzlqxGc+L1kNdV5IoMJHXmRkwmRlIJX0MPdMDJjnj5GOrOlW2Gls9gNOe97PqKIFGvjVCvjVKoTXKkDPBgDOOaeURw9Pfg0ZGIT9ikkvgZmI+z9iFJ5uo9AxmuvS0YKa8s0VpexPNTKGl0mhmCj2VQtGNz3yA4ZlOKooCms3VTi6cRv0WtfpH+H6lz9kCMEIYTGI7o1iNAarVLLVaXG/r48gwDEzTfGBrn2MYBoZhPJGK6o8ib79J88YBrRsHsSsqkaCI6FcGMK4PoV8aQHwBgxf9MKLkHcHNfgI/bQDa7wKiyiOUneiWKYk9sDPaBT9Dx+BHeYFiqyI/jKHGCQjtIB7Xy0R7H1Hf/4hycY1ys0zJdSmS5ZACNR7w3RxBGplcmCEXpchGBrnIRI0MSpHKGhFrhKwSsk7IJiHdr7QpN5lM7zCV2WI6s8P53C4D5gE70ijLXGSZi6wwxzYTRH0AZ1gOuZ7WeC1X4HrG5JW0wbT+ZJLbuX7IVqXFWtFivdRkrdjsjNdLzVOTGraVM5QYcAZNpgsx6EwPGMwMmEzk+1t19pv7PYCz1dhis7HJVn2Lon2UgFSIBDLOAPnWKPnWCDl7hHxrhAF7DMPNnHgs8//OIH/4T7/2iV+Tbp3BTJeeFsz88Df+N779P3/jxLogiGipFJppopnprnEKzUyhmt1zszNXjaM1WT2r5fFZUBRFOM4O9frNnqzG/SoaQ1xZPJ2+gq4tIEmzhNE0jp2i2WzSbDaxLAvLsjrjZrNJq3V6bpCHSdf1Hrjp13RdP9E/Sj2u014Pb8ei9cEBzQ8OCUpHlixBEdEvd4GN9uKBzcPkhGEP6HQDz76TQJAXW4AepbhotwYUKYGd7l1cbeCJt7CPqApp6QUqqxIGUFqBvQ9xt29S3FiieLBHsRVySIFi0hxOd4OICGQwyYYGudAgG5mkIp1WpLMXqawTsU7IGiFrBBz9FIgY0Msx5KS3mUjvMpIu4qZM1qRzrHLhgYCTFX0uGyHXM2leyw9zPZNm3tSRnyBURlHEft3pWHLWS03Wu0DnsPHgHFyiAOM5g+kBg+lCbMnpHg+ntRPxME2vyY6107HotCFnqxG3doFPJdDItYbJ2cMd0Jl6Ncv/40/+p0/s+cMZzPToacHMzX/7r7jxO7+JYzWwLQvHahA+Yr6Th0mUJFSjDTi9vWoY8dwwUU0TVTfivr1mGCi6kZxnIIov35f+Z11xZfHbiRXnESqLd9WjymSuYZrnEZIv4CAIaLVaHeDpbpZlnTjWarVwnNNzcDyKZFlG1/UewOlumqadGHf37fIV3maD5oeHtD48ICh3PSZZRF8oYLwyiHF5APEZ+O6ftaw+bq5996QFaN/1HisMxhBFRjW5Az7d43Yen1HtOW9hb1Vg7yPYv0W0exNrZ5Hi/h7FQKdEPoGcPCUK+Jy+00oURHJGhrySJielyEQGuBqVlsy2LbARwhoB64TsEiXu0pBh85DJ1C4T6R2GM0WErETdyLMhnGOV82wyTSCcfM8p+JyXm1xJiVzPZnm9MMn1bI6c8nSy91qOz2a5lVh0rM54I4GdB20xhzg78lTBYKpgMt3uE9iZKhgMpNQTO7Bqbo3Nxibbje0eyNlubPOnL/9pfu7yzz3R53gGM116VjEzURThuw621cBtNnGaFo5lYTct3KaF07XmNC3cVjJP1t1mE6fV7BuT8Ekka1oMPIaBqpsdyFF0A1XXk7HZNTZQdD2+TddY0XUU3UCS5Rfnl91nSEeVxY+sOHFl8ZO7GkTRiDMadyDnKqnUJSTp0TIadwNQq9V6YLNtu2f8JCQIApqmHTVVYzDKMN7IMFgx0J0jQI8E8MZkolkDcS6NWjA6QKSqKoqiIEmfXqAPk6rqB66X5O45Ap12Lp82/DQeYwu7KgiMaMcSFLaTFHYSFj5D6AlDqKzGkJO0cPcj6uX9BGxiyIn7PGVyBA8AHUEQyOdyFDJ5cmaWtJzGDlTKTYntpsRaw2Ot6bLmedSjCFEIGDaKTKR2Gcnso+d9vJRBTS+wIZxjjVlswez7t4aiKnNRgwUx5Kqe5tXsBJeHJjHyxlOzMEZRxEHdYaPcZKN0BDnt+U71wbE6EAcmx7ATg05vfxJ2nobOYKZLL1MAcBSGeI59BDitFm6rmYBPMxm3cLrWvFYT124lMNTqjMPglK17n1CiJMVgo8VwoySw1FnT9AR8dBRN611L5nL3etfaGSg9nsLQoWHdo1G/1VVd/GRmVQBBkEmZc3E9qsw1MukrpNNXUZQn95kIwxDHcbBtu9PakNNu7eNtC1D3muM4PPTrKIKBKM1sMMxsOMJAlO46FLEvVFmTDlgTD6mKcV4gWZY7YNOGnO65oigPHB9vsiz3zF8WWLL8gP025CR5eo6P912PkvfoFmZVEOLszMdAZ6yzFpeoeGruLbcJB3c6lhz2b8HeLULrgBppihQok+tATokCZfL4D9lMn06nKRQKDAwMoKUyOBiUWzLbDVgt+6xUbTYsBy8MGNDLjKX3yOcbiDkRJ2VSVQfYEqc5FEb63r8ceUyGB5x3K8y5Lgu+yhWhwAVtGi2bR8qqSFkVMaMiZbUnDj1eELJbtdkoNdkstxLIabJRbrFVbrFXtx/6u9pQJCbyOlOFeNfV1y6N8FNXR5/o4zyDmS69TDDzJOV7Hm6riWe3EihKQCeBH69nrRWfZ9udY55j49o2nt3Cs21879FqJH0SCYKYgE7cZPWolzUNRdWQVRVZS3pVQ1bUo7GqonSNZVVF6hxPmtJeUxClTx88nQw0vk29cQvP65+ES9enyWSudNxU6fSV51ZZPIoiPM/rgZvu5routm3jum5nLlYD8iWFwZpJwTF67q8iWKyJB6xLh+wLVaKn9JQEQehATht0uvvj6w9rkiSdOu83FsUnCwpOGHbieHYT686e67PjuD0A9DjQY0oi423I6aq91anLlcT4HK+79LFlHXbAhoPbsJ80p0YINEhRSiw6JfKUhQFK0gjlMI0dPvgxKIpCoVAgXyigGGk82aQaqOzZMmt1WC7ZbJabGHKD4WyR1ICDmD2CnF1x/FQrjh41mYp2OOeWmW21mGuEXKxoTLYGMZQplEwqhpusipSJgUfKaZ2x8ITKGDh+wHYlfh4bpRZblRh64tZkv+6cgJ2/8gfn+Fv/7uUn8vfbOoOZLn1WYeZJKwyCBHBiuHET4PEcG8+Om2vHc7+z7hyd4zjxeU77HCdec+wnFmv02BKEBG7kpFdi0JHlZKwgyV19z7qMJMuI7XVJRpRlJFlBlKX4mBRfcEQ5OSbFFx5RlhElKWnJuL0uxuuCKB71YrsXEZLWHj+K4kDj3U5F8UYCOra91ff8uLL4laSqeOym6o7DeVEVVB1at4u0PiriLFd7c6oYEswYeNMqzoiAi4/nebiui+d5J8btue/7p669SDoOOJIk9YwfdOxB5z3o9qEoUUagGEIxjDgMIva9gIOuzM2PW5ZiUJF7K6yrJyuu5z+uayuKoLoZW3L2b8F+0h/cBf/ImtlEo5y4qkrCIGVtmpI4SCUwqJ5a1+pIqVSKfD6PmsoSyCaNSKXoyWw0Je6XA7aqDfL5GqkBFykLrmlQ1/IcSiMEQn/XmBFZTLDFdHDAOafBrOVxoSYxVUuhN0dRmsOIkYJoykew02naEfRkVcSU8okzizt+wE7FZrN8BDpfvDDIly4OfaL7Pa4zmOnSGcy8+Ap8H9+N4cZPAMd33Xjunpz7joPnOviuG89dt3fseZ1x4CXHkj54wS5Cn1SCcAQ3iEI8T7L8tsdxZl+hZ4wgICk+asFCzzdQcxZavoGSaSKIJ78SQl/Eq6dxK2ncahq3msGtpYkCKQmd7FLylRJ1Mr515awhdgcd5a5pJ4aLelxM0fHj7Tts33f33+zzDSYLKiPqDOPaeUa1c6jiUdK0MAo49LbZc9fZd9ewotqJ10cQxKSEQBscBUhez/i1jpsgSvFYkkCQOuuIIpFw1EeCEK8LAmF8x0SCQIQQp/rhKI1PXCkhOmphRBiGBO0WBA93xz1niaLYgZ9Q1bB1k5Zu0FB1LE2noWjUZY26rFCTFKqijP+IgKIJMCSLjCoyY2oMP+O6xqShMWFoTOjq41l5whAqawnk3I77gztwsNgDOQA+ElUylBigkjpPWZ2iLA5Q9jXKzQDHe7B7XxAEstkseioLmokt6FQDlV1bZNWCzcBBy9vIOQhSKk0tQ0Ue6JsTB0CJHMbZZoJtJr0is3aLc1bIbF0hYw2hNEdQW8OIQVfSQFE4supk1Rh8EtCRshpS7um4tj6OPjUw83f+zt/hF3/xF3vWRkdH2d3tv3W1n85g5kzdiqKIwPePIMd1CXyv0weuh+97BJ4Xz71jY9+P+8An8H1CP1nzfUI/IPA9Qt8nCPykD7rmAWHgEwZB0nzCICQM43kUBPGFKgzjeRgSnVog8+lIkEL0goMxZGMMOZiDNvqgjaT0SZYXgVNRaRV1WkWt0/tNmdNrHjx7CYgM6ZNMmBeZMObIHisMWvfK7DTvs9Na5sDeIDgtVfwLpAhAiOEoSuBJUlQkVUNM3KuSoiAklkRBVhFlGSGxICJKCFLcEEQQpaSshZhAViefIlEUw5SfvD/95H3d3fv+J3vNIsBWVCxVx9KMo17TsVSdZjK2lUcLYgcwPZds4JILPPJhwAAhA0QMihHDksioIpGVZTRN7Yml6jRFRrP30WuryOUlxOK9I8hx6yf+XgS00KiYc5TTF6mok5SFApVAp9wKqdQaBA+xQguCQCqdQTbShIqJhcqBq7AcqeyKPl4mIkpLuIZJXc2daskBGIr2GWc7bkGJGcdmth4y3tDRmiMorRHU5jCSm+tbSkXQpB6LzhHoHI3FtPpU68d9qmDm13/91/md3/mdzpokSQwPDz/yfZzBzJleZkVhSBiGMdh0jcMwgOQi04aeKMnkG4UBYRh26iO1bwdtC0nUM44tJRz7tX9kXYmiAM/fxfbuY3v3cbxVbG+ZICz3fcySmEdXzqOrF+KmzKEpUwjisRilTu0noWspsY6cON5OI8wpLoaHfaEePeew7BGsNAnXW4RbdmwK6Tx4ECY0hCkNYUohyojJaxglr/Hp/x5tCA2DIJ4H4RHEhjHUtiE28P2kT2C3A8XHoNlL4DqxOAZdY99zn/juxwepe2ekkux2jHdJJhsADANJizcFSKqOpKqIqoqYuG8FWUGQZQRRIgjDDgT1a57n9Z03fZ9yJFIRJSqiTFWSqcvHIUgnfMSUFHLgk3JapBybtNMi5dqduem2exsROoHhmqpSkFsMCxWGoiKF4ICct0vG3kHzKqf+rVDSaeSvUs3MU9YmqYiDVEKDiiNQqTWoVqsPhR0AzUgh6SlcyWBXSbMp6ewrAg1DwDE1WnoaVzq9bpYSOYyxyxjbjLHDWLTPZOBy3o0YbqRQqoMojUGU1hDKcavOcYkgpVXEnEbqzRHSX5x46ON/HD3O9fvpbIB/gpJlmbGxsef9ME6oXrJplGxkVUJWxd5eeYESU53ppZYgikjPKBPvg/UK8Id6VhzngEbjNvXG7biv36bZXCYIK1jO+1jO+51zRVEllZonnb5KJn2ZdPoK6fSVJ7qb6pE1Sfx0gNDxcZYq2HfK2IslgqpLtOEQbcR5baSChj5fQJsvoM/lXqicNietjEcu145rNnHLHnfbxi7dJN7NOYptc+045s3t2gTQBiY/cQM3q5VP/NhlTUvyYpk9SUNV00Q3U+SSxKJqIY9upuP1VNy3E5BKsnz0OgRBT1zTvu2ybTts225cdd0LOPBD9oMwjvGJBJqCiC/JVM0MVfNkRtu2hCjCcBPYcewu4Bkm5U1hJmtq4KNjM0iZIUoMUWaIMoOUGKSCFNhki++RLb7H9LG/4UhpLH2ckjFLWZuhpo5iyXkakUHL8bAsi1qthu/7OC0LWnH6v6GkdUuSFZxUnsNUnj01zaGmUNVlmrpOU0vhCRobnGODc8kTJC4TooBuNhkb2WGUXca4zSj/hpGozlQIE4GJ7gyjNAaRKwWkch65OQg1CGouwULhE78vPoleeMvM3//7f59cLoemabzzzjv88i//MhcuXDj1Nu2dD23VajWmp6efuGXmvd9e47v/5P6px9tgoySQo2hSPNfiJmtH4+6m6jKK3h5LKJqMakiomoykvAgXtTOd6XQFQYtG424COXdoNG7RaNwlCPqXYdC1CdKZK6TTl+PcOOkrGMbMcwk2jqIIf7+JfbeMvVjGWTkWRCyAOpVBu5hHn8+jzmSf2O6RF1Xt/FntoP/OBoD2Lkm7eWxnZPNonOTO8uxWklqihe9+soSM3ZI1Db2rnEycbT2e68fHqTR6Kt3pVdPAjgR2HY8dx036uO26Se/EO7kedXuCHoXkw4Bs4JLxXEzXxrSb6M0GeqPCmLXFtLeXQE4MOIOUyPLgEiV1TEpJosB9hqkoY9SVIWylQCgqsQvQ9zsB7A9SiEBdN6hlBymnchzqKWq6Sk3XaSrmA4ufapHNCHuMsssou4ywxwi7jOAwJijMDH+d+Vf+r4/4aj2aPjVupt/8zd+k2WyysLDA3t4ev/RLv8SdO3f46KOPGBwc7HubfnE2wJPPAPytTX78Oxv4boDvhXhuQOg/3ZdSlAXUBG4UXUbVJVRDRtXlpI/nmpHMk7FmHo0VTXqqPs4znem4oiik1VqPk/41btNo3KHRuH3qbqo46d8C6dSlDuSk05dQlPwzfdyhG+CsVHEWy9j3yvj7vcGggiKins+hX8yjzeVRxlNnn62HKPD9E7mznGazJ7Ho8YSiTrOJYzVwWk0cy8KzP36Jjo4EAc0wO3Cjp48BTzqDnkqjpNI0zTQ1zaSsaJQkhYNQYMf1Oru1dpxHT0goAoOyxLAsMChAgZARt85MfY3J+grD9TUGrQ0y9g4Zdx8jfDDoWBjx1nJylMhRpMABA1TIYqPTdr+2A9zDB5TJ8AWRmpGiZqSoGmmqqSxVw6SqG1iqEQe0n/a8ooAvB/f4X3/qTz3S6/Co+tTAzHFZlsXc3Bw///M/z3/2n/1nfc95VpaZfgrDKIYbN8R3Azw3wHfCpI/nnhM3v2vs2ckxO567to9nB7hOgGf7+O6TCwIVBGKwaQOOKaOZSk+vd6+lkrWUgmrIJ2p5nOlMH1eeV6NhxVacRj2BHGuRMOyfSTiuTZXATeoS6fQlTPMCovhsXD9+xcFZKmMvVXCWKoSN3l/BgiGjXcihX8ihzeXjqt9nn5cnrjAIOmBzlFW90cm+bluNOPu61YghqGlhN5LeauB/wnIdgiCipdMY6SPwiTI5WrkBGuk8DTNNVTOpKBpFUaGIyEGybf2RrTyiwKiqMCfaXHO3mbe3mLY2GKmtUaivk66toTr9Y9baclGokKVMrtNKZCmRp0r2gRXMjysQBOq6GcOOnqKa9DXTpK6n8EWZn7C2+f/+0X/vke/zUfSphRmAn/qpn+LixYv8g3/wDx7p/E9DAHAYRgn0+LitGHbc7nHLx7WDuE+a06f/xJYjgdjSk1LQTRk9raCZCnpaQU8p6Ck56bvW0kpsDTqLITrTIyhO+rdGw7oTA451l0bjLra92fd8QVBImRdIpS91ACedvoSmjT/V91wURfh7Tex7ZZz7VZyVKpHTe6kSTRntfA71Qg7tfA5l7Mxy8yIo8L0juGk0kvp6cXMaDWyrjt2Iwcdu1OPjjTq2ZX0iN1koCPj5IdzhUezCEM3sAFY6R93IUNMNyrJGSZSp8Wiuy5Tf5Iq7w2veLpfdHWZb20y2NhlqbJKxdhAeshPSUXJYyiA1cYAyWYpBin3P4MBPUSVN+IghtRHQVHWmxsf4a3/h//JIt3lUfWphxnEc5ubm+Et/6S/xn//n//kj3ebTADNPSr4X4DR9nGYCOE0fp+l11o6PbSvpmz6+8/ET24mygNEGnLSCnlIxMvHYSLd7tdMbaeUsPuhMPfL9ehKLcycBnDs0GosEQaPv+bKcIZVaIJ1a6AKdhafmqoqCCHerjnO/grNcxV2tEXm9FxNBl9FmszHgnM+iTqQ/9TE3nzb5rhtDTr2WAJAVg06jjt1odACot8Xg9Mh/Q5KxzDT1VBbLzFBP57BzA7SyBaxUlpqRpqoa2NLpsKGEHlP2Hufsbc7Z28w5uyw4O0zbO4w3tzG9k1vLuxUhEJrDuKlxbG0YSxmkLuYpk6EUpNh3daqWg2VZnW35b731Fl//+tcf+Xk+ij41MPM3/+bf5Otf/zozMzPs7+/zS7/0S3zrW9/iww8/5Ny5c490H2cw82QU+CFO08e2PBzLw7Zi2OmdJ63hJ71H8JDKradJ1SX0TAw2Rnef6e3NTAxB0tlF4TOnKIqw7S0a1l2sRmzBaVh3aTZX+hbgBFDVkQRwEtBJzZNKXUSW033P/9iPzQ9xtxo4y1Wc5QruWp3I7f1BICgiylQmBpzZLOpMFtF44TeYnuljKAyCY6DToFWvdeatRgxIrUYdu17Htuq06vUHxge5soqVytAwMzRSWRpmmoaZPVpL57DMDK6inrhtzqszY+8wY+8wbe92xufsHaacPYzgEYrGmkOQnybMTOKaozD3E+iv/NFP8jKd0KcGZv7Un/pTfPvb3+bw8JDh4WG+8IUv8F/8F/8FV69efeT7OIOZ56d4J0TYAZtWw6VV9zrz9lrce7TqLrblEz2snGsfaabcgRwzo2Jk1Rh2sjHwGBkFIxvPz9xen26FoYPVXMFqLHbcVJZ171RXFYCuTyZgM0866VOpi0hS/xo6j6soiPB2GnFA8XIVd61G2DwGXALIIybaTBb1XAZ1Jos8ZJy5pj7DarvEWvUadr1Oy4phpw1CrXodu1FL+qP17hIxPdBjZnrHnZbG1pP3ehQx6FWZtneYdnaZtneZsvfi3onHmaB54rHee+OvMP/H/t4Tff6fGph5EjqDmZdLURjhtHxadZdWw8OuezTrLnYCQu31Zq193H3svGGyInbAxsyqR+OMipnr6rMayguQ0vtMT0a+38CylrCsxQ7gNKx7uO7+qbfR9akO2MRtnpR5AVk+PS/JoyiKIvyDFu5qDWethrtaxS+e/DUs6DLqTAZ1OhP3Uxmk1IuT6+ZML56iKMJttY4gp16jlVh9Wm0Q6swTSGrUsP0Ay0zHkGOksVIx6DTMDE0jWTfTNPUUmajFlLPLpL3PdAI4vrnAX/0P/+YTfS5nMNOlM5j5dCsKI+ymR6sWg06z7sbAU0+Ap+729I+7M0zRpA70dFoCOnGfjLMKonTm6noZ5XllGo17WNa9BHAWsawlPK946m00bYyUeREzNRdDjjlHKjWHogx+bKtf0HBx1+u4azHgeFuNE3E3ANKAHsPNVBp1KoMykX4h6uic6eWW5zonrD7HwadVr2HVapRdl8MAKpKMZcSQ81NXLvOf/Ps/+0Qf0xnMdOlpwYx/eEhQLiOPjSGm02dui5dEru0nYOPRqsXw06wlwFNzadaceF518ftcSE6VAEZawcxqpNqQk4uBJ5XTOhCUyp1Ze14WuW4Ry7qP1VzqgI5l3X+gJUeW86RSc6TMOczUhbg35zCMqcdOBBgFId5uE3e9hrtRx12v4x/2iaEQQB42UafSKJNp1Mk0yvgZ4Jzp6avbDaan0qQH+ud/+7g6g5kuPS2YKf3ar7H3d2P/oGiayKOjyGOjKKNjyKOjKGOj8droKMrICNLgIMILkZb+TI+iKIq3wzerR7DTbMNONYGgqkuz6tCse48V56PoUgdwUrle6GnPUzkV1ZDPIPkFlOfVaDaXEpfVUgI795MkgP3fB4KgYprnMM3zmOYcKfM8pnkB0zz/WDuswpaPu1mP20YDb7NOUHP7/EGQhwyUiTTqRBplIoUynkJKnwwGPdOZXlSdwUyXnhbMFP+Hb1D8h/+QoFp9tBvIMvLwMMrISAdy5JFhlNFR5JER5JG4l9KpJ/YYz/RsFIYRdsOjWXOwqgnkJNBj9Yydx3JzSYqYWHk0UvkjyImhJwGgvIZmnkHPi6AgaNFsrmA179O0luO+uUyzuUwYnp6fRFEGMM1ZTOM8pnkew5yNocc4hyQZD/+7NRd3q4631cDdbOBtN/oDDiBmVNSJFMpYDDfKWAp52EA4c5Ge6QXUGcx06WnHzIStFv7eHt7uHv7eLt7ePv7uLt7+Hv7uHt7eLsFh8ZGr24qpVAw3bdgZGYnnw8NH/fAwovHwL7kzvXhybb8DNu3eSiw87b5Zc3GO73R5gCRZTCw7iUsrl8BPAkFt+NFSZ9DzPBRFIba9TbPZBpyVBHJWcJzdB95W08YwjHOYxjlMczYGHWMWw5h5IOgEDRdv28LdauDtNPC2Lfxiq7/hSBJQhk3kMRNlNIUyaqKMmkgF/Wwn1Zmeq85gpksvQgBw5Hn4h4cx9Ozt4+/v4+/v4e3t4e8f4O/t4e/vE1qPnlhJzGR64EYeGT4adzUxlTq7gL2E8t2gB3K64ad7zbEeHXpEWSCVPbLopLIqZr7L2pOPj+kp5ew984wUBE2azdUEblZptlaS+Qq+/2Crr6aOYhgzfZuiFE78G4ZOgLdn4W1beLsW3k7cH89c3JagiMgjJsqIiTxqxsAzYiAPGAjS2fvjTE9fZzDTpRcBZh5VQcPCP9iPAWc/AZ39ffyD/RiCDuJ5ZD9CQqNEgmHEYDM01NUPdebS0BDy0DDyQAFBOdvy+bIp8MIYcGqJlaeSAE/Fwaq5WJUYgmzrwdV0uyVKQhzPk2/H9RwBUPfcyKhntbqeojyvnADOGq3mKs3WKq3WOs3mGr5feeBtJSmNYUzHTZ9GN6a6+qmOVSeKIoKKE4PNfhN/18Lba+IdNOG08ieSgDyoIw+bKMMG8pCJPGwgDxln28bP9ER1BjNdeplg5lEURRFho5FYdxLAOTiIweegtz2OpQdBQMrnO7AjDSbAMzSIPNSeDyIPDiINDCBIZzslXiYFXojVFbvTgZ7qUWyPVXWwG48OPYIoYGSUI9jJHsX1mF07uMysiqycvV+epDyvkoBNDDgteyPuW+sPdV0BqOoQuj6Frk9i6FPoxhS6No6uT6Lrk0iCiV+28fcSyNlrxv1Bq+928bZEU0YejMFGHtSTPh6L5hnonOnxdAYzXfq0wczjKGw2Y7A5PMQ/ODwCneJhsnZAcHCIXyzCA0rDn5AgIBUKMdgMDSIPDCIPDcbAMziANBhDjzwQj0Vdf3pP8kxPVIEfdqw8zWpi2akdd3PFeXse55tDM+XeHD09OXuO1vS0cmbt+YQKAgfb3uyCnA3s1gYte5NWa+PUelbdkuU8hj6Jpo+j6xNx08ZRtTFUexihmiI4cPAPW3E7aBFUH1yEUTDkGHAGdOQBA3lARxqI51JOO3NdnemEzmCmS59lmHlURUFAUKngHxbxDw8IDg+T8SF+8fBoXiwSlEqPHMzclmiaMeAMDCANDCANDiAXkn5gAKkwgDRQ6BwXNe0pPdMzPSmFQRhnYj4Rz+N23F7NqotVcx6rWrsgCnG+niQTs5Ht6jvjo3pdZ4kKH09RFOH7VWx7i5a9id1KensT297Ctrfw/QcXIQQQBAlVHUbXxmPg0cbRxHHU1hhyYwCxliKqygRFB79oE9b7767qSAQppyEXdKSCjlzQkPI6UkFDzmsx7JzVX/vM6QxmunQGM09WURAQlMv4xRh2gmIRv1giKCbAUyoSFEv4pRLB4SGR9+hui7bEVAqpUEAaGEAuFDpjqZA/mhcKSPkCUiGPlMud5fB5QRVFEU7TP9qunuTrsarHkhQm5SlOSdPSXwLoZlJzq1OAtKsYaVpJqrPHa5p5ZvV5FPl+nZa9hWPvYNvb2M523NvbOM4OjrN3aiHP41KUQXRtDFWawHBnUFsTKNYgopVBrGtEVYGg7EPwkH94Id5W3gYbKek785yGmFbOdl99ynQGM116WjDT9Jq0/DgbZ/SQb2CB+AMmCEJnLApiz5ooiAgIvXNBQBKkzvrLpnZ8T1AsxnBTKuEfFgnKJfxSuXe9XCIoV8B/9N05HYkiUjaLlM/HrVA4Gudj2Dk6lsxzubPt7S+Yuq097aSEre4MzV2lKeyG99g1uQQBtJSCkVbQ0wpGOnZrxWMFPZW0tIJmykl/BkDHFUUBrnuIbe/gOLvYTtw79i62s4vj7CXA8xBrTOcOJYzoHIZ3Ad2ZQrHHkFsDSM00QkODmgT9N1z1ShSQMipSTo0BJ6siZTWknIqYUeN5TkNUz+K3XhadwUyXnhbM/Pcf/vf81+/910/s/h6mNuD0a5Ig9e/Fo7ksyoiCiCzInWOyICOJEpIg9cxlUe7cRhKkzrhnXZRQROXEMUVUOnNZlJEFuXeerCmScuKYJEhIjRZCpY5QrUOlRlSuEpTLBJVKbBFKoKe9FtYfbhI/9TXVtA7YSLkcYj4ZZ3NIuWy8ls125mImEx/PZM52fj1ntRMVHq/H1d3bjXaRUu+x8vYcl2bKMdykFLRUAjqmkqwraKn4uGbEc9WI56oufWbdYFEU4XnlGHKcPRx3H8fZx3F2cZ19HHcf1znAcQ+Ah8TrRSC5WRR7EMUZQfemUN1xFHsIqZVFaqagpSJEjwadgiYhZboAJ6Mmc+VonFYQzTNLz/PW41y/5Wf0mM70CRUREUQBQfQoP1E+PRIQkE0ZOS0jz8gxLHUgaBg1GiNjC+RaAulWRLoZkm5GpJohZjPAaAYYTR/d8tAbHlrTRbVcxCAicpzOrrDHVaRrRJkUpFOQSSFk0oiZNEI6jZTNImYzSOkMcjaLnM0hZ3Io2SxKJo+ayyPq+ktpbXtRJIpCJ4j4UarBBEGI3fBiAEogyLHicXvNtjwcK+7thodrx581p+njNH1qh4+eEqEtRZNQDTkGHCMZ63LSH80VXYp7TUrGEooWz1VdQlLEl+r9IggCqjqAqg6QyVw99bzYylPCdQ8SwDk8GruHSTvAkQ+wtRVsVqjz/ZN3FIrIbh7ZLiA7BWS7gOIUUJxhFHcI2ckh2RkEXyFyAnynBf3qXHVLBDGlIKUT8EkpMfCkYtiR0gpiSkFMx8cE5bMJri+KziwzH1NRFD32l0v7pQ6jkCj5L/4//i+Mwtg1E4WExOMoiggJ47U+LYiCk30YdsCnvRaEQacPoxA/8jtrfuh3jvmRjx/6ndt5oRevJ+f4YXy8fV77mB/5p57rhV7n73mhd3QfXffVXn8miiJ0F9I2ZFqQsiPSrd55yoZ0i7hP5ikbzEe0nD9MvghNHVqagK2J2JqAbUg4moirSzi6jKtLeIaMpyv4uoxnKASGSqCrBGbch7qKIqsd61rHUtZldVNE5YTFrQ2E7fVuK1m3ta2vZS1piqh0LHHH+7Yb9WVWEIQ4lo/T9LAtvwM6TtPHbsa9Y3k4LR+36WM3fdxk/bGKlD6CBCEGI0WTkJNe0SQUNZl3ehFZlZCTXukay8rRMUkRkZXkWDIW5RfbnR0EDp5X7IKcQ1y3iOsV4949xPNKuG4Jzyv1jesRfR3JySM7eWQnl/R5JDeH7GRjIHLySF76sR+foEkx/KTakNM1NpXE2iN31gRNeqFf7xdBZ26mLp0FAL88aoNcG5S8wDsanwJB3ef1Paf7vOR4D5Qdv++oF9Da6x3o8zyUpoPcdFGaLlrTQ236aE0PzQ7QWwG6HVuEdCfCsENMB1IOmA7oDjzpy7ytQEuNm520lip0xraanKMJ2ErvmqMma8m6o8Qt+oTm9TZEKaLScSkq0tG8fUyVVFRR7ay356oUr2mSFq8l6+1597omab1NPhrrko4sPvsyDkEQ4rZii47b8nFaPl4riMGn5ePaPp4d4No+btJ73b0T4Nn+Y9Xy+sQS6IBNDDtiTy/JXeP2XO6d95wn965JsnBsfvx28fEn8W8V79qqJXBTjHuvjOeW8Lwyrhf3nldO4Kfcu2U9lJDcDLKbja06bg7ZzSC5OSQ3i+xmkdxsck4GIfoYTg6RGHLMGHJEM4GfZBz3cs9x0ZA/U7u6ztxMZ3op1Q54lpDQJA0+BWEpUXTkHvRDH8938Rt1/FoNv17Fb9QJ6nWCRp2w3iBoNMBqEloWUbNJ1LAQmjY0W2C1EFo2QtNGbDoISW4g3YtboSdHYr/fKI/+u8VTBFxVxFVFHFXAVYQEfhLwkSNaSoStRDTlsANBTgJGrhJiKz6O0uqsW0nvS8SmhmckURDRJA1DNmLAkXV0Se/bG7IRz2UdQzIwZANDMdCl+Fh7bsgGpmx2ekXqfbNKkoiRVjE+YZXqMIzw3QDPCfDspHcCPDeet4/5bojnBvhOsuaF+G6y7gQEXoDvhfju0bqfrHXeFhHJ8WcIUH0kSkIv8PSDIFlAUqSjY30hSUCSJWRlDFGe6ECWIovoiohk9sIXog9inZAqYVgliKr4XgXPq+D5ZTyviu8Vsb37eH6y7lWIQg/RNxPIySB5GSQ3aV46gZ40cnvdSyEGBoQQNjzCx0hUCYAKoiEhGgqiqSIlQCQYMuIDmqDLn+oYoDPLzJnO9BIqiuKYn9Cyeluz2TvumbeO1trrrRZhq0lkNQlbrcfOIfSxHrsoEukqka4SaiqhJhOoMoEm46sSvibjqRJeAlGuKnaBUoQtxwDVkkMakk9LDmhIPg3Roya5WDjYD6hS/TQki3IHbEzF7O2TsSEbPcdSSoqUnMJQjM64vW4qJor49Gk+iiJCP+qATdAGHi8gSNaD9roXEvjxOPDj83rmXeMTvR/F53ghoR92xoEfPlYeomctqcvyJB+zJMVWKgFJ8ZA1C0mzkFQLUbEQZQvkBoJkIYgNIrEBQp2IBiF1Ir+F4EYJ7KTj3ksjHpvHLZUcMxE+kV03Ag0EXUQwJERDRjI0JFOLrT56Aj66HIORLh3NdRlBffZxW2dupi6dwcyZzvRoiqKIyLZjwGm2CJsWUat1NG8143kbilpda634dlGrGR+37eRYcn+t1sfbdv9xJIpxgLVhgKGDoccB27pCoCkEukKgyvi6HFufNBFHEXBU4cjapIRYckBDDqhLHnXJoyY6NEObph+nZWj5raca56WKagdsUkqKtJI+gqDuJqdIqUmfrKXV9NFYSaNKn8xC9DTVAaoe+DkCneDY+hEQRT1r8fnt8cnb9QOsDqx1nf/sFCIqNpLSRFSbR71qISktJL2FrLWQtSaS2kKUW8hiiBIJyIGIFMod0JG8VGwd8lKIXipe983OWAw/eSLSSIgQtASINDG2DukKoqEimTrG/BDGlUcJx390nbmZznSmMz22BEFAMIw4/87Ak7//yPMSsLFj6LFtwmaLyO4CJrvVBUddMNRe7walZnI7245dcu0EjWFI2GxCs3niMYhJ+7g2D8EwEE0TMZVBNEcRTIPI0AgNLQ7MNhQ8LQ7edjQRWxVoqRFNDSw5pKEG1GSPquRRkxwsv0nTb9L0mlieheVZeGH8PNzQxXVcyk75Yz7aIymi0oGhtJI+Ap4EhNprbfjp9Grv3FTMJx7cLQhCYuEQ4TmnfmqDVTcgnbBKeUeWq7b77rilyu++jdtl9Tp2ru8aBH4OvxXi1kKi8DFsC0KAqLSQlNYRDCktJKWGqOwhpeK5qLSQJRdFjFCECFUQkJGQIwk5MBIIMrv6ZM03ET0TyU8hRFK89d3+/7d35kFylOf9//Yx03PPXtpLt2JiSaxk0GGKIAfh2BCDCThlRwGDpYKkohQCyQIMBF/BYOFSDDJlS0ZyCqVCsGwj7MIu4IdIAIOVWEZHLJAiZJAsIXa12muOnbO7n98fb3dv987e2mtWz0f11vu8b7/d8/arnu3vPO8lATnRM2lY/4AcgCTaO/bhogW3jtH/zOCwmGEYZlyQfD4oPh+UMfKQkq5bAilT4lFy8mwBZHuUrO41p+vNFknu7rhMxtm7jLJZGNksjPb2vu8RgN8Kg86HkWXI4TDkSARKJAw5PANyJAIpHIIZDkAP+qEHfSgEVOSDKrIBGVkN6NYIKb+JlM9Al7+INOUcIZQuph1hlC6mnYU9i2YRnfnOURFGvUVPb9sWSh5R1Id4mozeIrew8k+AsDINs2dsk+U1EraVdtl6oUdYOWOhbCFljYsy8gb0tIl8wUS3fbzQUx5S0RE8jpfI1w1ZbYcStvLVLFRFh182LUEEqJDhgwyVVCikQjGCKKjTx7/BXLCYGSnFLCDJgMr7CDHMZEBSVSiRCJTI8KfVDoQzPskeZ5TJCBHkSXf3G4zutGVnYKaFDdMUHqRUCmYqhYE6q1QrhPu7b01z1jWSY1Eo0XoosSjkaAxSNAIjrEEPaciHVOSCKjIBCZmAhLRGSGom0pRFupBGt96N7oIQQW5xZMd2l5p9rBXDX5/JjU/29SuG3Plub1Jfx8O+cMkA7HJFVmT4FRn+cdibl4hgGuQSOIYzAFwviEHmzkDxglcE6UUT+YKB7oIJvaCjqGfwJ/Nqx77SA8BiZqQc+HfgxXuBYCUQbQCi9SKO1Fl2PRCpB6J1IvbxztEMU45IkgQpEBC7v1edf/8bEVleoW4Y6TTMdDfMdEqkU2lL8KRhpMQMNzOddma7memUKJMS5QGA8nkY5/IwzrUN+tk+AHErOPcXCkGJRsVij3FrxetYo1gB205XxGFGgyiE/cgFVGRCMtIaoZtyQvBYIsgthLqL3UIkuTxG6WIaGV10/xXNIrryXejKd513m7q70foSPSHVmx/yhTxjjOyB2bY9FdZJGgxJkpzZYFqw/KVA+d/BRJE+K+JspwitRwYuH4h7xY0T1/cIoEgtoMXGddoqwzDjiyRJkEIhyKEQ1GnTRnwdMgwhdFJpmKmkED/JZE86mRJxIinEUDIFI5mEkUzATKZgpsW6KpTJQM9koJ89O6zPjwCIRSI9W4JUxCE724NMgxL/iJOv1FtbhsTjQCyKnKw7gidVSImuMb1v8eMWR709RnlDzFobzW40AAiqwRIhZAsge2Za7zxnJprqnbHW19R9ZvTh2UwjhQjIdQGpFiDVDKTOAqkPrbhZiB073xjGNFE1KERNpM4V97anAeFa9vYwDDNiyDBgpqx1jroSlsixxE8yCTOZcGwjkYCRSMBMJMSxdHrwDxgAKRj07IvWsyFs3Ls5bNwWSBVCLGnebn3dFKLILXw8tp4pEUK2cHIPurbzTBqb2UyqrPY5XT+khhD09TOl3xfyTPf3rG3kCyGgBKDIU3vTTJ6a7WLCp2Y7oucskG7pP063Avnk8K4diAtRYwucSB0QniaET7i2R/SEp7HwYRhm1CBdd0SOaQkdI5EQG8Imkt50MgGzK+GUtwdTjwQpEOgROy6PUI/osYSPK1+JxSCFQoOukUJEyBliMHW2mPUKHt3KcwmkTLHXTDSrfFbPOnkFc5T2P+kHezFHj9ixFnV0i5+SMmqwNLjOCyiTY+84FjMuJlzMDIdCRnh00q09AifdauVZ+d3nhG0M80uixYSoCU+zRI4tdGos8WPn1QCBCu7qYhhm1CHTFF1jiYTwBjkCqMuxzUQCelcXzETSOpY4bxEEaxadLW6c8UDxCisdgxyzxgfFY9ZmscKWAyP/IVg0i464sQVOVs/2iCBLJLnz7HWM3GLJPm7n0zBW8x4JEiRnRey+gvuYbS+pXYLLGi4b1XqwmHFRVmJmqNjeHrfYsUVO+hzQ3eoSPq2AOczlsmUVCNUIYROuESInVAOEq3vynbhaiB956g+YYxhmYiDTFAOkEwkYnV1er48tjLq6errEkglHMKE4zL9/vZD8fiF8orbIiQo7HoMcjYmZYzFxXI5GhDiKWnmRCCT/6E5Btz1I9sKNvQWQI3wskeQWQu5gl3WH/HCGRPTi9qbbsWHphtG7UfCieVMfSRKzqIKVwLSPDlyWCMgleoRNdyvQ3SbSTt45K68NyCcAU7c8Qy1DrI8iRE2o2hI4VT1pJ1QBQVe+P8zeH4ZhhoQky2LGVTQKzJgx5PPsmWOGNdbHGRuUSPR0h/UaK2QkrHQyCZgmqFCAca5tSLPF+qy7e+p8NAolEoEcjQrhE4mKdYaiEciRCORIFHIkLMrYIRyBHApCsn4wSpLkeEVGG8M0kDfyfYqfbDHrEVHukNNzWDxt8ajXZziwZ4bxoueFqMnYgqe9R/hk2kTaPpbpGP44HxvFL0RNsMoSOpU9gsexK0sDr+vDMMw4QERifSBbCCVTHuFjplM9M8asmWKmvWmsa7bYqCBJYuXpSMRZaFEOhyCHw1DCVl44LPJCLjsctlas9sZSYHKMiRkM9swwI0fVgPh0EYaCnheiJmN5djLt3nS2w0p3WMfaxewuo2DN9moeXv18ISFqAhVAsMJrO3G8l20FNcDeIIZhhoQkSc4ijL7pw1/d1jN1Pp1yZo4JwZPuWTfIsdOWLdYQstMwDMAWVtbaQqNwc0LUhKztOYJiqQBhB4UnKBgUwsidDoYgBwOQg650SGyBIsfiUCL9Le049rCYGSFEVBbKdsxRNSDWIMJQIAKKGSFush094sder8fOd+xOkc4lADLFucUMkDwz/LoqfjEQOhAT4sa2tTigRS07Jmwt2suOiNgfBRT+2jBlAJH40WAUAKPYy7bSpss2iqKL2WMXe8qYhsgzdZHnpHvFZLhsU9h2HhlWniliO+0JVGrDjq37AvXE7rxhY/0NlyRhDxRLstd2jsl9BkmSoEgylL6Oh2QgYqcVEctRQKqwbJFPkEA6YOZNmAUDRt6AmTdg5nUR53TLLsLM6TByRZi5okhnC1Z+HmauADObB+UKTnuZ3d1AdzeMkT1dJVTddhvqvnLvKF1t+PBf5RGyc+9JbP5/x1AZ8qMy7ENlyI+KkB9VIR8qw35Uhf2oDPXE1RER+9ULfKCsJInxMv4wUDFz6OeZpujSynaKwc/ZTiDb5U3nEiIvl7DyusQ5thAyCsJjlBlZ37eDGgD8ESFw/JEe2xey0uGe4AsB/hDgC1txyJUXAnxBEasBEXggdflimsLrqFueR3es51x2vqdciV0QZUuukQP0Qh/XL1p5tlCx8vT88Af+M5MOSy5hwL8KEoCAFQaBCCBDgqlLMItWrMtW3BPIzjfcaamPtCxsQ4Lc8rvRuOURw2JmhHRmisgUDGQKWZzpyg75vGhARbUldqojGqrDQuhUhzVUR/yoiWhOuirshyKz9weAeMkHK0QYLkRAIe0SN8kekZNLAPmUNz+ftvLsYymRZ4/013MinK8o6gtb1PiCwuulBsUaQWrASluxogGq34o14XVS/Faela/4rOAXsewTM9UUK/bYioglRdiS4vw6FGnXL0j7V2nvX6slca//g96/op3Y/gVOffxKt3/R9/qF7/EAuD0GhsuTYHkP3N4Fj6fB9kK4vRW2QCj0LRAcEZF3iQsrNgfaYWkyIIlnRfaJ50S2nw3Vayv2MesZ6W3Lqiut9v38yKrlYVB6PVOK9dy4nyv72erP4+FO9+M5gR0N9e8luRw59rPotnvFjnfI9YwC3mOmgZ7n2XSlyfv8CkXRt4eqxHtl9PJsmej7u9CHB8z53vR4zSQyIJkmZPv7YxR7zrW/Q2RYe4e5ygzB60Urbh5i248NPAB4hHTndZxL5dGZKYjQXeyxM0V0dhfQYYXOjIiHs7s7IL6nVSEhcGqiIp4W0VAT1YQd1VAT8WNaVEN1WGPhM9boBSGK8ikrTovYtosZK23H3VZeBih2W3G2p6uskAH07PDXDGLKA7fQVLW+RagtUPstE3DZ/tJrOrHWI1ztcrYt+ywRM7VXi2XGECKX4Cn2EkpW8EfExI1RhAcAjwNhTUVYUzGn371svZgmIZEtoiNTQHu6gI7uPNq7hd2eFnZbOi/SlgAigijTXcCxQbZNkSWgKiwEzrSohlornhbRUBvTUBsNoDYq7JCf/9tHhOoH1KpR/8LCNCyRkxXippjzxnY3hSfu1XXheBgK3m4G93gI2xthFgGjr3EPRdevOtcvs97ekjGn1ziEEk+R2uvXfx8eJo8HweWRsj1UilrqvbI9Fo5nS3WJB59XULhFQ29xYl+Xx9QxUwVJsr4PKobUnzUB8FttnJBlCZVhPyrDfvzJEPaW0w0THZkC2lIFtHfn0ZbOoy1VwLl0Hm2pPM6l8ziXyqMtLY6bBFEmncfRQSYIRTUV02JC8NRGA6iLaaiLBVAbE4KnLibyWPSME7JiDTCOTHRNBod6dw+5BmqKAi67F54ugV5dB57BlSwCGIYZHvy2mqSoimx5UwZXwbbwOZfKO6HVY+fQmsqjNZlHtmggldeROqfj/XMDT/OLaipqYxrq4wHURYXYqbeET108gPpYANOiGnwKD1q9YPCIDe62YBhmcsBiZgowVOFDREjndUfYtKZyaE3mcTYpxI47zhR6RM97A4geSQKqwxrq4xrqYwHUxQJoiIu43hI89fEAogHfaN82wzAMwwBgMXNBIUkSogEfogEf/mRa/10atug5m8yjNZnD2VQOLQlb7OTQksiJY6kcigY53Vtvn+l/NeCwX0FdXAid+lhQiJ94EA226IkHUBXyQ+ZBzAzDMMwwKQsxs3XrVmzevBnNzc24+OKLsWXLFnziE5+Y6GpNWdyi5yO1/Yse0yR0ZAqWuMmhJZnD2YSIm+28RA7JnI7ugoH3z3UP2LXlV2TUWR6e+njQEj6WAIoH0BAPYlqUZ20xDMMwXia9mPnJT36CDRs2YOvWrbjiiivw5JNP4jOf+QyOHDmCWbNmTXT1LmhkWRLTxiMamqbH+y2XKehosUSOJ04I0dOSzKEtnUfBMHG6I4vTHVkAnX1eS5El1EY1S9wIL09DPICGClv0BFHL43gYhmEuKCb9OjOXXXYZlixZgm3btjl5CxYswI033ohNmzaVlM/n88jne7YxTyaTmDlzJm80OckpGiZaU3m0JLL4sEt4dZotwfNhIouziRzOpvIwhrBYjyQBNRFNiBzLo9MjfkS6Lq5BU3kAK8MwzGRlyqwzUygUsH//ftx///2e/Kuvvhp79+7t85xNmzbhn//5n8ejeswo4lNkTK8IYnpFEEtn913GMAnt6TyaEzk0J7KO2LHTtsenaJAzk+v3HyT6/czqsL9H5NiixzWGpyEe4OnpDMMwZcCk/kvd1tYGwzBQV1fnya+rq0NLS0uf5zzwwAPYuHGjk7Y9M0z5o8iSWAsnFsDHZlb0WcY9jufDrmyphyeZx4ddWeR101mQ8J0P+x+4HAuolrgJoj6mWXHPjK2GeAAVIR9vOsowDDOBTGoxY9P7RTHQjtWapkHTtPGoFjMJGco4HiKxGrPj0UmI7q1m1xielkQO6byOZE5HMpfGu2fT/X6mpsolU9HrYrZtL0wY4E1GGYZhxohJLWZqamqgKEqJF6a1tbXEW8MwQ0WSJFRYu5wvaOi/HzaVK3o8Oy2JHJpdg5dbkjl0dBeQ102c6sjgVEdmwM+tDvud1ZXrrDV56noJnuowT09nGIYZLpNazPj9fixduhR79uzB5z73OSd/z549uOGGGyawZsyFQM/09Gi/ZfK6gdZk3vHm2NPRm5M5tDrT1cVMLbtb68gA202osuTsrVVrCR97X606a8Xl2hhvLMowDONmUosZANi4cSNuvfVWLFu2DJdffjm2b9+OU6dOYe3atRNdNYaBpiqYWRXCzKpQv2WICJ2ZohA7KbEWz1lLANmLEp5NioUHdZOc7i6g/8HLiiyhOuz3bCJausmoED9BP8/aYhhmajPpxcyqVavQ3t6Ohx56CM3NzWhqasILL7yA2bP7mfLCMJMMSZJQFfajKuzHQvTfrVU0TLSl884WE2dTYgVme+sJsepyHu3dYop6q7UHF9D/AGZArL48LSrGEdmxbVdH/MKOCDusTfo/CQzDMCVM+nVmzpfhzFNnmHJAt7qsnP21em0qam802pbOI1c0h3XtoE9BdcSP6oiGGkuAVUc0VDu2H9VhDVURP6pCfvb6MAwzZkyZdWYYhilFVWRn8DDQ/8rL9h5bbekCWpM5tKULzj5abWkhftx5uaKJbNHAB51ZfNCZHVJdgj7FETkVIT+qQj5UhoXQqQj7URnyCTvkR2XYh4ogCyCGYUYfFjMMM0Vx77E1tyY8aPnuvI72dAFt3Xm0pwtoT+fFoOV0Ae3deXR0F9CWLqDDsosGIVs0cKYrizNdQxM/gJjKXhnyoyLkQzzoc8V+xIM+xIIi7Q6xgIpY0MfbVDDMOGOahIJhomiYKBqEgi7sgmE6dtEwURsNDDh2cKxhMcMwDAAgrKkIaypmVQ/+B8n2+nRYM7S6MgV0dBfRaaU7uwvozBTQlSmiM9Nj6yYhr5ti9lcyN+w6hvwKYgEfopa4iQZUS7CpiGqqk45oKiJWXiQg7itq3V/Ir/Aih8ykxBYOeV0IBVswFHQTed1w2VYZ1/GCbnjLu8RGodf17Ot7RQl5ytjn6UPYQgYA1l31EdxzzUfHuIX6h8UMwzDDxu31mV09uNcH6BFAXZmiCFkhcBJZEboyBccWQUcyW0QyW0QqrwMAMgUDmYKBloHHPA9SdyDiVxHSFCHg/CrCmoKwX0XQ74o1BSG/iqBPQdCvIORXHDvoUxCw7IDPTssIqAqvE1RGEJF4ifd6gfclJgqGgXzR9IoNq4zIN7zn9hId+aJRIiY8IsXyfEx2VFmCT5HhV2URKxL8qoxYcGLlBIsZhmHGBbcAmlk1vHN1w0Q6ryORLSKVs0ROTkcyJ9IpK07ndKTylp230jkd3Xkd6YIOIoAISOV1SyDlB/3s4eJXZGg+GZoqBI6mCluzbL+qiDKqeCH4rReD++XgU2SoigyfY0vwySJWrJeJIktQZcmKZcgyoEgiLctSjy1JkGWIWBL/DxLcMSBBwlCcVUQAgWCSEAJk55GVB4JhEojEXmomiWCYgG6aME3AIIJpEnRTlDVMgm6aVmylrRe7blqxxxbegqKr66O33dP9QSVdIr29EJMZvypDs54P53lR7bTieXbcZX3u/N7nK72OW+f5XGXFc2jbkidvsop1FjMMw0x6VEV2Vm0eKURijE/aEjqZgoHuvI7ugo7uvLAzBQPZossuGMgUDWQLuuMVyhVFyBZF2v61blOwXp4p6KNx68w4osiSVyAovURE72M+pUQsaCUCQikRI5pTrvSY+xrcHTp0WMwwDHNBIEkSQn4VIb+K2lG+tmES8roQPzlddCnkddMSPt5uhnzR7mYwnC6OvO1JcMYxCI+C7vIu2N4I24NheyiMXsEksrwfol4Gkct7YnlOAIAA0+VdEVnCIILjqRH+G7sNUeLVkWVhy5Lw7sguj5AkCYFge4nsfFWxYsuLpMoSVEV2eZpE2ieLsj2210vl83ivbA+DnW95FRTF413QrNjxRLgECq+qXb6wmGEYhjlPFLlHKDEMM/7wPEeGYRiGYcoaFjMMwzAMw5Q1LGYYhmEYhilrWMwwDMMwDFPWsJhhGIZhGKasYTHDMAzDMExZw2KGYRiGYZiyhsUMwzAMwzBlDYsZhmEYhmHKGhYzDMMwDMOUNSxmGIZhGIYpa1jMMAzDMAxT1rCYYRiGYRimrGExwzAMwzBMWTPl96snIgBAMpmc4JowDMMwDDNU7Pe2/R4fiCkvZlKpFABg5syZE1wThmEYhmGGSyqVQjweH7CMREORPGWMaZr48MMPEY1GIUnSqF47mUxi5syZOH36NGKx2Khem+mB23l84HYeH7idxwdu5/FhLNuZiJBKpdDY2AhZHnhUzJT3zMiyjBkzZozpZ8RiMf6yjAPczuMDt/P4wO08PnA7jw9j1c6DeWRseAAwwzAMwzBlDYsZhmEYhmHKGhYz54GmafjGN74BTdMmuipTGm7n8YHbeXzgdh4fuJ3Hh8nSzlN+ADDDMAzDMFMb9swwDMMwDFPWsJhhGIZhGKasYTHDMAzDMExZw2KGYRiGYZiyhsXMCNm6dSvmzp2LQCCApUuX4o033pjoKpU1mzZtwvLlyxGNRlFbW4sbb7wRx44d85QhInzzm99EY2MjgsEgVq5ciXfeeWeCajw12LRpEyRJwoYNG5w8bufR4cyZM7jllltQXV2NUCiESy65BPv373eOczufP7qu46tf/Srmzp2LYDCIefPm4aGHHoJpmk4ZbueR8etf/xrXX389GhsbIUkSfvGLX3iOD6Vd8/k87rzzTtTU1CAcDuOv/uqv8MEHH4xNhYkZNrt27SKfz0c7duygI0eO0Pr16ykcDtMf//jHia5a2XLNNdfQU089RW+//TYdOnSIrrvuOpo1axal02mnzKOPPkrRaJR2795Nhw8fplWrVlFDQwMlk8kJrHn5sm/fPpozZw4tXryY1q9f7+RzO58/HR0dNHv2bFqzZg399re/pRMnTtArr7xCf/jDH5wy3M7nz8MPP0zV1dX0q1/9ik6cOEE/+9nPKBKJ0JYtW5wy3M4j44UXXqAHH3yQdu/eTQDo5z//uef4UNp17dq1NH36dNqzZw8dOHCArrrqKvrYxz5Guq6Pen1ZzIyAj3/847R27VpP3vz58+n++++foBpNPVpbWwkAvf7660REZJom1dfX06OPPuqUyeVyFI/H6Yc//OFEVbNsSaVSdNFFF9GePXvoyiuvdMQMt/PocN9999GKFSv6Pc7tPDpcd911dNttt3ny/vqv/5puueUWIuJ2Hi16i5mhtGtXVxf5fD7atWuXU+bMmTMkyzK99NJLo15H7mYaJoVCAfv378fVV1/tyb/66quxd+/eCarV1CORSAAAqqqqAAAnTpxAS0uLp901TcOVV17J7T4C7rjjDlx33XX41Kc+5cnndh4dnn/+eSxbtgxf+MIXUFtbi0svvRQ7duxwjnM7jw4rVqzAf/7nf+Ldd98FAPzv//4v3nzzTVx77bUAuJ3HiqG06/79+1EsFj1lGhsb0dTUNCZtP+U3mhxt2traYBgG6urqPPl1dXVoaWmZoFpNLYgIGzduxIoVK9DU1AQATtv21e5//OMfx72O5cyuXbtw4MAB/O53vys5xu08Orz//vvYtm0bNm7ciH/6p3/Cvn37cNddd0HTNHzpS1/idh4l7rvvPiQSCcyfPx+KosAwDDzyyCO46aabAPDzPFYMpV1bWlrg9/tRWVlZUmYs3pUsZkaIJEmeNBGV5DEjY926dfj973+PN998s+QYt/v5cfr0aaxfvx4vv/wyAoFAv+W4nc8P0zSxbNkyfPvb3wYAXHrppXjnnXewbds2fOlLX3LKcTufHz/5yU/w9NNP45lnnsHFF1+MQ4cOYcOGDWhsbMTq1audctzOY8NI2nWs2p67mYZJTU0NFEUpUZatra0lKpUZPnfeeSeef/55vPrqq5gxY4aTX19fDwDc7ufJ/v370draiqVLl0JVVaiqitdffx1PPPEEVFV12pLb+fxoaGjAwoULPXkLFizAqVOnAPDzPFrce++9uP/++/G3f/u3WLRoEW699VZ8+ctfxqZNmwBwO48VQ2nX+vp6FAoFdHZ29ltmNGExM0z8fj+WLl2KPXv2ePL37NmDP/uzP5ugWpU/RIR169bhueeew3/9139h7ty5nuNz585FfX29p90LhQJef/11bvdh8Bd/8Rc4fPgwDh065IRly5bhi1/8Ig4dOoR58+ZxO48CV1xxRcnSAu+++y5mz54NgJ/n0SKTyUCWva8xRVGcqdnczmPDUNp16dKl8Pl8njLNzc14++23x6btR31I8QWAPTX7X//1X+nIkSO0YcMGCofDdPLkyYmuWtnyj//4jxSPx+m1116j5uZmJ2QyGafMo48+SvF4nJ577jk6fPgw3XTTTTzFchRwz2Yi4nYeDfbt20eqqtIjjzxCx48fp//4j/+gUChETz/9tFOG2/n8Wb16NU2fPt2Zmv3cc89RTU0NfeUrX3HKcDuPjFQqRQcPHqSDBw8SAHrsscfo4MGDzhIkQ2nXtWvX0owZM+iVV16hAwcO0Cc/+Umemj3Z+MEPfkCzZ88mv99PS5YscaYQMyMDQJ/hqaeecsqYpknf+MY3qL6+njRNoz//8z+nw4cPT1ylpwi9xQy38+jwy1/+kpqamkjTNJo/fz5t377dc5zb+fxJJpO0fv16mjVrFgUCAZo3bx49+OCDlM/nnTLcziPj1Vdf7fNv8urVq4loaO2azWZp3bp1VFVVRcFgkD772c/SqVOnxqS+EhHR6Pt7GIZhGIZhxgceM8MwDMMwTFnDYoZhGIZhmLKGxQzDMAzDMGUNixmGYRiGYcoaFjMMwzAMw5Q1LGYYhmEYhilrWMwwDMMwDFPWsJhhGIZhGKasYTHDMMyYMWfOHGzZsmXMP0eSJPziF78Y888ZDq+99hokSUJXV9dEV4Vhpjy8AjDDlDlr1qxBV1fXpHuZA8C5c+cQDocRCoXG9HNaWlpQWVkJTdNw8uRJzJ07FwcPHsQll1wypp9rs3LlSlxyySUe4VYoFNDR0YG6ujpIkjQu9WCYCxV1oivAMEz5USwW4fP5Bi03bdq0cagNUF9fPybXHep99oXf7x+zejEM44W7mRhminPkyBFce+21iEQiqKurw6233oq2tjbn+EsvvYQVK1agoqIC1dXV+OxnP4v33nvPOX7y5ElIkoSf/vSnWLlyJQKBAJ5++mmsWbMGN954I/7lX/4FDQ0NqK6uxh133IFiseic27ubSZIk/OhHP8LnPvc5hEIhXHTRRXj++ec99X3++edx0UUXIRgM4qqrrsK//du/Ddpd4+5mmjt3LgDg0ksvhSRJWLlypVPuqaeewoIFCxAIBDB//nxs3bp10Ptsb2/HTTfdhBkzZiAUCmHRokX48Y9/7Jy3Zs0avP766/je974HSZIgSRJOnjzZZzfT7t27cfHFF0PTNMyZMwff/e53PfcxZ84cfPvb38Ztt92GaDSKWbNmYfv27c7xQqGAdevWoaGhAYFAAHPmzMGmTZv6bReGuWAYk+0rGYYZN1avXk033HBDn8c+/PBDqqmpoQceeICOHj1KBw4coE9/+tN01VVXOWWeffZZ2r17N7377rt08OBBuv7662nRokVkGAYREZ04cYIA0Jw5c2j37t30/vvv05kzZ2j16tUUi8Vo7dq1dPToUfrlL39JoVDIszv07Nmz6fHHH3fSAGjGjBn0zDPP0PHjx+muu+6iSCRC7e3tzmf5fD6655576P/+7//oxz/+MU2fPp0AUGdnZ79tAIB+/vOfExHRvn37CAC98sor1Nzc7Fx7+/bt1NDQ4NzD7t27qaqqinbu3DngfX7wwQe0efNmOnjwIL333nv0xBNPkKIo9D//8z9ERNTV1UWXX345/f3f/z01NzdTc3Mz6bru7Dps1/utt94iWZbpoYceomPHjtFTTz1FwWDQszP87Nmzqaqqin7wgx/Q8ePHadOmTSTLMh09epSIiDZv3kwzZ86kX//613Ty5El644036Jlnnhn4AWGYCwAWMwxT5gwkZr72ta/R1Vdf7ck7ffo0AaBjx471eU5raysBoMOHDxNRz0t+y5YtJZ87e/Zs0nXdyfvCF75Aq1atctJ9iZmvfvWrTjqdTpMkSfTiiy8SEdF9991HTU1Nns958MEHhyVm7PoePHjQU2bmzJklL/5vfetbdPnllw94n31x7bXX0t133+2kr7zySlq/fr2nTG8xc/PNN9OnP/1pT5l7772XFi5c6KRnz55Nt9xyi5M2TZNqa2tp27ZtRER055130ic/+UkyTXPQOjLMhQR3MzHMFGb//v149dVXEYlEnDB//nwAcLqS3nvvPdx8882YN28eYrGY001z6tQpz7WWLVtWcv2LL74YiqI46YaGBrS2tg5Yp8WLFzt2OBxGNBp1zjl27BiWL1/uKf/xj398qLfbL+fOncPp06dx++23e9ri4Ycf9nSpAaX3aRgGHnnkESxevBjV1dWIRCJ4+eWXS9pnMI4ePYorrrjCk3fFFVfg+PHjMAzDyXO3jyRJqK+vd9pnzZo1OHToED760Y/irrvuwssvvzysOjDMVIUHADPMFMY0TVx//fX4zne+U3KsoaEBAHD99ddj5syZ2LFjBxobG2GaJpqamlAoFDzlw+FwyTV6D46VJAmmaQ5Yp4HOIaKSmT80ChMu7evv2LEDl112meeYW4wBpff53e9+F48//ji2bNmCRYsWIRwOY8OGDSXtMxhDvbeB2mfJkiU4ceIEXnzxRbzyyiv4m7/5G3zqU5/Cs88+O6y6MMxUg8UMw0xhlixZgt27d2POnDlQ1dKve3t7O44ePYonn3wSn/jEJwAAb7755nhX02H+/Pl44YUXPHlvvfXWsK7h9/sBwOPtqKurw/Tp0/H+++/ji1/84rCu98Ybb+CGG27ALbfcAkAIo+PHj2PBggWez3R/Xl8sXLiwpG337t2LP/3TPy0RVAMRi8WwatUqrFq1Cp///Ofxl3/5l+jo6EBVVdUw7ophphYsZhhmCpBIJHDo0CFPXlVVFe644w7s2LEDN910E+69917U1NTgD3/4A3bt2oUdO3agsrIS1dXV2L59OxoaGnDq1Cncf//9E3MTAP7hH/4Bjz32GO677z7cfvvtOHToEHbu3AkAQ16rpba2FsFgEC+99BJmzJiBQCCAeDyOb37zm7jrrrsQi8Xwmc98Bvl8Hm+99RY6OzuxcePGfq/3kY98BLt378bevXtRWVmJxx57DC0tLR4xM2fOHPz2t7/FyZMnEYlE+hQWd999N5YvX45vfetbWLVqFf77v/8b3//+9z0zqgbj8ccfR0NDAy655BLIsoyf/exnqK+vR0VFxZCvwTBTER4zwzBTgNdeew2XXnqpJ3z9619HY2MjfvOb38AwDFxzzTVoamrC+vXrEY/HIcsyZFnGrl27sH//fjQ1NeHLX/4yNm/ePGH3MXfuXDz77LN47rnnsHjxYmzbtg0PPvggAEDTtCFdQ1VVPPHEE3jyySfR2NiIG264AQDwd3/3d/jRj36EnTt3YtGiRbjyyiuxc+dOZ4xQf3zta1/DkiVLcM0112DlypWor6/HjTfe6Clzzz33QFEULFy4ENOmTetzPM2SJUvw05/+FLt27UJTUxO+/vWv46GHHsKaNWuGdF8AEIlE8J3vfAfLli3D8uXLcfLkSbzwwguQZf5TzlzY8ArADMNMah555BH88Ic/xOnTpye6KgzDTFK4m4lhmEnF1q1bsXz5clRXV+M3v/kNNm/ejHXr1k10tRiGmcSwmGEYZlJx/PhxPPzww+jo6MCsWbNw991344EHHpjoajEMM4nhbiaGYRiGYcoaHjXGMAzDMExZw2KGYRiGYZiyhsUMwzAMwzBlDYsZhmEYhmHKGhYzDMMwDMOUNSxmGIZhGIYpa1jMMAzDMAxT1rCYYRiGYRimrPn/gQ3iQQIv/igAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "cost = DoubleBracketCostFunction.least_squares\n", + "nqubits = 5\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", "\n", "step = 1e-2\n", "iterations = 100\n", - "\n", "d, loss, grad, diags = gradient_ascent(dbi, d,step, iterations)\n", "\n", - "n = 3" + "plt.figure()\n", + "plt.plot(range(iterations+1), loss)\n", + "plt.xlabel('Learning iterations')\n", + "plt.ylabel('Loss: Least squares')\n", + "\n", + "plt.figure()\n", + "for i in range(2**nqubits):\n", + " plt.plot(diags[i,:], label='State ' + str(i))\n", + "plt.xlabel('Learning iterations')\n", + "plt.ylabel('Diagonal elements')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$||\\\\sigma(H_k)||$')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cost = DoubleBracketCostFunction.least_squares\n", + "nqubits = 5\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "d_fixed = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "d_trained = deepcopy(d_fixed)\n", + "dbi_trained = deepcopy(dbi)\n", + "flows = 10\n", + "iterations = 30\n", + "off_diagonal_norm = np.empty((2,flows+1))\n", + "off_diagonal_norm[0,0] = dbi_trained.off_diagonal_norm\n", + "off_diagonal_norm[1,0] = dbi.off_diagonal_norm\n", + "\n", + "for i in range(flows):\n", + " d_trained, loss, grad, diags = gradient_ascent(dbi_trained, d_trained,step, iterations)\n", + " s = dbi_trained.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_trained, n=3)\n", + " dbi_trained(s,d=d_trained)\n", + " off_diagonal_norm[0,i+1] = dbi_trained.off_diagonal_norm\n", + " s = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_fixed, n=3)\n", + " dbi(s,d=d_fixed)\n", + " off_diagonal_norm[1,i+1] = dbi.off_diagonal_norm\n", + "\n", + "plt.figure()\n", + "plt.plot(off_diagonal_norm[0,:], label='Trained')\n", + "plt.plot(off_diagonal_norm[1,:], label='Untrained')\n", + "plt.legend()\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "\n" ] } ], @@ -534,7 +673,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.9.18 (main, Sep 11 2023, 14:09:26) [MSC v.1916 64 bit (AMD64)]" }, "orig_nbformat": 4, "vscode": { diff --git a/examples/dbi/dbi_misc.ipynb b/examples/dbi/dbi_misc.ipynb new file mode 100644 index 0000000000..1a8a4da3e7 --- /dev/null +++ b/examples/dbi/dbi_misc.ipynb @@ -0,0 +1,944 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Normalization of D" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-21 14:14:06]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 7\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "factor = np.array([1,2**nqubits])\n", + "s_space = np.linspace(1e-5, 1.0, 100)\n", + "off_diagonal_norm_diff = np.empty((len(factor)+1,len(s_space)))\n", + "potential = np.empty((len(factor)+1,len(s_space)))\n", + "for i in range(len(factor)):\n", + "# generate data for plotting sigma decrease of the first step\n", + " d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/factor[i]\n", + " for s in range(len(s_space)):\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s_space[s],d=d)\n", + " off_diagonal_norm_diff[i,s] = (dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " potential[i,s] = dbi_eval.least_squares(D=d)\n", + " \"\"\"\n", + " # grid_search\n", + " step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + " print('grid_search step:', step_grid)\n", + " # hyperopt\n", + " step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + " print('hyperopt_search step:', step_hyperopt)\n", + " # polynomial\n", + " step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + " print('polynomial_approximation step:', step_poly)\n", + " \"\"\"\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "step = 1e-2\n", + "iterations = 200\n", + "d, loss, grad, diags = gradient_ascent(dbi, d,step, iterations)\n", + "for s in range(len(s_space)):\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s_space[s],d=d)\n", + " off_diagonal_norm_diff[2,s] = (dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " potential[2,s] = dbi_eval.least_squares(D=d)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Least squares cost function')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHFCAYAAADv8c1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACczElEQVR4nOzdeXxU9dU/8M+dNftk30hCEpawBJBFVhWoEEQBKa3Y8vyiVEX72IooiFKrYp8qVUR8hLZaS9WKio8LVlHDoohEkD1iCDtZyb7MZJ+ZzNzfHzPfm0w2MsnM3Htnzvv1yqtl5mbmm3FgTs453/PleJ7nQQghhBBCeqUQewGEEEIIIXJAQRMhhBBCSB9Q0EQIIYQQ0gcUNBFCCCGE9AEFTYQQQgghfUBBEyGEEEJIH1DQRAghhBDSBxQ0EUIIIYT0AQVNhBBCCCF9QEETIcTt3nrrLXAcJ3z5+fkhNjYWs2fPxoYNG1BZWSna2r788kusX7++2/uSk5OxfPlylz6fOx7zWgoKCsBxHN566y2PPi8h3kYl9gIIIb7jzTffxIgRI2A2m1FZWYns7Gy88MILeOmll/DBBx9gzpw5Hl/Tl19+ib/+9a/dBk47d+5ESEiIS5/PHY9JCPEMCpoIIR6Tnp6OSZMmCX/+xS9+gUceeQQ33HADlixZgosXLyImJkbEFToaP368LB6TEOIZVJ4jhIgqKSkJmzZtQkNDA15//fVrXp+bm4vbb78dYWFh8PPzw3XXXYe3337b4Zpvv/0WHMdh+/btePTRRxEbGwt/f3/MnDkTp06dEq5bvnw5/vrXvwKAQ/mwoKAAQNdSGnvc9957D48//jji4uIQFBSEhQsXoqKiAg0NDbj//vsRGRmJyMhI/OY3v0FjY6PD2jo/5qxZsxyeu+NXx3JaeXk5HnjgASQkJECj0SAlJQXPPvss2traHB6/tLQUS5cuRXBwMHQ6He68806Ul5df83UlhFwbZZoIIaK79dZboVQq8d133/V63fnz5zF9+nRER0fj1VdfRUREBLZv347ly5ejoqICa9eudbj+D3/4AyZMmIB//vOfMBgMWL9+PWbNmoVTp04hNTUVTz31FJqamvDRRx/h8OHDwvfFxcX1uo4//OEPmD17Nt566y0UFBRgzZo1+PWvfw2VSoVx48bh/fffx6lTp/CHP/wBwcHBePXVV3t8rL/97W+or693uO2pp57C/v37kZaWBsAWME2ePBkKhQJPP/00hgwZgsOHD+PPf/4zCgoK8OabbwIAWlpaMGfOHJSWlmLDhg0YPnw4vvjiC9x55529/jyEkD7iCSHEzd58800eAH/s2LEer4mJieFHjhzZ6+P86le/4rVaLV9UVORw+/z58/mAgABer9fzPM/z+/fv5wHwEyZM4K1Wq3BdQUEBr1ar+fvuu0+47Xe/+x3f0z+FgwcP5u+++27hz+xxFy5c6HDdqlWreAD8ypUrHW5fvHgxHx4e3utjdrZx40YeAP+Pf/xDuO2BBx7gg4KC+MLCQodrX3rpJR4Af+bMGZ7nef7vf/87D4D/z3/+43DdihUreAD8m2++2ePzEkKujcpzhBBJ4Hn+mtd88803uPnmm5GYmOhw+/Lly9Hc3OyQLQKAZcuWgeM44c+DBw/G9OnTsX///gGtdcGCBQ5/HjlyJADgtttu63J7bW1tlxJdT95//32sXbsWf/zjH7FixQrh9l27dmH27NmIj49HW1ub8DV//nwAwIEDBwAA+/fvR3BwMBYtWuTwuMuWLXPuBySEdIuCJkKI6JqamlBTU4P4+Pher6upqem2dMa+r6amxuH22NjYLtfGxsZ2uc5Z4eHhDn/WaDS93t7a2nrNx9y/fz+WL1+Ou+66C//zP//jcF9FRQU+//xzqNVqh6/Ro0cDAKqrqwHYfv7uGum7ex0IIc6jniZCiOi++OILWCwWzJo1q9frIiIiUFZW1uX20tJSAEBkZKTD7d01QJeXlyMiIqL/i3WD06dPY/HixZg5cybeeOONLvdHRkZi7NixeO6557r9fhY0RkRE4OjRo13up0ZwQlyDMk2EEFEVFRVhzZo10Ol0eOCBB3q99uabb8Y333wjBEnMv//9bwQEBGDq1KkOt7///vsOZb/CwkIcOnTIITjTarUAbE3UYigqKsL8+fORmpqKjz/+GGq1uss1CxYsQG5uLoYMGYJJkyZ1+WJB0+zZs9HQ0IDPPvvM4fvfe+89j/wshHg7yjQRQjwmNzdX6MeprKzEwYMH8eabb0KpVGLnzp2Iiorq9fufeeYZob/n6aefRnh4ON5991188cUXePHFF6HT6Ryur6ysxM9//nOsWLECBoMBzzzzDPz8/LBu3TrhmjFjxgAAXnjhBcyfPx9KpRJjx44VSmvuNn/+fOj1emzduhVnzpxxuG/IkCGIiorCn/70J+zduxfTp0/HypUrkZaWhtbWVhQUFODLL7/Ea6+9hoSEBNx1113YvHkz7rrrLjz33HMYNmwYvvzyS+zevdsjPwsh3o6CJkKIx/zmN78BYOv1CQ0NxciRI/H444/jvvvuu2bABABpaWk4dOgQ/vCHP+B3v/sdWlpaMHLkSLz55pvdHk3y/PPP49ixY/jNb36D+vp6TJ48GTt27MCQIUOEa5YtW4bvv/8ef/vb3/CnP/0JPM8jPz8fycnJrvqxe5WXlwcAWLJkSZf72M8VFxeH48eP43/+53+wceNGlJSUIDg4GCkpKbjlllsQFhYGAAgICMA333yDhx9+GE888QQ4jkNGRgZ27NiB6dOne+TnIcSbcXxftqwQQoiMfPvtt5g9ezY+/PBD/PKXvxR7OYQQL0E9TYQQQgghfUBBEyGEEEJIH1B5jhBCCCGkDyjTRAghhBDSBxQ0EUIIIYT0AQVNhBBCCCF9QHOaXMhqtaK0tBTBwcEOh4QSQgghRLp4nkdDQwPi4+OhUPScT6KgyYVKS0u7nL5OCCGEEHkoLi5GQkJCj/dT0ORCwcHBAGwvekhIiMirIYQQQkhf1NfXIzExUfgc7wkFTS7ESnIhISEUNBFCCCEyc63WGmoEJ4QQQgjpAwqaCCGEEEL6gIImQgghhJA+oKCJEEIIIaQPKGgihBBCCOkDCpoIIYQQQvqAgiZCCCGEkD6goIkQQgghpA9EDZq+++47LFy4EPHx8eA4Dp9++mmP1z7wwAPgOA6vvPKKw+1GoxEPPfQQIiMjERgYiEWLFqGkpMThmrq6OmRmZkKn00Gn0yEzMxN6vd7hmqKiIixcuBCBgYGIjIzEypUrYTKZXPSTEkIIIUTuRA2ampqaMG7cOGzdurXX6z799FMcOXIE8fHxXe5btWoVdu7ciR07diA7OxuNjY1YsGABLBaLcM2yZcuQk5ODrKwsZGVlIScnB5mZmcL9FosFt912G5qampCdnY0dO3bg448/xurVq133wxJCCCFE3niJAMDv3Lmzy+0lJSX8oEGD+NzcXH7w4MH85s2bhfv0ej2vVqv5HTt2CLddvXqVVygUfFZWFs/zPJ+Xl8cD4H/44QfhmsOHD/MA+HPnzvE8z/Nffvklr1Ao+KtXrwrXvP/++7xWq+UNBkOffwaDwcADcOp7CCGEECKuvn5+S7qnyWq1IjMzE4899hhGjx7d5f4TJ07AbDYjIyNDuC0+Ph7p6ek4dOgQAODw4cPQ6XSYMmWKcM3UqVOh0+kcrklPT3fIZM2bNw9GoxEnTpxw149HCCGEEBmR9IG9L7zwAlQqFVauXNnt/eXl5dBoNAgLC3O4PSYmBuXl5cI10dHRXb43Ojra4ZqYmBiH+8PCwqDRaIRrumM0GmE0GoU/19fX9+0HI70yNJsR5KeCUtH7wYmEEEKIJ0k2aDpx4gT+93//FydPnrzmqcOd8Tzv8D3dfX9/rulsw4YNePbZZ51aG+ndawcu4y9fnYNKwSEu1A8JoQFICPPH3FExyBgdK/byCCGE+DDJlucOHjyIyspKJCUlQaVSQaVSobCwEKtXr0ZycjIAIDY2FiaTCXV1dQ7fW1lZKWSOYmNjUVFR0eXxq6qqHK7pnFGqq6uD2WzukoHqaN26dTAYDMJXcXHxQH5kAuDD47bXsM3Ko7i2BYev1ODDEyX43XsnYWgxi7w6QgghvkyyQVNmZiZOnz6NnJwc4Ss+Ph6PPfYYdu/eDQCYOHEi1Go19u7dK3xfWVkZcnNzMX36dADAtGnTYDAYcPToUeGaI0eOwGAwOFyTm5uLsrIy4Zo9e/ZAq9Vi4sSJPa5Rq9UiJCTE4Yv0X3FtMy5XNUGp4LDv0Zvw4W+nYfOd4zAo1B9mC4/Dl6vFXiIhhBAfJmp5rrGxEZcuXRL+nJ+fj5ycHISHhyMpKQkREREO16vVasTGxiItLQ0AoNPpcO+992L16tWIiIhAeHg41qxZgzFjxmDOnDkAgJEjR+KWW27BihUr8PrrrwMA7r//fixYsEB4nIyMDIwaNQqZmZnYuHEjamtrsWbNGqxYsYICIQ86cKEKADAhKRRDo4MBANcnh+PHYgPeOlSAAxeqcUt6nJhLJIQQ4sNEzTQdP34c48ePx/jx4wEAjz76KMaPH4+nn366z4+xefNmLF68GEuXLsWMGTMQEBCAzz//HEqlUrjm3XffxZgxY5CRkYGMjAyMHTsW77zzjnC/UqnEF198AT8/P8yYMQNLly7F4sWL8dJLL7nuhyXX9O15W9A0K82xcX/m8CgAwHcXqsDzvMfXRQghhAAAx9OnkMvU19dDp9PBYDBQhspJpjYrrvvTHjSbLNj10A1IH6QT7ms2teG6Z/fCZLHim9UzkRoVJOJKCSGEeJu+fn5LtqeJ+JbjBbVoNlkQGaTFqDjHN2yARoVJybaxEt/ZS3iEEEKIp1HQRCSB9TPdNDwSim7mM93ESnQXqRmcEEKIOChoIpLAgqbO/UzMjcMiAQCHL9fA2Gbp9hpCCCHEnShoIqIrM7TgXHkDOA64cWhkt9eMjA1BZJAWLWYLThTWdXsNIYQQ4k4UNBHRsT6lcQmhCAvUdHuNQsEJ2abvLlCJjhBCiOdR0ERE1z5qIKrX624azoImagYnhBDieRQ0EVGZLVZk25u72Tymntww1HZ/Xlk9qhqMvV5LCCGEuBoFTURUp4r0aDC2ISxAjbEJob1eGxXcPo4g+xJlmwghhHgWBU1EVAcuVAIAbhwWBWU3owY6E0YPUF8TIYQQD6OgiYiqr/1MDOtrOnixGlYrDbMnhBDiORQ0EdFUNRhxprQegC3T1BcTB4fBX61EdaMRZ8vr3bk8QgghxAEFTUQ05+xBz5CoQEQFa/v0PVqVEtOGRACwZZsIIYQQT6GgiYimoKYZAJAS6dwBvNcnhwMAzpZRpokQQojnUNBERFNQ3QQASI4IcOr7UqMCAQBXqppcviZCCCGkJxQ0EdEIQVNkoFPfN0QImhrB89QMTgghxDMoaCKiKahhmSbngqak8EAoOKDJZEElDbkkhBDiIRQ0EVFYrDyKa1sAAMmRzpXnNCoFEsNt33O5qtHlayOEEEK6Q0ETEUWpvgUmixUapQJxOn+nvz/VXtLLr6a+JkIIIZ5BQRMRBSvNJUUE9GkSeGepUbYdd9QMTgghxFMoaCKiYOMGnN05x6R2aAYnhBBCPIGCJiKK9nEDzjWBM6n22U5XqDxHCCHEQyhoIqIorOnfuAGGZZqKa5thbLO4bF2EEEJITyhoIqLIH2CmKTpYi0CNElbeFjgRQggh7kZBE/G4gYwbYDiOE5rBL1MzOCGEEA+goIl43EDHDTB0nAohhBBPoqCJeNxAxw0wKZG0g44QQojnUNBEPG6g4wYYVp6jAZeEEEI8gYIm4nEDHTfAsKngNHaAEEKIJ1DQRDyOjRsY3M9xAwzraaptMkHfbBrwugghhJDeUNBEPI6V01IGmGkK0KgQp/MDQDvoCCGEuB8FTcSjOo4bGDzAniaAmsEJIYR4DgVNxKM6jhuID+3/uAGGleioGZwQQoi7UdBEPKrQvnNuoOMGGOEMOirPEUIIcTMKmohH5bMz51xQmgM6DLispvIccU6zqQ2XKhvEXgYhREYoaCIeVeiicQMMyzQV1DTDYuVd8pjE+7WaLVj6+mHMefk7fHG6TOzlEEJkgoIm4lEFLho3wAwK84dGpYCpzYqrdS0ueUzi3Xiex5M7c5F7tR4A8OSnP6GyvlXkVRFC5ICCJuJRrho3wCgVnFDqoxId6Yv3jhbh45MlUHBAUngA9M1mPP7xafA8ZSoJIb0TNWj67rvvsHDhQsTHx4PjOHz66acO969fvx4jRoxAYGAgwsLCMGfOHBw5csThGqPRiIceegiRkZEIDAzEokWLUFJS4nBNXV0dMjMzodPpoNPpkJmZCb1e73BNUVERFi5ciMDAQERGRmLlypUwmWhgoiu5etwAQ83gpK9yivV49rM8AMBj80bgn3dPgkalwP7zVfjgWLHIqyOESJ2oQVNTUxPGjRuHrVu3dnv/8OHDsXXrVvz000/Izs5GcnIyMjIyUFVVJVyzatUq7Ny5Ezt27EB2djYaGxuxYMECWCwW4Zply5YhJycHWVlZyMrKQk5ODjIzM4X7LRYLbrvtNjQ1NSE7Oxs7duzAxx9/jNWrV7vvh/dBrh43wFAzOOmLmkYjHtx+AiaLFfNGx+C3M1MxPCYYazKGAwD+Z1ceimubRV4lIUTSeIkAwO/cubPXawwGAw+A37dvH8/zPK/X63m1Ws3v2LFDuObq1au8QqHgs7KyeJ7n+by8PB4A/8MPPwjXHD58mAfAnzt3jud5nv/yyy95hULBX716Vbjm/fff57VaLW8wGPr8M7D1OfM9vuTghSp+8OO7+J+9tN+lj/t/x4r4wY/v4n/9j8MufVziPdosVv6/3viBH/z4Ln72xv28ocXkcN8dfz/ED358F3/Ha4d4i8Uq4koJIWLo6+e3bHqaTCYT/vGPf0Cn02HcuHEAgBMnTsBsNiMjI0O4Lj4+Hunp6Th06BAA4PDhw9DpdJgyZYpwzdSpU6HT6RyuSU9PR3x8vHDNvHnzYDQaceLEiR7XZDQaUV9f7/BFesbGDaS4qAmcSY2yledowCXpyZ4z5ci+VA1/tRKvZU5EiJ9auE+p4PDSHeMQoFHiaH4t/vV9vogrJYRImeSDpl27diEoKAh+fn7YvHkz9u7di8jISABAeXk5NBoNwsLCHL4nJiYG5eXlwjXR0dFdHjc6OtrhmpiYGIf7w8LCoNFohGu6s2HDBqFPSqfTITExcUA/q7dj4wYGu6gJnBliL8+VGVrRZGxz6WMT7/DdRVtJ/9eTkzA8JrjL/UkRAfjDrSMBAK9/d4Wawgkh3ZJ80DR79mzk5OTg0KFDuOWWW7B06VJUVlb2+j08z4Pj2qdNd/z/A7mms3Xr1sFgMAhfxcXUSNqbAvs08GQXZ5pCAzTQ+dsyByU0doB0I/tSNQDgxmGRPV7zy4kJ0CgVqGowCu9VQgjpSPJBU2BgIIYOHYqpU6di27ZtUKlU2LZtGwAgNjYWJpMJdXV1Dt9TWVkpZI5iY2NRUVHR5XGrqqocrumcUaqrq4PZbO6SgepIq9UiJCTE4Yv0rFRvC2gSXNgEzsTp/GzPYaCgiTgqqmlGcW0LVAoOk1PCe7zOT63EdYmhAICj+TUeWh0hRE4kHzR1xvM8jEYjAGDixIlQq9XYu3evcH9ZWRlyc3Mxffp0AMC0adNgMBhw9OhR4ZojR47AYDA4XJObm4uysvbJwHv27IFWq8XEiRM98WP5hMoG23+3mBA/lz/2IHsgVqanIYXEEcsyTUgKQ6BW1eu116fYSv1H8+t6vY4Q4pt6/xfEzRobG3Hp0iXhz/n5+cjJyUF4eDgiIiLw3HPPYdGiRYiLi0NNTQ3+9re/oaSkBHfccQcAQKfT4d5778Xq1asRERGB8PBwrFmzBmPGjMGcOXMAACNHjsQtt9yCFStW4PXXXwcA3H///ViwYAHS0tIAABkZGRg1ahQyMzOxceNG1NbWYs2aNVixYgVlj1zEbLGipskWNEWHaF3++HGh9kyTnjJNxNH39qBp+tCIa157fXI4gMs4WkCZJkJIV6IGTcePH8fs2bOFPz/66KMAgLvvvhuvvfYazp07h7fffhvV1dWIiIjA9ddfj4MHD2L06NHC92zevBkqlQpLly5FS0sLbr75Zrz11ltQKpXCNe+++y5Wrlwp7LJbtGiRw2wopVKJL774Ag8++CBmzJgBf39/LFu2DC+99JK7XwKfUd1oBM8DKgWH8ACNyx8/TmfLNFF5jnRktfI4dNkWNN0wtOd+Jmbi4DAoOKC4tgXlhlbE6lyfFSWEyJeoQdOsWbN63aXyySefXPMx/Pz8sGXLFmzZsqXHa8LDw7F9+/ZeHycpKQm7du265vOR/qmot2eZgrVQKHpuru8vKs+R7uSV1aOu2YxAjRLj7P1KvQn2U2NUfAhyr9bjaEEtFo2Lv+b3EEJ8h+x6mog8sQNRo9zQzwRQIzjpHivNTU2NgFrZt3/uJifbynjUDE4I6YyCJuIRFawJPNj1/UwAhGNZygytsFppxg6xyRb6ma5dmmMm25vBj1EzOCGkEwqaiEewTJM7ds6xx+U4wNRmRU0THbRMAGObBccKagH0rZ+JmZRsG0twvqIBdfReIoR0QEET8YgKIWhyT6ZJo1IgKsj22GVUoiMAThbq0Wq2IjJIi+ExQX3+vsggrTBl/nghZZsIIe0oaCIewWY0RQe7bzdSnL1EV0rN4ATt/Uw3DI3odbJ/d9gQTJapIj3jeZ6OnSE+g4Im4hHC7jk3ZZoAYBDNaiId9KefiWFB05F8Cpp6Um5oxV/3X8Lsl77F2Gf34Fw5HVhOvJ+oIweI73B3TxPQPquJynPE0GLG6RI9AGBGP4Km6+19TWeuGtBkbLvmJHFfsi+vAtuPFOK7C1XouOfiuS/O4p17p4i3MEI8gDJNxO1s08BtDbXuDJrYDrpSg2+V51rNFqz/7Az+lZ1PZRK7I1dqYOWB1MhAYYaXMxLCAhCv80OblcepIr3rFyhTu8+U475/H8e3520B0+SUcDy9YBTUSg4HL1bjuwtVYi+RELeiX5+I21XZ+5nUSg5hAWq3PU+8zjfLc9uy8/HWoQIAwJnSevzlF2P6PJPIW7F+pv5kmZjJKeH4NKcURwtqccOw/j+ON3nr+wIAwK1jYvHYvBFIibQ1zF/Vt2Bbdj42fHUOM4ZGQumGAbaESIFv/8tKPILtnIsO9nO6IdcZcT44Fbym0Yi/f3tZ+PPHJ0twz1vH0GhsE3FV4jt02TaYciBB0/WsGZz6mgAAV6oacfhKDRQc8ORto4SACQB+P3sogv1UOFtWj52nroq4SkLci4Im4naeaAIHgHh7I3hFQyvMFqtbn0sqtnxzCY3GNqQPCsG/lk+Cv1qJgxercefrh4U+Ml/TarbgclUjAGBCUmi/H2eKPWg6WVQHU5tvvJ96s+NYMQBgVlp0l5JnWKAGv589FACwac95tJotHl8fIZ5AQRNxu6oGlmlyb9AUGaiFWsmB59uzW94sv7oJ238oBAD8Yf5I/GxEDD54YCoigzQ4U1qPn//tEMp9rL8LAC5VNsLKA2EBakQN4D03JCoI4YEaGNus+OmqwYUrlB9jmwUfnSgBAPx6clK319w9PRmDQv1RZmjFm/YyHiHehoIm4nYs0+TOJnAAUCg44VT6Mh8IFl7MOoc2K4/ZaVHCtvqxCaH4+L+nIzkiAFf1Lfj34QJxFymCCxUNAIDhMcEDKgdzHIeJg21Hqpwq8u0hl3vOVKC2yYTYED/MTovq9ho/tRKrM4YDAP62/xJqaZo68UIUNBG3q/DAuAEmXscGXHp3M/iJwlp8lVsOBQc8MX+kw32DIwKx8uZhAIADPrib6bw9aEqLDR7wY6XF2B7jSnXTgB9Lzt4/WgQAWHp9IlS9bDJYfN0gjIoLQYOxDVu/ueSp5RHiMRQ0EberEKaBu7c8B3QYO+DFzeA8z+O5L84CAO6YmNhtcHDTcFs24ExpPSobvPe16M6F8vZM00Cl2o9TuWLvkfJF+dVNOHS5BhwH3Hl9Yq/XKhQc1t6SBgD45FQJHZ5NvA4FTcTtWENytAcyTXFCec57M01ZueU4WaSHv1qJR+3lkM4ig7QYM0gHADh4odqTyxPdhQpbgOOKTFNqlO3MustVvptp2nHMlmWaNTyqTzOvbhgaiSCtCvpmM87SlHDiZShoIm7Hzp1z12G9HbVnmrw3aNqWnQ8AuO/GlF5LnjPt2SZfKtHVt5px1f7ffni06zJNVQ1G1LeaB/x4cmNqs+Kj4703gHemUiqEY2gO20c/EOItKGgibmVsswgNoTFuPKyXiRfOn/POklSr2YIf7ceD3DGx91LJTHvD7ncXq2DxkTLJRXs/U2yIH3QuGKQa4te+A++KD2ab9uSVo6bJhJgQLX42IrrP3zctNQJA+7wsQrwFBU3Erdg0cI1SgVA3TgNn2PlzpV5anssp1sNs4REdrEVieO+lkvGJoQj2s5VJ2Dls3u58ua00N9wFpTlmiA/3Ne04apvNdOek3hvAO5s2xBY0Hc2vRZuPzExzRn51E371j8N4+j+5KKppFns5xAkUNBG3YqW5qGCtW6eBM6w8p282o8XkfQP2jhfYplNfnxJ+zddTpVTgRvvxH75SomPjBtJiglz2mKyvydcyTS0mC364YssULZmQ4NT3jooLgc5fjUZjm8/PuOqs1WzBf28/gR+u1OLfhwsx66X9+P17J5FLr5MsUNBE3KpSGDfg/n4mAAjxUyFQowTgndmmowW2eUHX2+cHXYuv9TWdd+HOOSbVflzIZR/LNJ0u0aPNyiMmRIvBEQFOfa9CwWFqqq2viUp0jp79PA/nyhsQGaTBjcMiYeWBXafLsGBLNu556xiafPwIJKnr14G9VqsVly5dQmVlJaxWx9TrTTfd5JKFEe/gqcGWDMdxiA/1x8XKRpTqWzAkynUZB7FZrDxOFtqCpknJ4X36HjZ6IKdYj7omE8ICNW5bnxRccOGMJmZItG9mmo6z99rga2c1uzN9SCR2n6nAD1dq8Dv7ESu+7rMfS/H+0SJwHPDKneNxw7BI5JXW4/XvLmPX6TJ8c64Sbx8uwIOz6PWSKqeDph9++AHLli1DYWEheN6xuZTjOFgs3lcSIf1X6aEjVDqKswdN3nZw77nyejQa2xCkVWFkXEifvidO54+0mGCcr2jAwUvVWDQu3s2rFE91oxE1TSZwHDA02nXB8pBI22Pl1zTBYuWhVLi/zCwFLECf0MesZmesr+lYQS2MbRZoVUqXrU2O8qubsO7j0wBsBxzfYC+dj4oPwf/+ajxuGBqJxz46jbcPFeC+G1KhUVEhSIqc/q/y29/+FpMmTUJubi5qa2tRV1cnfNXW0mngxFH7Yb2eyTQBQLx9VpO3leeO5dv+fk0YHObUB/cs+y66A+e9u0THhlomhQcgQNOvJHq3BoX5Q6NSwNRmxdU673pP9cRq5XHCfnTMxH4GTcOigxAZpEGr2YqcIr0LVyc/rWYLfv/eSTSZLJicEo6H7RP7O7r9ukGIDtaiot6Iz38sFWGVpC+cDpouXryI559/HiNHjkRoaCh0Op3DFyEdefIIFcZbZzUds//mPznZuQ+xjn1N3jyh+XyF6/uZAECp4JASYe9rqvaNvqYr1U3QN5vhp1ZgdHzfspqdcRyHqfbRA4ev+HZf01++OoczpfUID9Tg1V+N73YnokalwN3TkwEAbxy80qWSQ6TB6aBpypQpuHSJzhQifVNZ77nBlkycFx7ay/O8sHOur/1MzMTkMARolKhuNHr1hGbWzzTChf1MzJBoe9BU6RtBEyvNjU0IhdqJUQOdTR9iK0H5cjO4odmMd48UAgA23TFOOFS8O/81JQkBGiXOlTfg+0u++5pJmdM57IceegirV69GeXk5xowZA7XacfbO2LFjXbY4In/tPU2UaRqIkroWVNQboVZyuC4x1Knv1aqUmD4kAvvOVuLb81UYHe+dGWF37JxjUu19Tb5ycO/xQluA3t/SHDPd3td0qqgOLSYL/DW+19e0J68cZguPtJhgzL7GgNDQAA2WTkrEW4cK8I+DV4S+JyIdTgdNv/jFLwAA99xzj3Abx3HgeZ4awYkDY5sFdc22oyc8mWnqeGgve1/K3VF7P9OYQTr4qZ3/4Jk5PAr7zlbiwIUqr9zJxPO8S8+c64wdp+IrmaYTws65gQVNgyMCEKfzQ5mhFScK63wyCPjypzIAwG1j4/p0/T0zUvDvwwX47kIVzpc3uOX9TPrP6bxrfn5+l68rV64I/0sIw0pzGpUCOn/3TwNnWHmuxWyBocU7zgtjv/lf72Rpjpk53PYb7snCOhjbvO8Xm1JDKxqNbVArOSTb+49ciY2u8IVMU12TSTigeHzSwIImjuOEXXSHLvvWwdGArTSXfcn2c986pm9BU1JEAOaNjgUA/PMgfaZKjdNB0+DBg3v9IoTpOG7Ak9keP7US4fZ5RFe9pER3rMC5+UydJYb7I8RPhTYr75XzhtjOudTIILds1falg3tP2nfNpUYFCn+PBsKX+5o6luacGYOx4qZUAMB/ckqFf0eJNPTrX5fLly/joYcewpw5czB37lysXLkSly9fdvXaiMxVeniwZUfs4F5vmNVU22TCJXtZqL/lEo7jhDQ/a5j2JsLOOTeVMoL91MKsMW8MOjtyVWmOYZmmn64a0ODlAWdnzpbmmAlJYZg4OAwmixX/PlTojqWRfnI6aNq9ezdGjRqFo0ePYuzYsUhPT8eRI0cwevRo7N271x1rJDJV4eEjVDpiB/eWecGsJrZrblh00IAmerMG6XPl3hc0sUyTK8+c6yzVRw7uZZPAB9oEzgwK9cfgiABYrDyOFfjOLL/+lOY6uu+GFADAxydLaPyAhDjdCP7EE0/gkUcewV/+8pcutz/++OOYO3euyxZH5K3CflivJ3fOMWzA5VUvyDQdd/LolJ6wrfgXvDBocteMpo5So4Lww5Varz6Dzmyx4sdiPQDXBU2A7SiWwppmnC4x4GcjYlz2uFLW39IcM3tENDQqBcoMrbhc1eTSKfek/5zONJ09exb33ntvl9vvuece5OXluWRRxDuwTFO0CJkmtoPOGzJNbOfc5JSBfYixgOK8l5XnLFYeFyvdt3OOEZrBvbg8l1daD2ObFaEBamHMgiuMjLNnOcu8673Xm/6W5hg/tRLX2wfZfn/J95ropcrpoCkqKgo5OTldbs/JyUF0dO8zKIhvqbJnmmJEyDSxAXLlMh9w2WKyIPeqAYDtt/WBYEFTSV0LGr3oJPXCmiaY2qzwUyuQGBbgtudpL895b9DEspoTksKgcOEZe+ysxHNePFy1o4GW5pgbhtqm+R+8SEGTVDhdnluxYgXuv/9+XLlyBdOnTwfHccjOzsYLL7yA1atXu2ONRKbEOEKFYc9ZaQ/c5CqnWI82K4/YED8khPkP6LHCAjWIDtaissGICxUNmDDA7eRScaFDac6VH/SdDY3y/oN7T7q4n4lhpeHC2mY0GdsQqHXd2YBSNNDSHHPD0Ei8AOCHKzUwW6wDms5OXMPp/wJPPfUUnn76aWzZsgUzZ87ETTfdhK1bt2L9+vV48sknnXqs7777DgsXLkR8fDw4jsOnn34q3Gc2m/H4449jzJgxCAwMRHx8PO666y6UljoeZGg0GvHQQw8hMjISgYGBWLRoEUpKShyuqaurQ2ZmpnA+XmZmJvR6vcM1RUVFWLhwIQIDAxEZGYmVK1fCZDI59fMQRxUiHKHCsKCp3NAq6yZK9pv5mASdS8Y2pHlhXxPbWejuno/4UO8+uJfneZdNAu8sIkiLqGAteN47d292NtDSHDM6PgRhAWo0GttwukTvgpWRgXI6aOI4Do888ghKSkpgMBhgMBhQUlKChx9+2Ol/1JuamjBu3Dhs3bq1y33Nzc04efIknnrqKZw8eRKffPIJLly4gEWLFjlct2rVKuzcuRM7duxAdnY2GhsbsWDBAofJ5MuWLUNOTg6ysrKQlZWFnJwcZGZmCvdbLBbcdtttaGpqQnZ2Nnbs2IGPP/6YMmcD0NphsKQYjeAsUGsxW9Ag41IUCwiGu2hXWJoX9jUV1DQDgHCorrsoFRxSI+2Twb2wGfyq3nZUj1LBYVxCqMsfn2WbvHH3ZkeuKs0BgELBYfpQ25wrKtFJw4BypMHBA2u6nD9/PubPn9/tfTqdrssIgy1btmDy5MkoKipCUlISDAYDtm3bhnfeeQdz5swBAGzfvh2JiYnYt28f5s2bh7NnzyIrKws//PADpkyZAgB44403MG3aNJw/fx5paWnYs2cP8vLyUFxcjPj4eADApk2bsHz5cjz33HMICenfKd++jPUzaVUKhPh7PhUfoFEh2E+FhtY2VBhaEeLnuYnkrsQanIdFu6bBmc0xOu9FH1yFNbYeo8GR7g2aAFtf07nyBlyuarzmOWJyw+YzjY4PccsZcSPjQnDwYjXOlXl3X9PesxUuKc0xNwyNxBeny5B9sRqr5gx3wQrJQPTp02zChAn4+uuvERYWhvHjx/eaUTp58qTLFteZwWAAx3EIDQ0FAJw4cQJmsxkZGRnCNfHx8UhPT8ehQ4cwb948HD58GDqdTgiYAGDq1KnQ6XQ4dOgQ0tLScPjwYaSnpwsBEwDMmzcPRqMRJ06cwOzZs7tdj9FohNHY3jNTX+/d/xg4o2M/k1hnv8WG+KGhtREV9UYMc+NWdHdydemJZZq8qURSaM80DQ53XxM4480H954ptf375eyB0H3FMk1nvShg785h++TzOaNcE1TfYM80nSrWo6HVjGCZ/gLoLfoUNN1+++3QarXC/xfjQ7C1tRVPPPEEli1bJmR+ysvLodFoEBbmWH+PiYlBeXm5cE13u/qio6MdromJcZwdEhYWBo1GI1zTnQ0bNuDZZ58d0M/lrVimKSrY8/1MTEyIHy5WNqK8Xp476GoajahtMoHj2re7D9SwmCBwHFDdaEJ1oxGRQeL993GFZlOb0OzvjjPnOhsS7b0H915w86yrEbH2HXRl9V5zkHZ32DE0A52rxiSGByA5IgAFNc04cqUWc0b5xpwrqepT0PTMM88I/3/9+vXuWkuPzGYzfvWrX8FqteJvf/vbNa/v/Beyu7+c/bmms3Xr1uHRRx8V/lxfX4/ExMRrrs8XVDfZmugjXHB2VX+xZvAKmQZNrDSXGBbgsnJJgEaFpPAAFNY040J5AyKHyjtoKqq1ZZl0/mroAtz/GzjLNF32wrEDwlR1N826GhIdCJWCQ31rG8oMrcIsNW9S3WhEvj0LOSHRdc30M4ZGoqCmCNmXqiloEpnTjeCpqamoqel68KJer0dqaqpLFtWR2WzG0qVLkZ+fj7179zr0F8XGxsJkMqGurs7heyorK4XMUWxsLCoqKro8blVVlcM1nTNKdXV1MJvNXTJQHWm1WoSEhDh8EZvaRnvQFCRm0GQLCOQeNA1z8a4wbxpyWVBtC5qSI9xfmgOAZHvfVHWjEc0m+W4w6Kyh1YxS+0yz4S7qn+tMq1IKGVNvndfE+sKGxwS5NIi/cRhrBq9y2WOS/nE6aCooKHDYmcYYjcYuW/0HigVMFy9exL59+xAREeFw/8SJE6FWqx0axsvKypCbm4vp06cDAKZNmwaDwYCjR48K1xw5cgQGg8HhmtzcXJSVlQnX7NmzB1qtFhMnTnTpz+QraptsJZOIQPEyGWzApVyDpkv2oGaoi89TG+FFB/cKTeAeKM0BtoxWsJ8tQV+q956xAxcqbAF6TIjWrRm7EfbJ4Ge9dDL4CWHOlWtKc8y01EgoOFuG0xtOOZCzPm9r+uyzz4T/v3v3buh0OuHPFosFX3/9NVJSUpx68sbGRly6dEn4c35+PnJychAeHo74+Hj88pe/xMmTJ7Fr1y5YLBYhGxQeHg6NRgOdTod7770Xq1evRkREBMLDw7FmzRqMGTNG2E03cuRI3HLLLVixYgVef/11AMD999+PBQsWIC0tDQCQkZGBUaNGITMzExs3bkRtbS3WrFmDFStWUPaon1h5LlzE8hwbdVBeL88Bl67eOccImSYvaMgttJfnBnso0wQACWEBOFtWj+K6Fgx1U1bG0y564Ow+wNbX9B+Ueu3YARY0TXLxnCtdgBpjEkLxY7Ee2RerccckagMRS5+DpsWLFwOw9f7cfffdDvep1WokJydj06ZNTj358ePHHXamsf6gu+++G+vXrxcCteuuu87h+/bv349Zs2YBADZv3gyVSoWlS5eipaUFN998M9566y0ole09IO+++y5Wrlwp7LJbtGiRw2wopVKJL774Ag8++CBmzJgBf39/LFu2DC+99JJTPw9pJ4XyHMs0Vco003TRTUMbhQGXFY2yb8j1dKYJAAaF+uNsWT1KvGjAJcs0uT1oimMBu/eV51rNFvxUYjvyyNXDQQHgxqGRtqDpEgVNYupz0GS1WgEAKSkpOHbsGCIjIwf85LNmzep1WnNfJjn7+flhy5Yt2LJlS4/XhIeHY/v27b0+TlJSEnbt2nXN5yN9Uys0gou5e8723JUNRlitvFuP2HA1Q7NZ2IHo6qApJTIQaiWHRmMbrupbkODG89rcTRg34NFMk62BuaSu2WPP6W7tO+fcO1WdlYYvVzXB2GaBVuX6eVBiyb1qgMliRWSQxi3vxxlDI7F1/yV8f6la9r/syJnTPU35+fkuCZiId6ux9zSJWZ6LCtKC4wCLlUd1k7xKdJeqbB9i8To/BLn4nC61UiE05Mq5r8nYZhH6isQImrzpKBV3jxtgYkP8oPNXw2LlhRlk3uJEh3P73BHQTBgcCn+1EtWNJq8tb8qB00HTypUr8eqrr3a5fevWrVi1apUr1kRkzmrlUddsO0JFzPKcSqkQ5hBVyqyv6aK9XDLUTR9i7MNRzv/4ltS1wMoDARolojw4b4pl5rylPKdvNgmzrtw9BJbjuPbjVLysGfy4mw47ZrQqJSan2BrMf7jSdQc78Qyng6aPP/4YM2bM6HL79OnT8dFHH7lkUUTeDC1mWKy20mpYgHhBE9Beois3yKuvyV3jBhhvOLi3yF6aSwoP8Gipor085x1BE+tnGhTq7/KsZndGxtmHXHpRXxPP8zjppp1zHU1IsgVkp+29U8TznA6aampqHHbOMSEhIaiupgMFSXtpLsRPBY3K6beYS8WyAZcNFDR11H5wr3xLJAX2JnBPTALviAVN1Y1GtJq7jl+Rm/Me6mdivPHg3oKaZtQ0maBRKZA+yH07rscl2j57fyzWu+05pOzLn8pwvKC2T/3O7uL0J9rQoUORlZXV5favvvrKLcMtifzUCDvnxJ82Hc2CJpllmtiMpmFu+iBjmabLlY1os1jd8hzuJkYTOGCb1cQyMt6QbRLGDbhpEnhnI+yZJm+a1XS8oBYAMHaQzq3N7WMTQgHYzj40tJjd9jxSZLZY8fR/zuCXrx3GtxfEG/LpdC720Ucfxe9//3tUVVXhZz/7GQDg66+/xqZNm/DKK6+4en1EhmolcIQKI2SaZNTT1HE689Ao93yQDQr1R4BGiWaTBQU1TbKcNyTGuAHA1peTEOaPc+UNuKpvcfnuRk8TmsA99B4YLpx/aERVg1HU8yldRWgCT3ZPPxMTHqhBUngAimqb8VOJATcM851NWfvPVQrnZbJDjMXgdKbpnnvuwaZNm7Bt2zbMnj0bs2fPxvbt2/H3v/8dK1ascMcaicxIYbAlI/Q0yWhWEzvXLDrYfdOZFQpOaPo9Xy7PEh3LNHnqCJWOBoV6z9gB1tPkrjPnOgvQqISSqjcMWAU6DrV0Xz8TMy4xFADwY4ne7c8lJR8cKwYA/GLCIKiV4rV99OuZ//u//xslJSWoqKhAfX09rly5grvuusvVayMyJYXBlowcD+1l5RJ3ZzBGyPgMOouVR7E9YEkSIWjylmbw6kYjaptM4DgIYyg8ob2vSf7N4Ppmk9CDOCEp1O3PNy7B1teU40N9TRX1rdh/vhIARB/sOaBwLSoqCkFB8k5NE9eTwrlzjByDpktV7m0CZ1KjbL/tF9hPZZeTUn0LzBYeGqUCcTp/jz+/t4wdYLsnB4cHwF/juUGTI2K9p6/pZJEty5QaGeiRPk6Wacop1ovaEO1JH50ogZW3HU8jdjnc6aCpoqICmZmZiI+Ph0qlglKpdPgiRErlOdbTVNdshrFNHjudLrl5RhPDGqjZ+W1yUmRfc0K4P5QiTHpvH3Apv9euowvChgPP9rSx41S8IdN0vMC985k6Gx0fAqWCQ1WDUVZtB/3F8zw+PG4rzS29XvzjY5xuBF++fDmKiorw1FNPIS4ujka5ky6kVJ4LDVBDo1LA1GZFZb0RieHSPzLE3eMGGNZAzRqq5USscQPMIC8pz7GRE2meDprs5bmLlY2wWHlRAl9XEfqZ3NwEzgRoVBgeE4yzZfX4sdggSqbVk47k16KgphmBGiVuGxMn9nKcD5qys7Nx8ODBLofoEsJI4dw5huM4xIRoUVzbgor6VskHTS0mi9Cr4+6gKcn+WuibzTA0m93WdO4OhR0GW4qBlecqG2yzmvzU8syyX3TzaIueJIQFCL/MlOpbJP/3sidmi1VoyPZUpgkArkvU2YKmEj1uSY/12POK4f/sDeALx8Uj0APDV6/F6fJcYmKiz9RRSf9I4dy5jmKC5TN24HJVI3je9tq5uz8iUKsStnsX1sor21QoZJrE+bANC1AjwN4DxM6/kxue54VNAJ7aOccoFZzw34718MnRlaomtJqtCNKqkBrpucCTzWvy9iGX9a1mfJlbBkAapTmgH0HTK6+8gieeeAIFBQVuWA6RO6mcO9dRjM4WNMmh/s8OMfVUs+Ng+2/4LHMjF8Jgy0hxynNsVhMAXJVp0FRRb0RDaxuUCg4pIryOLMi4UiWvgL2jM6W240xGxYVA4cES4zh70PRTiQFWq/cmMT7LKUWr2Yph0UEYb2+AF5vTua4777wTzc3NGDJkCAICAqBWO6b0a2trXbY4Ij9SOneOYZmmShkETRcr7eUSDwVNSREBOF5YJzRWywHP8+1Bk4hlnYSwAFyoaJRtXxNrAk+JDHTrFOuesN2bV2ScacortTWyj4p339Ep3RkeEwQ/tQINxjZcqW4SfUeZu/yfvQH8zusTJdM/7XTQRFO/SW+kdO4cE6uTz4DLixWeaQJnWCO1nMYOVDUY0WK2QMG19xaJQe4DLi94+My5zlKj5J9pyiuzB01xng2aVEoFxgzS4VhBHX4s1ntl0JRXWo/TJQaolRyWTEgQezkCp4Omu+++2x3rIF5CSufOMXKa1cT6Ozx1rIkcxw4U2LNM8aH+ogbmch9w2R40iXOEjpBpqpZnponneZwRKdME2Ep0xwrq8GOJHr+YKJ2gwlX+k3MVADBnZIxk+mOBfgRNRUVFvd6flJTU78UQ+ZPSuXNMtEwawS1WHsX24CUlyjM9JklCT5N8ftsvFHncACP3AZds3IBYQdMQe09TRb0RjcY24RBkuSg1tMLQYoZKwXl89yEAjGXHqXhpM/i+sxUAgFslMGagI6ffpcnJyb3WFi0WeQwQJO4hpcGWTKyuPdPE87xkauOdCVOuVQrE2bNj7sYCj4p6+WydF/qZRNo5x7QPuJRf0MTzPC6JnGnSBagREahBTZMJ+VVNGGM/HkQuWD/T0OggUXrCrrM3g+eV1cPYZhFlDe5SUN2Ey1VNUCk4zEyLEns5DpwOmk6dOuXwZ7PZjFOnTuHll1/Gc88957KFEXmS0mBLhh3a22yyoMHYhhA/ac4jYsFAYpi/x3bihAaoEeynQkNrG4pqm0X7AHUGKyWKHTSxAZcVDa2y+9CqqDeiyWSBUsGJ+jqmRgWipsmEK9WNsgua2M650fHirDsx3B9hAWrUNZtxrqxBOF7FG3x9znbO3OSUcMn9e+100DRu3Lgut02aNAnx8fHYuHEjlixZ4pKFEXmS0rlzTIBGJQQGlfWtkvtLyIgx5ZrjOCRHBOKnqwYUVDfJI2iyv06DRS7PRQRq4KdWoNVsRZm+FckijT/oD9ZHlBQeIOqJ8UOignCsoA6XZdgMLtbOOYbjOIxLDMW356vwY4neu4Ime2nu5pExIq+kK5f9bRk+fDiOHTvmqocjMiXF8hzQ3gxebpBuX1ORkEHx7Idvkj3TIJexA2ynn9iZJtusJnn2NRVU2/5bizUclJHz2AGxds51xIZc5nhRX1N9qxlH822ji24eES3yarpyOtNUX+94wCLP8ygrK8P69esxbNgwly2MyJMUy3OA7eDeS5WNkt5BJ1YwwGYdFcigGdzQbEZ9axsA8Y5Q6SghzB+XKhtxVS+PgJMRspoiZ8fkOuDS0GwWAmUxg6brEm2lQW9qBj9wvgptVh5DogJFf392x+mgKTQ0tEsjLc/zSExMxI4dO1y2MCJPUjp3rqNoe19TRYN0g6YikXp1koWDe6X/wc/O5YsM0iBAI/5uq/ZZTfLKNOXbA/RUsYMme6Ypv7oJVivv0anaA8GyTAlh/qKe2cgyTVeqm9BkbJPE2WwDxUpzcyRYmgP6ETTt37/f4c8KhQJRUVEYOnQoVCr5/wcjAyO1c+eYWDarySDNoInneeG3fyrP9YyNZBBzqGVHci3PsaBJ7N/kE8MDoFJwaDFbUF7finh7ECp1UijNAUBkkBaxIX4or2/F2bJ6TEoOF3U9A9VmseLbC1UApNnPBPSxp2nChAmoq6sDABw4cADXX389Zs6ciZkzZ+LGG2/EiBEjKGAikjx3jmkfcCnNnqbKBiNazVYoFZyQvfAUltkqqWuB2WL16HM7i2WaEiVQmgM6DriUfsDJWKw8impYT5O4QZNaqRCCdjmV6IQz50RqAu9otH0NuVcNIq9k4E4W6aFvNiM0QI0JSaFiL6dbfQqazp49i6Ym2xv62WefFf4/IR1J8dw5RmgEl2hPU6Ew5drP41OuY4L9oFUpYLHyKJX44bPFtbb1JYZJIyMhx6ngpfoWmCxWaJQKSWR2hL4mGU0GZzvnxBo30NHoQbY15JbWX+NK6WOluVnDo6AScVdnb/qUHrruuuvwm9/8BjfccAN4nsfGjRsRFNT9BNSnn37apQsk8iHFc+cYNqtJqof2ijFugFEoOCSFB+BiZSMKappF38rfG6llmoRZTfWtMLVZJfe+705+hw0HSgn0EA2JCsS+s/LJNBnbLLhUaQvwpJRpOuMFQdM+CY8aYPoUNL311lt45plnsGvXLnAch6+++qrbchzHcRQ0+TApnjvHsKnglQ1GSTacsnKJWDvCBkcE4mJlI4pqmgBIawJvR6ynKVEiPU1RQVpoVQoY26woN7QKpSYpk8rOOYY1g1+WydiBixWNaLPy0PmrEa/zzOT+3qTbM00XKxpkN2S1IylPAe+oT0FTWlqasDNOoVDg66+/RnS09OYnEHFJ8dw5JjJIC44D2qw8appMiAqWVmAnZqYJ6HBwr4R30PE8L5TBEsPFLysBtl8UB4X540pVE0rqmmURNLFMU4pkgiZ5jR1oL82FSOJIpnidH0ID1NA3m3GhXH6T1RkpTwHvyOlcstVqpYCJdKtGooMtAVvDKRuDIMVZTWKfp8aet0DCQVNVgxHGNisUHCTRi8PIbQedsHNOImVYNvbgqr4FLSbpn10qlZ1zDMdxSI9nfU3ybQaX8hTwjqRfgCeyUSPRwZZMnI5NBZdW0CTmuAGGPW9RrXR/22f9THE6f1GP/uisfVaTdAPOjgoklmkKD9RA52/LLLCATsqktHOOGT2I9TXJM2hqkPgU8I6k8y8PkT0pnjvXkVR30OmbzWgQeco1mwpeWNMMq30HpNSwnXMJEtk5x7D1lEosGO+O2WJFsT0jJpWgieO49uNUJL6DzmrlcbasAYA0ds4xbC25V+XZDP7DlVq0WXkkRwRIpteuJxQ0EZeRcnkOkG6mqdDe3BwTooW/RpwmzkFh/lAqOBjbrKhskOYsK6EJXCI755j4UNv7SurjGgBbCdFi5eGvVgo7SqVALsepFNc1o9HYBo1KIQR6UpBuz3qdK69Hm8RnrXUn+6JtoOUNwyJFXsm1UdBEXEbq5Tm2g05qmaZCkUtzgK3ni5WZCiV6Bp0wbkAiO+eYeJ090ySDoCnfnslJjgyURBMzI5eDe9m2/rSYYEmViJMjAhGoUaLVbMUVGZQ4O8u+VA0AuGGoFwZNqampqKmp6XK7Xq9HamqqSxZF5Emq584x7CgVqWWa2Inzg0XOoEh9B50w2FIiO+cY1pReamiVbGmTybe/11IipRV4DhHKc9L+wGc756TSBM4oFJzQYyW3yeBlhhZcrmqCggOmDfHCoKmgoAAWS9cdDkajEVevXnXqsb777jssXLgQ8fHx4DgOn376qcP9n3zyCebNm4fIyEhwHIecnJxun/ehhx5CZGQkAgMDsWjRIpSUlDhcU1dXh8zMTOh0Ouh0OmRmZkKv1ztcU1RUhIULFyIwMBCRkZFYuXIlTCaTUz+Pr5N6eU6ymaZaaczNEYImiTaDS22wJROr8wPHAaY2q/B3QKoKJLZzjuk4doDnpRt4niu3BU0j44JFXklXrK9JbkMuD160ZZnGJoQKGwKkrM8Hxn322WfC/9+9ezd0uvYmOIvFgq+//hrJyclOPXlTUxPGjRuH3/zmN/jFL37R7f0zZszAHXfcgRUrVnT7GKtWrcLnn3+OHTt2ICIiAqtXr8aCBQtw4sQJKJW2/pBly5ahpKQEWVlZAID7778fmZmZ+Pzzz4X133bbbYiKikJ2djZqampw9913g+d5bNmyxamfyVfZzp2TSXlOYpkmsccNMIPDbR+kUsw0tVmsKLP/d5NaeU6tVCAm2HZoaqm+RXIzwDqSykG9nQ2OCICCAxqNbahqMCI6RPyhkd05V25rAk+LlVamCZDvGXTZ9qDpRhn0MwFOBE2LFy8GYNvpcPfddzvcp1arkZycjE2bNjn15PPnz8f8+fN7vD8zMxOALbvVHYPBgG3btuGdd97BnDlzAADbt29HYmIi9u3bh3nz5uHs2bPIysrCDz/8gClTpgAA3njjDUybNg3nz59HWloa9uzZg7y8PBQXFyM+Ph4AsGnTJixfvhzPPfccQkKk9xdEaqR87hzDynONxjY0tJoRLJEBakLQFC7uB1mShMtzZYZWWKw8NCoFoiUYlMSHtgdN4xJDxV5Oj1jQlCqxoEmrUiIhLABFtc24XNUkyaCp0dgmzOIaESu9TBObDJ5XWi/JUw+6Y7Xy+N7ezzRDBv1MgBPlOavVCqvViqSkJFRWVgp/tlqtMBqNOH/+PBYsWODOtXZx4sQJmM1mZGRkCLfFx8cjPT0dhw4dAgAcPnwYOp1OCJgAYOrUqdDpdA7XpKenCwETAMybNw9GoxEnTpzw0E8jb6wsIcVz55hArQrBfrbfE6Qy4LLR2IbqRttuNbGnSbOSTUGN9EokbOdcQqi/JD8MWF/TVQk3g7eaLSg12NYntUwTAMmPHThvzzJFB2sRJsEWhKHRQdCoFGgwtgmlbKk7V96AmiYTAjRKTEgKE3s5feL0p1t+fj4iIx0jws79QZ5SXl4OjUaDsDDHFzsmJgbl5eXCNd1NMI+Ojna4JibGcQppWFgYNBqNcE13jEYj6uvrHb58VY39g1+K58511N4MLo1t9WynWliAWvR6PpsR1dDaBn2zWdS1dMY+BBIk1s/EsJ2HpXppBOPdKaptBs8DwVqVJI86kvrYgfNCaU56WSbAViZmGTC59DVlX7KNGpiSEi7ZX7Y7c3qVL7zwAj744APhz3fccQfCw8MxaNAg/Pjjjy5dXH/xPO+wnba7rbX9uaazDRs2CM3lOp0OiYmJA1y5fEn53LmOWF9TmUEaGYEioZ9J/N/8/TVKoR9Har+pCjvnJDbYkhF20Ek409Sxn0lK4wYYlmmS6lTw8/YmcCmW5hi59TWxJvAbhkn3gN7OnA6aXn/9dSE42Lt3L/bt24esrCzMnz8fjz32mMsX2JvY2FiYTCbU1dU53F5ZWSlkjmJjY1FRUdHle6uqqhyu6ZxRqqurg9ls7pKB6mjdunUwGAzCV3Fx8UB/JNmS+s45hmWapFKeK5BIEzjDsk1FtRILmiS6c45hg1NLJRKMd0dqx6d0xvqspDqrScpN4IwwGVwGmaZWswXHCmxHp8hhPhPjdNBUVlYmBE27du3C0qVLkZGRgbVr1+LYsWMuX2BvJk6cCLVajb179zqsLzc3F9OnTwcATJs2DQaDAUePHhWuOXLkCAwGg8M1ubm5KCsrE67Zs2cPtFotJk6c2OPza7VahISEOHz5KqkPtmTihEyTNIImdtabFDJNQHvQxDI7UiFMA5fYzjlGDpkmdr6hFPuZgPaxA8V1LTC1SWuqNc/zOF9hC5rkkGk6c9Ugub7Ezk4W1qHVbEV0sBbDY4LEXk6f9Xn3HBMWFobi4mIkJiYiKysLf/7znwHY3lTdzW/qTWNjIy5duiT8OT8/Hzk5OQgPD0dSUhJqa2tRVFSE0tJSAMD58+cB2DJDsbGx0Ol0uPfee7F69WpEREQgPDwca9aswZgxY4TddCNHjsQtt9yCFStW4PXXXwdgGzmwYMECpKWlAQAyMjIwatQoZGZmYuPGjaitrcWaNWuwYsUKnw6EnCH1c+eYGJ3EMk32YYPJEsk0sfKX9DJN0hxsybCepupGE1rNFvipxTkOpzesV0hqgy2ZmBAtAjRKNJssKKptxtBo6XyQVjUYoW82Q8FBUuvqbGRcCJQKDjVNJlTUG4V2BCk62GEKuBTLxT1xOtO0ZMkSLFu2DHPnzkVNTY0wMiAnJwdDhw516rGOHz+O8ePHY/z48QCARx99FOPHj8fTTz8NwDYbavz48bjtttsAAL/61a8wfvx4vPbaa8JjbN68GYsXL8bSpUsxY8YMBAQE4PPPPxdmNAHAu+++izFjxiAjIwMZGRkYO3Ys3nnnHeF+pVKJL774An5+fpgxYwaWLl2KxYsX46WXXnL25fFZcinPSS3T1H6EijQ+yBKFTJN0gqZWswVV9vPwpJppCg1Qw98eKEnlvdUZyzSlRErzQ5/jOKF0KLUSHSvNJUcGSjIgZvzUSgy1Z+zOlEq7rylb6GeST2kO6EemafPmzUhOTkZxcTFefPFFBAXZ/gOVlZXhwQcfdOqxZs2a1WsKcfny5Vi+fHmvj+Hn54ctW7b0OoQyPDwc27dv7/VxkpKSsGvXrl6vIT2TS3kuRkI9Ta1mC8rs65BKeU4ImiTUCF5iX0uQVoXQAGnM1uqM4zjEh/rhclUTSvUtkusbajK2oaLeFnimSOS91p3UqCCcKa2XXDM42zkn5dIcMzo+BOcrGvDTVQNuHtlzT66Y6ppMyLUHdXKZz8Q4HTSp1WqsWbOmy+2rVq1yxXqITNXKJtPUXkYxtlmgVYn3W2NJnW0LeKBGKZldh6yn6WpdCyxWHkoJzERi/VUJYf6STuPHh/rjclWTJGc1FXQcbSHRwBNAh0yTtIImoQk8RvrtGmMSdPjk1FX8VCLdTNOhyzXgeWB4TJDwi6xcOB00AcDly5fxyiuv4OzZs+A4DiNHjsSqVavowF4fVsuOUJF4T1NYgBoalQKmNisq642i7sYq7DBuQCrBQEyIHzRKBUwWK8oMLUiQQDlM6jvnmEESbgYXeucklgHrbIhExw6cr7DtRpPqjKaOxibYdtCdtjeDS+Xflo6yhX4m+YwaYJzuadq9ezdGjRqFo0ePYuzYsUhPT8eRI0cwatQoh11sxHfwPI86mWSaOI5rH3ApcolOauMGAECp4DBIYs3gUt85x0h5B117P5O0gyZhwKWEpoJbrDwuVtjWI4fy3Kg4HZQKDlUNRqEkKzVsqKVczpvryOlM0xNPPIFHHnkEf/nLX7rc/vjjj2Pu3LkuWxyRhwZjG9rs585Jteeko9gQPxTVNot+cG+R/YNM7ONTOksMD0B+dRNKaluAIWKvpsNgS4nunGPiJTwVXBhsKeF+JgBItu/sq240wdBiFn1KPmALOI1tVvipFZLPdgK2IbXDooNwrrwBP5boEauLFXtJDopqmlFc2wKVgsPklHCxl+M0pzNNZ8+exb333tvl9nvuuQd5eXkuWRSRF5ZlCtQoJb2zhGHbcMUOmgprpXFQb2dSGzsglOckn2myD7iUYKaJTZ6Xenku2E8tHMgslRIdawIfHhMsiR6/vhiXEAoAkuxrYqW5CUlhCNT2q0NIVE4HTVFRUcjJyelye05OTrdnvBHvx5rApXiIZXeEoEnk8lyRBMtzgPSmggvlOYn/lj+ow6G9UhssKAy2lNh7rTushJgvkRJdexO49EtzzBh7X9OPJXpxF9KN7+1Bk9x2zTFOh3krVqzA/fffjytXrmD69OngOA7Z2dl44YUXsHr1anes0eet/+wMimqb8dSCUZLsSahrlkc/EyOFniaLlRcyKEkSCwaSJDR2wNBiRn1rGwDb7jkpY8G4sc2KumazZP4+NJvaUGmfcyW1rGZ3UqOCcCS/VjI76NiZc3JoAmdYM/hPEmsGt1p5fH9ZnvOZGKeDpqeeegrBwcHYtGkT1q1bBwCIj4/H+vXrsXLlSpcvkAAHL1bhclUTVtyYKsmgqbbJDAAIC5DGh8S1SKE8V2ZogdnCQ63khF4YqZDSgEu2hohAjeRT+VqV7cDjqgYjSvUtkgma2C7NUImPG2BSJTZ2oH1Gk/THDTBpscHQKBXQN5tRXNsimb7JvLJ66JvNCNKqMM4e2MmN0+U5juPwyCOPoKSkRDiotqSkBA8//LBkollvw4IRvT2jIzVy2TnHSCFoYqW5hLAAyfVJsKCputGEZlObqGthgy0TJJaN60l8hxKdVLRPnZfeL1zdSbWPHbgigZ6mZlOb0Hsop0yTVqXEiDjbek9f1Yu7mA4O2qeAT02NgErpdPghCU6vOj8/HxcvXgQABAcHIzjY9h/m4sWLKCgocOniiA3bkaZvMYu8ku6xGU2yyTR1mAputYrTe8L+IZZaaQ4AdP5qhPjZsjpiH9wr7JyTeGmOGSTBZnA22kIO/UxA+8G9+dWNov39ZC5WNILnbZnOqGBpz6DrTJjXJKFm8O+F+UwRIq+k/5wOmpYvX45Dhw51uf3IkSPXPPKE9I/On2WapBk0tWeapJ/6B4CoYC0UHNBm5YUz8zytUKJN4AxL54tdopPLYEsmXie9WU0dh6jKQUKYP1QKDq1mq+ibNVhpTk5ZJmbsoFAAwGmJNIO3mi04WlALQL79TEA/gqZTp05hxowZXW6fOnVqt7vqyMC1Z5qkWZ6T2+45tVKByCDbb41ileiKaqVdMmHb+8XeQSd84MslaJLgrCahPCeT11CtVAhBu9h9TecrZBw0JdoyTblX60XP2AHAicI6mNqsiA3xw5AoaR4a3Rf96mlqaGjocrvBYIDFYnHJooijMBY0NUk008R2z8mkPAcAcSKPHZB6MCCVHXRFEi5jdkeaPU1sRpM8XkOgvRlc7LEDcjqot7OhUUHwUyvQaGyTRH9YdodRA3Luf3Y6aLrxxhuxYcMGhwDJYrFgw4YNuOGGG1y6OGKjY43glGlyGXZIZLnB8x9uPM9LdkYTI4UddBYrLzSCS2X3z7VI7fy5VrMFpfb3uFSzmt1hfU2XRc40CTOaZLRzjlEpFUiPZ6MH9OIuBkD2RTZqQL79TEA/Rg68+OKLuOmmm5CWloYbb7wRAHDw4EHU19fjm2++cfkCCRBqP0pAsj1N9nXJZfccIG6mqa7ZjAajbVeaVHt1EiUw4LLjWIY4nTwawdlU8MoGI4xtFmhV4k7IL6lrBs8DQVoVImT097M90yRe0FTTaER1oxEcBwyPkWc5aUyCDscL6/BjsQE/H58g2jrqmkzILbU1pM8YIt9+JqAfmaZRo0bh9OnTWLp0KSorK9HQ0IC77roL586dQ3p6ujvW6PPYrjSDBHfPWay8MApBLrvnACDGHjSVidDTxHpMYkP8JHvsjFCeqxVvujXLxiVKcCxDT8IDNdCqbP+sVhjEPyy144YDOZVE2Dw6MQ/uPVtmyzINDg9AgEbaM8J6IhynclXcHXSHr9SA521T1aPtWX656tc7IT4+Hs8//7yr10J6wBrB6yQ4p6m+xQzWYyiHw3oZlmmqECHTJPTpSLjkFB/qB44DWswWVDeaRNluXSST41M64jjbsNL86iZc1Ys/VLB93IB8SnNAe3mupK4FrWaLKL9cnC2zTQIfGSe/0hzDjlM5U2pAm8Uq2mykbJkfndKRPKdL+RidhMtzbEZTiJ8KahkNK2M9TeJkmqTdBA7YhuPF2V8jsZrBhQONJRxcdkdKB/eyrKbYwZuzIoM0CNaqwPPilYi9IWhKiQhEsFaFVrMVFyvFy9oJ85lk3s8EUNAkCyyDY2yzotUsrR2KcpsGzrAemXJDq8fLT1Kf0cSI3QzOynNy2TnHSGlWk9wGWzIcx7VPBq8S58M+zwuCJoWCQ/ogNuRSL8oaimqaUVjTDJWCw+QUCpqIBwRpVVDZezqkVqKT4845oH0qeLPJIjRlewqb0ZQk8ZKJ2EFTIXud5BY0sR10IuzM7ExuR6h01N7X5PlmcFObFZftwdrIOPmNG+hI7Mng+89XAgAmDg5DkMTPj+wLCppkgOO49gGXEivRyXFGEwD4a5RC2bPCwyU6OZTngPZgRazySJHMJlkzg4RZTeIOuDRbrCipswVucutpAtr7msQYcHmpshFmC48QP5Xw31OuxtqbwcUOmn42IlqU53c1p4OmlpYWNDe3/yNaWFiIV155BXv27HHpwogjqfY11doHbsot0wS0Z5s82dfUYrKgssG2q0r65Tnbh4UYQZO+2YT6VlsGULaZJpHLc6X6FlisPPzUCkTL7Nw0oP3gXjHGDrB+phFxIbLaddgdlmk6V17v8faOFpMFhy/XAPDhoOn222/Hv//9bwCAXq/HlClTsGnTJtx+++34+9//7vIFEptQYeyAtMpzQqZJjkGTCLOaWAAS4qcS/ptKVcexA57GsnHRwVr4a6Q5lqEnHRvBxRrXALT3MyWFB0Ahk5ENHQnlORF6mljQNErG/UxMQpg/ooK1MFt45BTrPfrchy5Xw9hmxaBQfwyNluesq86cDppOnjwpDLX86KOPEBMTg8LCQvz73//Gq6++6vIFEpswYeyA1DJN8pvRxMQKU8E9FzTJqceEnT9nGzJp9ehzy+34lI5YpqnZZBE1Myyn91p3WNBU12wW/p3xlLPlrAlc3v1MgK29Y2qqrQH7hys1Hn3ujqU5uWfsGKeDpubmZgQH295Ie/bswZIlS6BQKDB16lQUFha6fIHERudvP0pFYkFT++45+cxoYsTMNMlhC3hUsBZalQJW3vOlJjm9Tp35qZXCgdCsp0gMBdXy3DnHBGhUQomYnQHnCTzPC4Mt5bxzrqNpIgRNPM9j/7kqAMDsEVEee153czpoGjp0KD799FMUFxdj9+7dyMjIAABUVlYiJMQ73mBSJDSCS6w8VyvDaeCMEDR5NNMkjyZwwPYbqljN4EKWJFyeWZKEMNuHvZgHHss90wQAaTG2z5QLFZ4LmiobjKhtMkHBAcNj5J9pAoCpqeEAgJNFeo/1NV2oaMRVfQu0KgWmpcp/qCXjdND09NNPY82aNUhOTsbkyZMxbdo0ALas0/jx412+QGLDzp8zSDbTJL+giU0F92QWRW4DGxNF6muSyyyrnrDXrUTMoKlWntPAO0qLtfXBnPNgponNZ0qJDJTsMUfOSokMRHSwFqY2K04V6T3ynKw0N31IhOz6EnvjdND0y1/+EkVFRTh+/Dh2794t3H7zzTdj8+bNLl0caRdqD0poTpPrdJxD5KmG3SI2oVkmGRSxMk3FMjxCpaNElmkSoYkesJ0JWSTzwBMA0mI9n2nyhkngnYnR1/TNOVvQNNtLds0x/ZrTFBsbi+DgYOzduxctLbZ/FK6//nqMGDHCpYsj7UIlOHLAbLEK28LlNqcJaJ+n02SyeKTBvq3D3By5fJAlCkGT57Z9G9ssKLP3mcnldepMCMhFyjSV17fCZLFCreSEjKocpdnLYxfKGzz2i4239TMx04bYgqbDHgiaDM1mnCisAwDMTvPxoKmmpgY333wzhg8fjltvvRVlZWUAgPvuuw+rV692+QKJDetpMrRIJ2hiAZyCA0L85dcI7qdWCjvoPJFJKTO0os3KQ6NSCM8rdayJOL/acx/+xbUt4HkgUKNEhAwzmED7zkPRpqnbZxslhgWIdkirK6REBkKt5NBgbEOph3oPvWncQEcs05Tjgb6mg5eqYLHyGBodJNtscU+c/tv0yCOPQK1Wo6ioCAEB7S/GnXfeiaysLJcujrQLleDuOVYqDA3QQCnDOTBA+wBHT3y4sT6dxDB/2czNYdu+C6qbPPabfrGwcy5QttuUWSN4SZ04s5oKvKA0BwAalQKpkba+pvP2MQDu1Gq2CHOhvC3TlBwRgJgQLUwWK04W1bn1uVhpzlsGWnbkdNC0Z88evPDCC0hISHC4fdiwYTRywI1ChTlN0ulpap/RJL8sEyNkBDxQRmFnqclpN1NieACUCg4tZgsq6o0eec5Coe9LvsdXxIf6g+Nsh2xXNXrmdevIG3bOMWmxthLd+XL3D7m8UNEAK2/7Ny0mRH5T1HvDcVz76IHL7ivRWa08Dpy3jxrwstIc0I+gqampySHDxFRXV0Or9a43mZSwoMnYZvX4KPyeyHnnHOPJQ2mLOkxolgu1UiE0NXvqOIv2HYby/cDXqBSIs5dgxZyoLvdME9AxaHJ/pqljE7hcs5y9aW8Gr3Xbc5y+akBNkwnBWhUmJYe57XnE4nTQdNNNNwnHqAC26NVqtWLjxo2YPXu2SxdH2gVpVUIJTColOjnPaGI8uaVerh9krETnqaBJjsFldxJEHDtQYM80yXncAMOawc9XuD/T5K1N4IzQ11SsR4vJPb98s9LcjcMjoZZxP11PVM5+w8aNGzFr1iwcP34cJpMJa9euxZkzZ1BbW4vvv//eHWsksAWnof5q1DSZoG8xCYMZxeQNmSZPbqmX24wmJjkyEDhfhfxqz5wBJucjVDpKDAvA0fxajzeD8zwv2wC9OyzTdLmyEWaL1a0fxHleOG6go8ERAYjT+aHM0IpTRXWYPtS1Qyd5nkdWrm1zmDeW5oB+ZJpGjRqF06dPY/LkyZg7dy6ampqwZMkSnDp1CkOGDHHHGomd0NfUJJFMk30dcpzRxLBGcHYivLvwPC+7GU1MqpBpcv+Hv9XKC0GT3D/wOzaDe1JVgxEtZgsUHJAQJu/XELCNBgnUKGGyWIVeLXewHZ/iPWfOdafjvCZ3jB44U1qPCxWN0KgUyBgd6/LHlwKnMk1msxkZGRl4/fXX8eyzz7prTaQHoQEaAE0wSOQoFdaULscZTUxMsB80SgVMFivKDC1u+5CpbDCiyWSBUsHJLoOSLARN7s80VTYYYWyzQqnghINv5UqsWU2Xq2yBRUJYADQq+ZdHFAoOw2KCkVOsx7nyBgyNdk9Ac1XfgobWNqgUHIZGB7nlOaRgamo4dp666pYhl5+eugoAmDsyBjoZjqHpC6f+RqnVauTm5rqsQe67777DwoULER8fD47j8Omnnzrcz/M81q9fj/j4ePj7+2PWrFk4c+aMwzVGoxEPPfQQIiMjERgYiEWLFqGkpMThmrq6OmRmZkKn00Gn0yEzMxN6vd7hmqKiIixcuBCBgYGIjIzEypUrYTJJIzhhpDbgUs7TwBmFghMyAu4s0V2utAUcg8Pl90HGepqKapvdmo1jzwHYsgty74cQayr4FXtwmxolr4xmb0bEtg+5dBfWzzQ0Oghalfcc+9EZOwfO1X1NbRYr/vNjKQBg8fhBLntcqXH6X6W77roL27Ztc8mTNzU1Ydy4cdi6dWu397/44ot4+eWXsXXrVhw7dgyxsbGYO3cuGhra/+KsWrUKO3fuxI4dO5CdnY3GxkYsWLAAFkv7m2HZsmXIyclBVlYWsrKykJOTg8zMTOF+i8WC2267DU1NTcjOzsaOHTvw8ccfS25Yp044tFcaQZOQaQqU928UQsOuGz/cLlexDzL5/QYbr/OHRqWA2cLjqptLTe3jBuSVjesOyzS5u/Tb2RV7ponNN/IG7OBcd55B543Hp3QnMdwf8To/mC28MLXbFb6/XIOqBiPCAtSYOTzKZY8rNU43gptMJvzzn//E3r17MWnSJAQGOv428/LLL/f5sebPn4/58+d3ex/P83jllVfw5JNPYsmSJQCAt99+GzExMXjvvffwwAMPwGAwYNu2bXjnnXcwZ84cAMD27duRmJiIffv2Yd68eTh79iyysrLwww8/YMqUKQCAN954A9OmTcP58+eRlpaGPXv2IC8vD8XFxYiPjwcAbNq0CcuXL8dzzz2HkBBp/CViu9SkMqupfU6TfDNNQHtGwJ2Zpkv2TNOQaPn99q9QcEiOCMCFikbk1zQhyY29RkITuMz7mQAgJsQPaiUHs4VHeX2rcGyPu7Fdjl6ZaXLjGXR5pd7dz8SwvqZPTl3F95erccMw1zSDs9LcwnHxssumO8Ppnyw3NxcTJkxASEgILly4gFOnTglfOTk5LltYfn4+ysvLkZGRIdym1Woxc+ZMHDp0CABw4sQJoc+KiY+PR3p6unDN4cOHodPphIAJAKZOnQqdTudwTXp6uhAwAcC8efNgNBpx4sSJHtdoNBpRX1/v8OVOrDxnkEh5zht2zwHtWQ139p6wPpMhMsw0AR3GDlS5t69J2PXlBZmmjn1ZntxBd6XK+8pzw+1BU2FtM5pNbS5/fJ7ncarYlnUZmxDq8seXmplptkzQ5z+WwuqCLGiTsQ1ZueUAgJ97cWkO6Eemaf/+/e5YRxfl5bb/ADExMQ63x8TECJPHy8vLodFoEBYW1uUa9v3l5eWIju669TE6Otrhms7PExYWBo1GI1zTnQ0bNni0IZ7tnpNCT1Or2YImez1czj1NQMdDad0ZNNk+yOTaYMqawdnxHO7iLTvnmMSwABTWNKO4tlnYteROpjYriu0lVLkG6N2JDNIiMkiD6kYTLlU2ujywKTW0oqLeCKWCw9gEnUsfW4oyRsUiWKtCSV0LfrhSM+DRA7vPlKPFbEFKZCCuSwx1zSIlSvI5tM5N5zzPX7MRvfM13V3fn2s6W7duHQwGg/BVXFzc67oGSmcvg+klsHuOBW4qBYdgrdOxt6QkuXnAZaOxDWX2w0aHyLTPhI0duOLmAZcsaPKWQz6Fsw09NHagqLYJFiuPQI0S0cHedUKDO/uaTtp7e0bGBSNAI+9/z/rCX6PEgnG2ysqHJ0qucfW17bSX5hZfN8grJ6l31K93x7Fjx/Dhhx+iqKioyw6zTz75xCULi421zXgoLy9HXFyccHtlZaWQFYqNjYXJZEJdXZ1DtqmyshLTp08XrqmoqOjy+FVVVQ6Pc+TIEYf76+rqYDabu2SgOtJqtR49OiZMQpmmjjvn5P6XhJ0/V91oRIvJAn+Na3fOsHJJZJBWaOaXGzZZ2p1jBxpazcL7Ss5HqHTERliUeKg8x8rAKVHyPey4J2mxwTh0ucYtO+jYAbYTkrzv2I+eLJ2UgPePFuGr3DI8e/tohPj179+myvpWfH+pGoD3l+aAfmSaduzYgRkzZiAvLw87d+6E2WxGXl4evvnmG+h0rktrpqSkIDY2Fnv37hVuM5lMOHDggBAQTZw4EWq12uGasrIy5ObmCtdMmzYNBoMBR48eFa45cuQIDAaDwzW5ubkoKysTrtmzZw+0Wi0mTpzosp9poEL97ZkmCQRN3jCjidEFqBHsZ/v9wR19Taw0N0TGPSYp9rVfrWuBsc09xy+wD/yoYC2CZJ69ZDw94NIbd84x7cepuCNo0gPwraDpusRQDI0OQqvZii9Ol137G3rwn5xSWHlg4uAwr9jAcS1OB03PP/88Nm/ejF27dkGj0eB///d/cfbsWSxduhRJSUlOPVZjYyNycnKEBvL8/Hzk5OSgqKgIHMdh1apVeP7557Fz507k5uZi+fLlCAgIwLJlywAAOp0O9957L1avXo2vv/4ap06dwv/7f/8PY8aMEXbTjRw5ErfccgtWrFiBH374AT/88ANWrFiBBQsWIC0tDQCQkZGBUaNGITMzE6dOncLXX3+NNWvWYMWKFZLZOQd06GmSQHmuPdMkz8xJZ0luPLj3cqW9CVym/UwAEBVkC2SsvPuamtnOqOEx8n2dOvP0gEtvbAJn2g/udW3Q1Gq2IK/UAMC3giaO43DHxAQAwP8d739rySf20pwvZJmAfgRNly9fxm233QbAVp5qamoCx3F45JFH8I9//MOpxzp+/DjGjx+P8ePHAwAeffRRjB8/Hk8//TQAYO3atVi1ahUefPBBTJo0CVevXsWePXsQHNy+JXTz5s1YvHgxli5dihkzZiAgIACff/45lMr2Esu7776LMWPGICMjAxkZGRg7dizeeecd4X6lUokvvvgCfn5+mDFjBpYuXYrFixfjpZdecvblcStW2mk1W9Fqds9v+33VPqNJ/pkmoL1E545mcKEJXMaNuRzHITnS9hq56ziVi/agaZibJj6Lgb2vyutb3Zah6+iKMG5Avu+1ngyzZ5oqG4zCzl1XyL1qgNnCIzJIK/Sg+YqfTxgEpYLDqSI9LlU6H4z+VGLA2bJ6aJQKLBgbd+1v8AJO58DDw8OF4ZKDBg1Cbm4uxowZA71ej+Zm5/4xnTVrFni+5+2OHMdh/fr1WL9+fY/X+Pn5YcuWLdiyZUuva96+fXuva0lKSsKuXbuuuWYxBWtVUCo4WKw89M1mxOrEm1rrLTOaGJZWdkczuFCek3GmCQBSIoOQe7Xe3tfUc69ff120z7Ia5kWZpsggDfzVSrSYLSjVtwqjG9xFyDS5+XnEEKRVITHcH8W1LThf0eCy3Yjt/UyhXtcHdi3RwX6YNTwKX5+rxIcnSrBu/sg+fy/P83juyzwAwK1jYu3HfHk/pzNNN954o9BDtHTpUjz88MNYsWIFfv3rX+Pmm292+QJJO47j2o9SEblE5y0zmhjhyAsXl1HaLFZh2KCce5oAICXC3Zkm2wc+2yXlDTiO69DX5N4SXV2TCXX2fkdvLM8BHfqaXFiiO1moBwBMGOw7pbmO7piUCAD45ORVtFmsff6+PXkV+OFKLbQqBdbMS3PX8iTH6UzT1q1b0dpq2z69bt06qNVqZGdnY8mSJXjqqadcvkDiSBegRk2TSfRm8Fr783tLpinBTT1NxXUtMFt4+KuViNfJO/XPmsHdsYOu0diGq3pblm+4F5XnAFsz+MXKRrefQcdKc3E6P6/dNp8WG4x9ZyuFI08Giud5n9w519HPRkQjPFCDqgYjDlyows0jr51FNrZZ8PyXZwEA99+U6raDzqWoX+U5RqFQYO3atVi7dq1LF0V6JpVDe70t09SxEbwvs8D6ih3UmxoVCIVC3qn/9rEDrp/VxPqZooPlO5ahJ55qBvfmJnDmukRbYHO0oNYlj3dV34LKBiNUPjLUsjsalQKLrxuEf32fjw+Pl/QpaHrr+wIU1jQjOliL384c4oFVSofTQVNRUVGv9zu7g444h2V29CKfP9dxTpM3YOeCNZksqG0yISLINfO32scNyL9Ph/XjVNQb0WRsQ6ALxwKw0pw39TMxrBnc3UepsEyTu/umxDQ5ORwcZxutUNnQiuhgvwE9Hhs1MCo+BH5q8XpExXbHpAT86/t8fH2uAufK6zEitudd41UNRmz55hIAYO0tI1z674AcON3TlJycjJSUlB6/iHvphLEDImeavGhOEwD4qZWICbEFSq6c3iwc1OsFQVNogEbILBbUuDbbdLHS+3bOMZ6aCt7eBC7/91pPdAFqjLR/oB+5MvBsE5sE7qulOWZkXAhuHBYJs4XHXduOoqiX45Je3nsBjcY2jBmkwxIfGTPQkdNB06lTp3Dy5Enh68iRI3jttdcwfPhwfPjhh+5YI+lACgMueZ73ujlNQHuJzpVjB9p3znnHb//J9mbwAhc3g1/wwiZwhvV7XHV7eY6NG/CO91pPpqTaWkSO5NcM+LFO2fuZxieFDvix5G7rrycgLSYYlQ1GZP7rCCobWrtck1dajw+O2apNTy8cJfuWg/5wOmgaN26cw9ekSZOwYsUKvPTSS3j11VfdsUbSARtwaRBx91yL2QJjm22Xhbf0NAGuL6PwPC9MufaGTBNgGzsAuL4Z/KIXDrZk2o/pMaHZ1OaW57BYeRTaswPe8l7rCRs18MMAM02tZgvOlNoayn090wTYsnj/vncyEsP9UVjTjLv/dQwGe0WjrsmEv+6/hOVvHoWVBxaMjcP1yeHXeETv5LJi5PDhw3Hs2DFXPRzpATt/rq5JvEwTyzJpVQr4e1EfAGvYddXW8JomEwwtZnCc9/SZpLhhwGVDqxml9gONvbE8x47paWhtQ0ldi1uyaSV1zTBZrNCoFIgPlfcuzWuZkmLra7pU2YjqRiMi+9l/eLrEgDYrj6hgrTAWwtfFhPjhnXum4JevHcbZsnrc9/YxDI0Oxs5TJWg1235RHhTqj3W39n2ek7dxOtNUX1/v8GUwGHDu3Dk89dRTGDZsmDvWSDrQsUZwETNNLGAL94LDejtKdHF5jvUzJYYFeE2TqTsyTex18sadc4y7m8FZaS4lIhBKLy+ZhAZohHlNA+lr8uWhlr1JjgzEv++ZjGA/FY4V1OH9o0VoNVuRPigELy8dh2/WzBQ2zvgipzNNoaFd32A8zyMxMRE7duxw2cJI96QwcqC22bumgTPCgEsXzdPxhoN6O2MZs4JeGkWd5Y1DLTtLDPdHXlm92w7ubT8+xXvea72ZmhqBc+UN+OFKDW7r5/Ed1ATes1HxIfjX8uvx+EenMTwmGPfemIJJg8MouEQ/gqb9+/c7/FmhUCAqKgpDhw6FSuVbWw/FIBzaK2LQ5G0zmhh2lMpVfQvaLFaolE4nYh0IB/V6UY8JO3+utskEfbPJJUcnsIN6vXHcAJPg9kyT989o6mhqajjeOlTQ72Zw21BLPQDfnQR+Ldcnh+ObNbPEXobkOB3lzJw50x3rIH0UJoHyXI09aAr1slJKTLAfNEoFTBYrygytQrmuv4SDemV+5lxHARoVYkP8UF7fistVjZg4eODNoBfYmXNe2M/EDBaOoHH9YFCgQ3nOi8cNdDQ5xdYMfqGiETWNRqfnqpXUtaC60TbUcswg3xxqSfrH6aDps88+6/O1ixYtcvbhyTWwno9WsxWtZosovTK1TUYA6HcDplQpFLZzwq5UN6G4tnnAQZMwo8mLgiYAGB0fgvL6VvxUYnBJ0HTJi3fOMSwgvNCPk+T74kq1b2WawgNtfU3nKxpwNL8W88c4V6Lbd7YCADAuMdRr+g2JZzgdNC1evBgcx4HneYfbO9/GcRwsFsvAV0gcBGtVUCo4WKw8DC1mkYIm7yzPAbYmyCvVTbhY2YjpQyP7/TgtJotwlpo3lecAYEyCDl+fq8Tpq4YBP5bDzjkv7mliAWFxbQuaTW0uPRuu0diGinrbLzJDfCTTBNhKdOcrbH1NzgZNn+aUAgAW9rMfivgup5s29uzZg+uuuw5fffUV9Ho9DAYDvvrqK0yYMAG7d++G1WqF1WqlgMlNOI6Dzt4MXifSUSo1jd4bNKXH26YN/zTAgID95h8WoPa614md0fVTycCDpov2bFxMiFZ4X3ujiCAtIuzvA5aBdJV8e2kuIlDjtbsPuzOln/OaCqqb8GOxHkoFh9vGxrtjacSLOf3rzqpVq/Daa6/hhhtuEG6bN28eAgICcP/99+Ps2bMuXSDpKjRAbW/EFacZnPU0RXhZMAAAYxJCAQw8IPC2oZYdpdt7QC5VNQ74DDo21NKb+5mYYTFBqLlSiwsVjRhrf5+5gq+V5pjJKbbS8PmKBtQ2mfr8y8lnP9qyTDOGRiIq2LtaDIj7OZ1punz5MnS6ro1zOp0OBQUFrlgTuQaxxw54c3mONYVerGxAi6n/2VLWp+ONQVN0sB/idH7geQgTlfvrghcf1NsZG6nAAkVXYQG6N585153IIC2G2fsFj/ZxFx3P8/g05yoA4PZxlGUiznM6aLr++uuxatUqlJWVCbeVl5dj9erVmDx5sksXR7rHtnmLdZRKTaOtf8LZHStyEBOiRWSQFlYeyCvrf0BwqlgPAEgf1PNp4XLGgsvTJfoBPQ4rz3nzjCaG/YznXRw0+dq4gY6cPVLlTGk9rlQ1QatSIGN0jDuXRryU00HTv/71L1RWVmLw4MEYOnQohg4diqSkJJSVlWHbtm3uWCPpJFToafJ8pslssaK+1XZ+ljeW5ziOwxh7oJPbz74mi5XHKS+fATMuMRSA7SiKgfDmM+c6a880ubanKc+e7RsR550Bem/ag6a+ZZr+Y88yzRkZg2A/3+n/Iq7jdDPC0KFDcfr0aezduxfnzp0Dz/MYNWoU5syZQ9NCPYRlmsQoz7HBlkoF57WNu2MSQrH/fFW/A4ILFQ1oNLYhUKPEiFjv/CBjmaaBNMzXt5pRZt85N9QHeppYYHhV34JGYxuCBtALxjS0moVp4KPjvfO91hvW13SuvAFVDcZee5QsVl7oZ7r9OirNkf7p199ajuOQkZGBjIwMAIBer6eAyYPYUEkxynPVjewIFTUUXnrGFQsI+ptpOmE/nmF8UpjXngPGXqP86iYYWsz9CqBZxsXbd84xoQEaRAVrUdVgxMWKBox3wfEdZ8tsmbo4nZ/XzU3ri6hgLcYl6PBjiQFbvrmIP92e3uO1R/NrUVFvRIifCjPTojy4SuJNnC7PvfDCC/jggw+EPy9duhQREREYNGgQfvzxR5cujnRPzKNUvLkJnBloMzgLmiZ6aWkOAMICNUgMt53Vd6afweWlSlaa8/4sE8OyTa4q0bHAfnS87061fnz+CADAu0eKem2yZ6W5W8fEQauigZakf5wOml5//XUkJiYCAPbu3Yu9e/fiq6++wvz58/HYY4+5fIGkKzHnNNXYp4FHBHrvb7UxIVpEBfe/GdwXgiYAGDsoFAD6PeRS2DnnA6U5xtXN4Cxo8tYNB30xfUgk5o6KgcXK489fdD/yxthmwZc/2TYvLaLSHBkAp4OmsrIyIWjatWsXli5dioyMDKxduxbHjh1z+QJJV2Ei9jQJmaYg78002ZrB2QBHvVPfW9nQiqLaZnAccF1SqOsXJyFjBjjk8lSRLbgcEed7QdMFVwVNpbbX3tfPT/vDrSOhVnI4cKEK+89Xdrn/wPkq1Le2ITbED1Ps59YR0h9OB01hYWEoLi4GAGRlZWHOnDkAbPMvaAq4Z7DSGAtgPKnWiwdbdpQuNDo7l2k6ac8ypcUEI8TLd+eMZWMHruqd/t76VjN+tAdb04f4zoeYK8tzLSaLMF083ceDppTIQNw9LRkA8NwXZ2G2WIX7Kutb8fcDlwEAC8fFeW2fIfEMp4OmJUuWYNmyZZg7dy5qamowf/58AEBOTg6GDh3q8gWSrljQVNds6nIGoLtVe/ERKh2N7Wcz+PEC3yjNAcBo+2tUXNvidAB/+HINLFYeKZGBSAgb2MHIcsJ2CZbXt8LQMrBM8dnyelh525DHaJpsjYduHoawADUuVTbi/aNF4HkeH58owdzN3+FUkR4alQJ3Xp8o9jKJzDkdNG3evBm///3vMWrUKOzduxdBQbbfnMrKyvDggw+6fIGkKxawmC08GoxtHn3uWqGnybuDJlZ6crYZ/IS95DQp2fuDJp2/GimRtoGKzo4e+P5SNQDghgEciixHOn81YkP8ALQ3wvdXx34m2r1se20fzUgDALy89wLueesYVn/4IwwtZowZpMN/fjfDJ0ZbEPdyeuSAWq3GmjVruty+atUqV6yH9IGfWokAjRLNJgtqG00eLQMJ5Tkv394cE+InbA/PKzNg4uDwa35Pq9kifJBNTLr29d5gzCAd8qub8FOJHjOH930bd/ZFe9A0zLeCJgAYHhuM8vpWXKho7NP7qifsvebr/Uwd/fr6RLxzuAAXKhqx/3wVNEoFVs0dhvtvTIVK6XSOgJAu6F0kUyzbVOPhvqYaHxg5wLQ3g/cti/LTVQPMFh5RwVphO763G5vAjlPpe6bpqr4FV6qboFRwmOZD/UzMcPt5aefLB5ppsvXb+fK4gc5USgWeXZQOrUqBCUmh+PLhG/DgrKEUMBGXGfhIWiKK8EANSupahAndnuIrjeCALWj65lxln5vBhVEDSWE+Uy4ZmxAKwLnyXPbFKgDAuASd1zfLd0c4TmUA5Tljm0XYgefL4wa6M21IBH58JgN+aprFRFyPwm+ZEmMHndliFcYc+FKmqa/N4L7UBM6Mjg8BxwFlhlZUNrT26XsOXvTNfiZmmH0H3YUB7KC7UN6INiuP0AA1BoX6RlbTGRQwEXehoEmmwu2zmmo9OOCSDdPkuPbz77xZx2bwZlPvDfc8z+OkvQl8og80gTOBWhWGRtmCgL4El1Yrj0OXbYer3jDMN4+yGGbPNFU1GKHv599fltlLj9f5TFaTEClwOmhKTU1FTU3XE6X1ej1SU1NdsihybWJkmoTBlgEan5h1EhPih2j7ZPCz15gMXlDTjNomEzQqhc8dnMqCyx+Lrx005ZXVo7bJhECNEuO9fPhnT4K0KiE71N9sExtq6evzmQjxNKeDpoKCgm6HWBqNRly9etUliyLXxiZyezRo8pEZTR31tRn8eEEtAFufjq+da8VmWrFMW29YaW5qagTUPtycy4Zc9vc4lTN0fAohouhzI/hnn30m/P/du3dDp2v/DcdiseDrr79GcnKySxdHeiaU5zwYNFX70M45Jn2QDl/3oRmcBQwTfKifibnRPmog+1I1rlQ1ItVerutO9iVbE7gvjhroaHhMMPafr+r1gNmemC1WnLXvvEunnXOEeFSfg6bFixcDsJ3Ldffddzvcp1arkZycjE2bNrl0caRnYowcqG20D7b04nPnOmOZpmMFtbBY+R7LkqwJfNIA5u7I1ZCoINw8Ihpfn6vEtux8PPfzMd1e12q24Jj9dbrRx4OmYQM4g+5iRSNMbVYEa1VICvedaeqESEGf8+NWqxVWqxVJSUmorKwU/my1WmE0GnH+/HksWLDA5QtsaGjAqlWrMHjwYPj7+2P69OkOBwPzPI/169cjPj4e/v7+mDVrFs6cOePwGEajEQ899BAiIyMRGBiIRYsWoaSkxOGauro6ZGZmQqfTQafTITMzE3q93uU/j6sIR6mI0dPkQ5mmyanhCPFToai2Gf93vLjbay5VNuKi/QywCT7ap7PiJls/40cnSlBjD647O1ZQC1ObFbEhfhjSSzbKFwzkDDrWzzR6UAgUPtBbSIiUON1UkJ+fj8hIx98S3Rlc3Hfffdi7dy/eeecd/PTTT8jIyMCcOXOE/qkXX3wRL7/8MrZu3Ypjx44hNjYWc+fORUND+29wq1atws6dO7Fjxw5kZ2ejsbERCxYscOjNWrZsGXJycpCVlYWsrCzk5OQgMzPTbT/XQInRCN4+2NK7p4F3FOKnxsNzhgMAXtp9HvWtjueFWa081n1yGgDwsxHRXj8pvSdTUsIxNkEHY5sV238o6vaajlPAfX3H11D7gMuaJhOqewgye3Kmw845QohnOR00vfDCC/jggw+EP99xxx0IDw/HoEGD8OOPP7p0cS0tLfj444/x4osv4qabbsLQoUOxfv16pKSk4O9//zt4nscrr7yCJ598EkuWLEF6ejrefvttNDc347333gMAGAwGbNu2DZs2bcKcOXMwfvx4bN++HT/99BP27dsHADh79iyysrLwz3/+E9OmTcO0adPwxhtvYNeuXTh//rxLfyZXYUFTo7ENxra+n402ECxAi/Sh8hwA3DVtMFKjAlHTZMLWby453PfukUIcK6hDgEaJP90+WqQVio/jOKy40ZZt+vfhArSau74nWRO4r5fmACBAo0JqlO3cvmP5tU59b26prb+Ods4R4nlOB02vv/46EhNtJ0Xv3bsX+/btQ1ZWFubPn4/HHnvMpYtra2uDxWKBn5+fw+3+/v7Izs5Gfn4+ysvLkZGRIdyn1Woxc+ZMHDp0CABw4sQJmM1mh2vi4+ORnp4uXHP48GHodDpMmTJFuGbq1KnQ6XTCNd0xGo2or693+PKUED+10F9T1zSw09L7qsYHd88BgFqpwFO3jQIAvPl9PvKrmwAApfoW/OWrcwCAtfPSkBDm2/0l89NjMSjUHzVNJnxy0nEn7bnyeuTZxzbM8NGhlp3dPCIaALAnr6LP32Ox8sgTgibaOUeIpzkdNJWVlQlB065du7B06VJkZGRg7dq1Dr1GrhAcHIxp06bhf/7nf1BaWgqLxYLt27fjyJEjKCsrQ3l5OQAgJibG4ftiYmKE+8rLy6HRaBAWFtbrNdHR0V2ePzo6WrimOxs2bBB6oHQ6nfC6eIJCwSHMwzvoappsZQRfC5oAYPaIaMwcHgWzhcdzX5wFz/P446e5aDJZMCEpFJnTksVeouhUSgXuuSEFAPDPg1dgtfIAgG/PV+KOvx8GYCvjRfpoCbOzuaNiAQBfn62A2WLt0/dcqmxEi9mCAI0SKZG+3RdGiBicDprCwsJQXGxriM3KysKcOXMA2Bqyu5vfNFDvvPMOeJ7HoEGDoNVq8eqrr2LZsmVQKttn4XTuj+B5/po9E52v6e76az3OunXrYDAYhC/2unhKeKDt3C5PBU3t58755ofeUwtGQqngsO9sBZ78NBffnKuERqnAC78Y6xPDPvvizusTEeynwpXqJnx9rhL/ys7HPW8dQ4OxDZOTw/H3/zdR7CVKxsTBYQgP1KC+ta3PJbqvcssAAJOSw+k9R4gInA6alixZgmXLlmHu3LmoqanB/PnzAQA5OTkYOnSoyxc4ZMgQHDhwAI2NjSguLsbRo0dhNpuRkpKC2Fjbb2qds0GVlZVC9ik2NhYmkwl1dXW9XlNR0TVFXlVV1SWL1ZFWq0VISIjDlye1jx1wrpG0PyxWHvoW3zl3rjtDo4OROXUwAOC9I7Zm59/NHipsHye2adf/NcX2Gj36fzn40648WHlg6aQEbL9vis++d7qjVHBOleh4nsfOU7ay58/Hx7t1bYSQ7jkdNG3evBm///3vMWrUKOzduxdBQbYUcVlZGR588EGXL5AJDAxEXFwc6urqsHv3btx+++1C4LR3717hOpPJhAMHDmD69OkAgIkTJ0KtVjtcU1ZWhtzcXOGaadOmwWAw4OjRo8I1R44cgcFgEK6RIk+OHahrNoHnbefOhQX43sn0zKo5wxBq//nTYoLx37OGiLwi6Vk+PRlqJYeG1jZwHPDH20bihV+MhUbluxPAe5Ix2vaL3968CvA83+u1p4r1KKxphr9aiQx7aY8Q4ll9Hm7JqNVqrFmzpsvtq1atcsV6uti9ezd4nkdaWhouXbqExx57DGlpafjNb34DjuOwatUqPP/88xg2bBiGDRuG559/HgEBAVi2bBkAQKfT4d5778Xq1asRERGB8PBwrFmzBmPGjBFKiyNHjsQtt9yCFStW4PXXXwcA3H///ViwYAHS0tLc8nO5gifHDrAm8FB/NVQ+fPxFaIAGf1kyFq9/dxl/XpxOgUA3YnV+ePjmYfjwRAmeXjAKN4/sOVvr624cFgl/tRJX9S04U1rf6464nfbm+lvSYxGodfqfbkKIC/T7b15eXh6KiopgMjl+YC9atGjAi+rIYDBg3bp1KCkpQXh4OH7xi1/gueeeg1pt+21/7dq1aGlpwYMPPoi6ujpMmTIFe/bsQXBwe8lk8+bNUKlUWLp0KVpaWnDzzTfjrbfecuiLevfdd7Fy5Uphl92iRYuwdetWl/4sriYcpdLPk9Kd4ctN4J3dkh6LW9LpN/3e/P5nw/D7nw0TexmS56dW4sZhkdiTV4G9eRU9Bk2mNit2nS4FACweP8iTSySEdMDx18oJd3LlyhX8/Oc/x08//QSO44SUMmuYdkczuFzU19dDp9PBYDB4pL/pre/zsf7zPNw6JhZ/+y/3NtjuOl2K3793CpOTw/F/v53m1ucixJd8dKIEaz78ESPjQvDVwzd2e83evAqs+PdxRAVrcfiJn/l0tpcQd+jr57fTf/MefvhhpKSkoKKiAgEBAThz5gy+++47TJo0Cd9+++1A1kycFG7fuu2J8pwvHqFCiCf8bEQ0FBxwtqwexbXN3V6z85Tt2KdF4+IpYCJERE7/7Tt8+DD+9Kc/ISoqCgqFAgqFAjfccAM2bNiAlStXumONpAfhHpzTxHqafOmwXkI8ITxQg+uTbQc97+1mF52hxYx9ZysBAD+n0hwhonI6aLJYLMKOucjISJSW2ursgwcPluyRI97Ko43g9p6mCMo0EeJyc0fZmuX35HUdpvvVT2UwtVkxPCYIo+NpCjghYnI6aEpPT8fp07YDSqdMmYIXX3wR33//Pf70pz8hNTXV5QskPRNGDjSbhenL7kLlOULch40QOFZQ12WECJvNtHj8IJ8/6JgQsTkdNP3xj3+E1Wob+f/nP/8ZhYWFuPHGG/Hll1/i1VdfdfkCSc/C7BPBLVYe9a3uPX9OOHeOjsAgxOWSIgIwIjYYFivvUKIrqWvGEfu08MXXUWmOELE5PXJg3rx5wv9PTU1FXl4eamtrERYWRr8FeZhWpUSQVoVGYxtqm0wIDXBfFqj9CBXKNBHiDhmjYnCuvAFrPz6Nv2SdQ2pkIKz23clTU8MRH+ov8goJIf3ehnHp0iXs3r0bLS0tCA8Pd+WaiBM81dckBE3UCE6IW9wxKRGpkYEAbH/fjhfW4WSRHgCwZHyCiCsjhDBOZ5pqamqwdOlS7N+/HxzH4eLFi0hNTcV9992H0NBQbNq0yR3rJD0ID9SgqLbZrUGTxcoLAzSpp4kQ90gMD8A3a2ahydiG/Oom4Uup4LBkApXmCJECpzNNjzzyCNRqNYqKihAQECDcfueddyIrK8uliyPX5olMk95+7hwAhLmxBEgIAQK1KqQP0mHhuHisvHkYfjd7KM1mIkQinM407dmzB7t370ZCgmO6eNiwYSgsLHTZwkjfCEGTG49SYQGZzl8NNf3jTQghxEc5/QnY1NTkkGFiqqurodXSzipPE4KmRvcFTTXUBE4IIYQ4HzTddNNN+Pe//y38meM4WK1WbNy4EbNnz3bp4si1eaI8R03ghBBCSD/Kcxs3bsSsWbNw/PhxmEwmrF27FmfOnEFtbS2+//57d6yR9EI4SsWN5bmaRts0cGoCJ4QQ4suczjSNGjUKp0+fxuTJkzF37lw0NTVhyZIlOHXqFIYMGeKONZJeeCLTVCNMA6fyKyGEEN/ldKYJAGJjY/Hss8863FZcXIx77rkH//rXv1yyMNI34UEeLM9RpokQQogPc9lWqNraWrz99tuuejjSR0J5ziOZJgqaCCGE+C7aPy5zLNPUbLKg1Wxxy3OwnXnUCE4IIcSXUdAkc8FaFdRK25l/7so21TTZGsEjqKeJEEKID6OgSeY4jhOmdLsraKql8hwhhBDS90bwJUuW9Hq/Xq8f6FpIP4UHalDZYHRL0NRmsQqPG0nlOUIIIT6sz0GTTqe75v133XXXgBdEnOfOsQM1TSZYeUCp4BARROU5QgghvqvPQdObb77pznWQAXBn0FRuaAUARAVpoVRwLn98QgghRC6op8kLuDNoqqi3BU0xOj+XPzYhhBAiJxQ0eQEhaHLDUSpC0BRMpTlCCCG+jYImLyAETY3uCJps4wZiQijTRAghxLdR0OQFPFGei6XyHCGEEB9HQZMXEI5ScUN5rtweNEVTeY4QQoiPo6DJC7jz0N5Ke3mOMk2EEEJ8HQVNXoCV5/TNJlisvEsfm2WaqKeJEEKIr6OgyQuwY1SsPGBoMbvscVvNFuHxYoIpaCKEEOLbKGjyAmqlAiF+tjmlrizRsdKcn1qBEP8+z0ElhBBCvBIFTV7CHTvoOpbmOI6mgRNCCPFtFDR5ifagyeiyx6ygfiZCCCFEQEGTl4i29xxVNlDQRAghhLgDBU1ego0EKNW3uuwx6QgVQgghpB0FTV4izh40lRtaXPaYFTSjiRBCCBFIOmhqa2vDH//4R6SkpMDf3x+pqan405/+BKvVKlzD8zzWr1+P+Ph4+Pv7Y9asWThz5ozD4xiNRjz00EOIjIxEYGAgFi1ahJKSEodr6urqkJmZCZ1OB51Oh8zMTOj1ek/8mC7BApsyg+syTcI0cCrPEUIIIdIOml544QW89tpr2Lp1K86ePYsXX3wRGzduxJYtW4RrXnzxRbz88svYunUrjh07htjYWMydOxcNDQ3CNatWrcLOnTuxY8cOZGdno7GxEQsWLIDFYhGuWbZsGXJycpCVlYWsrCzk5OQgMzPToz/vQMSH+gNoD3RcoZLKc4QQQohA0sN3Dh8+jNtvvx233XYbACA5ORnvv/8+jh8/DsCWZXrllVfw5JNPYsmSJQCAt99+GzExMXjvvffwwAMPwGAwYNu2bXjnnXcwZ84cAMD27duRmJiIffv2Yd68eTh79iyysrLwww8/YMqUKQCAN954A9OmTcP58+eRlpYmwk/vnNiQ9kwTz/MDHhHA87wQgFF5jhBCCJF4pumGG27A119/jQsXLgAAfvzxR2RnZ+PWW28FAOTn56O8vBwZGRnC92i1WsycOROHDh0CAJw4cQJms9nhmvj4eKSnpwvXHD58GDqdTgiYAGDq1KnQ6XTCNVJnm6UEmNqsLpnVVN/ahlazVXhsQgghxNdJOtP0+OOPw2AwYMSIEVAqlbBYLHjuuefw61//GgBQXl4OAIiJiXH4vpiYGBQWFgrXaDQahIWFdbmGfX95eTmio6O7PH90dLRwTXeMRiOMxvYt/vX19f34KV1Do1IgMkiLqgYjygytiAgaWEmNleZ0/mr4qZWuWCIhhBAia5LONH3wwQfYvn073nvvPZw8eRJvv/02XnrpJbz99tsO13UuRfWlPNX5mu6uv9bjbNiwQWgc1+l0SExM7MuP5TZxLmwGb58GTv1MhBBCCCDxoOmxxx7DE088gV/96lcYM2YMMjMz8cgjj2DDhg0AgNjYWADokg2qrKwUsk+xsbEwmUyoq6vr9ZqKioouz19VVdUli9XRunXrYDAYhK/i4uL+/7AuwPqaXDF2gI0boNIcIYQQYiPpoKm5uRkKheMSlUqlMHIgJSUFsbGx2Lt3r3C/yWTCgQMHMH36dADAxIkToVarHa4pKytDbm6ucM20adNgMBhw9OhR4ZojR47AYDAI13RHq9UiJCTE4UtMbAedKzJNNA2cEEIIcSTpnqaFCxfiueeeQ1JSEkaPHo1Tp07h5Zdfxj333APAVlJbtWoVnn/+eQwbNgzDhg3D888/j4CAACxbtgwAoNPpcO+992L16tWIiIhAeHg41qxZgzFjxgi76UaOHIlbbrkFK1aswOuvvw4AuP/++7FgwQJZ7JxjXDmrqYLKc4QQQogDSQdNW7ZswVNPPYUHH3wQlZWViI+PxwMPPICnn35auGbt2rVoaWnBgw8+iLq6OkyZMgV79uxBcHCwcM3mzZuhUqmwdOlStLS04Oabb8Zbb70FpbK9wfndd9/FypUrhV12ixYtwtatWz33w7pAe0+TK8pz9nEDlGkihBBCAAAcz/O82IvwFvX19dDpdDAYDKKU6o5cqcGd//gByREB+Pax2QN6rNv/+j1+LNbj9cyJmDc61kUrJIQQQqSnr5/fku5pIs7p2NM00Fi4knqaCCGEEAcUNHmRaHv/kbHNirpmc78fx2LlUdlgP6yXgiZCCCEEAAVNXkWrUiIySANgYH1NNU1GWKw8FByExyOEEEJ8HQVNXiZOZz+4dwA76CrtM5oig7RQKektQgghhAAUNHkdNnagdABBEwu4qJ+JEEIIaUdBk5dhYwcGMhW8ooFmNBFCCCGdUdDkZVh5biADLiso00QIIYR0QUGTl2nPNA0gaKJz5wghhJAuKGjyMq44SoWV52jcACGEENKOgiYv0/Eolf4OuGRZqmjqaSKEEEIEFDR5GVZSazVbYWjp34BLNtiSynOEEEJIOwqavIyfWomIQNtAylK98yU6Y5sFtU0mAFSeI4QQQjqioMkLsb6m8nrnxw6wwZYalQKhAWqXrosQQgiRMwqavNBAxg5U1LfPaOI4zqXrIoQQQuSMgiYvJDSD96M8J4wbCKbSHCGEENIRBU1eaCBjB9ozTRQ0EUIIIR1R0OSF4kP739NUUmf7HhZ4EUIIIcSGgiYvFBvS/56mi5UNAIDhMUEuXRMhhBAidxQ0eaGOPU3ODrg8X86CpmCXr4sQQgiRMwqavBArrbWYLahvaevz99U1mYTBlsMoaCKEEEIcUNDkhfzUSoTbB1yWOdHXdKHClmVKCPNHkFbllrURQgghckVBk5di07ydGTvAgqY0yjIRQgghXVDQ5KXi+jF24Lw9aBoeS0ETIYQQ0hkFTV4qjo0dMDhRnitvBECZJkIIIaQ7FDR5KWePUuF5vj3TREETIYQQ0gUFTV5K6GnqY9BU2WCEocUMpYJDalSgO5dGCCGEyBIFTV6KledK+1ieY/OZkiMC4KdWum1dhBBCiFxR0OSlkiNs2aKimma0mCzXvF7YOUdN4IQQQki3KGjyUnE6P8SG+KHNyiOnWH/N62kSOCGEENI7Cpq8FMdxmJgcBgA4WVR3zetpRhMhhBDSOwqavNjEJFvQdLygttfrrFYeFyps4wZoRhMhhBDSPQqavNgke6bpRGEdrNaeD+4tqWtBi9kCjUqBweEBnloeIYQQIisUNHmxkXEh8FcrUd/ahktVjT1ex+YzDY0KgkpJbwlCCCGkO/QJ6cXUSgWuSwwFABwv6LmviXbOEUIIIddGQZOXYyW644U99zXRzjlCCCHk2iho8nITB7f3NfWkPdMU5JE1EUIIIXJEQZOXmzA4DBwHFNY0o6rB2OV+s8WKy/Z+J8o0EUIIIT2TfNCUnJwMjuO6fP3ud78DYDtodv369YiPj4e/vz9mzZqFM2fOODyG0WjEQw89hMjISAQGBmLRokUoKSlxuKaurg6ZmZnQ6XTQ6XTIzMyEXq/31I/pNiF+amH20oluSnQF1U0wW3gEaVUYFOrv6eURQgghsiH5oOnYsWMoKysTvvbu3QsAuOOOOwAAL774Il5++WVs3boVx44dQ2xsLObOnYuGhgbhMVatWoWdO3dix44dyM7ORmNjIxYsWACLpf14kWXLliEnJwdZWVnIyspCTk4OMjMzPfvDusmEwWxeU9cSHds5NzwmCBzHeXRdhBBCiJxIPmiKiopCbGys8LVr1y4MGTIEM2fOBM/zeOWVV/Dkk09iyZIlSE9Px9tvv43m5ma89957AACDwYBt27Zh06ZNmDNnDsaPH4/t27fjp59+wr59+wAAZ8+eRVZWFv75z39i2rRpmDZtGt544w3s2rUL58+fF/PHd4lJLGjqpq/pQjntnCOEEEL6QvJBU0cmkwnbt2/HPffcA47jkJ+fj/LycmRkZAjXaLVazJw5E4cOHQIAnDhxAmaz2eGa+Ph4pKenC9ccPnwYOp0OU6ZMEa6ZOnUqdDqdcE13jEYj6uvrHb6kaNLgcADAmVIDWs2Oh/e2Z5ooaCKEEEJ6I6ug6dNPP4Ver8fy5csBAOXl5QCAmJgYh+tiYmKE+8rLy6HRaBAWFtbrNdHR0V2eLzo6WrimOxs2bBB6oHQ6HRITE/v9s7lTYrg/ooK1MFt4nC4xONzHjk+hM+cIIYSQ3skqaNq2bRvmz5+P+Ph4h9s79+LwPH/N/pzO13R3/bUeZ926dTAYDMJXcXFxX34Mj+M4rkOJrr0Z/NDlahTUNAGgM+cIIYSQa5FN0FRYWIh9+/bhvvvuE26LjY0FgC7ZoMrKSiH7FBsbC5PJhLq6ul6vqaio6PKcVVVVXbJYHWm1WoSEhDh8SZUwr8neDP75j6VY/q9j4HlgdloUIoO0Yi6PEEIIkTzZBE1vvvkmoqOjcdtttwm3paSkIDY2VthRB9j6ng4cOIDp06cDACZOnAi1Wu1wTVlZGXJzc4Vrpk2bBoPBgKNHjwrXHDlyBAaDQbhG7iYl2/qaThTV4Z8Hr+Ch90/BZLHi1jGx+Pv/myjy6gghhBDpU4m9gL6wWq148803cffdd0Olal8yx3FYtWoVnn/+eQwbNgzDhg3D888/j4CAACxbtgwAoNPpcO+992L16tWIiIhAeHg41qxZgzFjxmDOnDkAgJEjR+KWW27BihUr8PrrrwMA7r//fixYsABpaWme/4HdYHR8CPzUCuibzfjzF2cBAMunJ+OpBaOgVNCoAUIIIeRaZBE07du3D0VFRbjnnnu63Ld27Vq0tLTgwQcfRF1dHaZMmYI9e/YgOLi9R2fz5s1QqVRYunQpWlpacPPNN+Ott96CUqkUrnn33XexcuVKYZfdokWLsHXrVvf/cB6iViowNiEUR/NtPU3r5o/A/Tel0mwmQgghpI84nud5sRfhLerr66HT6WAwGCTZ3/SfnKvYuPs81mSkYfH4QWIvhxBCCJGEvn5+yyLTRFzj9usG4fbrKFgihBBC+kM2jeCEEEIIIWKioIkQQgghpA8oaCKEEEII6QMKmgghhBBC+oCCJkIIIYSQPqCgiRBCCCGkDyhoIoQQQgjpAwqaCCGEEEL6gIImQgghhJA+oKCJEEIIIaQPKGgihBBCCOkDCpoIIYQQQvqAgiZCCCGEkD6goIkQQgghpA9UYi/Am/A8DwCor68XeSWEEEII6Sv2uc0+x3tCQZMLNTQ0AAASExNFXgkhhBBCnNXQ0ACdTtfj/Rx/rbCK9JnVakVpaSmCg4PBcZzLHre+vh6JiYkoLi5GSEiIyx6XOKLX2XPotfYMep09g15nz3Dn68zzPBoaGhAfHw+FoufOJco0uZBCoUBCQoLbHj8kJIT+QnoAvc6eQ6+1Z9Dr7Bn0OnuGu17n3jJMDDWCE0IIIYT0AQVNhBBCCCF9QEGTDGi1WjzzzDPQarViL8Wr0evsOfRaewa9zp5Br7NnSOF1pkZwQgghhJA+oEwTIYQQQkgfUNBECCGEENIHFDQRQgghhPQBBU2EEEIIIX1AQZNE/O1vf0NKSgr8/PwwceJEHDx4sNfrDxw4gIkTJ8LPzw+pqal47bXXPLRSeXPmdf7kk08wd+5cREVFISQkBNOmTcPu3bs9uFr5cvb9zHz//fdQqVS47rrr3LtAL+Lsa200GvHkk09i8ODB0Gq1GDJkCP71r395aLXy5ezr/O6772LcuHEICAhAXFwcfvOb36CmpsZDq5Wn7777DgsXLkR8fDw4jsOnn356ze/x+GchT0S3Y8cOXq1W82+88Qafl5fHP/zww3xgYCBfWFjY7fVXrlzhAwIC+IcffpjPy8vj33jjDV6tVvMfffSRh1cuL86+zg8//DD/wgsv8EePHuUvXLjAr1u3jler1fzJkyc9vHJ5cfZ1ZvR6PZ+amspnZGTw48aN88xiZa4/r/WiRYv4KVOm8Hv37uXz8/P5I0eO8N9//70HVy0/zr7OBw8e5BUKBf+///u//JUrV/iDBw/yo0eP5hcvXuzhlcvLl19+yT/55JP8xx9/zAPgd+7c2ev1YnwWUtAkAZMnT+Z/+9vfOtw2YsQI/oknnuj2+rVr1/IjRoxwuO2BBx7gp06d6rY1egNnX+fujBo1in/22WddvTSv0t/X+c477+T/+Mc/8s888wwFTX3k7Gv91Vdf8Tqdjq+pqfHE8ryGs6/zxo0b+dTUVIfbXn31VT4hIcFta/Q2fQmaxPgspPKcyEwmE06cOIGMjAyH2zMyMnDo0KFuv+fw4cNdrp83bx6OHz8Os9nstrXKWX9e586sVisaGhoQHh7ujiV6hf6+zm+++SYuX76MZ555xt1L9Br9ea0/++wzTJo0CS+++CIGDRqE4cOHY82aNWhpafHEkmWpP6/z9OnTUVJSgi+//BI8z6OiogIfffQRbrvtNk8s2WeI8VlIB/aKrLq6GhaLBTExMQ63x8TEoLy8vNvvKS8v7/b6trY2VFdXIy4uzm3rlav+vM6dbdq0CU1NTVi6dKk7lugV+vM6X7x4EU888QQOHjwIlYr+Seqr/rzWV65cQXZ2Nvz8/LBz505UV1fjwQcfRG1tLfU19aA/r/P06dPx7rvv4s4770Rrayva2tqwaNEibNmyxRNL9hlifBZSpkkiOI5z+DPP811uu9b13d1OHDn7OjPvv/8+1q9fjw8++ADR0dHuWp7X6OvrbLFYsGzZMjz77LMYPny4p5bnVZx5T1utVnAch3fffReTJ0/GrbfeipdffhlvvfUWZZuuwZnXOS8vDytXrsTTTz+NEydOICsrC/n5+fjtb3/riaX6FE9/FtKvdSKLjIyEUqns8htLZWVllwiaiY2N7fZ6lUqFiIgIt61VzvrzOjMffPAB7r33Xnz44YeYM2eOO5cpe86+zg0NDTh+/DhOnTqF3//+9wBsH+w8z0OlUmHPnj342c9+5pG1y01/3tNxcXEYNGgQdDqdcNvIkSPB8zxKSkowbNgwt65ZjvrzOm/YsAEzZszAY489BgAYO3YsAgMDceONN+LPf/4zVQNcRIzPQso0iUyj0WDixInYu3evw+179+7F9OnTu/2eadOmdbl+z549mDRpEtRqtdvWKmf9eZ0BW4Zp+fLleO+996gfoQ+cfZ1DQkLw008/IScnR/j67W9/i7S0NOTk5GDKlCmeWrrs9Oc9PWPGDJSWlqKxsVG47cKFC1AoFEhISHDreuWqP69zc3MzFArHj1elUgmgPRNCBk6Uz0K3tZiTPmPbWbdt28bn5eXxq1at4gMDA/mCggKe53n+iSee4DMzM4Xr2TbLRx55hM/Ly+O3bdtGIwf6wNnX+b333uNVKhX/17/+lS8rKxO+9Hq9WD+CLDj7OndGu+f6ztnXuqGhgU9ISOB/+ctf8mfOnOEPHDjADxs2jL/vvvvE+hFkwdnX+c033+RVKhX/t7/9jb98+TKfnZ3NT5o0iZ88ebJYP4IsNDQ08KdOneJPnTrFA+Bffvll/tSpU8JoByl8FlLQJBF//etf+cGDB/MajYafMGECf+DAAeG+u+++m585c6bD9d9++y0/fvx4XqPR8MnJyfzf//53D69Ynpx5nWfOnMkD6PJ19913e37hMuPs+7kjCpqc4+xrffbsWX7OnDm8v78/n5CQwD/66KN8c3Ozh1ctP86+zq+++io/atQo3t/fn4+Li+P/67/+iy8pKfHwquVl//79vf6bK4XPQo7nKVdICCGEEHIt1NNECCGEENIHFDQRQgghhPQBBU2EEEIIIX1AQRMhhBBCSB9Q0EQIIYQQ0gcUNBFCCCGE9AEFTYQQQv5/e3eIskoUh3H4H26xWATrYDQMBpegCEaDwW3MMgTB7hYEu2BREKa4BpuCQVCM4rcDv3PLzIX7PCt4449zZjhAAtEEAJBANAEAJBBNAAAJRBPAL9brdeR5Ho1GI1qtVgyHw3i9XnXPAir2p+4BAP+yy+USs9ks5vN5TCaTeD6fcTgcwrOd8P/xYC/AF6fTKfr9fpzP58iyrO45QI1czwF80ev1YjAYRJ7nMZ1OY7Vaxf1+r3sWUAMnTQC/+Hw+cTweY7vdxmaziev1GmVZRqfTqXsaUCHRBPAX3u93ZFkWRVFEURR1zwEq5ENwgC/Ksozdbhej0Sja7XaUZRm32y263W7d04CKiSaAL5rNZuz3+1gul/F4PCLLslgsFjEej+ueBlTM9RwAQAJ/zwEAJBBNAAAJRBMAQALRBACQQDQBACQQTQAACUQTAEAC0QQAkEA0AQAkEE0AAAlEEwBAAtEEAJDgB2TMW5COFHomAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the results\n", + "plt.figure()\n", + "plt.plot(s_space, off_diagonal_norm_diff[0,:],label= 'No normalization')\n", + "plt.plot(s_space, off_diagonal_norm_diff[1,:],label= 'Normalization')\n", + "plt.plot(s_space, off_diagonal_norm_diff[2,:],label= 'Gradient Ascent')\n", + "plt.xlabel('s')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-||\\sigma(H_k)||$')\n", + "plt.legend()\n", + "\n", + "plt.figure()\n", + "plt.title('D not normalized')\n", + "plt.plot(s_space, potential[0,:],label= 'No normalization')\n", + "plt.xlabel('s')\n", + "plt.ylabel('Least squares cost function')\n", + "\n", + "plt.figure()\n", + "plt.title('D normalized')\n", + "plt.plot(s_space, potential[1,:],label= 'Normalization')\n", + "plt.xlabel('s')\n", + "plt.ylabel('Least squares cost function')\n", + "\n", + "plt.figure()\n", + "plt.title('D optimized')\n", + "plt.plot(s_space, potential[2,:],label= 'Gradient Ascent')\n", + "plt.xlabel('s')\n", + "plt.ylabel('Least squares cost function')" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [], + "source": [ + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "dbi_eval = deepcopy(dbi)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "flows = 50\n", + "off_diagonal_norm = np.empty((flows+1,3))\n", + "off_diagonal_norm[0,:] = dbi_eval.off_diagonal_norm\n", + "for i in range(flows):\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n", + " dbi_eval(step_poly,d=d)\n", + " off_diagonal_norm[i+1,0] = dbi_eval.off_diagonal_norm\n", + "\n", + "\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/2**nqubits\n", + "dbi_eval = deepcopy(dbi)\n", + "for i in range(flows):\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n", + " dbi_eval(step_poly,d=d)\n", + " off_diagonal_norm[i+1,1] = dbi_eval.off_diagonal_norm\n", + "\n", + "dbi_eval = deepcopy(dbi)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "step = 1e-2\n", + "iterations = 200\n", + "d, loss, grad, diags = gradient_ascent(dbi_eval, d,step, iterations)\n", + "for i in range(flows):\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n", + " dbi_eval(step_poly,d=d)\n", + " off_diagonal_norm[i+1,2] = dbi_eval.off_diagonal_norm\n" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(off_diagonal_norm[:,0],label= 'No normalization')\n", + "plt.plot(off_diagonal_norm[:,1],label= 'Normalization')\n", + "plt.plot(off_diagonal_norm[:,2],label= 'Gradient Ascent')\n", + "plt.xlabel('Flows Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hyperopt does it get stuck" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-21 15:05:50]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 7\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "dbi_eval = deepcopy(dbi)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "flows = 50\n", + "off_diagonal_norm = np.empty(flows+1)\n", + "off_diagonal_norm[0] = dbi_eval.off_diagonal_norm\n", + "for i in range(flows):\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d)\n", + " dbi_eval(step_poly,d=d)\n", + " off_diagonal_norm[i+1] = dbi_eval.off_diagonal_norm\n" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(off_diagonal_norm[:],label= 'Hyperopt')\n", + "plt.xlabel('Flows Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Difference between numerical gradients and analytic ones\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-21 14:20:15]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 7\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "nqubits = [3,4,5,6,7]\n", + "iterations = 100\n", + "step = 1e-2\n", + "differences = np.empty((len(nqubits),iterations+1))\n", + "loss_max = np.empty(len(nqubits))\n", + "for q in range(len(nqubits)):\n", + " # define the hamiltonian\n", + " H_TFIM = hamiltonians.TFIM(nqubits=nqubits[q], h=h)\n", + "\n", + " # define the least-squares cost function\n", + " cost = DoubleBracketCostFunction.least_squares\n", + " # initialize class\n", + " dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + " loss_max [q] = dbi.least_squares(D=np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q])))\n", + " d = np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q]))\n", + " d_analytic, loss_analytic, grad_analytic, diags_analytic = gradient_ascent(dbi, d,step, iterations)\n", + " d = np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q]))\n", + " d_numerical, loss_numerical, grad_numerical, diags_numerical = gradient_ascent(dbi, d,step, iterations, analytic=False)\n", + " differences[q,:] = loss_analytic - loss_numerical\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "for q in range(len(nqubits)):\n", + " plt.plot(differences[q,:],label= 'nqubits = {}'.format(nqubits[q]))\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel('Difference in analytic and numerical loss function')\n", + "plt.legend()\n", + "\n", + "plt.figure()\n", + "plt.title('Normalized difference')\n", + "for q in range(len(nqubits)):\n", + " plt.plot(differences[q,:]/loss_max[q],label= 'nqubits = {}'.format(nqubits[q]))\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel('Difference in analytic and numerical loss function')\n", + "plt.legend()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Difference in optimization moments\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-21 14:44:56]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 7\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "dbi_eval = deepcopy(dbi)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "step = 1e-2\n", + "iterations = 100\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "flows = 100\n", + "dbi_eval = deepcopy(dbi)\n", + "dbi_eval2 = deepcopy(dbi)\n", + "d_not_optimized = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "step = 1e-2\n", + "iterations = 100\n", + "d_optimized, loss, grad, diags = gradient_ascent(dbi_eval, d,step, iterations,analytic=False)\n", + "off_diagonal_norm = np.empty((flows+1,3))\n", + "off_diagonal_norm[0] = dbi_eval.off_diagonal_norm\n", + "for i in range(flows):\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n", + " dbi_eval(step_poly,d=d)\n", + " step_poly = dbi_eval2.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_not_optimized)\n", + " dbi_eval2(step_poly,d=d_not_optimized)\n", + " off_diagonal_norm[i+1,0] = dbi_eval.off_diagonal_norm\n", + " off_diagonal_norm[i+1,1] = dbi_eval2.off_diagonal_norm\n", + "\n", + "dbi_eval3 = deepcopy(dbi)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "for i in range(flows):\n", + " d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + " d_opt, loss, grad, diags = gradient_ascent(dbi_eval3, d,step, 20,analytic=False)\n", + " step_poly = dbi_eval3.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_opt)\n", + " dbi_eval3(step_poly,d=d_opt)\n", + " off_diagonal_norm[i+1,2] = dbi_eval3.off_diagonal_norm " + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACR+ElEQVR4nOzdd3hTdfvH8XeS7r1o091S2jLKBpGNAxAXioqK/hBF5HlwoSKoqIAICCoiQ8EFPO4BuGUKqOy9KauLDlq6Zzpyfn8cGqgtYbVN2t6v68pFe87JyZ0w+uE7NYqiKAghhBBCNBJaSxcghBBCCFGbJNwIIYQQolGRcCOEEEKIRkXCjRBCCCEaFQk3QgghhGhUJNwIIYQQolGRcCOEEEKIRsXG0gXUN6PRSEpKCq6urmg0GkuXI4QQQojLoCgK+fn5BAQEoNWab5tpcuEmJSWF4OBgS5chhBBCiKuQlJREUFCQ2WuaXLhxdXUF1A/Hzc3NwtUIIYQQ4nLk5eURHBxs+jluTpMLN5VdUW5ubhJuhBBCiAbmcoaUyIBiIYQQQjQqEm6EEEII0ahIuBFCCCFEo9LkxtwIIURdqKiooKyszNJlCNFg2draotPpauVeEm6EEOIaKIpCWloaOTk5li5FiAbPw8MDvV5/zevQSbgRQohrUBlsfH19cXJyksVBhbgKiqJQVFREeno6AP7+/td0Pwk3QghxlSoqKkzBxtvb29LlCNGgOTo6ApCeno6vr+81dVHJgGIhhLhKlWNsnJycLFyJEI1D5d+lax2/JuFGCCGukXRFCVE7auvvklWFm/z8fMaOHUtoaCiOjo706NGDHTt2mM4risLkyZMJCAjA0dGRfv36cejQIQtWLIQQQghrY1Xh5vHHH2fNmjV8/vnnHDhwgAEDBnDzzTeTnJwMwKxZs5g9ezbz589nx44d6PV6+vfvT35+voUrF0IIIYS1sJpwU1xczLJly5g1axZ9+vShRYsWTJ48mfDwcD788EMURWHOnDlMnDiRIUOGEBMTw9KlSykqKuKrr76ydPlCCCEuMHnyZDp06HBN94iPj0ej0bB3795aqakmS5YswcPDo87uf6ERI0Zw11131fnr1NV70mg0/Pjjj7V+37pgNeGmvLyciooKHBwcqhx3dHTkn3/+IS4ujrS0NAYMGGA6Z29vT9++fdm8efNF72swGMjLy6vyqAuZeZnsjf2HY/F76uT+QghRm5KSkhg5ciQBAQHY2dkRGhrKs88+S2Zm5hXfq6YfeuPGjWPdunXXVGNwcDCpqanExMRc033qWm0Eudp0//33c+zYsVq/b2pqKoMGDar1+9YFqwk3rq6udO/enalTp5KSkkJFRQVffPEF27ZtIzU1lbS0NAD8/PyqPM/Pz890riYzZszA3d3d9AgODq6T+t/74VH+b+t/eX/NC3VyfyGEqC2nTp2iS5cuHDt2jK+//poTJ06wcOFC1q1bR/fu3cnKyrrm13Bxcbnm6fE6nQ69Xo+NjaxaciUcHR3x9fWt9fvq9Xrs7e1r/b51wWrCDcDnn3+OoigEBgZib2/P3LlzGTZsWJW57v8eSa0oitnR1S+//DK5ubmmR1JSUp3UbmfnAUC5sahO7i+EsH6KolBUWm6Rh6Iol13nk08+iZ2dHatXr6Zv376EhIQwaNAg1q5dS3JyMhMnTjRdGxYWxtSpUxk2bBguLi4EBAQwb968KucB7r77bjQajen7f7dmVHbJTJ8+HT8/Pzw8PJgyZQrl5eW8+OKLeHl5ERQUxGeffWZ6zr+7pUaMGIFGo6n22LBhAwClpaWMHz+ewMBAnJ2d6datm+lcpSVLlhASEoKTkxN33333ZbVUTZgwgaioKJycnGjevDmvvfaaaarykiVLmDJlCvv27TPVs2TJErP3mzJlCr6+vri5uTF69GhKS0tN5xRFYdasWTRv3hxHR0fat2/PDz/8UOX5P//8M5GRkTg6OnLDDTewdOlSNBqNaZXsf3dLVf5efP7554SFheHu7s4DDzxQZbxqv379eOaZZxg/fjxeXl7o9XomT55c5XUvbKGr/L1Zvnw5N9xwA05OTrRv354tW7ZUec7HH39McHCw6fOePXt2vXQDWlUcjoiIYOPGjRQWFpKXl4e/vz/3338/4eHh6PV6QF0N9MKVC9PT06u15lzI3t6+XpKmvYM3FEK5UlLnryWEsE7FZRW0fn2VRV778BsDcbK79D/pWVlZrFq1imnTppkWTauk1+t56KGH+Pbbb/nggw9M/3F8++23eeWVV5g8eTKrVq3iueeeo2XLlvTv358dO3bg6+vL4sWLueWWW8wuvPbnn38SFBTEX3/9xaZNmxg5ciRbtmyhT58+bNu2jW+//Zb//Oc/9O/fv8ZW9vfff5+33nrL9P1bb73F119/TcuWLQF49NFHiY+P55tvviEgIIAVK1Zwyy23cODAASIjI9m2bRuPPfYY06dPZ8iQIaxcuZJJkyZd8jNzdXVlyZIlBAQEcODAAUaNGoWrqyvjx4/n/vvv5+DBg6xcuZK1a9cC4O7uftF7rVu3DgcHB9avX098fDyPPvooPj4+TJs2DYBXX32V5cuX8+GHHxIZGclff/3Fww8/TLNmzejbty/x8fHce++9PPvsszz++OPs2bOHcePGXfI9nDx5kh9//JFff/2V7Oxshg4dyltvvWV6XYClS5fy/PPPs23bNrZs2cKIESPo2bMn/fv3v+h9J06cyDvvvENkZCQTJ07kwQcf5MSJE9jY2LBp0yb+85//MHPmTO68807Wrl3La6+9dslaa4NVtdxUcnZ2xt/fn+zsbFatWsXgwYNNAWfNmjWm60pLS9m4cSM9evSwYLUqR6dmAJRTeokrhRDCco4fP46iKLRq1arG861atSI7O5uMjAzTsZ49e/LSSy8RFRXF008/zb333st7770HQLNm6r99lXsCVX5fEy8vL+bOnUt0dDSPPfYY0dHRFBUV8corrxAZGcnLL7+MnZ0dmzZtqvH57u7u6PV69Ho9mzdvZuHChSxbtgy9Xs/Jkyf5+uuv+f777+nduzcRERGMGzeOXr16sXjxYkANRwMHDjS9l2eeeYaBAwde8jN79dVX6dGjB2FhYdxxxx288MILfPfdd4DaBeTi4oKNjY2ptn+HxgvZ2dnx2Wef0aZNG2677TbeeOMN5s6di9FopLCwkNmzZ/PZZ58xcOBAmjdvzogRI3j44YdZtGgRAAsXLiQ6Opq3336b6OhoHnjgAUaMGHHJ92A0GlmyZAkxMTH07t2b//u//6s2Jqpdu3ZMmjSJyMhIhg8fTpcuXS45bmrcuHHcdtttREVFMWXKFBISEjhx4gQA8+bNY9CgQYwbN46oqCjGjBlTb2N2rKrlZtWqVSiKQnR0NCdOnODFF18kOjqaRx99FI1Gw9ixY5k+fTqRkZFERkYyffp0nJycGDZsmKVLx8XVHzKgVFMBigKyqJcQTY6jrY7Db1z6h2VdvXZtqOzeurC7v3v37lWu6d69O3PmzLnie7dp0wat9vz/qf38/KoMFtbpdHh7e5v2F7qYPXv2MHz4cBYsWECvXr0A2L17N4qiEBUVVeVag8FgGvtz5MgR7r777mrvZeXKlWZf74cffmDOnDmcOHGCgoICysvLcXNzu/QbrkH79u2rrGjdvXt3CgoKSEpKIj09nZKSkmotJaWlpXTs2BGA2NhYunbtWuX8ddddd8nXDQsLw9XV1fS9v79/tc+5Xbt2Vb6v6Zp/u/A5lb0q6enptGzZktjY2Gqf93XXXcevv/56yXqvlVWFm9zcXF5++WVOnz6Nl5cX99xzD9OmTcPW1haA8ePHU1xczJgxY8jOzqZbt26sXr26ym+Ypbi5BwJQogWKs8HJy7IFCSHqnUajuayuIUtq0aIFGo2Gw4cP1zgt+ejRo3h6euLj42P2Plezkmzlv+UX3qOmY0aj8aL3SEtL484772TkyJGMHDnSdNxoNKLT6di1a1e1rjEXFxeAKxqXVGnr1q088MADTJkyhYEDB+Lu7s4333zDu+++e8X3MufC9/3bb78RGBhY5Xzl8Iqaxplezvu6nM/5Sn8v/v2cyroqn3O1tdYGq/pbOHToUIYOHXrR8xqNhsmTJ1cb5GQNvF3V/xkUarUo+aloJNwIIayQt7c3/fv354MPPuC5556r0oWSlpbGl19+yfDhw6v8UNq6dWuVe2zdutU0zgXUH3AVFRV1XntJSQmDBw+mZcuWzJ49u8q5jh07UlFRQXp6Or17967x+a1bt67xvZizadMmQkNDqwyyTkhIqHKNnZ3dZb//ffv2UVxcbPrct27diouLC0FBQXh6emJvb09iYiJ9+/at8fktW7bk999/r3Js586dl/Xa9a1ly5Zs3769yrH6qtUqx9w0RM2c1dajIo2G0pxUC1cjhBAXN3/+fAwGAwMHDuSvv/4iKSmJlStX0r9/fwIDA6sMMgX1B/ysWbM4duwYCxYs4Pvvv+fZZ581nQ8LC2PdunWkpaWRnZ1dZ3WPHj2apKQk5s6dS0ZGBmlpaaSlpVFaWkpUVBQPPfQQw4cPZ/ny5cTFxbFjxw5mzpxpCgPPPPMMK1euNL2X+fPnX7JLqkWLFiQmJvLNN99w8uRJ5s6dy4oVK6pcExYWRlxcHHv37uXs2bMYDIaL3q+0tJSRI0dy+PBh/vjjDyZNmsRTTz2FVqvF1dWVcePG8dxzz7F06VJOnjzJnj17WLBgAUuXLjV9BkePHmXChAkcO3aM7777zjQ7y9r2OHv66af5/fffmT17NsePH2fRokX88ccf9VKnhJta4u10LtxotZRkp1i4GiGEuLjIyEh27txJREQE999/PxERETzxxBPccMMNbNmyBS+vqi3PL7zwArt27aJjx45MnTqVd999t8pA3HfffZc1a9YQHBxsGhtSFzZu3EhqaiqtW7fG39/f9KhcyHXx4sUMHz6cF154gejoaO688062bdtmmnl1/fXX88knnzBv3jw6dOjA6tWrefXVV82+5uDBg3nuued46qmn6NChA5s3b6424+eee+7hlltu4YYbbqBZs2Z8/fXXF73fTTfdRGRkJH369GHo0KHccccdVXojpk6dyuuvv86MGTNo1aoVAwcO5JdffiE8PByA8PBwfvjhB5YvX067du348MMPTa1K1rYGTc+ePVm4cCGzZ8+mffv2rFy5kueee67aYr11QaPUVweYlcjLy8Pd3Z3c3NyrHhBW431L8+j5dU8AVvs+gP+giZd4hhCioSspKSEuLo7w8PB6+QfbEsLCwhg7dixjx461dCniIqZNm8bChQvrbB232jRq1CiOHj3K33//XeN5c3+nruTnt1WNuWnIHG3O91sX5iZbsBIhhBCN2QcffEDXrl3x9vZm06ZNvP322zz11FOWLqtG77zzDv3798fZ2Zk//viDpUuX8sEHH9T560q4qSW2Wlt0ipYKjZHiwjOWLkcIIUQjdfz4cd58802ysrIICQnhhRde4OWXX7Z0WTXavn07s2bNIj8/n+bNmzN37lwef/zxOn9dCTe1yEaxpUJjoLTY/LoAQgjRUMTHx1u6BPEv7733nmkRRWtXudhhfZMBxbXIRqMO5iovvfZN54QQQghxdSTc1CJbrTruprw8R12lWAghhBD1TsJNLbLRqqtgllIBhjwLVyOEEEI0TRJuapG9jTOgLuRHvgwqFkIIISxBwk0tcrJVN0Mr0mogX1YpFkIIISxBwk0tMoUbjRYKpOVGCCHqWnx8PBqNhr17917Tffr161fnCxVqNBp+/PHHOn0NoZJwU4tcbM91S2k1kJ9m4WqEEKJmI0aMQKPR8NZbb1U5/uOPP17xvj9hYWHMmTOnFqu7uBEjRlTbyTw4OJjU1FRiYmKu6d7Lly9n6tSp13QPYT0k3NQiN/vKMTdaCTdCCKvm4ODAzJkz63Sjy/qg0+nQ6/XY2Fzbsm1eXl64urrWUlXC0iTc1CJ3e3W2VJFWAwUSboQQ1uvmm29Gr9czY8YMs9ctW7aMNm3aYG9vT1hYGO+++67pXL9+/UhISOC5555Do9GYbfVJTExk8ODBuLi44ObmxtChQzlz5nz3/eTJk+nQoQOLFi0iODgYJycn7rvvPnJyckznly5dyk8//WR6rQ0bNlTrltqwYQMajYZVq1bRsWNHHB0dufHGG0lPT+ePP/6gVatWuLm58eCDD1JUVFTlvVR2S1Xe49+PESNGmK7/5Zdf6Ny5Mw4ODjRv3pwpU6ZQXl5uOn/8+HH69OmDg4MDrVu3Zs2aNZf6LRG1SFYorkUejpXhRouSn4Z1bT4vhKhzigJlRZe+ri7YOsEVdCnpdDqmT5/OsGHDeOaZZwgKCqp2za5duxg6dCiTJ0/m/vvvZ/PmzYwZMwZvb29GjBjB8uXLad++PU888QSjRo266GspisJdd92Fs7MzGzdupLy8nDFjxnD//fezYcMG03UnTpzgu+++45dffiEvL4+RI0fy5JNP8uWXXzJu3DiOHDlCXl4eixcvBtTWlpSUlBpfc/LkycyfPx8nJyeGDh3K0KFDsbe356uvvqKgoIC7776befPmMWHChGrP7dGjB6mp5yeFHDlyhFtvvZU+ffoAsGrVKh5++GHmzp1L7969OXnyJE888QQAkyZNwmg0MmTIEHx8fNi6dSt5eXmy8Wg9k3BTizwdzoUbjQZjfho6C9cjhKhnZUUwPcAyr/1KCtg5X9FT7r77bjp06MCkSZP49NNPq52fPXs2N910E6+99hoAUVFRHD58mLfffpsRI0bg5eWFTqfD1dUVvV5/0ddZu3Yt+/fvJy4ujuDgYAA+//xz2rRpw44dO+jatSug7gi9dOlSU9CaN28et912G++++y56vR5HR0cMBoPZ16r05ptv0rNnTwBGjhzJyy+/zMmTJ2nevDkA9957L+vXr68x3NjZ2ZleIzMzk1GjRvHYY4/x2GOPAeou3C+99BKPPPIIAM2bN2fq1KmMHz+eSZMmsXbtWo4cOUJ8fLzpvUyfPp1BgwZdsm5RO6Rbqha5O5zvltLImBshRAMwc+ZMli5dyuHDh6udO3LkiCkgVOrZsyfHjx+noqLisl/jyJEjBAcHm4INQOvWrfHw8ODIkSOmYyEhIVVakLp3747RaCQ2NvZK3hIA7dq1M33t5+eHk5OTKdhUHktPN78PYFlZGffccw8hISG8//77puO7du3ijTfewMXFxfQYNWoUqampFBUVceTIkRrfi6g/0nJTi5xszk8F15YVgqEAzo3DEUI0AbZOaguKpV77KvTp04eBAwfyyiuvVBlTAmp30r/H0ShXsbVMTfcxd7xS5bkrncEFYGtrW+U+F35fecxoNJq9x3//+18SExPZsWNHlQHLRqORKVOmMGTIkGrPcXBwqPEzupr3IK6ehJtaVLnOTYH2XIdUwRkJN0I0JRrNFXcNWYO33nqLDh06EBUVVeV469at+eeff6oc27x5M1FRUeh06r9zdnZ2l2zFad26NYmJiSQlJZlabw4fPkxubi6tWrUyXZeYmEhKSgoBAWrX3pYtW9Bqtaa6Lue1asvs2bP59ttv2bJlC97e3lXOderUidjYWFq0aFHjcyvf77/fi6g/0i1Viypbbgo058KNrFIshGgA2rZty0MPPcS8efOqHH/hhRdYt24dU6dO5dixYyxdupT58+czbtw40zVhYWH89ddfJCcnc/bs2Rrvf/PNN9OuXTseeughdu/ezfbt2xk+fDh9+/alS5cupuscHBx45JFH2LdvH3///TfPPPMMQ4cONY1/CQsLY//+/cTGxnL27FnKysrq4NNQxwiNHz+ed955Bx8fH9LS0khLSyM3NxeA119/nf/9739MnjyZQ4cOceTIEb799lteffVV0/uNjo5m+PDhpvcyceLEOqlV1EzCTS2qsv0CyFo3QogGY+rUqdW6Uzp16sR3333HN998Q0xMDK+//jpvvPFGle6rN954g/j4eCIiImjWrFmN965cmdfT05M+ffpw880307x5c7799tsq17Vo0YIhQ4Zw6623MmDAAGJiYvjggw9M50eNGkV0dDRdunShWbNmbNq0qfY+gAv8888/VFRU8J///Ad/f3/T49lnnwVg4MCB/Prrr6xZs4auXbty/fXXM3v2bEJDQwHQarWsWLECg8HAddddx+OPP860adPqpFZRM41yNR2oDVheXh7u7u7k5ubi5uZWq/dOLUhlwLIB2BhhT0IiDJwO3Z+s1dcQQliPkpIS4uLiCA8Px8HBwdLlNGiTJ0/mxx9/vOZtFETDZu7v1JX8/JaWm1pU2XJTroUykJYbIYQQwgIk3NSiyjE3AMWyv5QQQghhERJuapGtzhbtuQlo6s7gEm6EEOJyTJ48WbqkRK2RcFPL7HWOQOXO4GcucbUQQgghapuEm1pmCjeyM7gQQghhERJuapnjhS03hlwoK7ZwRUIIIUTTIuGmllXOmMrR2KkHpPVGCCGEqFcSbmqZi6269Hqa5ty2CwUy7kYIIYSoTxJuapmrvRpu0jVq95RswSCEEELULwk3tczt3EaZZ03hRlpuhBBNz+TJk+nQocM13SM+Ph6NRlOnU8SXLFmCh4dHnd2/voWFhTFnzhxLl2FxEm5qmfO5MTfZWnv1gKx1I4SwQklJSYwcOZKAgADs7OwIDQ3l2WefJTMz84rvVbl31IXGjRvHunXrrqnG4OBgUlNTiYmJuab71LXaCHLWasSIEdx1112WLuOKSbipZZWrFMuAYiGEtTp16hRdunTh2LFjfP3115w4cYKFCxeybt06unfvTlZW1jW/houLC97e3td0D51Oh16vx8bG5prrEU2LhJtaVjlbKk9z7i+jhBshhJV58sknsbOzY/Xq1fTt25eQkBAGDRrE2rVrSU5OZuLEiaZrw8LCmDp1KsOGDcPFxYWAgADmzZtX5TzA3XffjUajMX3/79aMyhaA6dOn4+fnh4eHB1OmTKG8vJwXX3wRLy8vgoKC+Oyzz0zP+Xe31IgRI9BoNNUeGzZsAKC0tJTx48cTGBiIs7Mz3bp1M52rtGTJEkJCQnBycuLuu+++rJaqCRMmEBUVhZOTE82bN+e1116jrKzMdL8pU6awb98+Uz1Lliy56L0WL15Mq1atcHBwoGXLllV2Pb/Ua1X6+eef6dKlCw4ODvj4+DBkyJAq54uKinjsscdwdXUlJCSEjz76yOz7++GHH2jbti2Ojo54e3tz8803U1hYyOTJk1m6dCk//fRTtc86OTmZ+++/H09PT7y9vRk8eDDx8fGme1b+fk+ZMgVfX1/c3NwYPXo0paWll/i0a4nSxOTm5iqAkpubWyf3X3xgsRKzJEbp/f4dijLJTVEWXF8nryOEsLzi4mLl8OHDSnFxsaIoimI0GpXC0kKLPIxG42XVnJmZqWg0GmX69Ok1nh81apTi6elpul9oaKji6uqqzJgxQ4mNjVXmzp2r6HQ6ZfXq1YqiKEp6eroCKIsXL1ZSU1OV9PR0RVEUZdKkSUr79u1N933kkUcUV1dX5cknn1SOHj2qfPrppwqgDBw4UJk2bZpy7NgxZerUqYqtra2SmJioKIqixMXFKYCyZ88eRVEUJScnR0lNTTU9nn32WcXX11dJTU1VFEVRhg0bpvTo0UP566+/lBMnTihvv/22Ym9vrxw7dkxRFEXZunWrotFoTO/l/fffVzw8PBR3d3ezn9nUqVOVTZs2KXFxccrPP/+s+Pn5KTNnzlQURVGKioqUF154QWnTpo2prqKiohrv89FHHyn+/v7KsmXLlFOnTinLli1TvLy8lCVLllzWaymKovz666+KTqdTXn/9deXw4cPK3r17lWnTppnOh4aGKl5eXsqCBQuU48ePKzNmzFC0Wq1y5MiRGmtKSUlRbGxslNmzZytxcXHK/v37lQULFij5+flKfn6+MnToUOWWW24xvTeDwaAUFhYqkZGRymOPPabs379fOXz4sDJs2DAlOjpaMRgMpt9vFxcX5f7771cOHjyo/Prrr0qzZs2UV155xexn/e+/Uxe6kp/f0tZXyypbboq0GvWAtNwI0WQUlxfT7atuFnntbcO2mf79Mef48eMoikKrVq1qPN+qVSuys7PJyMjA19cXgJ49e/LSSy8BEBUVxaZNm3jvvffo378/zZo1A8DDwwO9Xm/2tb28vJg7dy5arZbo6GhmzZpFUVERr7zyCgAvv/wyb731Fps2beKBBx6o9nx3d3fc3d0BWL58OQsXLmTt2rXo9XpOnjzJ119/zenTpwkICADUcT8rV65k8eLFTJ8+nffff5+BAwdWeS+bN29m5cqVZut+9dVXTV+HhYXxwgsv8O233zJ+/HgcHR1xcXHBxsbmku9/6tSpvPvuu6aWlvDwcA4fPsyiRYt45JFHLvlaANOmTeOBBx5gypQppuvat29f5XVuvfVWxowZA6gtQe+99x4bNmygZcuW1WpKTU2lvLycIUOGEBoaCkDbtm1N5x0dHTEYDFXe2xdffIFWq+WTTz5Bo1F/1i1evBgPDw82bNjAgAEDALCzs+Ozzz7DycmJNm3a8MYbb/Diiy8ydepUtNq67Tiyqm6p8vJyXn31VcLDw3F0dKR58+a88cYbGI1G0zWKojB58mQCAgJwdHSkX79+HDp0yIJVV+Voo86SMmgU9UBxFpQbLFiREEJcPkVR/+2q/KEF0L179yrXdO/enSNHjlzxvdu0aVPlh5qfn1+VH6Q6nQ5vb2/S09PN3mfPnj0MHz6cBQsW0KtXLwB2796NoihERUXh4uJiemzcuJGTJ08CcOTIkRrfy6X88MMP9OrVC71ej4uLC6+99hqJiYmX/b4BMjIyTIO4L6zvzTffNNV3Oa+1d+9ebrrpJrOv1a5dO9PXGo0GvV5/0c+0ffv23HTTTbRt25b77ruPjz/+mOzsbLP337VrFydOnMDV1dX0Pry8vCgpKanyXtq3b4+T0/nA3b17dwoKCkhKSjJ7/9pgVS03M2fOZOHChSxdupQ2bdqwc+dOHn30Udzd3Xn22WcBmDVrFrNnz2bJkiVERUXx5ptv0r9/f2JjY3F1dbXwOzjfclOhraBcY4eNUgq5p8E7wsKVCSHqmqONI9uGbbPYa1+OFi1aoNFoOHz4cI2zYI4ePYqnpyc+Pj5m73Nh+Llctra21e5R07EL/0P7b2lpadx5552MHDmSkSNHmo4bjUZ0Oh27du1Cp9NVeY6Li7pER2VwuxJbt241tZQMHDgQd3d3vvnmG959990ruk/le/r444/p1q1q615lvZfzWo6Ol/59vpLPVKfTsWbNGjZv3szq1auZN28eEydOZNu2bYSHh1/0vXTu3Jkvv/yy2rnKljxzrubPzpWyqnCzZcsWBg8ezG233QaoTXJff/01O3fuBNQ/mHPmzGHixImmZr2lS5fi5+fHV199xejRo6vd02AwYDCcbznJy8ur0/fgfG6FYrSlpDi2IKToMCTvlnAjRBOg0Wguq2vIkry9venfvz8ffPABzz33XJUflmlpaXz55ZcMHz68yg+grVu3VrnH1q1bq3Rx2NraUlFRUee1l5SUMHjwYFq2bMns2bOrnOvYsSMVFRWkp6fTu3fvGp/funXrGt+LOZs2bSI0NLTKIOuEhIQq19jZ2V3y/fv5+REYGMipU6d46KGHrvq12rVrx7p163j00UfNvt6V0Gg09OzZk549e/L6668TGhrKihUreP7552t8b506deLbb781DRS+mH379lFcXGz6M7Z161ZcXFwICgqqtdovxqq6pXr16sW6des4duwYoH4w//zzD7feeisAcXFxpKWlmfrzAOzt7enbty+bN2+u8Z4zZsww9dO6u7sTHBxcp++hciq4RmvghN25Pu3T2+v0NYUQ4krMnz8fg8HAwIED+euvv0hKSmLlypX079+fwMBApk2bVuX6TZs2MWvWLI4dO8aCBQv4/vvvTa3poP5HdN26daSlpV2yS+NajB49mqSkJObOnUtGRgZpaWmkpaVRWlpKVFQUDz30EMOHD2f58uXExcWxY8cOZs6cye+//w7AM888w8qVK03vZf78+Zccb9OiRQsSExP55ptvOHnyJHPnzmXFihVVrgkLCyMuLo69e/dy9uzZKv+hvtDkyZOZMWMG77//PseOHePAgQMsXrzYFNQu57UmTZrE119/zaRJkzhy5AgHDhxg1qxZV/uRsm3bNqZPn87OnTtJTExk+fLlZGRkmMZkhYWFsX//fmJjYzl79ixlZWU89NBD+Pj4MHjwYP7++2/i4uLYuHEjzz77LKdPnzbdu7S0lJEjR3L48GH++OMPJk2axFNPPVXn420A65otZTQalZdeeknRaDSKjY1NtRH9mzZtUgAlOTm5yvNGjRqlDBgwoMZ7lpSUKLm5uaZHUlJSnc6WOp51XIlZEqO0/qSbMm/uW+qMqYV96uS1hBCWZW5mh7WLj49XRowYoej1esXW1lYJDg5Wnn76aeXs2bNVrgsNDVWmTJmiDB06VHFyclL8/PyUOXPmVLnm559/Vlq0aKHY2NgooaGhiqLUPFtq8ODBVZ7Xt29f5dlnn632eu+9956iKNVnS4WGhipAtcf69esVRVGU0tJS5fXXX1fCwsIUW1tbRa/XK3fffbeyf/9+0/0//fRTJSgoSHF0dFTuuOMO5Z133rnkbKkXX3xR8fb2Ns3+ee+996o8p6SkRLnnnnsUDw8P08yxi/nyyy+VDh06KHZ2doqnp6fSp08fZfny5Zf9WoqiKMuWLTPdw8fHRxkyZEiNn1+l9u3bK5MmTaqxnsOHDysDBw5UmjVrptjb2ytRUVHKvHnzTOfT09OV/v37Ky4uLlU+69TUVGX48OGKj4+PYm9vrzRv3lwZNWqU6Wdr5e/366+/bno/jz/+uFJSUnLxD1qpvdlSGkW5ik7IOvLNN9/w4osv8vbbb9OmTRv27t3L2LFjmT17No888gibN2+mZ8+epKSk4O/vb3reqFGjTP/zuJS8vDzc3d3Jzc0125x2tVIKUhi4bCCK0Ybr817jk+xHQWsDLyWBnXU3VwshrkxJSQlxcXGEh4fj4OBg6XLqRFhYGGPHjmXs2LGWLkU0ICNGjCAnJ6faytWXYu7v1JX8/LaqMTcvvvgiL730kmkKYNu2bUlISGDGjBk88sgjpqloaWlpVcJNeno6fn5+Fqn53853S5Vz3OAKLnp1C4bUvRDaw7LFCSGEEE2AVY25KSoqqtYXp9PpTKO8w8PD0ev1rFmzxnS+tLSUjRs30qOHdQSHCwcT5pUWQ3BX9ZskGXcjhBBC1Aerarm54447mDZtGiEhIbRp04Y9e/Ywe/ZsHnvsMUAd0T127FimT59OZGQkkZGRTJ8+HScnJ4YNG2bh6lW2Wlt0Gh0VSgX5pYUogV3RHPkFTu+wdGlCCHHFLlxSX4jLZW4LivpgVeFm3rx5vPbaa4wZM4b09HQCAgIYPXo0r7/+uuma8ePHU1xczJgxY8jOzqZbt26sXr3aKta4gXNTQW2cyC/LpwIDJfrOOIIabhQF6mF+vxBCCNGUWVW4cXV1Zc6cOcyZM+ei12g0GiZPnszkyZPrra4r5WzrTH5ZPhqtgRzP1jhqbaDgDOQmgUeIpcsTQtQyK5qXIUSDVlt/l6xqzE1jUTnuRqM1kFtmA/pzy4vLuBshGpXKlWCLioosXIkQjUPl36V/r7J8payq5aaxqJwxhbaUvOJyCLoOUvaoXVNt77VscUKIWqPT6fDw8DDt2+Pk5FQvS8sL0dgoikJRURHp6el4eHhU20LjSkm4qQPnW25KySsug+DrYPsiGVQsRCNUuUTFpTZ7FEJc2uXsLn85JNzUgQu3YMgtLoPmXdQTqfuhrARsG+diX0I0RRqNBn9/f3x9fSkrK7N0OUI0WLa2ttfcYlNJwk0dcLQ9txGdppS8kjLwCANnXyhMVxfzC7nekuUJIeqATqertX+YhRDXRgYU14FqLTcajdo1BdI1JYQQQtQxCTd1wNnWWf2ickAxQNC5rimZMSWEEELUKQk3deDCqeB5Jef64IMuaLmRNTGEEEKIOiPhpg6c75YqVbulAAI6gEYH+amQl2y54oQQQohGTsJNHTi/zo1BnQoOYOcM+hj1a+maEkIIIeqMhJs6UGWdm5Ly8ycqu6Yk3AghhBB1RsJNHbiwW8rUcgMQ2kP99dR6C1QlhBBCNA0SbuqAaZ2bC7ulACJuUMfdZByF7ATLFCeEEEI0chJu6sCFLTf5hnIqjOdmRzl6QnA39evjqy1UnRBCCNG4SbipA+fXuTEAkF9yQetNZH/11+Nr6rkqIYQQommQcFMHLhxQDJBVWGo6Z4i4AQUg7i8oK7ZAdUIIIUTjJuGmDpzvlioDjKTllQCwNXUrXdYM5wvfICgvhvhNFqxSCCGEaJwk3NSBypYbALSlpOWq4WZtwloA1rt7qedk3I0QQghR6yTc1AE7rR06jbo7sEZbSuq5cHMk8wgApzTn1r45vkq2YhBCCCFqmYSbOqDRaKqsUpyWW0K5sZzY7FgAMssKyLW1h+x4yDxhuUKFEEKIRkjCTR2pXOtGozWQmltCXG4chgqD6fypoI7qF9I1JYQQQtQqCTd1pHI6uEZbSlpeMUeyjlQ5f9I3Uv1Cwo0QQghRqyTc1JHz3VLqgOLK8TaVTjm7q1/EbwJDfj1XJ4QQQjReEm7qiGmtG42BswWlHD4Xbjr5dgLglCETvJqDsQxObbRYnUIIIURjI+GmjlS23NjYqmvdVHZL3db8NgBO5Z6CyAHqxdI1JYQQQtQaCTd1pDLcuDsZ0dhmUVxehL3OnptCbgIgtTCVouZ91IuPr5Ep4UIIIUQtkXBTRyq7pVwcK9A5JAMQ5RmFt6M33g7eAMS5+4OtE+SnwOkdFqtVCCGEaEwk3NQRRxt1KrijfQVahxQAWnm1AqC5R3MAThaehtaD1SfsXlr/RQohhBCNkISbOlLZcmNvV4auMtx4nws37mq4OZVzCjqPUJ9wcDmU5NV7nUIIIURjI+GmjlSuc2NrW4b2XLfUv8PNydyTENwNfKKhrAgOfG+ZYoUQQohGRMJNHakcUJxXnozWpggULZEe6sJ9ER4RAMTlxoFGc771ZtcSC1QqhBBCNC4SbupIZbdUcrG6d5SmTI+dzg4433KTlJ+kbsnQ/gHQ2UHafkjZY5mChRBCiEZCwk0dqWy5MSoVAJQW+VNWYQTAx9EHVztXjIqRhLwEcPI6P7BYWm+EEEKIayLhpo6Ytl84p6IkkPR8deNMjUZTdVAxQKdH1F8P/ACGgnqrUwghhGhsJNzUkcpuqUoVJYGk5Rabvq8cd3Mq91y4CesFXhFQWgCHltdbnUIIIURjI+GmjlSucwOAosFY4k9qbonpkGnGVM5J9YBGA53Ptd5I15QQQghx1STc1JHKqeAAThp/UOxIqyHcmFpuANoPA60tJO+CtAP1VqsQQgjRmFhVuAkLC0Oj0VR7PPnkkwAoisLkyZMJCAjA0dGRfv36cejQIQtXXbMLu6Wa2atB5sKWm8puqfi8eMqN5epBl2bQUt1Ykx2f1k+hQgghRCNjVeFmx44dpKammh5r1qwB4L777gNg1qxZzJ49m/nz57Njxw70ej39+/cnPz/fkmXX6MIBxaEu6vo2qReMudE763G0caTcWM4dC3+mpEydVcV1o9Rf934Fean1Vq8QQgjRWFhVuGnWrBl6vd70+PXXX4mIiKBv374oisKcOXOYOHEiQ4YMISYmhqVLl1JUVMRXX31l6dKrsdfZo9WoH2/Lc3tKXdhyo9VoCXYJA+B41gl2JWSrJ0J7QvD1UGGALfPrtWYhhBCiMbCqcHOh0tJSvvjiCx577DE0Gg1xcXGkpaUxYMAA0zX29vb07duXzZs3X/Q+BoOBvLy8Ko/6oNFo6NCsA75OvnT1bw9QZcwNgCP+AGjt09l/OrfyidD3RfXrnZ9B4dl6qVcIIYRoLKw23Pz444/k5OQwYsQIANLS0gDw8/Orcp2fn5/pXE1mzJiBu7u76REcHFxnNf/bpwM/ZeWQlYR7ewGQnm+g/NxCfgDFhT5AZbjJOf/EiJsgoKO639SWBfVWrxBCCNEYWG24+fTTTxk0aBABAQFVjms0mirfK4pS7diFXn75ZXJzc02PpKSkOqm3JjZaG2x1tvi42KPTaqgwKpwtKDWdP53uCoDW7oKWG1Bbb/qca73Z/jEUZ9dbzUIIIURDZ5XhJiEhgbVr1/L444+bjun1eoBqrTTp6enVWnMuZG9vj5ubW5VHfdNpNfi52gPnBxUnZRWRnuUBqC03yTmFnC0wnH9S1CDwbQOl+bDto/ouWQghhGiwrDLcLF68GF9fX2677TbTsfDwcPR6vWkGFajjcjZu3EiPHj0sUeYV0bs7AOfH3Ww+eRal1AuNYoNGW4bWPo0DF7beaLXQZ5z69dYPoKR+xgoJIYQQDZ3VhRuj0cjixYt55JFHsLGxMR3XaDSMHTuW6dOns2LFCg4ePMiIESNwcnJi2LBhFqz48vi7qysWV86Y2nQiE9AR4tgZADuvf9h34bgbUDfT9I6EkhzYKeveCCGEEJfD6sLN2rVrSUxM5LHHHqt2bvz48YwdO5YxY8bQpUsXkpOTWb16Na6urhao9MqYWm7ySlAUhc0nMwF4qOUIAGzc97LjdFzVJ2l10PsF9evN86G0sL7KFUIIIRosqws3AwYMQFEUoqKiqp3TaDRMnjyZ1NRUSkpK2LhxIzExMRao8sr5nws3qbklnEgv4GyBAQdbLUPadKeVR0c0GiOHCn5GUZSqT2x7L3iGQdFZtXtKCCGEEGZZXbhprM6PuSk2tdp0DfPC3kbHfzuoqxKXO2/laMa/prXrbOHG19Sv/3kfCjPrrWYhhBCiIZJwU08ubLnZfFJdmK97hDcA/UJ6YVsehEZbyid7v6j+5DZDQN9OnTn19zv1VrMQQgjREEm4qSf6cwOKz+SVsPVUFgA9ItRF/DQaDTHOdwGwMW0FRWVFVZ+s1UL/KerX2z+G7Pj6KFkIIYRokCTc1BNfV3s0GiirUMgtLsPV3oaYgPNr7gwIG4Cx1AuDks+KEyuq3yDiRmjeD4xlsH56/RUuhBBCNDASbuqJrU5LMxd70/fdmnthozv/8XcI9qI0sw8ASw8tpcxYVv0mN09Wf93/HaTur8tyhRBCiAZLwk09qhx3A9D9XJdUpWi9K5rCrhjLXUgtTGVl3MrqNwjoCDH3AAqsnVy3xQohhBANlISbeqS/INz0ODeYuJKtTktrvTdl2d0AWJ+0vuab3PgaaG3h5Do4taGuShVCCCEaLAk39ahylWIvZzui/aovPNg+yJ2KkkAAkguSa76JVzh0ObfA4S9joSS35uuEEEKIJkrCTT1q3swZgF4tfNBqq+9k3i7IA6XMA4CUgpSL3+iGl8E9BLLj4Oen4d8L/wkhhBBNmM2lLxG1ZWiXYABubetf4/n2we4YyzwByDHkUFRWhJOtU/ULHT3hvsXw2S1w+CfY/hF0G11ndQshhBANibTc1CMHWx3Du4fhc8GsqQs193HB2cYFpUI9n1qYevGbBXWBAVPVr1dNhORdtV2uEEII0SBJuLEiWq2GmMDzrTdmu6YAuv0HWt2hrn3z3Qgozq77IoUQQggrJ+HGyrQP9kA5F27MttwAaDQweIG6sWZuIvw4BozGui9SCCGEsGISbqxM20B3jJczqLiSgzvctxR0dhD7O/zytAQcIYQQTZqEGytzYbdU8uWEG4CADnD3QtBoYc8X8PNTYKyouyKFEEIIKyazpaxMqJcT9qgL/J3KSbr8J8bco/66bBTs/VKdHj54Pmh1dVClEEIIYb2k5cbKaLUawt2DAEgtuMSYm3+LuQfu+QQ0Otj31bkxONKCI4QQommRcGOFYvShAOSXZ1FWUcMGmmafPATu/VQNOPu/gWUjoaykDqoUQgghrJOEGyvUOTAExWgDKKQVpl35DdrcrS7yp7WFQyvg87ugKKu2yxRCCCGskoQbKxQTdH5Q8en8i+wxdSmtB8PDy8DeHRK3wKf9ISuuFqsUQgghrJOEGyvUopkLmnI13BxMT7j6GzXvCyNXgXswZJ6AT26G07KSsRBCiMZNwo0VstFpcbfzBeDgmWtsbfFtBY+vBX07KDoLS26Dfd/WQpVCCCGEdZJwY6UCXQIAiM89fe03c9XDo39A5EAoL4YVT8DvL0J56bXfWwghhLAyEm6sVKRXCADpRVcxoLgm9i7w4NfQZ7z6/faPYOntkHeF082FEEIIKyfhxkp1DAgHoKAiA0VRauemWh3cOBEe/FYdaJy0DRb1gVMba+f+QgghhBWQcGOlugZFAKDY5HA6p7B2bx59CzyxHnzbQGE6/O9O+H08lNby6wghhBAWIOHGSgW76UHRotEY2RJfB1O4vSPg8TXQ+VH1++2LYGEvSNxa+68lhBBC1CMJN1ZKp9XhqFX3mNqVXEfr09g5wx1z4OHl4BYIWafgs1tg1URpxRFCCNFgSbixYt72fgAcPRtfty/U4ib472bo8BCgwJb5sOB6iP2jbl9XCCGEqAMSbqxY6LkNNJPyUur+xRw94K4PYNh34B4CuYnw9QPw9TC4kt3JhRBCCAuTcGPFWvqo08ELjRlk5Bvq50WjBsKTW6HnWNDaQOxvsOA6+Ptd2YBTCCFEgyDhxopVttxobXM4lJJbfy9s5wz9p8B//oGQHlBWBOvegPld4cAPUFtT04UQQog6IOHGivm7+AOgsc3mUEpe/Rfg2woe/R2GfKwOOM5NhGUj1U04k3bUfz1CCCHEZZBwY8UCnNUtGLS2ORxMzrFMERoNtBsKT+2EG14FW2c4vQM+vRm+fRgyYi1TlxBCCHEREm6smN5ZD4BGW8aB1HoYVGyOnRP0fRGe3gUdHwaNFo78Ah9cDz89CbWxB5YQQghRCyTcWDE7nR0+Ds0ASClMIbeozMIVAW7+MHiBOnW85e2gGGHPFzC3E/zxkuxVJYQQwuIk3Fi5QNfzXVMbjqVbuJoL+LaCB76EkWsgtCdUGGDbh/B+e/jtBZk+LoQQwmIk3Fi5ynE3Gttsftln4a6pmgRfByN+g/9bASHd1ZCz4xOY2xF+fgYyT1q6QiGEEE2M1YWb5ORkHn74Yby9vXFycqJDhw7s2rXLdF5RFCZPnkxAQACOjo7069ePQ4cOWbDiulU5Y0prm8PGYxnkFJVauKIaaDQQcSM8+gc88iuE9QZjGexeCvM6w3ePQMoeS1cphBCiibCqcJOdnU3Pnj2xtbXljz/+4PDhw7z77rt4eHiYrpk1axazZ89m/vz57NixA71eT//+/cnPz7dc4XWosuXGzSWfsgqFlQfTLFyRGRoNhPeGEb/CoyshciCgwOEf4aN+sPROOLFW1skRQghRp2yu5OLw8HA0Gs0Vv8jYsWN55plnLnndzJkzCQ4OZvHixaZjYWFhpq8VRWHOnDlMnDiRIUOGALB06VL8/Pz46quvGD16dLV7GgwGDIbzq/vm5VlgvZhrUNly4+ycTwbwy/4UHrguxLJFXY7Q7urjzCHY9L66+F/cRvXhEw3X/xfa3a/OwhJCCCFqkUZRLv+/0Rs3bryqFwkLCyM0NPSS17Vu3ZqBAwdy+vRpNm7cSGBgIGPGjGHUqFEAnDp1ioiICHbv3k3Hjh1Nzxs8eDAeHh4sXbq02j0nT57MlClTqh3Pzc3Fzc3tqt5PfTqZc5K7froLZ1tX0vZPRKuBra/chK+rg6VLuzI5ibDlA3VmVem5VjZHT+g8ArqMBI9gi5YnhBDCuuXl5eHu7n5ZP7+vKNzUNQcH9Qf2888/z3333cf27dsZO3YsixYtYvjw4WzevJmePXuSnJxMQECA6XlPPPEECQkJrFq1qto9a2q5CQ4ObjDhpqisiG5fdQMgrOA9DiQZmHRHax7tGW7hyq5SSZ4acLYthJwE9ZhGCy1vg+ueUMfrXEXroBBCiMbtSsKNVY25MRqNdOrUienTp9OxY0dGjx7NqFGj+PDDD6tc9++uMUVRLtpdZm9vj5ubW5VHQ+Jk64SXgxcAPVqqOdQqZ01dLgc36D4GntkD93+hhhnFqC4IuPQOdVHAbR9BcY6lKxVCCNFAWVW48ff3p3Xr1lWOtWrVisTERAD0enXF3rS0qoNq09PT8fPzq58iLSDSIxKAAN9sNBrYnZhDUlaRhau6RlodtLpDHXw8ZqvaNWXrDBlH4Y8X4d2W8OMYSNouA5CFEEJcEasaUNyzZ09iY6vuVXTs2DHTeJ3w8HD0ej1r1qwxjbkpLS1l48aNzJw584rraiiivaLZlraN1OJTXB/ejy2nMvl1fyr/7Rdh6dJqh28ruH023DwJ9n0DOxdDxhHY+6X68G0NHf9PHYDs7G3paoUQQli5Kwo3S5YsuaoXuXDGkznPPfccPXr0YPr06QwdOpTt27fz0Ucf8dFHHwFqd9TYsWOZPn06kZGRREZGMn36dJycnBg2bNhV1dYQtPRqCcDRrKPc2WEYW05l8vO+lMYTbio5uEO30erYm6TtsGsJHFoO6Ydh1cuw5nWIHqQGnYgbQXdFf3yFEEI0EVY1oBjg119/5eWXX+b48eOEh4fz/PPPm2ZLgTq+ZsqUKSxatIjs7Gy6devGggULiImJuaz7X8mAJGtxLPsY9/x8Dy62Lvx25waum76OcqPC2uf70MLX1dLl1a3ibHUa+d4vqy4E6OIHMfdC+/tB304GIQshRCNXb7OlysrKSEtLo6ioiGbNmuHl5XW1t6o3DTHclBnL6PZlN8qMZfwx5A9eX5bKn0fTeeqGFowbGG3p8upP2kE15Oz7Boqzzh9v1lLtsoq5BzwvveSAEEKIhqdOZ0sVFBSwaNEi+vXrh7u7O2FhYbRq1YpmzZoRGhrKqFGj2LFjx1UXL6qz1drSwqMFALFZsQzpFAjA0s3xnC0wmHtq46KPgVtmwAux8MDX0Pou0Nmrg5DXTYH328GnA9TZVgUZlq5WCCGEhVxRuHnvvfcICwvj448/5sYbb2T58uXs3buXY8eOsWXLFiZNmkR5eTn9+/fnlltu4fjx43VVd5MT7aW20BzNPsqtMf7EBLqRbyhn9ppjFq7MAmzsoOWtMHQpjDsGd8xVp5SjgaRt52ZbRcP/7lLH7RRmWrhgIYQQ9emKuqXuu+8+Xn/9ddq2bWv2OoPBwKeffoqdnR2PP/74NRdZmxpitxTAl0e+5K3tb9EvuB/zbpzH9rgshi7aglYDvz/bm5b6hvNe6kxeChxaoY7RSdl9/rhGB+F9oM3d0PJ2mXElhBANUINdobg+NNRwszNtJ4+uepQA5wBW3auuxDzmy138fiCNXi18+HzkdVc1Tb/Ryjypbth56EdI23/+uEYHYb2g9WB1nR0XX0tVKIQQ4gpYZIXiCze7FLWvslsqpTCFXEMuAC/d0go7nZZ/Tpzlz6PplizP+nhHQO8X4D9/w9O74cbX1FlVSoW6eedvz8M7UbD4Vtj6IeQkWbpiIYQQtaTWws3y5ctZv3696fvi4mIeeuih2rp9k+dq50qgizqQ+Fi2Os4mxNuJx3qpe0xN++0IZRVGi9Vn1bwjoM84Neg8swdungIBnQAFEjbBypdgTgws6gt/vQMZsZe8pRBCCOtVa+Hmiy++YOLEiRw9epTjx4/Tu3dv+vXrV1u3F1RdzK/SkzdE4ONix6mzhXy+JcFSpTUcXs2h11h4Yj2MPQi3vAWhPdXNO1P3wp9TYcF1MK8LrJkEp3eCUUKjEEI0JNc85ub555+nQ4cOdOjQATs7O4YNG4aiKHz22WemLRKsSUMdcwPw4b4P+WDvB9wZcSfTek0zHf9qWyKvrDiAu6MtG8b1w9PZzoJVNlAFGRD7Gxz5Ve22qig9f87VH6JvVXcuD+utztYSQghRr+p1zE3fvn1JSEhg6tSp3HfffSQkJBAQEMDq1av57bffrvX24gItPdWWm9isqt0m93cNpqXeldziMuasbYJTw2uDSzPoPAIe/gFePAn3fgZthoCdC+Snws5P4Ysh8HYE/DASDi4HQ76lqxZCCFGDWp8tVVxczMGDB9m/fz8HDx7kvffeq83bX7OG3HKTUpDCwGUDsdHasH3Ydmx1tqZzm0+eZdjH29BpNfzxbG+i/Br5tgz1pdwAcX/B0V/h6O9QeMHAbZ0dNO+ntuhE3yozr4QQog7V6VRwRVEa9JTjhhxuFEWh5zc9yS/N5/s7vjeNwak0+vOdrDp0ht6RPvzvMZkaXuuMRkjeCUd+gaO/QdbJC05qILgbtLpdDTtezS1WphBCNEZ12i3l4uJCz549eeaZZ1i6dCkHDx7EKAMu64VGozEFmn93TQFMvLU1djotfx8/y7ojMjW81mm1EHwdDJgKT++CMdvUKeYBHQEFkrbC6ldhbkf4oAesn6Huh9W0lpISQgiLu+KWmw8++IDdu3eza9cuDh06REVFBQ4ODrRr147OnTvTuXNnOnXqRPv27euq5mvSkFtuAGZun8kXR77g4VYPM+G6CdXOv/XHURZuPEmYtxOrn+uLnU2tTYgT5uSeVrutjv4K8f+o6+lU8mquLhjY6k4I7Cw7mAshxFWotxWKDQYDjo6OvPLKK2RlZbF7927279+PwWCgoqLi0jewgIYebn468ROvbnqVrvqufDbws2rnCwzl3PDOBjLyDbxya0ue6BNhgSqbuKIsOLZSnXl1ch2Ul5w/5x6sro7cejAEdlFbg4QQQlxSvW6/oNVq2bt3L+3atQOgoqKCQ4cOmb63Ng093MRmxXLvL/fiaufKpgc21Tiu5rudSYz/YT+u9jasf7EfPi72FqhUAGAogBNr4PDPcGwVlBWeP+cWqO53FTNEXVRQWnSEEOKiLLL9QiWdTme1waYxaO7eHButDfml+aQWptZ4zb2dgmgb6E6+oZyZfxyt8RpRT+xd1ABz32IYfxLu/xLaDgU7V8hLhi3z4eMb1XE666ZCuvx+CSHEtZI28QbGVmdLC48WQNWVii+k1WqYfGdrNBr4ftdp/j6eUZ8liouxdVRnU93zMbx4Ah74CmLuAVsnyI6Dv9+BD7rBoj7qflcF8vsmhBBX44rDzahRo1i4cCE7d+7EYDAAyJTjehblGQXUPGOqUudQLx7pHgbAS8sOUGgor4/SxOWydVCnjN/7mRp07v1MXStHawup+9T9rt6Nhi+HqlPPK8osXbEQQjQYVxxuYmNjmTBhAtdddx2urupCcVOmTGH+/Pls3ryZoqKiWi9SVNXauzUA65PWY1QuPg3/xYHRBHk6kpxTzKyV0t1hteyc1RacB7+GF2Lh1nfUWVVKBRxfBd8+DLNbq3tdZZ689P2EEKKJu+oBxcePH2fXrl2maeF79uwhJycHnU5HVFQUhw4dqu1aa0VDH1AMkFWSxa3Lb6WwrJCZvWdya/NbL3rtP8fP8vCn2wD4bnR3rgv3qq8yxbU6exz2fAF7v6q6MnLzfnD9k9DiZpltJYRoMup1ttSF4uLi2LlzJ3v27GH69Om1ddta1RjCDcCifYuYv3c+gS6B/HzXz9jpLr6Z44Qf9vPtziTCfZz549neONjq6rFScc0qyiD2D9i9FE6sA879lfWOhOv/C+0fBDsni5YohBB1rc7CTWJiIiEhIZddSHJyMoGBgZd9fX1oLOGmqKyI21fcTkZxBhO6TuDh1g9f9Nrc4jIGvLeRM3kGRvdtzsuDWtVjpaJWZSfA9o9g9//AkKcec/SE68dAt9Hg4G7Z+oQQoo7U2VTwrl27MmrUKLZv337Ra3Jzc/n444+JiYlh+fLlV3J7cQWcbJ34b4f/ArBo/yLySy++Q7W7oy3T724LwMd/nWJXQna91CjqgGcoDJwGzx+GW2aCZxgUZ8P6aTCnLWx4C4pzLF2lEEJY1BW13GRlZTF9+nQ+++wzbG1t6dKlCwEBATg4OJCdnc3hw4c5dOgQXbp04dVXX2XQoEF1WftVaSwtNwDlxnKG/DyEuNw4Hm/7OM92etbs9c9/u5fle5IJ9Xbit2d642JvU0+VijpjrIBDK+CvtyHj3KBxe3fo8RT0eFqdfi6EEI1AnY+5KSkp4ffff+fvv/8mPj6e4uJifHx86NixIwMHDiQmJuaqi69rjSncAPyZ+CfPrn8WB50Dv979K37Ofhe9Nq+kjEFz/iY5p5j7uwQz815ZbLHRMBrh8I+wcRZkHFGPeYTAwOnQ8nZZ/VgI0eDVy4DivLy8BhkOGlu4URSFR1Y+wp70PQyJHMKUHlPMXr/1VCYPfrwVRYGFD3fmlhh9PVUq6oXRCIeWw5rX1RWQASJuVLuwmkVZtjYhhLgG9bL9gqenJ8uWLbvap4taotFoeL7z8wD8eOJHDmWan4J/fXNvRp/bTPPl5ftJzysxe71oYLRaaHsvPLUDer8AOjs4+Sd82B02zJTFAIUQTcJVhxtFUfjwww/p1q0b119/PU899RTbtm2rzdrEZerg24FB4YMwKkZe/edVyi7xA+z5/lG09ncju6iMcT/spxZXAxDWws4ZbnodxmyFqFvAWA4bpsOnA9T1c4QQohG7phXA9u3bx3XXXUe/fv2IjY2lb9++PPfcc7VVm7gCL133El4OXpzIOcGi/YvMXmtno+X9Bzpgb6Plr2MZLNkcXz9FivrnHQEPfgNDPlGniafshoW9YdsitQtLCCEaoWsKN1999RXz5s3jrbfeYs2aNezYsYOff/6Zd999t7bqE5fJy8GLid0mAvDJgU84nHnY7PWRfq68cqu63s2M349y4HRundcoLESjgXb3wX+3QPMboLwY/hgPX96rTiMXQohG5qrDjbe3N8HBwVWOtW3blrlz57Jw4cJrLkxcuQFhAxgQOoAKpYJXN126e2p491D6t/ajtMLImK92kVss4zEaNfdA+L8V6t5VNo5wch18fBNkHLN0ZUIIUauuOty0b9+eTz/9tNrxFi1akJSUdE1Fiav3SrdX8LT35Hj2cT468JHZazUaDe/c254gT0eSsoqZIONvGj+NBq4bBY+vAfdgyDoJn9wMJ9ZaujIhhKg1Vx1u3nzzTebPn8+wYcP4559/yMvL48yZM0yfPp3w8PDarFFcAW9Hb165/hUAPtn/CUcyj5i93t3JlgXDOmGr07DyUJqMv2kq9G1h1HoIvh4MufDlfbD1Q5BwK4RoBK463Fx//fVs3bqVlJQU+vXrh6enJwEBAfzwww8y5sbCBoYOpH9of8qVcsb/NZ7CskKz17cP9jCNv5n++xH2JeXUQ5XC4lyawSM/Q4eHQTHCypfUhww0FkI0cLWyK3h6ejq7du3CaDTSrVs3fHx8aqO2OtHYFvG7mKySLO775T7Si9IZGDaQt/u8jcbMKrWKojDmy938cTCNIE9Hfn26Fx5OF99pXDQiigJb5sPqV9Xv2w+DO+eBTrbnEEJYj3pZobihairhBmBv+l4eXfko5Uo5L133Eg+1esjs9XklZdw+9x8Ss4roG9WMz0Z0RaeVZfubjH3fwo//BaVC3bLhnk/B1sHSVQkhBFBPKxQL69fBtwMvdHkBgHd2vMPe9L1mr3dzsGXhw51xsNWy8VgGc9bKLJompf39cP8XoLOHo7/CV/eB4eK7zQshhLW6onATHh5O8+bNr/gxd+7cy7r/5MmT0Wg0VR56/fm9jxRFYfLkyQQEBODo6Ei/fv04dMj8dgNN3UOtHmJg2EDKlXJe2PgCmcWZZq9vHeDGjCFtAZj35wlWHUqrjzKFtWh5Kzz8A9i5QNxf8L+7oETWQBJCNCxX1Km+ZMmSq3qRsLCwy762TZs2rF17flqqTqczfT1r1ixmz57NkiVLiIqK4s0336R///7Exsbi6up6VbU1dhqNhik9pnAs+xhxuXFM+HsCC29eiI324r/1d3cMYl9SLks2x/PCd/to8ZQLEc1c6rFqYVHhfeCRX+CLIZC8E764F/5vOdjL3zEhRMNgVWNuJk+ezI8//sjevXurnVMUhYCAAMaOHcuECRMAMBgM+Pn5MXPmTEaPHn1Zr9GUxtxc6GTOSR787UGKy4t5uNXDTLhugtnryyqMPPTxNrbHZ9HC14Ufn+yJi70MMG1SUvfD0jugJAdCepxr0XG2dFVCiCaqQY+5OX78OAEBAYSHh/PAAw9w6tQpAOLi4khLS2PAgAGma+3t7enbty+bN2++6P0MBgN5eXlVHk1RhEcEb/Z8E4AvjnzBsmPmd3S31WmZ/1BH/NzsOZFewPPf7sVotJocLOqDfzt1RWN7d0jcDF/dD6VFlq5KCCEuyarG3HTr1o3//e9/rFq1io8//pi0tDR69OhBZmYmaWnq2A8/P78qz/Hz8zOdq8mMGTNwd3c3Pf69ZURTMiBsAGM6jAHgzW1vsjNtp9nrfV0d+PDhztjptKw+fIb3ZIBx0xPYSe2SsnOF+L/hmwehrNjSVQkhhFlX1C21cePGq3qRsLAwQkNDr/h5hYWFREREMH78eK6//np69uxJSkoK/v7+pmtGjRpFUlISK1eurPEeBoMBg8Fg+j4vL4/g4OAm1y1VSVEUxv81npXxK/Gw9+Dr274myDXI7HN+2HWacd/vA+D9BzowuENgfZQqrEniVvh8CJQVQoub4YGvwMbe0lUJIZqQK+mWuqJBFH379r2mwq6Us7Mzbdu25fjx49x1110ApKWlVQk36enp1VpzLmRvb4+9vfwjXEmj0TC151SS8pM4lHmIp/98ms8HfY6L3cUHDN/bOYjjZ/JZ9NcpXvxhP6HeznQI9qi/ooXlhVwPD30PX9yj7kP13SMw9H9gIws9CiGsj9WNubmQwWDgyJEj+Pv7Ex4ejl6vZ82aNabzpaWlbNy4kR49eliwyobHwcaB9294n2aOzTiRc4Jxf42jzGh+R/Dxt7Tkxpa+lJYbeeJ/O0nLLamnaoXVCOsJw74BGwc49gcsewwusfO8EEJYglWFm3HjxrFx40bi4uLYtm0b9957L3l5eTzyyCNoNBrGjh3L9OnTWbFiBQcPHmTEiBE4OTkxbNgwS5fe4Pg5+zHvxnk46BzYlLyJqVummt0RXKfV8P4DHYj0dSE938Co/+2kuLSiHisWVqF5P7j/S9DZwZFfYMVoMMqfAyGEdbGqcHP69GkefPBBoqOjGTJkCHZ2dmzdutU0Xmf8+PGMHTuWMWPG0KVLF5KTk1m9erWscXOV2vi04Z2+76DVaFlxYgUf7PvA7PWuDrZ8+khXPJ1sOZCcy9hv91AhM6iansib1S4prQ0cXAY/jpGAI4SwKla1zk19aKrr3Jjzw7EfmLJlCgCTuk/i3qh7zV6/PS6Lhz/ZRmmFkcd7hfPq7a3ro0xhbQ7/DN+PUPeiavcA3PUBaHWXfJoQQlyNBr3Ojah/90bdy+h26iKIb259k41J5mfFXRfuxdv3tQPgk3/i+N+W+LouUVij1nfCvZ+CRgf7v1E33ZQWHCGEFZBwIwB4ssOT3NXiLiqUCl7868VLbrI5uEMgLw6MBmDyz4dYd+RMPVQprE6bu+G+xWoX1f5vYcV/JOAIISxOwo0A1Cnir3d/nV6BvSguL2bMujHEZsWafc6YfhHc3yUYowJPf72Hg8mywWKT1How3Hsu4Bz4Th1kXFFu6aqEEE2YhBthYqu15d2+79LRtyP5pfmMXjOaxLzEi16v0Wh48+4YerXwoai0ghGLd5CYKcvzN0mt74T7lp4LON/DDyOgTJYLEEJYhoQbUYWTrRPzb5pPtGc0mSWZPLHmCc4UXrzLyVan5YOHO9HK342zBQb+77NtZOQbLnq9aMRa3Q5DPz8/TfzLe6Gkae7lJoSwLAk3oho3OzcW9l9IiGsIyQXJjF4zmpySnItf72DL0ke7EuTpSEJmEY8u2U6BQbolmqSWt8LDy87vRbX0dijIsHRVQogmRsKNqJGPow8fDfgIXydfTuaeZPTa0eSVXvx/4b5uDnw+shveznYcTM5j9Oc7MZTLwNImKbwPjPgVnHwgdR98NgCy4y1dlRCiCZFwIy4q0CWQj/p/hKe9J4czD/PfNf+loLTgoteH+ziz+NGuONnp2HQikxe+24dRFvlrmgI6wGOrwD0Esk7BpwPg9C5LVyWEaCIk3AizIjwi+HjAx7jbu7P/7H7GrBtDUdnFBw23C/Jg0f91xlan4df9qbz600Gz2zqIRsynBYxcBb6toeAMLLlVXdFYCCHqmIQbcUnRXtF81P8jXO1c2ZO+55IBp3dkM2YP7YBGA19tS2Tab0ck4DRVbgFqC07kQCgvgR8eg/UzQP48CCHqkIQbcVlae7fmo/4f4WLrwq4zu3jmz2coLi++6PV3tA9g5pDzqxjPWXu8vkoV1sbBDR78Gro/pX6/8S015JTKsgFCiLoh4UZcthifGD68+UOcbJzYlraNJ9c9abYFZ2jXYCbdoe479f6643z018n6KlVYG60OBk6DO+epa+EcWg6f3AwZxyxdmRCiEZJwI65IB98OLOq/CBdbF3ak7eA/a/9jdpDxoz3DTds0TP/9KJ/LPlRNW6fhMPwncPaF9EPwUT/Y/52lqxJCNDISbsQV6+DbgY8HfGwag/PEmifINVx864Unb2jBmH4RALz20yG+2JpQX6UKaxTWC/7zD4T1hrJCWD4Kfn4Gyi7ezSmEEFdCwo24KjE+MXw64FM87D04cPYAo1aPMrvQ34sDoxnVOxyAV388KAGnqXP1U1tw+r4EaGD3Uvj4RnVdHCGEuEYSbsRVa+Xdik8HfoqXgxdHso7w6KpHSS9Kr/FajUbDK7e2koAjztPq4IaXYfiP4NwM0g+rAWfjLKgos3R1QogGTMKNuCZRnlEsHrgYX0dfTuScYPgfwy+62aYEHFGj5v3gv1ug1R1gLIf10+DT/pB+1NKVCSEaKAk34po192jO/279n2kvquF/DCc2K7bGa2sKOIs3xdVnucIauTRTN90c8gk4eEDKHljUBza+DeWyEasQ4spIuBG1ItAlkKWDlpp2E3905aPsPrO7xmsrA84TfZoDMOWXwyxYf6I+yxXWSKOBdvfBmK0QOQAqDLD+TfiwB5zaYOnqhBANiIQbUWt8HH347JbP6OTbifyyfEavGc36xPU1XqvRaHh5UEvG3hwJwNurYpm58qisZCzAzR+GfQf3fAoufpB5Av43GH4YCflplq5OCNEASLgRtcrNzo2F/RfSJ6gPJRUljN0wlm+PflvjtRqNhrE3RzHx1lYAfLjhJJN+PiSbbQq1FaftvfDUDrhuNGi0cPAHmNcZ/npbpo0LIczSKE3sv8p5eXm4u7uTm5uLm5ubpctptMqN5by59U2WHVc3ShwZM5JnOj2DVlNznv5yWwKv/ngQRYEhHQOZeW87bHWSvcU5KXvgtxcg+dzO4m6BcNPr0HYoaOXPiRBNwZX8/JZwI+qMoigs2r+IBXsXAHBb89uY2mMqtjrbGq9fsec0477fT4VRoV90Mz54qBNOdjb1WbKwZkajuqv4uimQm6Qe8+8AN0+C5jeorT1CiEZLwo0ZEm7q348nfmTK5imUK+V01XflvX7v4W7vXuO1fx49w5gvd1NSZqRDsAefjeiKl7NdPVcsrFpZMWz9EP6eDaX56rGQHnDjRHX1YyFEoyThxgwJN5axKXkTz294nqLyIkJcQ5h/03zC3cNrvHZXQjYjl+4gp6iM5s2c+d9j1xHk6VTPFQurV5ABf78LOz9TZ1YBhPeFGyZCSDfL1iaEqHUSbsyQcGM5x7KP8fS6p0kpTMHVzpXZ/WZzvf/1NV57Ij2f4Z9uJyW3BD83ez4b0ZU2ATW39ogmLjdZDTm7/wfGcysbh/WGXs9BxI3SXSVEIyHhxgwJN5aVWZzJs+ufZV/GPnQaHa90e4Wh0UNrvDYtt4RHPttO7Jl8nO10zB/WiRta+tZzxaLByE5QZ1Lt++Z8yPHvAL1fgJa3y8BjIRo4CTdmSLixPEOFgUmbJ/Hbqd8AuD/6fiZ0nVDjQOPc4jLGfLmLTScy0Wpgyp1t+L/uYfVcsWhQck/D5vmwawmUn5sy7hUB1/8XOgwDO2eLlieEuDoSbsyQcGMdFEXhkwOfMG/PPBQUOvp2ZHa/2fg4+lS7trTcyKs/HuC7nacBeLxXOC/f2gqdVrobhBmFZ9WBxzs+hpJc9ZijJ3R5DLqOUhcLFEI0GBJuzJBwY13+Ov0XE/6aQEFZAb5OvszpN4e2zdpWu05RFD7YcJK3V6l7VvVv7cd793fAxV6miotLMBTA3q9g6wLIjlePaW2g9WB1gcDg62RcjhANgIQbMyTcWJ/43HieXf8sp3JPYau15dXrX2VI5JAar/15Xwrjvt9HabmRaD9XPnmkC8FeMpNKXAZjBcT+DlsWQOKW88f17aDbaIi5B2wdLVefEMIsCTdmSLixTgWlBUz8ZyJ/Jv0JwOCIwUy8fiKONtV/2OxJzGb057tIzzfg6WTLBw91pnuEd32XLBqy1H2w/SM48AOUl6jHHDzUMTldHgOfSIuWJ4SoTsKNGRJurJdRMfLpgU+Zv3c+RsVIpGcks/vOJsw9rNq1abklPPH5TvafzsVGq2HynW14+PrQ+i9aNGxFWbB7Kez4DHITzx8P662GnJa3g40sIimENZBwY4aEG+u3PXU7L/71IlklWTjbOjOlxxQGhg2sdl1JWQXjf9jPz/tSALi/SzBTBrfBwVZX3yWLhs5YASfWqQsCHl8FilE97uQDHR6ETiPAp4VFSxSiqZNwY4aEm4YhvSidFze+yO703YA6XXxcl3E42DhUuU5RFD7cqA40VhRoF+TOhw93JtBDxk6Iq5STpLbm7P4cCtLOHw/tBZ0fgVZ3yNgcISxAwo0ZEm4ajnJjOfP2zOOzg58BEOkZydt93ibCI6LatX8dy+CZb/aQU1SGl7Md8x7sSM8W1aeVC3HZKsrh+Gp1vZwTa8635ji4q7uRd/o/8G9v0RKFaEok3Jgh4abh2ZS8iVf+eYWskiwcdA68dN1LDIkcguZf03eTsor4zxe7OJSSh1YD4wZG858+EWhlPRxxrXJPw54vYM+XVcfm6NtBp+HqTCsnL8vVJ0QTIOHGDAk3DdPZ4rO88vcrbElVp/D2D+3PpO6Tqu0uXlJWwas/HuSHXeqCfzdEN2P20A54ys7iojYYjRC3Qe2yOvorVJSqx3X20PI26PgwNO8HWhn3JURtu5Kf31a72cqMGTPQaDSMHTvWdExRFCZPnkxAQACOjo7069ePQ4cOWa5IUW98HH1Y2H8hz3V+DhuNDWsS1jDkpyFsTtlc5ToHWx1v39uOGUPaYmejZX1sBrfO/ZtdCVkWqlw0KlqtuhnnfYvhhVgYNAv82qq7kh9aDl8MgTntYN1UyDxp6WqFaLKsMtzs2LGDjz76iHbt2lU5PmvWLGbPns38+fPZsWMHer2e/v37k5+fb6FKRX3SarQ8FvMYX9z6BWFuYaQXpzN6zWhmbJtBSeVaJYBGo+HB60L4cUxPwn2cSc0t4f5FW/nor5MYjU2qoVLUJScvdfG///wNT2xUt3RwcIe80/D3OzCvE3w2SO3OMhRYulohmhSr65YqKCigU6dOfPDBB7z55pt06NCBOXPmoCgKAQEBjB07lgkTJgBgMBjw8/Nj5syZjB49usb7GQwGDAaD6fu8vDyCg4OlW6qBKy4vZvbO2XwT+w0Azd2bM73XdNr4tKlyXYGhnJeXH+CXc9PF+0Y145372tPM1b7eaxZNQFkJxP6mjs05+Sdw7p9XW2d1u4cOwyC0p+xQLsRVaNDdUk8++SS33XYbN998c5XjcXFxpKWlMWDAANMxe3t7+vbty+bNm/99G5MZM2bg7u5uegQHB9dZ7aL+ONo4MvH6iXx484f4OPpwKvcUD/3+EHN3z6W0chwE4GJvw9wHOjDt7hjsbbRsPJbBoPf/YkNsugWrF42WrYM6uPj/lsNzh+Cm18G7BZQVwr6vYOntMLcDrJ8BWXGWrlaIRsuqws0333zD7t27mTFjRrVzaWnqehN+fn5Vjvv5+ZnO1eTll18mNzfX9EhKSqrdooVF9QrsxYo7VzAofBAVSgUfH/iYB357gMOZh03XaDQaHuoWys9P9SLaz5WzBaWMWLyDN345jKG8woLVi0bNPRB6vwBP7YTHVkOnR8DeDXISYONbashZfKs6OLkkz9LVCtGoWE24SUpK4tlnn+WLL77AwcHhotf9e/qvoijVjl3I3t4eNze3Kg/RuHg4eDCrzyxm95uNl4MXx7OP89BvDzF/z/wqrTjReld+eqonj3RXt2n4bFMcg+dv4mia/GARdUijgZBucOdcdRDykE/UQcloIGET/PwUvBMFy0apqyQbJXALca2sZszNjz/+yN13341Od34KZUVFBRqNBq1WS2xsLC1atGD37t107NjRdM3gwYPx8PBg6dKll/U6MhW8ccsqyWLa1mmsTlgNqGNxpvSYQgffDlWuW3fkDC/+sJ+swlLsdFrGDYxiZK/m6GRNHFFfcpNh/7ew72s4e+z8cRc9tBsK7R8AvzYXf74QTUyDXOcmPz+fhISEKsceffRRWrZsyYQJE2jTpg0BAQE899xzjB8/HoDS0lJ8fX3NDij+Nwk3TcPq+NVM3zadzJJMNGh4oOUDPNvpWZxtnU3XpOeX8PKyA6w7qo6/6RbuxbtD2xPk6WSpskVTpCiQvFsNOQd/gOLs8+f82kL7+6HtfeCqt1yNQliBBhluatKvXz/TbCmAmTNnMmPGDBYvXkxkZCTTp09nw4YNxMbG4urqeln3lHDTdOQacnl357usOLECAL2znleue4UbQm4wXaMoCt/uSOKNXw9TVFqBi70Nr97Wivu7Bpvt7hSiTpSXqls+7Psajq0CY5l6XKOF8L7Q7n5odTvYX96/d0I0Jo023CiKwpQpU1i0aBHZ2dl069aNBQsWEBMTc9n3lHDT9GxN3cqUzVM4XaCuWnxj8I283O1l9M7n/yeckFnIC9/tY2eC+r/m3pE+vHVPO9mAU1hOURYcWqF2XSVtO3/cxhFa3qoGnYgbQWdruRqFqEeNJtzUBQk3TVNxeTGL9i1i6aGllCvlONo48mSHJ3mo1UPYaG0AqDAqfPZPHO+sjsVQbsTF3oaJt7XiAWnFEZaWdQoO/KAGncwT5487ekGbu9Vuq+Busn6OaNQk3Jgh4aZpO559nKlbp7InfQ8AUZ5RTOw2kU5+nUzXnMwoYPwP+9l1rhWnZwtvZtzdjhBvGYsjLExRIGUP7P8ODi6DwgvWa3IPhpghEHMv6Nuqs7SEaEQk3Jgh4UYYFSMrjq9g9q7Z5JWq08DvaH4Hz3d5Hh9HH0BtxVm8KY63V6mtOA62Wp7vH8VjPcOx0cn/joUVqCiH+L/UFp3DP0PpBdvQ+ESpiwnG3As+LSxXoxC1SMKNGRJuRKXskmze3/0+y48vR0HBxdaFMR3G8EDLB7DVquMY4s8W8vLyA2w5lQlATKAbbw1pR0ygu7lbC1G/yorVAcgHf4Bjq9WNPCvp26pBp83d4BlmsRKFuFYSbsyQcCP+7UDGAaZtm8ahTHWH+ebuzRnfdTw9A3sC6kD273edZtpvR8gtLkOn1TCiRxjP9Y/Cxd7GkqULUV1JHhz9Te22OvknKBcsChjYGdoMUfe58pCtaETDIuHGDAk3oiYVxgqWn1jOvN3zyDaoY236BvVlXJdxhLmHAZCRb2DyL4f4bX8qAHo3B16/ozWDYvQy4FhYp8JMOPIzHFoO8f+AYjx/LqgrtL5Lgo5oMCTcmCHhRpiTV5rHwn0L+frI15Qr5dhobXiw5YOMbjcad3u1K2pDbDqv/3SIxKwiQN1p/I3BbQj1djZ3ayEsqyAdDv8Eh35Ut33ggn/6g7qqIafVneAZaqkKhTBLwo0ZEm7E5YjLjePtHW/zd/LfALjZuTG63WgebPkgtjpbSsoq+GD9CRZuPEVphRE7Gy1P9G7OmBsicLKTriph5fLT4Mgv6jo6CZupEnQCOp4POt4RFitRiH+TcGOGhBtxJTYlb+Kdne9wIkddWyTYNZixncbSP7Q/Go2GkxkFTPrpEP+cOAuAv7sDr9zaitvb+UtXlWgYKoPO4Z/UFp0Lu65820DrO6HVHeDbWqaXC4uScGOGhBtxpSqMFfx44kfm753P2WI1xLTzacfYzmPpqu+KoiisOpTG1F+PkJxTDMD1zb147fbWtAmQWVWiASlIV4POkV8g7q+qg5G9mqshp+Ud6sBkWTBQ1DMJN2ZIuBFXq6isiMWHFrP00FKKy9UQ0zuwN892epZor2hKyipYuPEkH244iaHciEYDQzsH88LAKHxdHSxcvRBXqCgLjq1U19A5+WfV6eWu/tDyNmh5O4T1ki0gRL2QcGOGhBtxrc4Wn2XhvoUsO7aMcqUcDRpua34bY9qPIdgtmNPZRbz1x1F+PTerytlOx5gbWjCyVzgOtjoLVy/EVTDkw/E1cPRXdR2dCxcMtHeHqAFq2Glxs2zqKeqMhBszJNyI2pKQl8C8PfNYFb8KABuNDXdF3sXodqPRO+vZlZDFG78eYV9SDgAB7g48PyCauzsGotPK2AXRQJUb4NRGNejE/g6FGefP6ewgvI8adKIGgZu/5eoUjY6EGzMk3IjadijzEPP2zGNT8iYA7LR2DI0eysi2I/Gy9+aX/SnM/OMoKbklALTUuzJhUEv6RTWTQceiYTNWwOmdcPQXdeHArFNVzwd2huhBatDxayMDksU1kXBjhoQbUVd2ndnFvD3z2HVmFwAOOgfuj76fETEjcLHxZMnmeBasP0F+STkAPSK8eXFgNB1DPC1ZthC1Q1EgIxZif4Ojv0Pyzqrn3UMg+haIukUdp2Njb5k6RYMl4cYMCTeiLimKwpaULSzYu4D9Z/cDVUOOjeLGgvUnWLo5gdIKdcpt/9Z+vDAgipZ6+fMoGpH8NHVAcuxKOLUeykvOn7NzhYgb1FadyAHg7GO5OkWDIeHGDAk3oj4oisKmlE18uPfDKiHn3qh7GdFmBGWlrry/9jjLdp/GqKit9Xe0C+C5/lGE+8hKx6KRKS2CUxvUMTrHVkFh+gUnNeoKyVED1FYdvxjpvhI1knBjhoQbUZ9qCjm2WlvuanEXI9uOpLjInffWHOO3A+rMKp1Ww10dAnn6xhaEScgRjZHRCKl71BadY39A2oGq590CIbI/RA5UByfbu1imTmF1JNyYIeFGWIKiKGxN3cqi/YtMY3J0Gh23ht/KozGPYijyZfaaY/x5VP0frYQc0WTkJsPx1WqLzqkNcG4NKUCdfRXWS+26ihwg20E0cRJuzJBwIyxtZ9pOPtr/EVtSt5iO9Qvqx8i2I9EYwnh/3fEqIeeOdv48eUMLIv1k/RDRyJUVq7uXV4adnISq5z3DzwWd/mrosXW0TJ3CIiTcmCHhRliLQ2cP8enBT1mbsBbl3MaFnXw7MaLNCDxoz7w/T5pCDsAtbfQ8eUML2gbJlg6iCVAUOHscjq9SFxBM2AzGsvPnbRzUgNPiZmjRX23VkbE6jZqEGzMk3AhrE58bz5JDS/jp5E+UG9Vp4mFuYQxvM5wIh758/FcSKw+lUfk3tXekD//tG0H3CG9ZJ0c0HYZ8dfHAE2vUsJOXXPW8ZxhE3KSGnfDeslJyIyThxgwJN8JapRel89WRr/gu9jvyy9Tl7b0cvBgaPZSuXrfx9ZYcft6XQoVR/SvbLsid0X0iuCVGLysei6ZFUSDjqBpyTqyt3qqjtYXgbtDiJoi4EfTtZKPPRkDCjRkSboS1KywrZMXxFXx++HNSClMAdYbVoPBB9A+8j/X7bfh2ZxIlZeo6OSFeTozsFc69nYNwtrexZOlCWIahAOL/hhPr1LCTHVf1vHMzaH6DGnaa3wCufpapU1wTCTdmSLgRDUW5sZy1iWv54vAX7MvYZzre2a8zd4TdR3xicz7fmkROkfo/VjcHGx7sFsKIHmH4u8tAS9GEZZ5UdzI/sQ7i/oKywqrn/WKgeT+1VSe0hwxMbiAk3Jgh4UY0RPsz9vPF4S9YnbCaCqUCAD8nP4a0uA9dwfV8vTWL+MwiAGy0Gga19WdEj1A6hXjKuBzRtJWXwuntatA5uQ5S9wMX/NjT2UPI9eqKyc37gb69dGFZKQk3Zki4EQ1ZWmEa38V+x7Ljy8gqyQLULqv+oQNoYT+Atfsc2HYq23R920B3HukRxu3t/HGw1VmqbCGsR+FZdT2dU+vh5PrqA5MdvaB5XzXoNO+nDlQWVkHCjRkSbkRjYKgwsDp+NV8d+YqDmQdNx6M8o+jldyeJCdH8tj+b0nJ1XI6Xsx1DuwTzULcQgr2cLFW2ENalcrp5ZdCJ/xtKC6pe4xkG4efCTngf2QfLgiTcmCHhRjQ2B88e5NvYb/kj7g8MFQYAnGycuCn4FuyKe7B6tw0pueqmhRoN9I1qxsPdQrmhpa/MshLiQhVlcHonxG1UW3dO74BzyzOY+LVVW3bC+0Jod5lyXo8k3Jgh4UY0VrmGXH4++TPfxX5HfF686Xgrr1a0chnA8VMt2Hz8/MDKAHcH7usSzNCuwQR6yIBKIaox5EP8pnNhZyOkH6p6XmsDgZ3VFp3wPhB0Hdg6WKbWJkDCjRkSbkRjpygKO8/s5IdjP7AmYQ1l59b/cNA50F1/I5qCrmzY70pukfo/0srWnAe6hnBTK19sdTKYUogaFaSrs69ObVB//ff2EDp7COkGYefCTmAn0NlapNTGSMKNGRJuRFOSXZLNLyd/YdnxZZzKPWU6HuwSTLTLTSQmtGLXqfP/BPi42HF3x0Du6xJMlOxlJYR52fHnws5GdbxOwZmq522dz4Wd3mrY8e8AOlmL6mpJuDFDwo1oihRFYf/Z/aw4voI/4v6gqFydNq5BQ3ufrjiVXs/OwwFk5p9/Tvsgd+7tEswd7fzxcLKzUOVCNBCVg5PjNqqBJ/4fKM6qeo2dqzrtPKyXGnj820vYuQISbsyQcCOauqKyIlbFr+Knkz+x68wu03EXWxdau/ei4Gx7dsV6UG5UBxvb6bTc2NKXIZ0C6Rfti52NdFsJcUlGI6QfVkNO/N/qryU5Va+xcz3XstMLQntBQAfpxjJDwo0ZEm6EOC8pP4lfTv7Czyd/Jrng/Hoffk56gu16kZTYihPJzqbjnk623N4ugMEdAugcKgsECnHZjBVw5tD5sJOwCUpyq15j6wzB10FYTwjtqQ5WtrG3TL1WSMKNGRJuhKjOqBjZfWY3v576ldXxq00bdwKEuUbiXnEdR09GcDbn/Bo5QZ6O3Nk+gMEdAonWy/gcIa6IsQLOHFRnYyWcexRnV73GxgGCuqpbRIR0V4OPnXPN92sCJNyYIeFGCPMMFQY2JG3g15O/8k/yP5Qr59f5iHBti21JJw4fD6Ow+Pz08Sg/F25vF8Dt7fxp3szFAlUL0cBVdmMlbIaEf9RfCzOqXqO1UQclh3aHkB7q+B0nL4uUawkSbsyQcCPE5cspyWFN4hp+P/U7O8/sNB3XarQ0d+lARX57jp4IpbTs/NoebQLcuK2dP7fG+BPm03T/lynENVEUyDyhdmMlblFbePJOV7+uWauqYccjuP5rrScNNtx8+OGHfPjhh8THxwPQpk0bXn/9dQYNGgSoMz6mTJnCRx99RHZ2Nt26dWPBggW0adPmsl9Dwo0QVyetMI2VcStZGb+SQ5nnFzPTaWwIc25PWV5bjp4MpaL8fItOa3816AyK0UuLjhDXKifxXMvOZjXwnD1W/Rq3QDXkhHSH4G7g1wa0jWNfuQYbbn755Rd0Oh0tWrQAYOnSpbz99tvs2bOHNm3aMHPmTKZNm8aSJUuIiorizTff5K+//iI2NhZX18vr85dwI8S1S8xLZGW8GnSOZx83HddpdIQ4tac8L4bYuFAqys633ET5uXBLGz0DY/S09neTwchCXKvCs2rISdgCSVshdV/17SLsXCG46/kxO4FdwL5h/kejwYabmnh5efH222/z2GOPERAQwNixY5kwYQIABoMBPz8/Zs6cyejRoy/rfhJuhKhdp3JPsTp+NasTVlcJOlq0BDu1oaKgLcfjwigvPf/3LdjLkQGt9fRv7UeXUE9sZFVkIa5daSEk7zofdpJ2QGl+1Ws0WvCLUVt1Qq5XByx7hKhLlVu5RhFuKioq+P7773nkkUfYs2cPDg4OREREsHv3bjp27Gi6bvDgwXh4eLB06dIa72MwGDAYDKbv8/LyCA4OlnAjRB2Iy41jTcIa1ias5UjWkSrnAh2j0ZXEcDI+nJKi8zsrezrZcmNLP/q39qN3pA/O9rKomRC1onL6edI2SNwKSdshN7H6dS56tVUn+Dp1fyz/9la5R1aDDjcHDhyge/fulJSU4OLiwldffcWtt97K5s2b6dmzJ8nJyQQEBJiuf+KJJ0hISGDVqlU13m/y5MlMmTKl2nEJN0LUrdP5p1mXuI61CWvZl7EPhfP/1DSzD8K5oj2Jp8PJzQ4A1JYbO52W7hHe3NTKl5ta+cmGnkLUtryUc2FnG5zeXnNXls4O9O3OhZ0uauuOe7DFW3cadLgpLS0lMTGRnJwcli1bxieffMLGjRvJycmhZ8+epKSk4O/vb7p+1KhRJCUlsXLlyhrvJy03Qlje2eKzrE9az5+Jf7ItdZtpM08AV1sPvDUdyEiPIC0tBJTzi5a11LvSL9qXG1v60inEQ7qvhKhtZcWQskdt1Unargaef09BB3DxU0NOUBd13E5Ax3ofu9Ogw82/3XzzzURERDBhwoSr6pb6NxlzI4RlFZQW8E/yP6xPWs/fyX+Tf8GYABuNLQH2MRjyoolLCqGi9PwaHm4ONvSJakbfqGb0jW6Gr6v1NZsL0eApirrbedIONeic3gFpB6q37mi06jT0oM5q2AnsDL6t6nRmVqMKNzfddBPBwcEsXryYgIAAnnvuOcaPHw+orTy+vr4yoFiIBqrMWMaeM3tYn7SeDUkbOF1QdR0PX/sQHMrbcDo5jNzsIOD8P5yt/d3oF92MPlHN6BTiKXteCVFXyorV7qvTO849dtW85o6ts7o/VmAniByg7oReixpsuHnllVcYNGgQwcHB5Ofn88033/DWW2+xcuVK+vfvz8yZM5kxYwaLFy8mMjKS6dOns2HDBpkKLkQjoCgKcblxbDy9kY2nN7I3fS8VSoXpvIPOCT/bthRktyDhdAhKubvpnLOdju4R3vSJakbvyGaEeTvJVHMh6lJ+GpzeCck71RlayXuqzszq/hQMnFarL9lgw83IkSNZt24dqampuLu7065dOyZMmED//v2B84v4LVq0qMoifjExMZf9GhJuhGgYcg25bEnZwt/Jf/NP8j9klWRVOe/rEIZDWStSUkLJzg4E5fxuyoEejvRq4UOvSB96RHjj7SKbDwpRp4xGdVHB5F3qo9XtEHFjrb5Egw039UHCjRANj1ExcujsIf5J+Yd/kv/h4NmDGBWj6byd1h4/u9aUFrQg8XQQpcW+wPmWm9b+bvSI8KZnCx+uC/eS6eZCNEASbsyQcCNEw5dTksPW1K38nfw3W1O2kl6cXuW8u603nto25GaFkZQShFJ+/u+6jVZDh2APukd40725N51CPXGwbRzL0wvRmEm4MUPCjRCNi6IonMg5weaUzWxO2cyuM7swVBiqXOPrEIpTRUsyMoJJOxMExvMzrexstHQM9uD65t5c39ybjiEeEnaEsEISbsyQcCNE42aoMLAnfQ9bUrawJWULR7OOVllAUIsWf8dIbEojSTsTxNmzAaDYmc7b6bR0CPHg+nAvrgv3plOoB0520o0lhKVJuDFDwo0QTUt2STbb07azLXUb21K3kZhfdfl5G40NeodobAyRpJwJIDPTv8rgZButhjaB7nQL96JrmBddQj3xdLb798sIIeqYhBszJNwI0bSlFqSyLW0bO9J2sD1tO2mFaVXO22ht8XeIxsbQgjPpAZzJ0Fdp2QGI9HWha7gXXcM86RLqRZCno0w9F6KOSbgxQ8KNEKKSoigk5SexPW07O8/sZEfqjmqDk200Nvg7RmJX3oKzGYGcTvMDY9U9r3xd7ekS5knnUC86h3rS2t9NFhUUopZJuDFDwo0Q4mIURSExP5EdaTvYeWYnO9N2cqboTJVrNGjwdwzHSYkkPyeYhGQ/ykqrLiJqb6OlXZA7nUI96RTiSccQD9kuQohrJOHGDAk3QojLpSgKyQXJpqCzO303SflJ1a7zcfDHUxtFaWEoSam+5OZ6UbnTeaUgT0c6hnjSKcSDDsEetA5ww95GZmUJcbkk3Jgh4UYIcS0yijLYnb6b3Wd2syd9D7HZsVUWFARwsnHB3yEaXWk4mWf9SUjzQamoukqynU5L6wA3OgR70DHEg/ZBHoTKthFCXJSEGzMk3AghalNBaQH7M/azJ2MPu8/s5sDZAxSXF1e5RqvREuAYjqumBSUFQSSl+pKd68aFqygDeDjZ0i7Igw5B7rQL8qBdsLt0ZwlxjoQbMyTcCCHqUrmxnGPZx9iTvoe96XvZl7GP1MLUate52rqps7LKwsjJ8Scu2YvS0upBRu/mQLsgd9oFudM2yIO2ge54yVR00QRJuDFDwo0Qor6lF6WzL2Mf+9L3sS9jH4czD1NqLK12nb9TMF42LagoDibjrC8JaR4oxuoLCAZ5OtI20J2YQHfTrxJ4RGMn4cYMCTdCCEsrqygjNjuWfRn72J+xnwNnD9Q4UNlGa0OQUwSumuaUFQWRltGMpDMu/HuwMqg7obcJcCMm0J2YQDfaBLjj62ovY3hEoyHhxgwJN0IIa5Rdks3Bswc5cPYA+8/u59DZQ+QYcqpd52jjSKBTJM6EUVoYQGqGD0lnnKgp8Pi42NM6wI025x6t/d0I83ZGq5XAIxoeCTdmSLgRQjQEldPQD549qD4yD3I483C1wcoATjbOBDm3wJkwyooCOJPhTXyaE0aleuBxstPRUu9K6wA3Wvu70zrAjWg/VxztZFq6sG4SbsyQcCOEaKgqjBXE58Vz8OxBDmUe4nDmYY5mHa22CzqoLTxBzi1w04RRXuLP2Sxf4pKdMZRXb7XRaCDc25lW/m601Luqv/q7Eugh20oI6yHhxgwJN0KIxqTcWM6p3FMcOnuII1lHOJx5mNisWEoqSqpda6u1JcQlAg+bUCgNJC/Xl4RUdzLzaw4wrvY2tPR3paXejWi9Ky31rkTpXXFzsK3xeiHqkoQbMyTcCCEau8oWnsOZhzmSdYSjWUc5mnmU/LL8Gq8PcA7C1z4ce2MQJYV60jK8SEi3payi5vsHuDsQrXclWu9GtN6FKD9XIpq54GArXVui7ki4MUPCjRCiKVIUhdP5pzmafVQNO+ce6UXpNV7vaudKkHMEbtoQlFJ/8nJ9SDrjRlpOzT8ytBoI83Ymys+VKD8XIv1cifJzJdzHWTYRFbVCwo0ZEm6EEOK8rJIsjmUfIzYrVn1kx3Iq5xTlSnm1azVoCHAOxM8hHAclkLISPZlZnsSlOZJXbKzh7mCj1RDm40ykrxp41F9dCPdxlr21xBWRcGOGhBshhDCvrKKMU7mnzoee7FiOZx8nsySzxuvttHaEuIbjZReCXUUAJYW+ZGR7Ep9mS4Gh5r4trQZCvZ1p4euiPpqpv0b4uuBiX33hQiEk3Jgh4UYIIa5OVkkWx7OPcyz7GMezj3M8+zgnc0/WOD0dwNnWmWCXcDxtgrGp8KeksBkZ2R7En7Ehv+QiA3oAf3cHIirDTjNnIpqpoUcWJWzaJNyYIeFGCCFqj1ExkpyfzLGcY5zIPsHJnJMczzlOfG58jV1bAC62LmrosQ3CtkKPodiHzGxPEtLtySwou+hrudjbENHMmebNXGjuc+7XZs6E+zjLYOYmQMKNGRJuhBCi7pVVlJGQl8CJXDXwnMw5yYmcEyTmJVKh1Nxq46BzINg1FG+7YOwVPRUGX3LzPElOdyIpqwzjRX5aaTQQ4O5I82bOptAT7qOGngAPR3SyInOjIOHGDAk3QghhOZWh52TuSU7lnOJEzglO5Z4iIS+BMmPNrTZajZZAl0D8HEJw1vpDmR+FBZ6czfIgIQPySmpuIQKws9ES5u1EmLcz4c2cCfd2Juxc8JFuroZFwo0ZEm6EEML6lBvLOZ1/mlO5pziVe4q43DjicuM4lXuKwrLCiz7P3c6dIJdQPGwDsFf0lJV4k5fnSWqmM0mZZZRW1DyLC9StKEK9nQn3cVJ/9XYm1NuJcB9nmknwsToSbsyQcCOEEA2HoihkFGcQnxuvBp68OE7lnCI+L57UwtSLPk+DBn9nf/ROwbjo/NGVN8NQ7EVOngcpZx1IzjZctJsLwNFWR+i5Fp9Qn3O/ejkR6uOM3s1BurosQMKNGRJuhBCicSguLyYxL5G4PLWVJyEvgYTcBOLz4ikoK7jo82y0NgS6BNHMIRBnjR5tRTMMRZ5k57mRkulAyiWCj51OS5CXIyFeToR6ORFyLviEeDsR4uUkg5vriIQbMyTcCCFE46YoCpklmWrYyVPDTmJeIgl5CSTmJVJqLL3oc03Bxz4AZ50eTbkPZSWe5Oa5kZbpxOnsUsoqzP/Y9HW1J9TbiWAvNexUPoK9nGjmYo9WWn2uioQbMyTcCCFE02VUjKQVppmCTmJ+ounXpPykiw5qBnVgs5+THl/HAFx1ftgYfSg3eFFQ4M7ZbBdOZ0K+4eKDmwHsbbQEeTqawk6wpxPBXo4EearfuzvKpqQXI+HGDAk3QgghalJhrOBM0RmS8pPUsJOXREJeAkkFSZzOP33RxQorudm54e8ciLutHgeaQZkXJcUe5OS5kprpQFruxaezm+7hYHMu6JwLPJ7qr0Hnvm/KqzdLuDFDwo0QQogrVdnVlZSfRGJeIqcLTnM6/zRJ+Ukk5SeRVZJl9vlajRZfJz987PW46HyxVXyoKPWksNCN7DwXUjPtyCo03+oD4OlkS6CnI0EeTuqvno4Eejie+7pxt/xIuDFDwo0QQojaVlRWRHJBMqfzT3O6QA09yQXJJOcnk1yQTElFidnn22ht0Dv542nvh7O2GboKL8pLPSgsdCMnz4WULFtyiy4+rb2Sq70NgRcEngCP818Hejg26DE/Em7MkHAjhBCiPlW2+pzOP60GnspHfjIphSmkFqRedKuKSjqNjmaOvnjZ63HS+mCjeFFR6k5RkRs5ec6cyXYk++ITxExsdRr83R0J8HAg0MOJQA8HAjwczz0c8Hd3xNlKu74k3Jgh4UYIIYQ1qTBWkFGcwen806QWppJckExKQQophSkk5yeTVpRGufEyuqzsPfF28MNZ1wxbxQvKPTAUu5FX4MzZHCfSc2wwKtpL3sfd0VYNO+5q8PH3cCDA3RH/c9/r3R2w1V36PrVNwo0ZEm6EEEI0JEbFSEZRhin4pBamklqQamr1SSlMueRgZwBbrS3eDs1wt/XFQeOF1uhJeakbxUWu5OY7kZ7tSEGxHWC+20qjAR8XewLc1ZYefw8H/Cu/dndA7+6An1vtByAJN2ZIuBFCCNGYKIpCXmkeaYVppBamklKQYvq68teM4gyMyqXH7NjrHPCyb4aLjTd2eKKt8KTM4EphsTO5+c5kZDtSWuoAmA8uw7uH8sbgmFp6h6or+fltnR1rQgghhLgsGo0Gd3t33O3difaKrvGaMmMZGUUZpBWmmQLPmaIzpu/PFJ0hqyQLQ0UJqUVJQFLVG9gCXmDvBS5aWzzsfEwBSFPhTnmpK8XFLuQWOJKZ44ivW0Sdv29zrCrczJgxg+XLl3P06FEcHR3p0aMHM2fOJDr6/G+WoihMmTKFjz76iOzsbLp168aCBQto06aNBSsXQgghrJet1pYAlwACXAIueo2hwkB6YTppRecDz5nCM5wpOkN6UTpnis6QWZypBqWSVDL4195edpgCUI7DA8DEOn1P5lhVuNm4cSNPPvkkXbt2pby8nIkTJzJgwAAOHz6Ms7MzALNmzWL27NksWbKEqKgo3nzzTfr3709sbCyurq4WfgdCCCFEw2SvsyfYLZhgt+CLXlNmLONs0Vk1+JwLP+lF6abwU/m13sWvHiuvzqrH3GRkZODr68vGjRvp06cPiqIQEBDA2LFjmTBhAgAGgwE/Pz9mzpzJ6NGjq93DYDBgMBhM3+fl5REcHCxjboQQQog6oCgK5Uo5ttraXVDwSsbc1P9criuQm5sLgJeXFwBxcXGkpaUxYMAA0zX29vb07duXzZs313iPGTNm4O7ubnoEB188kQohhBDi2mg0mloPNlfKasONoig8//zz9OrVi5gYdcR1WloaAH5+VZu7/Pz8TOf+7eWXXyY3N9f0SEpKqvE6IYQQQjQOVjXm5kJPPfUU+/fv559//ql2TqOpOgdfUZRqxyrZ29tjb29fJzUKIYQQwvpYZcvN008/zc8//8z69esJCgoyHdfr9QDVWmnS09OrteYIIYQQommyqnCjKApPPfUUy5cv588//yQ8PLzK+fDwcPR6PWvWrDEdKy0tZePGjfTo0aO+yxVCCCGEFbKqbqknn3ySr776ip9++glXV1dTC427uzuOjo5oNBrGjh3L9OnTiYyMJDIykunTp+Pk5MSwYcMsXL0QQgghrIFVhZsPP/wQgH79+lU5vnjxYkaMGAHA+PHjKS4uZsyYMaZF/FavXi1r3AghhBACsPJ1buqC7C0lhBBCNDyNZp0bIYQQQogrJeFGCCGEEI2KhBshhBBCNCoSboQQQgjRqEi4EUIIIUSjIuFGCCGEEI2KVa1zUx8qZ77n5eVZuBIhhBBCXK7Kn9uXs4JNkws3+fn5AAQHB1u4EiGEEEJcqfz8fNzd3c1e0+QW8TMajaSkpODq6nrRncSvVl5eHsHBwSQlJckCgXVIPuf6IZ9z/ZDPuX7I51w/6vJzVhSF/Px8AgIC0GrNj6ppci03Wq22yk7jdcHNzU3+8tQD+Zzrh3zO9UM+5/ohn3P9qKvP+VItNpVkQLEQQgghGhUJN0IIIYRoVCTc1CJ7e3smTZqEvb29pUtp1ORzrh/yOdcP+Zzrh3zO9cNaPucmN6BYCCGEEI2btNwIIYQQolGRcCOEEEKIRkXCjRBCCCEaFQk3QgghhGhUJNzUkg8++IDw8HAcHBzo3Lkzf//9t6VLatBmzJjx/+3deUzT9xsH8HehpZZTLHIUJ8KQeQDKMReVcajxwms6p04E4uaCG3ItHpkm6jIn2eIOEuNBHCxTx9xApxtBAaULQjgKZRwGBDk2AyMgQ5kIBZ7fH8ZvrKi/DorM+rySbyKfz1P69B1in3y//QJeffVVWFhYwNbWFqtWrUJ1dbVWDRFh3759UCgUkMlkCAwMRGVl5Sh1bBgOHjwIkUiEmJgYYY1z1o+bN28iJCQEcrkcpqammDlzJlQqlbDPOQ9fX18f9uzZA2dnZ8hkMri4uODjjz/GwMCAUMM5D81vv/2G5cuXQ6FQQCQS4dy5c1r7uuTa09ODbdu2wcbGBmZmZlixYgX+/PPPkWmY2LClpKSQRCKhxMREqqqqoujoaDIzM6PGxsbRbu25tWjRIkpKSqKKigpSq9UUHBxMEydOpK6uLqEmPj6eLCwsKDU1lcrLy2ndunXk4OBAt2/fHsXOn1+FhYU0adIk8vT0pOjoaGGdcx6+W7dukZOTE4WHh1NBQQHV19dTVlYW1dbWCjWc8/B98sknJJfL6ZdffqH6+nr68ccfydzcnL766iuhhnMemvT0dNq9ezelpqYSADp79qzWvi65RkREkKOjI2VmZlJJSQkFBQXRjBkzqK+vT+/98nCjB7NmzaKIiAittSlTptCuXbtGqSPD09raSgBIqVQSEdHAwADZ29tTfHy8UHPv3j2ysrKio0ePjlabz607d+7Q5MmTKTMzkwICAoThhnPWj507d5Kfn98T9zln/QgODqbNmzdrra1evZpCQkKIiHPWl0eHG11y/fvvv0kikVBKSopQc/PmTTIyMqKMjAy998iXpYapt7cXKpUKCxcu1FpfuHAh8vLyRqkrw9PZ2QkAGDduHACgvr4eLS0tWrlLpVIEBARw7kPwwQcfIDg4GAsWLNBa55z14/z58/D19cXatWtha2sLLy8vJCYmCvucs374+fkhOzsbNTU1AICysjLk5uZi6dKlADjnkaJLriqVChqNRqtGoVDA3d19RLJ/4f5wpr61tbWhv78fdnZ2Wut2dnZoaWkZpa4MCxEhLi4Ofn5+cHd3BwAh28fl3tjY+Mx7fJ6lpKSgpKQERUVFg/Y4Z/24ceMGjhw5gri4OHz00UcoLCxEVFQUpFIpQkNDOWc92blzJzo7OzFlyhQYGxujv78fBw4cwIYNGwDwz/NI0SXXlpYWmJiYwNraelDNSLxX8nCjJyKRSOtrIhq0xoYmMjISv//+O3Jzcwftce7D88cffyA6OhqXLl3CmDFjnljHOQ/PwMAAfH198emnnwIAvLy8UFlZiSNHjiA0NFSo45yH54cffsDJkydx+vRpTJ8+HWq1GjExMVAoFAgLCxPqOOeRMZRcRyp7viw1TDY2NjA2Nh40eba2tg6aYtm/t23bNpw/fx5XrlzBhAkThHV7e3sA4NyHSaVSobW1FT4+PhCLxRCLxVAqlUhISIBYLBay5JyHx8HBAdOmTdNamzp1KpqamgDwz7O+bN++Hbt27cL69evh4eGBTZs2ITY2FgcPHgTAOY8UXXK1t7dHb28vOjo6nlijTzzcDJOJiQl8fHyQmZmptZ6ZmYk5c+aMUlfPPyJCZGQk0tLScPnyZTg7O2vtOzs7w97eXiv33t5eKJVKzv1fmD9/PsrLy6FWq4XD19cXGzduhFqthouLC+esB3Pnzh30qwxqamrg5OQEgH+e9eXu3bswMtJ+WzM2NhZuBeecR4Yuufr4+EAikWjVNDc3o6KiYmSy1/tHlF9AD24FP3HiBFVVVVFMTAyZmZlRQ0PDaLf23Nq6dStZWVlRTk4ONTc3C8fdu3eFmvj4eLKysqK0tDQqLy+nDRs28C2devDw3VJEnLM+FBYWklgspgMHDtD169fp1KlTZGpqSidPnhRqOOfhCwsLI0dHR+FW8LS0NLKxsaEdO3YINZzz0Ny5c4dKS0uptLSUANAXX3xBpaWlwq880SXXiIgImjBhAmVlZVFJSQnNmzePbwX/rzt8+DA5OTmRiYkJeXt7C7css6EB8NgjKSlJqBkYGKC9e/eSvb09SaVS8vf3p/Ly8tFr2kA8Otxwzvpx4cIFcnd3J6lUSlOmTKHjx49r7XPOw3f79m2Kjo6miRMn0pgxY8jFxYV2795NPT09Qg3nPDRXrlx57P/JYWFhRKRbrt3d3RQZGUnjxo0jmUxGy5Yto6amphHpV0REpP/zQYwxxhhjo4M/c8MYY4wxg8LDDWOMMcYMCg83jDHGGDMoPNwwxhhjzKDwcMMYY4wxg8LDDWOMMcYMCg83jDHGGDMoPNwwxhhjzKDwcMMYe6zAwEDExMSMdhv/aeHh4Vi1atVot8EYewQPN4y9oMLDwyESiQYdtbW1o93aIMnJyRg7dqzw9b59+zBz5sxn9vwNDQ0QiURQq9Va619//TWSk5OfWR+MMd2IR7sBxtjoWbx4MZKSkrTWxo8fP0rdPHsajQYSiWTIj7eystJjN4wxfeEzN4y9wKRSKezt7bUOY2Pjx9Z2dHQgNDQU1tbWMDU1xZIlS3D9+nUAABFh/PjxSE1NFepnzpwJW1tb4ev8/HxIJBJ0dXUBuH/2ZeLEiZBKpVAoFIiKitKp5+TkZOzfvx9lZWXC2aYHZ086Ozvx3nvvwdbWFpaWlpg3bx7KysqExz444/PNN9/AxcUFUqkURISMjAz4+flh7NixkMvlWLZsGerq6oTHOTs7AwC8vLwgEokQGBgIYPBlqZ6eHkRFRcHW1hZjxoyBn58fioqKhP2cnByIRCJkZ2fD19cXpqammDNnDqqrq4WasrIyBAUFwcLCApaWlvDx8UFxcbFO2TDG7uPhhjGmk/DwcBQXF+P8+fPIz88HEWHp0qXQaDQQiUTw9/dHTk4OgPuDUFVVFTQaDaqqqgDcf2P38fGBubk5fvrpJ3z55Zc4duwYrl+/jnPnzsHDw0OnPtatW4cPP/wQ06dPR3NzM5qbm7Fu3ToQEYKDg9HS0oL09HSoVCp4e3tj/vz5uHXrlvD42tpanDlzBqmpqcJlpn/++QdxcXEoKipCdnY2jIyM8MYbb2BgYAAAUFhYCADIyspCc3Mz0tLSHtvbjh07kJqaim+//RYlJSVwdXXFokWLtJ4fAHbv3o1Dhw6huLgYYrEYmzdvFvY2btyICRMmoKioCCqVCrt27RrW2SXGXkgj8rfGGWP/eWFhYWRsbExmZmbC8eabbwr7AQEBFB0dTURENTU1BICuXr0q7Le1tZFMJqMzZ84QEVFCQgK5u7sTEdG5c+fI19eXVq9eTYcPHyYiooULF9LOnTuJiOjQoUPk5uZGvb29OvWalJREVlZWwtd79+6lGTNmaNVkZ2eTpaUl3bt3T2v95ZdfpmPHjgmPk0gk1Nra+tTna21tJQBUXl5ORET19fUEgEpLS7XqwsLCaOXKlURE1NXVRRKJhE6dOiXs9/b2kkKhoM8++4yIiK5cuUIAKCsrS6j59ddfCQB1d3cTEZGFhQUlJyc/PRDG2FPxmRvGXmBBQUFQq9XCkZCQ8Ni6a9euQSwW47XXXhPW5HI5XnnlFVy7dg3A/burKisr0dbWBqVSicDAQAQGBkKpVKKvrw95eXkICAgAAKxduxbd3d1wcXHBli1bcPbsWfT19Q3rtahUKnR1dUEul8Pc3Fw46uvrtS4xOTk5DfpcUV1dHd5++224uLjA0tJSuAzV1NSk8/PX1dVBo9Fg7ty5wppEIsGsWbOEjB7w9PQU/u3g4AAAaG1tBQDExcXh3XffxYIFCxAfH6/VO2NMNzzcMPYCMzMzg6urq3A8eKN9FBE9cV0kEgEA3N3dIZfLoVQqheEmICAASqUSRUVF6O7uhp+fHwDgpZdeQnV1NQ4fPgyZTIb3338f/v7+0Gg0Q34tAwMDcHBw0BrW1Go1qqursX37dq3X/Kjly5ejvb0diYmJKCgoQEFBAQCgt7dX5+d/kNGDPB5ef3Tt4ctMD/YeXALbt28fKisrERwcjMuXL2PatGk4e/aszn0wxni4YYzpYNq0aejr6xPe9AGgvb0dNTU1mDp1KgAIn7v5+eefUVFRgddffx0eHh7QaDQ4evQovL29YWFhITxeJpNhxYoVSEhIQE5ODvLz81FeXq5TPyYmJujv79da8/b2RktLC8RisdbA5urqChsbmyd+r/b2dly7dg179uzB/PnzMXXqVHR0dAx6PgCDnvNhrq6uMDExQW5urrCm0WhQXFwsZKQrNzc3xMbG4tKlS1i9evWgO9oYY0/Hww1j7P+aPHkyVq5ciS1btiA3NxdlZWUICQmBo6MjVq5cKdQFBgbi9OnT8PT0hKWlpTDwnDp1SrjDCLh/x9OJEydQUVGBGzdu4LvvvoNMJoOTk5NO/UyaNAn19fVQq9Voa2tDT08PFixYgNmzZ2PVqlW4ePEiGhoakJeXhz179jz1biNra2vI5XIcP34ctbW1uHz5MuLi4rRqbG1tIZPJkJGRgb/++gudnZ2Dvo+ZmRm2bt2K7du3IyMjA1VVVdiyZQvu3r2Ld955R6fX1d3djcjISOTk5KCxsRFXr15FUVHRvx6OGHvR8XDDGNNJUlISfHx8sGzZMsyePRtEhPT0dK1LLEFBQejv79caZAICAtDf3y983gYAxo4di8TERMydOxeenp7Izs7GhQsXIJfLdeplzZo1WLx4MYKCgjB+/Hh8//33EIlESE9Ph7+/PzZv3gw3NzesX78eDQ0NsLOze+L3MjIyQkpKClQqFdzd3REbG4vPP/9cq0YsFiMhIQHHjh2DQqHQGugeFh8fjzVr1mDTpk3w9vZGbW0tLl68CGtra51el7GxMdrb2xEaGgo3Nze89dZbWLJkCfbv36/T4xlj94noSRfTGWOMMcaeQ3zmhjHGGGMGhYcbxhhjjBkUHm4YY4wxZlB4uGGMMcaYQeHhhjHGGGMGhYcbxhhjjBkUHm4YY4wxZlB4uGGMMcaYQeHhhjHGGGMGhYcbxhhjjBkUHm4YY4wxZlD+B2XP4JOY1cwYAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(off_diagonal_norm[:,0],label= 'Optimized at beginning')\n", + "plt.plot(off_diagonal_norm[:,1],label= 'Not optimized')\n", + "plt.plot(off_diagonal_norm[:,2],label= 'Optimized at each step')\n", + "plt.xlabel('Flows Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-21 16:37:52]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 7\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "end = np.linspace(1.1,10*2**nqubits,100)\n", + "loss = np.empty(100)\n", + "spacing = np.empty(100)\n", + "for i in range(100):\n", + " dbi_eval = deepcopy(dbi)\n", + " d = np.diag(np.linspace(1,end[i],2**nqubits))\n", + " spacing[i] = d[1,1] - d[0,0]\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d,n = 3)\n", + " dbi_eval(step_poly,d=d)\n", + " loss[i] = dbi_eval.off_diagonal_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Loss function')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(spacing,loss)\n", + "plt.xlabel('Spacing')\n", + "plt.ylabel('Loss function')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def d_poly_spacing(nqubits,degree):\n", + " d = np.empty(2**nqubits)\n", + " for i in range(len(d)):\n", + " d[i] = 1 + i**degree\n", + " return np.diag(d)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "degrees = np.linspace(0.1,5,100)\n", + "nqubits = [3,4,5,7]\n", + "h = 3.0\n", + "\n", + "loss = np.empty((100,len(nqubits)))\n", + "best_degree = np.empty(len(nqubits))\n", + "for q in range(len(nqubits)):\n", + " H_TFIM = hamiltonians.TFIM(nqubits=nqubits[q], h=h)\n", + " dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + " for i in range(100):\n", + " dbi_eval = deepcopy(dbi)\n", + " d = d_poly_spacing(nqubits[q],degrees[i])\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d,n = 3)\n", + " dbi_eval(step_poly,d=d)\n", + " loss[i,q] = dbi_eval.off_diagonal_norm\n", + " best_degree[q] = degrees[np.argmin(loss[:,q])]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.18888889 1.13939394 1.13939394 1.13939394]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(degrees,loss[:,3],label = f'{nqubits[q]} qubits')\n", + "plt.xlabel('Degree')\n", + "plt.ylabel('Loss function')\n", + "plt.legend()\n", + "print(best_degree)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvjUlEQVR4nO3dd1yVdf/H8ddhbxRkKiIoOHGP3JYrNa0sG7YtG7as7tbd/Su9K00rK6u7rLvM9l2ZZcuRg9wiinsLLkQcyN5cvz8uOUoaoQLnAO/n43Eecq7rOud8uCJ5+50WwzAMRERERGoJB1sXICIiIlKZFG5ERESkVlG4ERERkVpF4UZERERqFYUbERERqVUUbkRERKRWUbgRERGRWsXJ1gVUt5KSEpKTk/H29sZisdi6HBEREakAwzDIzMwkNDQUB4fy22bqXLhJTk4mLCzM1mWIiIjIRTh48CCNGjUq95o6F268vb0B8+b4+PjYuBoRERGpiIyMDMLCwqy/x8tT58JNaVeUj4+Pwo2IiEgNU5EhJRpQLCIiIrWKwo2IiIjUKgo3IiIiUqvUuTE3IiI1TXFxMYWFhbYuQ6RKOTs74+joWCnvpXAjImKnDMMgJSWFU6dO2boUkWpRr149goODL3kdOoUbERE7VRpsAgMD8fDw0MKjUmsZhkFOTg6pqakAhISEXNL7KdyIiNih4uJia7Dx9/e3dTkiVc7d3R2A1NRUAgMDL6mLSgOKRUTsUOkYGw8PDxtXIlJ9Sn/eL3WMmcKNiIgdU1eU1CWV9fNuV+EmMzOT8ePHEx4ejru7Oz169CAuLs563jAMJkyYQGhoKO7u7vTr14+tW7fasGIRERGxN3YVbu655x4WLlzIZ599xubNmxk0aBADBgzg8OHDAEydOpVp06bxzjvvEBcXR3BwMAMHDiQzM9PGlYuIiIi9sJtwk5uby+zZs5k6dSp9+vShWbNmTJgwgYiICN577z0Mw+DNN9/kueeeY+TIkbRp04ZZs2aRk5PDl19+aevyRUSkGjRp0oQ333yzVnzO0qVLsVgslT7Vv1+/fowfP75S37OmsZtwU1RURHFxMW5ubmWOu7u7s3z5chITE0lJSWHQoEHWc66urvTt25eVK1f+5fvm5+eTkZFR5lEVSopLSN63jaMHdlfJ+4uI1CWffPIJ9erVO+d4XFwc9957b/UXJDWK3YQbb29vunfvzosvvkhycjLFxcV8/vnnrFmzhiNHjpCSkgJAUFBQmdcFBQVZz53P5MmT8fX1tT7CwsKqpP64D8cR+ml39v7yRpW8v4iIQEBAgGaQ2QF7XzHbbsINwGeffYZhGDRs2BBXV1emT5/O6NGjy8x1//NIasMwyh1d/eyzz5Kenm59HDx4sEpqLwmKASD4ZNzfXCkicnEMwyCnoMgmD8MwKlxnfn4+jzzyCIGBgbi5udGrV68yk0NKu2N++eUX2rVrh5ubG926dWPz5s3W83fddRfp6elYLBYsFgsTJkwAzu0uslgszJgxg6uuugoPDw9atmzJqlWr2LNnD/369cPT05Pu3buzd+9e62v27t3L1VdfTVBQEF5eXnTp0oXff//9gv5b3HnnnVxzzTVMnDiRwMBAfHx8uO+++ygoKKjwfThbdnY2Pj4+fPfdd2WO//TTT3h6ev7l2NLs7Gxuv/12vLy8CAkJ4fXXXz/nmoKCAp566ikaNmyIp6cn3bp1Y+nSpWWu+fDDDwkLC8PDw4Nrr72WadOmlWk5mzBhAu3bt+fjjz8mMjISV1dXDMMgPT2de++913oPrrjiCjZu3HjO99CpUyfc3NyIjIxk4sSJFBUVlXd7L5ldLeLXtGlTYmNjyc7OJiMjg5CQEG688UYiIiIIDg4GzBU7z165MDU19ZzWnLO5urri6upa5bV7tbgcNkJ44R7ISwc33yr/TBGpW3ILi2n1/HybfPa2fw/Gw6VivzKeeuopZs+ezaxZswgPD2fq1KkMHjyYPXv24OfnZ73uySef5K233iI4OJh//vOfjBgxgl27dtGjRw/efPNNnn/+eXbu3AmAl5fXX37eiy++yLRp05g2bRpPP/00o0ePJjIykmeffZbGjRszZswYHnroIX777TcAsrKyGDp0KC+99BJubm7MmjWL4cOHs3PnTho3blzhe7Jo0SLc3NxYsmQJSUlJ3HXXXTRo0ICXX375gu4DgKenJzfddBMzZ87k+uuvtx4vfe7t7X3eGp588kmWLFnCnDlzrPcxPj6e9u3bW6+56667SEpK4uuvvyY0NJQ5c+Zw5ZVXsnnzZqKiolixYgX3338/U6ZMYcSIEfz+++/83//93zmftWfPHr755htmz55tbXQYNmwYfn5+/Prrr/j6+jJjxgz69+/Prl278PPzY/78+dx6661Mnz6d3r17s3fvXmu34gsvvFDhe32h7KrlppSnpychISGkpaUxf/58rr76amvAWbhwofW6goICYmNj6dGjhw2rNTWJiCKxJAhHSsjetczW5YiI2ER2djbvvfcer776KkOGDKFVq1Z8+OGHuLu789FHH5W59oUXXmDgwIHExMQwa9Ysjh49ypw5c3BxccHX1xeLxUJwcDDBwcHlhpu77rqLG264gejoaJ5++mmSkpK45ZZbGDx4MC1btuTRRx8t01LRrl077rvvPmJiYoiKiuKll14iMjKSuXPnXtD36uLiwscff0zr1q0ZNmwY//73v5k+fTolJSUXdB9K3XPPPcyfP5/k5GQAjh8/zs8//8yYMWPOe31WVhYfffQRr732Wpn7WFxcbL1m7969fPXVV3z77bf07t2bpk2b8o9//INevXoxc+ZMAN5++22GDBnCP/7xD6Kjoxk3bhxDhgw55/MKCgr47LPP6NChA23btmXJkiVs3ryZb7/9ls6dOxMVFcVrr71GvXr1rC1QL7/8Ms888wx33HEHkZGRDBw4kBdffJEZM2Zc0L2+UHbVcjN//nwMw6B58+bs2bOHJ598kubNm3PXXXdhsVgYP348kyZNIioqiqioKCZNmoSHhwejR4+2del4uzmz2LktEcULydy5BM+2V9m6JBGpZdydHdn278E2++yK2Lt3L4WFhfTs2dN6zNnZma5du7J9+/Yy13bv3t36tZ+fH82bNz/nmopo27at9evSlvyYmJgyx/Ly8sjIyMDHx4fs7GwmTpzIzz//THJyMkVFReTm5nLgwIEL+tx27dqVGf/TvXt3srKyOHjwIOnp6RW+D6W6du1K69at+fTTT3nmmWf47LPPaNy4MX369Dnv9Xv37qWgoOC897HU+vXrMQyD6OjoMq/Nz8+3buuxc+dOrr322nNq+fnnn8scCw8PJyAgwPo8Pj6erKysc7YHyc3NtXYDxsfHExcXZ23NAnNrkby8PHJycqps/JRdhZv09HSeffZZDh06hJ+fH9dddx0vv/wyzs7OgNnEl5uby7hx40hLS6Nbt24sWLDgL5vrqtuR+p3h+EKcD66wdSkiUgtZLJYKdw3ZSunYnAsdH1nqYlaoLf0dcfbrz3espKQEMLty5s+fz2uvvUazZs1wd3fn+uuvLzNe5lJYLJaLvg/33HMP77zzDs888wwzZ860/uP+fCoyDqqkpARHR0fi4+PP2auptDXsfDWd7709PT3Pee+QkJBzxu8A1vE6JSUlTJw4kZEjR55zzZ9nR1cmu/q/5IYbbuCGG274y/Olg8pKB5bZm4JGPeA41M/YAbmnwL2erUsSEalWzZo1w8XFheXLl1tb1QsLC1m3bt05a6+sXr3aOsYlLS2NXbt20aJFC8Ds8jm7e6UyLVu2jDvvvNPaWpGVlUVSUtIFv8/GjRvJzc21bvi4evVqvLy8aNSoEf7+/hW+D2e79dZbeeqpp5g+fTpbt27ljjvu+MtrmzVrhrOz83nvY9++fQHo0KEDxcXFpKam0rt37/O+T4sWLVi7dm2ZY+vWrfvb779jx46kpKTg5OREkyZN/vKanTt30qxZs799v8pkV+GmpgsNi2Tv+hCaOhyB/SuhxVBblyQiUq08PT154IEHePLJJ/Hz86Nx48ZMnTqVnJwc7r777jLX/vvf/8bf35+goCCee+45GjRowDXXXAOYs6KysrJYtGiRtfunsrowmjVrxvfff8/w4cOxWCz83//9n7VV50IUFBRw9913869//Yv9+/fzwgsv8NBDD+Hg4HBB9+Fs9evXZ+TIkTz55JMMGjSIRo0a/eW1Xl5e3H333Tz55JNl7qODw5nhtNHR0dxyyy3cfvvtvP7663To0IHjx4+zePFiYmJiGDp0KA8//DB9+vRh2rRpDB8+nMWLF/Pbb7/9bSvagAED6N69O9dccw1TpkyhefPmJCcn8+uvv3LNNdfQuXNnnn/+ea666irCwsIYNWoUDg4ObNq0ic2bN/PSSy9d8D2vKLscUFxTRQd5sbqklfkkabltixERsZFXXnmF6667jttuu42OHTuyZ88e5s+fT/369c+57tFHH6VTp04cOXKEuXPn4uLiAkCPHj24//77ufHGGwkICGDq1KmVVt8bb7xB/fr16dGjB8OHD2fw4MF07Njxgt+nf//+REVF0adPH2644QaGDx9epmehovfhz+6++24KCgr+ciDx2V599VX69OnDiBEjGDBgAL169aJTp05lrpk5cya33347TzzxBM2bN2fEiBGsWbPGuu5bz549ef/995k2bRrt2rVj3rx5PPbYY3/bbWSxWPj111/p06cPY8aMITo6mptuuomkpCTr2KfBgwfz888/s3DhQrp06cJll13GtGnTCA8P/9vv7VJYjAtZvKAWyMjIwNfXl/T0dHx8fCr1vXMKinh64gu87fwORYFtcBqnsTcicnHy8vJITEwkIiKiSscm2MLSpUu5/PLLSUtLO+8qxDXBnXfeyalTp/jhhx8q/b2/+OILHn30UZKTk61hr7qNHTuWHTt2sGxZ9c7+Le/n/kJ+f6tbqhJ5uDhx0KcT5IJj6lbIOQkefn//QhERqfNycnJITExk8uTJ3HfffdUabEqnk3t6evLbb78xa9Ys/vOf/1Tb51c2dUtVsgbBYewpCcWCYY67ERERqYCpU6fSvn17goKCePbZZ6v1s9euXWtdK+f9999n+vTp3HPPPdVaQ2VSt1QlmzpvByHLn+M2p9+h2wMw5JVK/wwRqf1qc7eUyF+prG4ptdxUsugg77MGFWulYhERkeqmcFPJzHDT0nxydIs57kZERESqjcJNJYsM8CTN4suukobmAU0JFxERqVYKN5XMzdmRJg08WaX1bkRERGxC4aYKRAdq3I2IiIitKNxUgeggL9aUjrtJ3QbZx21bkIhINerXr1+Z/ZOaNGnCm2++abN67N2f75dcOi3iVwWig705iQ/7HcMJL95vdk21vsbWZYmI2ERcXNw5O0rLGd9//32ZXczl0qnlpgpEB3kDsLzodOuNxt2ISB0WEBBQaZteXorCwkJbl3Befn5+eHt727qMWkXhpgo08ffE2dHCH4UtzAMadyMiddifu6UsFgv//e9/ufbaa/Hw8CAqKoq5c+eWec22bdsYOnQoXl5eBAUFcdttt3H8+Jku/nnz5tGrVy/q1auHv78/V111FXv37rWeT0pKwmKx8M0339CvXz/c3Nz4/PPPz1vfhAkTaNy4Ma6uroSGhvLII4+Uqf3FF19k9OjReHl5ERoayttvv13m9dOmTSMmJgZPT0/CwsIYN24cWVlZZa5ZsWIFffv2xcPDg/r16zN48GDS0tKA83fjTZo0iTFjxuDt7U3jxo354IMPyrzfypUrad++PW5ubnTu3JkffvgBi8VCQkLCX/+HqEMUbqqAi5MDEQ08z4y7ObYDso7ZtigRqfkMAwqybfOo5MXsJ06cyA033MCmTZsYOnQot9xyCydPmuuCHTlyhL59+9K+fXvWrVvHvHnzOHr0KDfccIP19dnZ2Tz++OPExcWxaNEiHBwcuPbaaykpKSnzOU8//TSPPPII27dvZ/DgwefU8d133/HGG28wY8YMdu/ezQ8//EBMTEyZa1599VXatm3L+vXrefbZZ3nsscdYuHCh9byDgwPTp09ny5YtzJo1i8WLF/PUU09ZzyckJNC/f39at27NqlWrWL58OcOHD6e4uPgv78/rr79O586d2bBhA+PGjeOBBx5gx44dAGRmZjJ8+HBiYmJYv349L774Ik8//fQF3P3aT2Nuqkh0kDe7jmZxwjMK/+zdZutNm5G2LktEarLCHJgUapvP/mcyuFTeuJk777yTm2++GYBJkybx9ttvs3btWq688kree+89OnbsyKRJk6zXf/zxx4SFhbFr1y6io6O57rrryrzfRx99RGBgINu2baNNmzbW4+PHj2fkyL/+u/fAgQMEBwczYMAAnJ2dady4MV27di1zTc+ePXnmmWcAiI6OZsWKFbzxxhsMHDjQ+hmlIiIiePHFF3nggQesG09OnTqVzp07l9mIsnXr1uXen6FDhzJu3DjADGhvvPEGS5cupUWLFnzxxRdYLBY+/PBD3NzcaNWqFYcPH2bs2LHlvmddopabKlI67marazvzgMbdiIhYtW3b1vq1p6cn3t7epKamAhAfH8+SJUvw8vKyPlq0MLv5S7ue9u7dy+jRo4mMjMTHx4eIiAjADCtn69y5c7l1jBo1itzcXCIjIxk7dixz5syhqKiozDXdu3c/5/n27dutz5csWcLAgQNp2LAh3t7e3H777Zw4cYLs7GzgTMvNhTj7/lgsFoKDg633Z+fOnbRt27bM3kt/DmR1nVpuqkh0kBcAywpb0Ac07kZELp2zh9mCYqvPrsy3+9PsIIvFYu1SKikpYfjw4UyZMuWc14WEhAAwfPhwwsLC+PDDDwkNDaWkpIQ2bdpQUFBQ5vq/m6UVFhbGzp07WbhwIb///jvjxo3j1VdfJTY2ttwZTBaLBYD9+/czdOhQ7r//fl588UX8/PxYvnw5d999t3UAs7u7+9/cjXOVd38Mw7B+fqk6tgf231K4qSKlLTdzTzXhn44WLMd3QeZR8A6ycWUiUmNZLJXaNWSvOnbsyOzZs2nSpAlOTuf+mjpx4gTbt29nxowZ9O7dG4Dlyy++ddzd3Z0RI0YwYsQIHnzwQVq0aMHmzZvp2LEjAKtXry5z/erVq60tSevWraOoqIjXX38dBwezM+Sbb74pc33btm1ZtGgREydOvOgaz1baNZWfn4+rq6u1DjlD3VJVJNzfExcnB44WelDYQKsVi4hU1IMPPsjJkye5+eabWbt2Lfv27WPBggWMGTOG4uJi6tevj7+/Px988AF79uxh8eLFPP744xf1WZ988gkfffQRW7ZsYd++fXz22We4u7sTHh5uvWbFihVMnTqVXbt28e677/Ltt9/y6KOPAtC0aVOKiop4++23ra9///33y3zGs88+S1xcHOPGjWPTpk3s2LGD9957r8zsrwsxevRoSkpKuPfee9m+fTvz58/ntddeAzinRaeuUripIo4OFpoFmF1TR/y6mAc17kZE5G+FhoayYsUKiouLGTx4MG3atOHRRx/F19cXBwcHHBwc+Prrr4mPj6dNmzY89thjvPrqqxf1WfXq1ePDDz+kZ8+e1haWn376CX9/f+s1TzzxBPHx8XTo0IEXX3yR119/3Trzqn379kybNo0pU6bQpk0bvvjiCyZPnlzmM6Kjo1mwYAEbN26ka9eudO/enR9//PG8rVIV4ePjw08//URCQgLt27fnueee4/nnnwcoMw6nLrMYdayjLiMjA19fX9LT0/Hx8anSzxr/9QZ+SEjm3U4pDNv6OPg3g4fjq/QzRaR2yMvLIzExkYiICP3CsqEmTZowfvx4u98e4YsvvuCuu+4iPT39osb42Ivyfu4v5Pe3xtxUoajT426WFUQxDAuc2AMZR8AnxMaViYhITfbpp58SGRlJw4YN2bhxI08//TQ33HBDjQ42lUndUlWo+elwk3AMCDk9rU9dUyIicolSUlK49dZbadmyJY899hijRo06ZxXjukwtN1WodMbUvmPZlPTujcORjeag4rajbFyZiIhURFJSkq1LOK+nnnqqzCrIUpZabqpQo/ruuDs7UlBcwlH/0wtJacaUiIhIlVK4qUIODhaiTi/mt8WxNVgc4OQ+SD9s48pEpKaoY3M+pI6rrJ93hZsqVto1te2kBUK0FYOIVEzpCrU5OTk2rkSk+pT+vJe3OnRFaMxNFSvdhmHX0Uxo0huSN0DSH9DuRhtXJiL2zNHRkXr16ln3E/Lw8NACbVJrGYZBTk4Oqamp1KtXD0dHx0t6P4WbKlY6HXzX0Uzo0htWTlfLjYhUSHBwMIA14IjUdvXq1bP+3F8KhZsqVjodPPF4NgUNe+JicYS0JDh1AOo1tm1xImLXLBYLISEhBAYGWjdhFKmtnJ2dL7nFppTCTRUL8XXD29WJzPwiEjMdaN6wIxyKg8Rl0OEWW5cnIjWAo6Njpf2lL1IXaEBxFbNYzsyYso67AU0JFxERqSIKN9Ug+uxxNxF9zIOJf4CmeIqIiFQ6hZtqUCbchHUDB2fIOGyueSMiIiKVSuGmGpwJN1ng4gFhXc0TiX/YsCoREZHaSeGmGpSudbP/RDZ5hcUadyMiIlKFFG6qQYC3K/U8nCkxYO+xLIg4HW4Sl2ncjYiISCVTuKkGFouF6MCzxt006gJObpCdCsd22rg6ERGR2kXhpppEB5dOB88CJ1dzYDGoa0pERKSSKdxUE+ug4pRM84C1a0qDikVERCqTwk01iSrtlkotDTd9zT+TlkFJiY2qEhERqX3sKtwUFRXxr3/9i4iICNzd3YmMjOTf//43JWf98jcMgwkTJhAaGoq7uzv9+vVj69atNqy6YkpnTB08mUt2fhGEdgBnT8hNg1T7r19ERKSmsKtwM2XKFN5//33eeecdtm/fztSpU3n11Vd5++23rddMnTqVadOm8c477xAXF0dwcDADBw4kMzPThpX/PX8vVxp4uQCwJzULHJ0hvId5MlHjbkRERCqLXYWbVatWcfXVVzNs2DCaNGnC9ddfz6BBg1i3bh1gttq8+eabPPfcc4wcOZI2bdowa9YscnJy+PLLL21c/d8rs1IxaNyNiIhIFbCrcNOrVy8WLVrErl27ANi4cSPLly9n6NChACQmJpKSksKgQYOsr3F1daVv376sXLnyvO+Zn59PRkZGmYetlIabnaWDiksX89u/EkqKbVSViIhI7eJk6wLO9vTTT5Oenk6LFi1wdHSkuLiYl19+mZtvvhmAlJQUAIKCgsq8LigoiP3795/3PSdPnszEiROrtvAKimnoC8CKvSfMAyHtwNUX8tPhyEZo2NGG1YmIiNQOdtVy87///Y/PP/+cL7/8kvXr1zNr1ixee+01Zs2aVeY6i8VS5rlhGOccK/Xss8+Snp5ufRw8eLDK6v87V7QIxNHBwvYjGRw4kQMOjtCkp3lSXVMiIiKVwq7CzZNPPskzzzzDTTfdRExMDLfddhuPPfYYkydPBiA4OBg404JTKjU19ZzWnFKurq74+PiUedhKfU8XukX4ATB/6+nvQftMiYiIVCq7Cjc5OTk4OJQtydHR0ToVPCIiguDgYBYuXGg9X1BQQGxsLD169KjWWi/W4NZmQLOGm4g+5p/7V0FxoY2qEhERqT3sKtwMHz6cl19+mV9++YWkpCTmzJnDtGnTuPbaawGzO2r8+PFMmjSJOXPmsGXLFu688048PDwYPXq0jauvmEGtzRam+ANppGbmQWArcPeDwmw4vN7G1YmIiNR8djWg+O233+b//u//GDduHKmpqYSGhnLffffx/PPPW6956qmnyM3NZdy4caSlpdGtWzcWLFiAt7e3DSuvuBBfd9o18mXjoXQWbjvKLd3CoUkv2D4Xkv6Axt1sXaKIiEiNZjEMw7B1EdUpIyMDX19f0tPTbTb+5j9L9zB13k76RAfw6ZiusPZD+PUf5pYMd8y1SU0iIiL27EJ+f9tVt1RdUTruZtXe42TkFZ4Zd3NwDRTl27AyERGRmk/hxgaaBnjRLNCLwmKDJTtSoUE0eAVBUR4cirN1eSIiIjWawo2NXHm69WbelhSwWM5MCdc+UyIiIpdE4cZGSrumlu48Rl5hsfaZEhERqSQKNzbSpqEPDeu5k1tYzLLdx8+MuzkUBwU5ti1ORESkBlO4sRGLxcLAVuaaN/O3pkD9CPBpBCWF5sBiERERuSgKNzZ0ZRuza+r37UcpKjHUNSUiIlIJFG5sqEsTP/w8XTiVU8jaxJNnuqa0z5SIiMhFU7ixIUcHCwNaBgKnu6ZKZ0wdXg/5mTasTEREpOZSuLGxMxtpHqXEpxHUbwJGsbmRpoiIiFwwhRsb69msAZ4ujqRk5LHpcPqZrqnt2oZBRETkYijc2JibsyP9WpzVNdXqGvPEhs9g3ce2K0xERKSGUrixA9auqS0pGE2vgH7Pmid+eQJ2/mbDykRERGoehRs7cHnzAFwcHdh3PJs9qVnQ92nocBsYJfDtXXBona1LFBERqTEUbuyAt5szPZv5A6e7piwWuOoNaDYQinLhyxvgxF4bVykiIlIzKNzYibNnTQHg6AyjPoGQ9pBzAj6/DrKO2aw+ERGRmkLhxk4MaBWEgwU2H07nUNrpvaVcveCWb6FeOKQlmi04Bdm2LVRERMTOKdzYiQZernRu4gfAgtLWGwCvQLh1Nrj7QfJ6+G4MFBfZqEoRERH7p3BjR850TaWUPdEgCm7+GpzcYNc8+PUJMAwbVCgiImL/FG7syKDTu4THJZ3kRFZ+2ZONu8F1/wUsEP8JLHut2usTERGpCRRu7EiYnwetQ30oMcydws/RcjgMfdX8evFLsOX76i1QRESkBlC4sTNXnu6a+nLNAYzzdT11HQvdHzK/Xvl2NVYmIiJSMyjc2JmbujbGw8WRjYfSzx17U6rHw+afyeshK7X6ihMREakBFG7sTIC3K/f0igDg1fk7KSouOfci72AIaWd+vXthNVYnIiJi/xRu7NDYPpHU93Bm77Fsvl9/+PwXRQ02/9y9oPoKExERqQEUbuyQt5szD17eDIA3ft9FXmHxuRdFDTL/3LsYigursToRERH7pnBjp269LJxQXzeOpOfx2ar9517QsCN4+EN+BhxYXf0FioiI2CmFGzvl5uzI+IHRALy7dA8ZeX9qnXFwNDfWBHVNiYiInEXhxo6N7NCQZoFenMop5MM/9p17QfTprimFGxERESuFGzvm5OjAPwY1B+C/yxI5lvmnVYubXgEWRzi2A9LO03UlIiJSBync2LnBrYNoF1aP3MJi3l68u+xJ9/oQ1s38Wq03IiIigMKN3bNYLDx9pdl68+WaAxw4kVP2AnVNiYiIlKFwUwP0aNqA3lENKCoxmLZwZ9mTpVPCE/+AgpxzXywiIlLHKNzUEE9f2QKAHzcmsy0548yJwFbg0wiK8iBpmY2qExERsR8KNzVEm4a+XNU2BMOA1xac1XpjsahrSkRE5CwKNzXIE4Oa4+hgYfGOVNYmnjxzonQrhl0L4Hw7iYuIiNQhCjc1SEQDT27sEgbAlHk7MEqDTERvcHSF9APmtHAREZE6TOGmhnm0fxSuTg7E709j3pYU86CLpxlwQF1TIiJS5ync1DBBPm7c1TMCgEe/TuDLNQfME2d3TYmIiNRhCjc10KP9o7iydTAFxSX8c85mnpm9ifzI/ubJA6sg95RN6xMREbElhZsayN3Fkfdu7chTVzbHYoGv4w5ywzcpFPlFgVEM+5bYukQRERGbUbipoSwWC+P6NWPWXV3xdXdm48FTfJVmroWjrikREanLFG5quD7RAfz8cC9ahvjwa35bAHK3z8MoKbZxZSIiIrZhV+GmSZMmWCyWcx4PPvggAIZhMGHCBEJDQ3F3d6dfv35s3brVxlXbXpifB98/0IPQmH5kGu64F5xk2qxvyC1QwBERkbrHrsJNXFwcR44csT4WLlwIwKhRowCYOnUq06ZN45133iEuLo7g4GAGDhxIZmamLcu2C+4ujrx2UxdOBPUEwHHvAka+t5K9x7JsXJmIiEj1sqtwExAQQHBwsPXx888/07RpU/r27YthGLz55ps899xzjBw5kjZt2jBr1ixycnL48ssv//I98/PzycjIKPOorSwWC026XwvAQKeNbD+SweA3/mDC3K2czC6wcXUiIiLVw67CzdkKCgr4/PPPGTNmDBaLhcTERFJSUhg0aJD1GldXV/r27cvKlSv/8n0mT56Mr6+v9REWFlYd5dtOs4EAtGYv1zRzoqjE4JOVSfR9dQkzYveSV6iuKhERqd3sNtz88MMPnDp1ijvvvBOAlBRzNd6goKAy1wUFBVnPnc+zzz5Lenq69XHw4MEqq9kueAdBSHsA3ux0nC/u6UarEB8y84qY/NsO+r8ey48Jhykp0R5UIiJSO9ltuPnoo48YMmQIoaGhZY5bLJYyzw3DOOfY2VxdXfHx8SnzqPWiT69WvHs+PZs14OeHe/HaqHYE+7hx+FQuj36dwLX/WcGafSdsW6eIiEgVsMtws3//fn7//Xfuuece67Hg4GCAc1ppUlNTz2nNqfNKt2LYuwSKC3FwsHB9p0Ys+Uc//jEoGk8XRzYeSufGD1Yz9tN1bD9Se8chiYhI3WOX4WbmzJkEBgYybNgw67GIiAiCg4OtM6jAHJcTGxtLjx49bFGm/QrtAB4NID8DDqy2HnZ3ceShK6JY+uTl3NKtMY4OFhZuO8qQt5Zxy39Xs3jHUXVXiYhIjWd34aakpISZM2dyxx134OTkZD1usVgYP348kyZNYs6cOWzZsoU777wTDw8PRo8ebcOK7ZCDA0SZA4vZPf+c0wHerrx8bQzzHu3NsJgQHCywYs8JxnyyjgHTYvlsVRI5BUXVXLSIiEjlsBiGYVf/VF+wYAGDBw9m586dREdHlzlnGAYTJ05kxowZpKWl0a1bN959913atGlT4ffPyMjA19eX9PT02j3+Zsts+G4MBLaGcX89mwzgUFoOs1Ym8fXag2Tmm6HG192Zm7s25o4e4YT4uldHxSIiIn/pQn5/2124qWp1JtzknISpkYABT+wE7+C/fUlWfhHfrTvIzJVJ7D+RA4Cjg4WhMSHc2q0xXSP8yh28LSIiUlUUbspRZ8INwIy+cCQBrp0B7W6q8MuKSwwWbT/KR8sTWZN40no8zM+dkR0aMbJjQ8L9PaugYBERkfNTuClHnQo3v0+E5dOg7U0wcsZFvcWWw+l8uiqJXzenkJV/ZhxOlyb1GdmxEUNjQvB1d66sikVERM5L4aYcdSrcJP4Bs4aDV5DZNXUJXUq5BcUs2JbCd/GHWLHnOKWTqlycHBjUKojrOjaid1QDnBztboy6iIjUAgo35ahT4aYoH6Y0gcIceGAlBLWulLdNSc/jh4TDzI4/xO7UMxtz1vdwZlCrYIa2DaFHU3+cFXRERKSSKNyUo06FG4DPr4c9C2HQS9Dj4Up9a8Mw2HI4g9nrD/HTxmROnLU5p6+7MwNbBTEsJoSezRrg4qSgIyIiF0/hphx1Ltysehfm/xOa9ofbvq+yjykqLmFt4kl+2XyE+VtTOJ51Juh4uzkxsGUQQ2JC6B3VADdnxyqrQ0REaieFm3LUuXCTuh3+cxk4ucPTSeDsVuUfWVxiEJd0kl83H+G3LSkcy8y3nnN3dqRPdAMGtAziihaB+Hu5Vnk9IiJS8ynclKPOhRvDgGktIfMI3P4jRPar1o8vKTGIP5DGL5uOMG9LCikZedZzFgt0bFyfAS2DGNgqkKYBXlpHR0REzkvhphx1LtwAzLkfNn4FPcfDwIk2K8MwDLYmZ7Bw21F+336UrcllN+xs4u9htui0DKRzuJ/G6YiIiJXCTTnqZLjZ9A18PxaC28L9y2xdjVXyqVwWbT/Kwu2prNp7nMLiMz+KXq5O9GrWgMtbBNA3OpBg36rvThMREfulcFOOOhluslLhtSjz6yf3gmcD29ZzHln5RSzbdYyF248Su/NYmZlXAC1DfLi8eQCXtwikQ1g9racjIlLHKNyUo06GG4D3esHRzXDdRxBzva2rKVdJicHmw+ks2ZnK0p3H2HjoFGf/lPq4OdE7KoA+0Q3oEx2gjT1FROoAhZty1Nlws+BfsPJtaH8rXPOurau5ICey8vlj9zGW7DhG7K5jpOcWljkfFehFn+gA+kQH0C3CT1PNRURqIYWbctTZcLNnEXw+EnwawmNbL2krBlsqKi5h46FTxO46zrLdx9h48JR1Kwgwt4PoFuFHn6gAekc3oHmQt2ZgiYjUAgo35aiz4aYwF14Jh+J8eDAOAqJtXVGlOJVTwIo9J/hj1zH+2H2MI+l5Zc438HKlVzN/ekUF0KtZAw1MFhGpoRRuylFnww3Ap1fDvqVw5RS47H5bV1PpDMNg77EsYncd549dx1iTeIK8wpIy1zQL9KJXswb0ataAbpF+eLtpR3MRkZpA4aYcdTrcLH8Tfn8Boq+E0f+zdTVVLr+omPX7T7F8zzGW7znB5kNlu7AcHSy0D6tHj6b+9GjagI7h9XB10ngdERF7pHBTjjodbo5sghm9wdnT3IrBycXWFVWr9JxCVu07zrLdx1mx5zhJJ3LKnHd1cqBLEz96NPOnZ9MGtGnoi6ODxuuIiNgDhZty1OlwU1JirneTcxzu/BWa9LR1RTZ18GQOK/ceZ8WeE6zce4LjWfllznu7OXFZpD89mvrTvak/0YHeOCjsiIjYhMJNOep0uAGYfQ9s/hb6PAlX/MvW1dgNwzDYnZrFij3HWbn3BKv3nSAzr6jMNX6eLlwW6Uf3SDPsaC8sEZHqo3BTjjofbjZ8AT+Og4adYOxiW1djt4qKS9iSnMGKPcdZve8E65LSyC0sLnNNgLcrl0X6W8NOE38PhR0RkSqicFOOOh9uMpLNXcItDuZWDB5+tq6oRigoMtfXWbX3BKv2niD+QBoFRWVnYgX5uNItwp/LIv3pFulHZANPhR0RkUqicFOOOh9uAN7tBsd2wKhZ0PoaW1dTI+UVFpNw8HTY2XeChAOnKCguG3YCvF3pFuHHZZFm4GkaoLAjInKxFG7KoXAD/PYMrHkPOt0Jw9+ydTW1Ql5hMRsOnGL1PnO8zoaDp85p2Wng5ULXCD+6NvGjW6Q/zYM0QFlEpKIUbsqhcAPsWgBfjoJ6jeHRTTV2KwZ7Vtqys2bfSVbvO8H6A2nk/yns+Lo706VJfbpF+NM1wo/WoT7a7VxE5C8o3JRD4QYoyDa3YigphIfXg39TW1dU6+UXFbPpUDpr9p1gTeJJ4venkVNQdoCyp4sjHcPr0y3Cj64R/rRt5KtNQEVETruQ399O1VST2BMXTwjrBvuXw74lCjfVwNXJkS5N/OjSxI+HgMLiErYmZ7A28QRrE0+yNvEkGXlFLNttLjII4OLoQPuwenSJqE/XCH86hdfHy1X/y4qI/B213NRVf7wGi1+EFlfBTV/Yupo6r7jEYEdKBnGJJ4lLSmNN4slzFhV0sEDrUF+6NPGja4QfXZrUx9/L1UYVi4hUL3VLlUPh5rTD8fDhFeDqA08lgqNaBOyJYRgkncg53bKTRlzSSQ6czDnnuqYBnnSN8KdrRH26NPGjUX0PG1QrIlL1qizcREREXNRU1vHjx/PII49c8OuqgsLNaSXFMDUS8k7B3QshrKutK5K/kZKex5rEE8QlnSQuMY2dRzPPuSbU182ckXV6kLKmn4tIbVFl4SY2NvaiCmrSpAnh4eEX9drKpnBzlm/ugG0/QL9nod8ztq5GLlBadgHr9putOmsTT7LlcDpFJWX/dy6dfl46I0vTz0WkplK3VDkUbs6y/lOY+zDUbwIPrQNHZ1tXJJcgp6CIDQdOsSbxJGsTT7DhwKlzpp/X83CmSxM/6+KCrUJ8FHZEpEZQuCmHws1Z8rPgrXbmLuEj3oGOt9m6IqlEFZl+Xt/DmR7NGtC7WQN6NmtAmJ/G7IiIfVK4KYfCzZ+sfAcWPAe+jeHheHBysXVFUkUKi0vYcjidtYnmwoJrE0+S/aewE+7vQa9mDejVrAE9mjbA10OteSJiHzSguBwKN39SkAPT20PWUbjqDeg8xtYVSTUpLC5h48FTLNt9nBV7jrPh4CmKzxqz42CBdmH1GNQqmEGtg2ga4GXDakWkrtOA4nIo3JzH6vdh3tPg0xAe2QBOWjulLsrMK2TNvpMs32OGnd2pWWXONw3wZFDrYAa1CqJdo3oaqyMi1UrdUuVQuDmPwjyY3gEyk2Hoa9B1rK0rEjtwJD2XRdtTWbDtKKv2Hqew+MxfFYHergxoFcSgVkF0b+qPq5O2iRCRqlVt4aawsJCUlBRycnIICAjAz8/vYt+q2ijc/IW4/8IvT4BXMDyaAM7utq5I7EhGXiFLdx5jwdYUlu48RlZ+kfWcr7szI9qFcn2nRrRt5Kt1dUSkSlRpuMnKyuKLL77gq6++Yu3ateTn52MYBhaLhUaNGjFo0CDuvfdeunTpcknfRFVRuPkLRfnwdidIPwiDJ0P3cbauSOxUflExq/edZMHWFBZsO8qxzDPbREQFenFdp0Zc26EhQT5uNqxSRGqbKgs3b7zxBi+//DJNmjRhxIgRdO3alYYNG+Lu7s7JkyfZsmULy5YtY86cOVx22WW8/fbbREVFXfI3VJkUbsoR/wn89Ch4BsCjG80NNkXKUVxisHLvcb6LP8S8LSnWdXUcLNAnOoDrOzViQMsg7W4uIpesysLNqFGjeP7554mJiSn3uvz8fD766CNcXFy45557Kvr21ULhphzFhWbrzan9MPBF6GkfM9ykZsjIK+SXTUeYHX+IdfvTrMd93Jy4un1DbuseTnSQtw0rFJGaTAOKy6Fw8zc2fAE/jgMPf7P1xlW/jOTCJR7PZnb8Ib5ff4jk9Dzr8e6R/tzePZyBrYJwcnSwYYUiUtPYJNzMnDmTu+66qzLeqkop3PyN4iJ4twuc3Af9n4feT9i6IqnBSkoMVuw9zuer97Nw21FKl9EJ8XXjlm6NubFLYwK8tfSAiPy9C/n9XWn/dPr+++9ZsmSJ9Xlubi633HLLBb/P4cOHufXWW/H398fDw4P27dsTHx9vPW8YBhMmTCA0NBR3d3f69evH1q1bK+V7EMDRCfqe3kRzxXTIy7BtPVKjOThY6B0VwIzbOrPs6St48PKm+Hu6cCQ9j9cW7KLHK4sY//UG4venUccakUWkClVauPn888957rnn2LFjB7t376Z3797069fvgt4jLS2Nnj174uzszG+//ca2bdt4/fXXqVevnvWaqVOnMm3aNN555x3i4uIIDg5m4MCBZGZmVta3IjHXQ4NoyDsFa963dTVSSzSs586Tg1uw8tkreOPGdrQPq0dhscEPCclc995Krn53BXM3JlNUXPL3byYiUo5L7pZ6/PHHad++Pe3bt8fFxYXRo0djGAYff/wxHTp0uKD3euaZZ1ixYgXLli0773nDMAgNDWX8+PE8/fTTgDl4OSgoiClTpnDfffed85r8/Hzy889MVc3IyCAsLEzdUn9ny2z4bgy4+sL4TeBez9YVSS206dApPl21n7kbkyk4PdOqYT13xvSK4MYuYXi5Otm4QhGxF9XaLdW3b1/279/Piy++yKhRo9i/fz+hoaEsWLCAX3755YLea+7cuXTu3JlRo0YRGBhIhw4d+PDDD63nExMTSUlJYdCgQdZjrq6u9O3bl5UrV573PSdPnoyvr6/1ERYWdnHfaF3T6loIbAX56bDqXVtXI7VU20b1eG1UO1Y9cwWPDYjG39OFw6dyefHnbfSYvIgp83ZwNCPv799IROQslT5bKjc3ly1btrBp0ya2bNnCG2+8UeHXurmZi349/vjjjBo1irVr1zJ+/HhmzJjB7bffzsqVK+nZsyeHDx8mNDTU+rp7772X/fv3M3/+/HPeUy03l2DbXPjmNnDxNltvPOx/BWqp2fIKi/l+/WH+u2wf+45nA+DsaOHq9g0Z2zuS5sGavSdSV1XpbKnS1YirgouLC507dy7TCvPII48QFxfHqlWrrOEmOTmZkJAQ6zVjx47l4MGDzJs3728/Q7OlLkBJCXzQB1I2Q/tbYPh0c8CxSBUrKTFYtCOVD//Yx9qkk9bjfaMDuL9vUy6L9NM2DyJ1TJV2S3l5edGzZ08eeeQRZs2axZYtWygpqZwBgCEhIbRq1arMsZYtW3LgwAEAgoODAUhJSSlzTWpqKkFBQZVSg5zFwQH6v2B+nfAFfHEd5Jws/zUilcDBwcLAVkF8c3935ozrwbCYEBwsELvrGDd/uJpr/rOSeVtSKCnRDCsROdcFh5tXX32Vli1bsmzZMsaOHUu7du3w9vame/fuPPTQQ8ycOZONGzdeVDE9e/Zk586dZY7t2rWL8PBwACIiIggODmbhwoXW8wUFBcTGxtKjR4+L+kz5G1EDYdQn4OwB+5bCB/3MlhyRatKhcX3evaUjS/9xObddFo6rkwMbD57i/s/jGfBGLP+LO0B+UbGtyxQRO3JJY27y8/Nxd3fnn//8JydPnmT9+vVs2rSJ/Px8iosv/C+buLg4evTowcSJE7nhhhtYu3YtY8eO5YMPPrCumTNlyhQmT57MzJkziYqKYtKkSSxdupSdO3fi7f33/fHqlrpIR7fC16MhLQmc3OGad6HNdbauSuqg41n5fLIiiU9XJZGRZ+5OHuTjypieEYzu1hhvN2cbVygiVaFaVyh2cHAgISGBtm3bAlBcXMzWrVutzy/Uzz//zLPPPsvu3buJiIjg8ccfZ+zYsdbzhmEwceJEZsyYQVpaGt26dePdd9+lTZs2FXp/hZtLkHMSZt8Nexebz3s8AgMmgIM2RZTql5VfxFdrDvDf5fs4mmFOGvB2c+LWy8K5q0cTArUruUitYtNwY+8Ubi5RSTEs+jeseNN8Hnk5XP+xZlKJzeQXFfPjhmTe/2Mv+46ZM6xcHB24pkMo9/aJpFmgZliJ1AYKN+VQuKkkW76HHx+Ewhyo3wRu/AKCK9Z6JlIVSkoMFm4/ygd/7CP+rF3J+7cIZGyfSLpFaIaVSE1WpeFm7NixdOrUic6dOxMTE4O7uzsbN24kJibmkoquLgo3lShlizkO59R+c8DxiLfNrRtEbCx+/0lmxO5j4fajlP4N166RL/f2acqVbYJxdFDIEalpqjTc9OnTh40bN5KZmYmTkxNFRUWMHDmSfv360bFjR9q3b4+Hh8clfQNVSeGmkuWcNLdp2Hd609QuY2Hwy+CknZ7F9vYdy+K/yxP5Lv6QdXuHxn4e3N0rgus7NcJT2zuI1BjV0i21e/du4uPjWb9+PfHx8WzYsIFTp07h6OhIdHS03e7UrXBTBYqLYOkkWPa6+Ty0ozl9vH64TcsSKXU8K59PVybx6er9nMopBMzBxzd3bczt3cNpVN9+/0EmIqZqHXNztsTERNatW8eGDRuYNGlSZb1tpVK4qUK7FsCceyE3DdzqwbUzoPmVtq5KxCqnoIjv4g8xc0USiae3d3CwwJVtghnTM4JO4fU1LkfETlVZuDlw4ACNGzeucCGHDx+mYcOGFb6+OijcVLFTB+DbO+FwvPm812Nw+b+0bYPYlZISg6W7Uvl4eRLL9xy3Hm/byJcxPSMYGhOCi9Ml7yssIpWoyrZf6NKlC2PHjmXt2rV/eU16ejoffvghbdq04fvvv7+Qt5faoF5juGsedL3PfL78Dfj0ashMKf91ItXIwcHCFS2C+Pyebswb35ubuoTh4uTApkPpjP9fAr2mLOadxbs5kZX/928mInbnglpuTp48yaRJk/j4449xdnamc+fOhIaG4ubmRlpaGtu2bWPr1q107tyZf/3rXwwZMqQqa78oarmpRlvnwI8PQ0EmeAbC9R9BRB9bVyVyXiey8vlq7QE+XbWf1Ewz1Lg4OTCiXSh39mhCm4a+Nq5QpG6r8jE3eXl5/PrrryxbtoykpCRyc3Np0KABHTp0YPDgwRVeLdgWFG6q2fE98M3tkLoVLA5w+XPQ63FzU04RO1RQVMIvm5P5ZEUSGw+lW493Dq/PnT2bMLh1MM6O+vkVqW7VMqA4IyOjRoYDhRsbKMiBX5+EhM/N59FXwrXvg3t929Yl8jc2HEjjk5VJ/LLpCEWndyAP9nHjtu7h3NQlDH8vLXkgUl2qJdw4OjryzTffcN11NWvzRIUbG1r/KfzyDyjOh3rhcONnENLO1lWJ/K2jGXl8seYAX67Zz/GsAkBdViLVrVrCjYODA1dccQWZmZlYLBY6d+7MbbfdRrdu3S6q6OqicGNjRzbC/24zVzV2dIVhr0PH22xdlUiF5BcV88umI8xckcTmw+qyEqlO1RZu/P39uemmm/D09CQ+Pp5ly5bxwAMP8MYbb1xU4dVB4cYO5KbBnPth1zzzeYfbYOir4Oxu27pEKsgwDNYfOMWslUn8urlsl9WtlzXmpq6NaaAuK5FKVW3hZv78+QwcONB6bPPmzVxzzTWMGzeOJ5544mLetsop3NiJkhJYPg2WvAxGCQS3hRs+Bb8IW1cmckHOdFkd4PjpqeMujg4MP91lFdNIXVYilaFawk1AQADLli2jRYsWZY7/8ssvjB8/nt27d1/M21Y5hRs7s3cJzL4bck6Amy9c+4FWNZYaKb+omF83H+GTlfvZePCU9XjHxvW4s2cEQ9qoy0rkUlRLuBkwYAAdOnTg1VdfLXN8586dtGvXjry8vIt52yqncGOH0g/Dt3fAoTjzee8nzCnjDo62rUvkIm04kMaslUn8svkIhcXmX7GB3q7c0i2c0d0aE+CtLiuRC1Ut4Wb16tVcfvnlXHvttYwbN462bduSm5vLU089xdq1a9m+fftFFV/VFG7sVFEBLPgXrJ1hPo/sB9d9BJ4NbFqWyKVIzczjqzUH+XzNfo6dXhjQ2dHCVW1DuaNHE9qH1bNtgSI1SLVtnLlx40YeffRRli9fTunbuLm58e233zJ06NCLfdsqpXBj5zZ/B3MfhsIc8GkEN8yCRp1tXZXIJSkoKuG3LUeYtTKJ9QdOWY+3C6vHnT3CGRoTgquTWipFylPtu4KnpqYSHx9PSUkJ3bp1o0ED+/3XtsJNDZC6Hf53K5zYAw7OcOVk6HIPaLdmqQU2HTrFJyuT+HnjEQqKSwBo4OXK6K5hjO4WTrCvm40rFLFP1R5uahKFmxoiLwN+HAfbfzKft70RrnoTXDxsWpZIZTmelc9Xaw7w+Zr9HM0wu6wcHSxc2TqY27qH0y3CD4sCvYiVwk05FG5qEMOAVe/AwhfAKIbA1uaqxv5NbV2ZSKUpLC5hwdajzFqVxNrEk9bjzYO8ub1HONe0b4inq5MNKxSxD1UWbiIiIi7qXxLjx4/nkUceueDXVQWFmxooaTl8exdkp4Krj7kvVYthtq5KpNJtP5LBp6v288OGw+QWFgPg7ebEqE5h3NY9nIgGnjauUMR2qizcxMbGXlRBTZo0ITw8/KJeW9kUbmqojCPw7Z1wcLX5vNdjcMX/abq41ErpuYV8F3+Iz1YlkXQix3q8d1QDbukWzoCWgThpzRypY9QtVQ6FmxqsuBAWPg+r/2M+j+wH130Mnv42LUukqpSUGPyx+xizViaxdNcxSv+2DvZx46auYdzUpbEGIEudoXBTDoWbWmDLbPjxYSjMBt8wc7p4w062rkqkSh08mcOXaw/wTdxBTmSbO5M7OlgY2DKIWy8Lp0dTfxwcNABZai+NuSmHwk0tkbodvr4FTu4FRxcY+hp0usPWVYlUufyiYuZtSeGL1QdYm3RmAHJEA09u6daYkR0b4efpYsMKRaqGxtyUQ+GmFslLhzkPwM5fzOcdb4chr4KzmumlbtiZkskXa/bz/frDZOUXAeamnYNaB3Fz18Z0j1RrjtQe6pYqh8JNLVO6u/jilwADQjvADZ9BvTBbVyZSbbLzi/gxIZmv1h5g8+F06/HGfh7c2CWMUZ0aEeij0C81m8JNORRuaqk9v8PseyA3DTz84fqPzQHHInXMlsPpfB13gB83JJN5ujXH0cHCFS0CublrGH2jA3FUa47UQAo35VC4qcXS9pvbNqRsAosD9H8eeo7Xtg1SJ+UWFPPL5iN8vfYA6/anWY8H+7gxsmNDru/UiMgALxtWKHJhFG7KoXBTyxXmwi9PQMIX5vMWV8E174Gb/ltL3bX7aCb/izvI7PWHSMsptB7vFF6fUZ0aMaxtCN5uzjasUOTvKdyUQ+GmDjAMWPcx/PY0lBSCfxTc+DkEtrB1ZSI2lV9UzKLtqXwXf4ilO1MpOf23v5uzA0PahHB9p0YahCx2S+GmHAo3dcihdfC/2yAzGZw94Zp3ofW1tq5KxC6kZuQxZ8Nhvo0/xJ7ULOvxhvXcua5jQ67t2EjbPYhdUbgph8JNHZN1DL67C5KWmc97PAz9J4CjNiIUATAMg4SDp/gu/hBzNyaTmVdkPdc+rB4jOzbkqrahWjtHbE7hphwKN3VQcREsmggrp5vPm/SG62eCV4Bt6xKxM3mFxczfmsL36w+zbPcxa7eVk4OFfs0DGdmxIVe0CMTNWXu6SfVTuCmHwk0dtvUH+PFBKMgC71C44VMI62LrqkTsUmpmHj9tPMKcDYfYcjjDetzbzYlhMSFc26EhXZr4aXyOVBuFm3Io3NRxx3aa2zac2A0OzjBkCnQeo+niIuXYfTST7zcc5scNh0lOz7Meb1jPneHtQrm6fSgtQ/T3qVQthZtyKNwIeRlmC872uebzdjfDsGng4mHbukTsXEmJwerEE8xZf5h5W1KsiwQCNA/yZkT7UEa0CyXMT/8vSeVTuCmHwo0A5nTxFW+ZY3GMEgiKgRs/Bb9IW1cmUiPkFRazZEcqPyQcZsmOYxQUl1jPdQ6vz9XtQxmmgchSiRRuyqFwI2Uk/gHf3gU5x8HVF0Z+AM2vtHVVIjVKem4h87Yc4ceEZFbtO4Fx1kDkXlENGNEulEGtg/Fy1SxFuXgKN+VQuJFzpB+Gb++AQ3Hm8z5PQr9nwUEzQkQu1NGMPH7amMwPCYfLDER2dXKgf8tARrQLpV9zzbiSC6dwUw6FGzmvogJY8Bys/cB83vQKuO4j8PCzbV0iNdjeY1n8tDGZuRuT2Xcs23rc29WJQa2DGdE+lJ5N/XFydLBhlVJTXMjvb7v6iZowYQIWi6XMIzg42HreMAwmTJhAaGgo7u7u9OvXj61bt9qwYqk1nFxg6Ksw8kNwcoe9i2FGXzi83taVidRYTQO8GD8gmkWP9+Xnh3txb59IQnzdyMwvYvb6Q9zx8Vq6TVrE//2whbikk5SU1Kl/a0sVsquWmwkTJvDdd9/x+++/W485OjoSEGAutjZlyhRefvllPvnkE6Kjo3nppZf4448/2LlzJ97e3hX6DLXcyN9K2QLf3AYn94Hj6dDT8Q5NFxepBCUlBuv2pzF342F+3ZzCyewC67lQXzeGtwtleLtQWof6YNH/c3KWGtstNWHCBH744QcSEhLOOWcYBqGhoYwfP56nn34agPz8fIKCgpgyZQr33XdfhT5D4UYqJPcU/DAOdv5iPm93Mwx7HVy0145IZSksLmHFnuPM3ZjMgq1HyTpranlkA09r0GkW6GXDKsVe1NhuKYDdu3cTGhpKREQEN910E/v27QMgMTGRlJQUBg0aZL3W1dWVvn37snLlyr98v/z8fDIyMso8RP6Wez1zJ/H+L4DFATZ+Bf8dAMd327oykVrD2dGBfs0DmXZDe9b9awDv39qRoTHBuDo5sO94Nm8t2s2AabEMfWsZ78fu5fCpXFuXLDWEXbXc/Pbbb+Tk5BAdHc3Ro0d56aWX2LFjB1u3bmXnzp307NmTw4cPExoaan3Nvffey/79+5k/f/5533PChAlMnDjxnONquZEKS1wG342B7FRw8YIRb0ObkbauSqTWyswr5PftR5mbkMyy3ccpOmssTufw+oxoH8rQmBAaeLnasEqpbjW2W+rPsrOzadq0KU899RSXXXYZPXv2JDk5mZCQEOs1Y8eO5eDBg8ybN++875Gfn09+fr71eUZGBmFhYQo3cmEyU+C7u2H/cvN51/tg0EvmQGQRqTJp2QX8tiWFHxMOszbppHUNHUcHCz2a+jOiXSiD2wTj4+Zs20KlytWacAMwcOBAmjVrxpNPPknTpk1Zv349HTp0sJ6/+uqrqVevHrNmzarQ+2nMjVy04iJY8jIsn2Y+b9gZRn0C9cJsWpZIXZGSnsfPm8yp5ZsOpVuPuzg5cHnzAK5ur13La7MaPebmbPn5+Wzfvp2QkBAiIiIIDg5m4cKF1vMFBQXExsbSo0cPG1YpdYajEwx4AW7+H7jVg8PrYEZv2L3wb18qIpcu2NeNe3pHMvehXiz5Rz8eHxhNs0AvCopKmL/1KOO+WE/nl37n8W8SWLozlaKztoSQusWuWm7+8Y9/MHz4cBo3bkxqaiovvfQSsbGxbN68mfDwcKZMmcLkyZOZOXMmUVFRTJo0iaVLl2oquFS/tP3mqsbJG8znvf9hrmrsqOXlRaqTYRhsP5LJ3I3J/LQxucygY39PF4bGhHB1+1A6Nq6Pg4OmltdkNbZb6qabbuKPP/7g+PHjBAQEcNlll/Hiiy/SqlUrwPwhnjhxIjNmzCAtLY1u3brx7rvv0qZNmwp/hsKNVJqifJj/T4j7r/m8cQ+47r/g29C2dYnUUSUlBusPpPFjQjK/bD5SZg2dhvXcuapdCFe3a0jLEG+toVMD1dhwUx0UbqTSbf4OfhoPBZng7gfXvg/Rg21dlUiddvYaOvO3pJBdUGw9FxXoxdXtQxnRriGN/T1sWKVcCIWbcijcSJU4sRe+uwuObDSf93gYrnhes6lE7EBeYTGLd6QyNyGZxTtSKThrLE6HxvUY0S6UYW1DCPR2s2GV8ncUbsqhcCNVpigfFj4Pa943nzfsDNd/DPXDbVuXiFil5xYyf2sKcxOSWbn3OKVL6DhYoGezBppabscUbsqhcCNVbvvP8OM4yEsHN18Y8Q60GmHrqkTkT1Iz8/hl0xF+TEgm4eAp63EXJweuaB7IiPahmlpuRxRuyqFwI9Xi1AFzVeNDcebzrvfCwBfBWc3eIvZo/4ls5iYk8+PGZPakZlmPe7k6Mah1EFe3b0jPpv44Odr1Ciq1msJNORRupNoUF8Kif8PK6ebz4Bi47iMIaG7bukTkL/3d1PJhbUMY0U5Ty21B4aYcCjdS7XYvhDn3Qc4JcHKHwS9D5zGgqagidq0iU8uHtw2ldaiPppZXA4WbcijciE1kpsCc+2HfEvN582HmBpye/ratS0QqxDq1PCGZ+VvLTi2PDPBkRLtQhrcLpWmAlw2rrN0UbsqhcCM2U1ICa96D3ydAcQF4BZlr4jS9wtaVicgFyCssZsmOVOZuTGbRjlQKis5MLW8d6sOIdqFc1S6UhvXcbVhl7aNwUw6FG7G5I5tg9j1wfKf5vPtD0P95cHK1bV0icsEy8wpZuO0oP21MZtnu4xSVnPmV2im8Ple1DWFoTAhBPppMcKkUbsqhcCN2oSAHFvwL1n1kPtdgY5Ea72R2Ab9tOcJPG5NZk3iS0t+uFgt0beLHVe1CGdImmAZe+ofMxVC4KYfCjdiVnb/Bjw+eGWw86EXoco8GG4vUcEcz8vh1sxl01h84ZT3uYIEeTRtwVdsQrmwTTD0PrWJeUQo35VC4EbuTmQI/PAB7F5vPIy+Hq98B30a2rUtEKsXhU7n8simZnzcdYdOhdOtxJwcLPZs1YFhMCINaByno/A2Fm3Io3IhdKimBtR/A7y9AUR64+sKQKdDuJrXiiNQi+09k8/OmI/y86Qjbj2RYjzs5WOjRrAHDYoIZ1CqY+p4KOn+mcFMOhRuxa8d3m1PGD68zn7e4Cq56A7wCbVuXiFS6fcey+HXzEX7ZnFIm6Dg6WOjR1J9hMSEMbq2gU0rhphwKN2L3iovMVY2XTIKSQvDwh2HToPU1tq5MRKrIvmNZ/LYlhV82HWHbn4LOZZF+XNkmhMGtg+r0zuUKN+VQuJEaI2WL2YpzdLP5PGYUDJkKHn62rUtEqlTi8WyzRedPQcdigU6N63Nlm2CubBNMo/oeNqyy+inclEPhRmqUogL4YyosmwZGMXgFw4jpED3Y1pWJSDVIOp7N/K0p/LYlpczO5QAxDX2tQacurIyscFMOhRupkQ7Fww/3w/Fd5vOYUXDlK+DZwLZ1iUi1ST6Vy4LTQScu6SRnrRdIVKAXA1sFMah1MG0b+tbKTT0VbsqhcCM1VmEuLH4JVv8HjBJzLM6Vr5hBRzOqROqU41n5LNx2lN+2pLByT9mVkYN8XM2g0yqYyyL9cXFysGGllUfhphwKN1LjHY6HuY/A0S3m82YDzRlV9cJsW5eI2ER6biFLd6ayYNtRlu5ILbOpp7erE5e3CGRgqyD6Ng/Ax83ZhpVeGoWbcijcSK1QXAgr3oTYqeYmnC5e0P8Fc3Vjh9rxrzQRuXD5RcWs3HuCBVuPsnDbUY5n5VvPOTlY6Bbpx4CWQQxoGUSYX80akKxwUw6FG6lVju2Cnx6BA6vM5426woi3IbCFbesSEZsrKTHYcPAUC7alsHDrUfYdzy5zPjrIi/4tgxjQMpD2YfVxtPNxOgo35VC4kVqnpMTcgPP3CVCQBY4u0PsJ6DkenOvumhgiUta+Y1ks2p7K79uPsm5/GsVnjdPx93ShX/NA+rcMpFdUA7vsvlK4KYfCjdRa6Yfg58dh93zzuV8kDHkVogbYti4RsTuncgqI3XWMhduOErvrGJl5RdZzTg4WOjepz+XNA7miRSDNAr2w2MGkBYWbcijcSK1mGLB1Dsx7FrJSzGMtR8CVk7URp4icV2FxCXGJJ1m0I5UlO1PZd6xs91Wj+u5c3jyQy1sE0D2yAe4ujjapU+GmHAo3UifkZcDSV2DN++bif86e0O9puGwcONpfc7OI2I+k49ks3ZnK4p3HWL3vBAVFJdZzrk4OdIv0p290AH2jA2ga4FltrToKN+VQuJE6JWUL/PIEHFxtPg9oCcNehyY9bVuXiNQIOQVFrNp7gsU7UlmyI5Xk9Lwy5xvWc6fP6aDTo5l/lY7VUbgph8KN1DklJbDxK1j4f5BzwjzW9iYY9KJ2GxeRCjMMg92pWfyx6xixu46xZt9JCorPtOo4Oljo1Lg+fZsH0L9lIC2CK/d3rMJNORRupM7KOQmLX4R1MwEDXH2gz5PQ7T5wcrV1dSJSw+QUFLFm30lidx3jj13Hykw1v6VbY16+NqZSP0/hphwKN1LnHY43u6qSN5jP60fA4Jeh+VBt4yAiF+3AiRxid5tBZ3S3xlzevHJbhhVuyqFwI4LZVbXpa/h94plZVRF9zVlVQa1tW5uIyHlcyO9vrdMuUhc5OED70fBwvLngn6MrJMbC+73g58cg+7itKxQRuWgKNyJ1masX9H8eHoqDVteYu42v+ximd4SV70BRga0rFBG5YAo3IgL1w+GGWXDnrxDcFvLTYcFz8G5X2PK92Y0lIlJDKNyIyBlNesK9S2HEO+AZCGmJ8N1d8N8rYF+srasTEakQhRsRKcvBETreBo9sgH7/BBcvc2bVpyPgs5FwZJOtKxQRKZfCjYicn6uXuWXDIwnQ9T5wcIa9i2BGb5g9FtKSbF2hiMh5KdyISPm8AmDoVHhoLbS53jy2+Rt4uzP89rRmVomI3VG4EZGK8YuE6z+Ce2Oh6RVQUmhuzPlWO1j0b3MFZBERO6BwIyIXJrQ93DYHbvsBQtpDQRYsex3ebAtLJkHuKdvWJyJ1nsKNiFycppebM6tu/AKC2kBBJsROMUNO7FTIy7B1hSJSRynciMjFs1ig5VVw3zIYNQsCWphr5Cx5Gd5qa7bo5GfZukoRqWO0t5SIVJ6SYtg6B5a+Aid2m8c8/KHHI9DlbnD1tm19IlJj1Yq9pSZPnozFYmH8+PHWY4ZhMGHCBEJDQ3F3d6dfv35s3brVdkWKSFkOjhBzPTy4Bq79wByEnHMCfn8B3mgDSyZr4LGIVDm7DDdxcXF88MEHtG3btszxqVOnMm3aNN555x3i4uIIDg5m4MCBZGZm2qhSETkvB0dodyM8GAdX/wf8m0HeKYh9Bd6MgQX/B5lHbV2liNRSdhdusrKyuOWWW/jwww+pX7++9bhhGLz55ps899xzjBw5kjZt2jBr1ixycnL48ssvbVixiPwlRyfocAs8uBaunwlBMebsqpXTzZDzyxNw6oCtqxSRWsbuws2DDz7IsGHDGDBgQJnjiYmJpKSkMGjQIOsxV1dX+vbty8qVK//y/fLz88nIyCjzEJFq5uAIbUbC/cvg5v9Boy5QnA9x/4XpHeCHcXBsl62rFJFawq7Czddff8369euZPHnyOedSUlIACAoKKnM8KCjIeu58Jk+ejK+vr/URFhZWuUWLSMVZLND8Srh7Idw+FyL6QkkRJHxh7kD+1WjYvwrq1jwHEalkdhNuDh48yKOPPsrnn3+Om5vbX15nsVjKPDcM45xjZ3v22WdJT0+3Pg4ePFhpNYvIRbJYILIv3DEX7v4dmg8FDNj5C8y8Ev47ALb+YM6+EhG5QHYTbuLj40lNTaVTp044OTnh5OREbGws06dPx8nJydpi8+dWmtTU1HNac87m6uqKj49PmYeI2JGwLnDzV+bg4453gKMrHF4H394Bb3eENR9AQbatqxSRGsRuwk3//v3ZvHkzCQkJ1kfnzp255ZZbSEhIIDIykuDgYBYuXGh9TUFBAbGxsfTo0cOGlYtIpQiIhhHT4bEt0OcpcK9v7jz+25PwRmtY/JJmWIlIhTjZuoBS3t7etGnTpswxT09P/P39rcfHjx/PpEmTiIqKIioqikmTJuHh4cHo0aNtUbKIVAWvQLjiOeg1HhK+hFXvQloi/PEqrHgLWo+EbvdBw462rlRE7JTdhJuKeOqpp8jNzWXcuHGkpaXRrVs3FixYgLe3Vj0VqXVcPKHrWOg8Bnb8AivfhkNrYdPX5qNRVzPktLoaHJ1tXa2I2BFtvyAiNceheFg7A7Z8DyWF5jHvEOh8N3S+Czwb2LY+EakyF/L7W+FGRGqezKMQPxPiPoLsVPOYoyu0uQ663QuhHWxbn4hUOoWbcijciNQiRQWw7QdY/R4krz9zPLSjuVFn65Hg4mGz8kSk8ijclEPhRqSWOrQO1rx/en2c011Wbr7QbrTZZRXQ3KblicilUbgph8KNSC2XdQwSPod1M+HU/jPHm/Q2Q06L4eDkYrv6ROSiKNyUQ+FGpI4oKYG9i2Hdx7DrNzBKzOOeAdDhVuhwG/g3tW2NIlJhCjflULgRqYPSD8H6TyF+FmSdtcp5eC/oeDu0GgHO7rarT0T+lsJNORRuROqw4kLY+ZsZdPb8Dpz+68/VF2KuN4NOaHtbVigif0HhphwKNyICmK05CV/C+s8g/cCZ48Ex0OF2aDvK3AJCROyCwk05FG5EpIySEkiMhQ2fwfafoLjAPO7oCs2HQPvR0LQ/ONaoBd1Fah2Fm3Io3IjIX8o5CZu+MbutUreeOe4ZCG1vgHY3mS07IlLtFG7KoXAjIn/LMCBlEyR8BZu/hZzjZ84FxUD7myFmlLnJp4hUC4WbcijciMgFKS40Bx8nfAm75p3ptrI4QrP+EHMDtBhqbvQpIlVG4aYcCjcictFyTsLW780WncPrzhx39oQWw8zWnKaXa5dykSqgcFMOhRsRqRTHd5vjczZ/C2mJZ457+EPra80WnbCuYLHYrkaRWkThphwKNyJSqQwDDsebIWfLbMg+duZcvcbQ5npoMxKC2ijoiFwChZtyKNyISJUpLoLEpbD5O3NaeUHWmXP+UWaLTpuRENjSZiWK1FQKN+VQuBGRalGQY+5pteV72L0QivPPnAtoAa1HmmEnINp2NYrUIAo35VC4EZFql59pbvuwdY4586p0xhWY3VWtr4GWVyvoiJRD4aYcCjciYlO5p04Hne/NXctLis6ca9Dc3MSz5QhzsUCN0RGxUrgph8KNiNiNnJOw4xfY9iPsWwolhWfO1Y+AlsOh1dXQsJOCjtR5CjflULgREbuUewp2zYftc82uq6K8M+d8GppBp8UwaNxD+1xJnaRwUw6FGxGxe/lZsGchbJsLuxeUnXXlXh+iBptBp1l/rYwsdYbCTTkUbkSkRinMhb1LYMfP5lid3JNnzjm6misitxgG0UPAK8B2dYpUMYWbcijciEiNVVwEB9eY43R2/Ayn9p910mKuiBx9JTQfYk431zgdqUUUbsqhcCMitYJhQOq200HnFziSUPZ8vfDTQedKCO8JTq42KVOksijclEPhRkRqpfRD5q7lO+dB4h9lFw108YKmV5hhJ2qQuq+kRlK4KYfCjYjUegXZ5tTyXfPMGVhZR886aYGGHaHZQDPohHYABwdbVSpSYQo35VC4EZE6paTE7LLaNd/cDuLIxrLnPfyh2QAz6DS9Ajz8bFKmyN9RuCmHwo2I1GmZKeY6OrsXmLOw8jPOnLM4QMPOEDUQmvaH0Pbg4GizUkXOpnBTDoUbEZHTigvh4Foz6Oz5HY5uKXvevT5EXm626DTrDz6htqlTBIWbcinciIj8hfTD5uKBe36HfX9AfnrZ8wEtzZDT9HJzBpazu23qlDpJ4aYcCjciIhVQXASH18GeRbB3ERxeD5z168LJDRpfBpH9zNad4LYamCxVSuGmHAo3IiIXIeekOQNr7yLYsxgyk8ued/eDiD5mq05kP6jfxAZFSm2mcFMOhRsRkUtkGHB8lzkged9SSFoOBZllr6kfYYaciD7QpLfW1pFLpnBTDoUbEZFKVlwIh+PNoLNvKRyKg5KistcEtjaDTkQfCO8B7vVsUKjUZAo35VC4ERGpYvmZZmtO4h/m48+zsCwOENL+dNjpDWGXgauXTUqVmkPhphwKNyIi1Sz7OCQtOx12lsGJ3WXPOziZKyWH9zS7sBp3A1dv29QqdkvhphwKNyIiNpaRbIacxFgz9Jw6UPa8xdFcQNAadi4DN/19Xdcp3JRD4UZExM6k7Yf9KyBpxemws7/seYsDBMeYYadxd3PMjmcD29QqNqNwUw6FGxERO3fq4Omws8wcu5OWdO41DZpDePczgadeWLWXKdVL4aYcCjciIjVM+mE4sMoMPPtXwbHt517j29gcq9P4MnOAcmBL7YtVyyjclEPhRkSkhss5eTrsrDQfRzaCUVz2GldfCOtiBp3Gl0HDTuDiYZt6pVIo3JRD4UZEpJbJzzLX1jm4xgw9h9ZBQVbZaxyczC0iwrpBWFfz4dvINvXKRamx4ea9997jvffeIykpCYDWrVvz/PPPM2TIEAAMw2DixIl88MEHpKWl0a1bN959911at25d4c9QuBERqeWKi8y1dQ6ugQOrzceft4sA8GlohpxGXc3QExwDTi7VX69USI0NNz/99BOOjo40a9YMgFmzZvHqq6+yYcMGWrduzZQpU3j55Zf55JNPiI6O5qWXXuKPP/5g586deHtXbE0EhRsRkTrGMCD9IBxYA4fWmqEnZcu5XVlObuZ6O406Q8PO0KgL+Da0Tc1yjhobbs7Hz8+PV199lTFjxhAaGsr48eN5+umnAcjPzycoKIgpU6Zw3333Vej9FG5ERISCbHOn84NrznRp5aade513qBl2Gp0OOyHtNXbHRi7k97dTNdV0wYqLi/n222/Jzs6me/fuJCYmkpKSwqBBg6zXuLq60rdvX1auXPmX4SY/P5/8/Hzr84yMjCqvXURE7JyLp7n1Q0Rv87lhwIk9cHAtHF5nBp6j28zurO1zzQeYCwwGtTbDTmhHc6ByQHPNzLIzdhduNm/eTPfu3cnLy8PLy4s5c+bQqlUrVq5cCUBQUFCZ64OCgti/f//53gqAyZMnM3HixCqtWUREajiLBRpEmY8Ot5jHCrIhOeFM2Dm0DjKPQMom88HH5nUuXmaLTsPTYadhJ3OwssVio29G7C7cNG/enISEBE6dOsXs2bO54447iI2NtZ63/OmHxTCMc46d7dlnn+Xxxx+3Ps/IyCAsTIs9iYjI33DxhCY9zUep9MNm0Eleb3ZrJW8wZ2btX24+SnkGmuN3QjuYoSe0A3gFVv/3UEfZXbhxcXGxDiju3LkzcXFxvPXWW9ZxNikpKYSEhFivT01NPac152yurq64urpWbdEiIlI3+DY0H62vMZ+XFMPxXXA4/szj6FbIToXd881HKZ+GZwJP6cPDzybfRm1nd+HmzwzDID8/n4iICIKDg1m4cCEdOnQAoKCggNjYWKZMmWLjKkVEpE5ycDRXQw5sCR1uNY8V5kLKZrNLK/l0686xnZBx2Hzs+PnM6+s1Nru0QtqZm4WGtNe+WZXArsLNP//5T4YMGUJYWBiZmZl8/fXXLF26lHnz5mGxWBg/fjyTJk0iKiqKqKgoJk2ahIeHB6NHj7Z16SIiIiZn9zMLBZbKzzLH6SRvONOddXKvuSP6qQNnBiwD+DQ6HXTanQ4+bcE7uLq/ixrNrsLN0aNHue222zhy5Ai+vr60bduWefPmMXDgQACeeuopcnNzGTdunHURvwULFlR4jRsRERGbcPUydzMP73HmWO4pM/Ac2Wi28hxJMGdsZRwyH2e38HgGmiEnuO3p0NMW6kdo0PJfsPt1biqb1rkRERG7lZdhdmkdSTgdeDbCid1glJx7rauPuapycNvTf8ZAQItau8pyrVrEr7Ip3IiISI1SkG2uuZOy0Qw7RzZB6jYoLjj3Wgdnc92d0rATHANBbWrFwGWFm3Io3IiISI1XXGgOUk7ZZIado1vMr/PSz3+9T0Mz5AS1huA25td+TcHRrkanlEvhphwKNyIiUiuV7qGVssXs2krZZP556i8WunVyM7uxSkNP6cNOZ2sp3JRD4UZEROqUvHRz7Z2jW80WnqNbzW6uwuzzX+8ZCEGtzNAT2Mr8OqCFOQvMhhRuyqFwIyIidV5JCaQl/in0bIG0pPNfb3EAv0gz7AS2OrO2TzV2bSnclEPhRkRE5C/kZ8GxHWbgSd125s+cE+e/3tEFGkSbQSegxZngUy8cHBwqtbRasSu4iIiIVDNXL3PH80adzxwzDMhKhdTT3VnHtkPqdkjdYXZtlbb6nK3TnTD8rWot/WwKNyIiIvLXLBbwDjIfTa84c7ykxBzAnLrdbN1JPR16ju+CBs1tVy8KNyIiInIxHBygfrj5aH7lmePFRVBSaLu6ULgRERGRyuToZPP1cyp3tI+IiIiIjSnciIiISK2icCMiIiK1isKNiIiI1CoKNyIiIlKrKNyIiIhIraJwIyIiIrWKwo2IiIjUKgo3IiIiUqso3IiIiEitonAjIiIitYrCjYiIiNQqCjciIiJSq9S5XcENwwAgIyPDxpWIiIhIRZX+3i79PV6eOhduMjMzAQgLC7NxJSIiInKhMjMz8fX1Lfcai1GRCFSLlJSUkJycjLe3NxaLpVLfOyMjg7CwMA4ePIiPj0+lvrecoftcPXSfq4fuc/XQfa4eVXmfDcMgMzOT0NBQHBzKH1VT51puHBwcaNSoUZV+ho+Pj/7nqQa6z9VD97l66D5XD93n6lFV9/nvWmxKaUCxiIiI1CoKNyIiIlKrKNxUIldXV1544QVcXV1tXUqtpvtcPXSfq4fuc/XQfa4e9nKf69yAYhEREand1HIjIiIitYrCjYiIiNQqCjciIiJSqyjciIiISK2icFNJ/vOf/xAREYGbmxudOnVi2bJlti6pRvvjjz8YPnw4oaGhWCwWfvjhhzLnDcNgwoQJhIaG4u7uTr9+/di6dattiq3BJk+eTJcuXfD29iYwMJBrrrmGnTt3lrlG9/rSvffee7Rt29a6sFn37t357bffrOd1j6vG5MmTsVgsjB8/3npM97pyTJgwAYvFUuYRHBxsPW/r+6xwUwn+97//MX78eJ577jk2bNhA7969GTJkCAcOHLB1aTVWdnY27dq145133jnv+alTpzJt2jTeeecd4uLiCA4OZuDAgda9w6RiYmNjefDBB1m9ejULFy6kqKiIQYMGkZ2dbb1G9/rSNWrUiFdeeYV169axbt06rrjiCq6++mrrX/a6x5UvLi6ODz74gLZt25Y5rntdeVq3bs2RI0esj82bN1vP2fw+G3LJunbtatx///1ljrVo0cJ45plnbFRR7QIYc+bMsT4vKSkxgoODjVdeecV6LC8vz/D19TXef/99G1RYe6SmphqAERsbaxiG7nVVql+/vvHf//5X97gKZGZmGlFRUcbChQuNvn37Go8++qhhGPp5rkwvvPCC0a5du/Oes4f7rJabS1RQUEB8fDyDBg0qc3zQoEGsXLnSRlXVbomJiaSkpJS5566urvTt21f3/BKlp6cD4OfnB+heV4Xi4mK+/vprsrOz6d69u+5xFXjwwQcZNmwYAwYMKHNc97py7d69m9DQUCIiIrjpppvYt28fYB/3uc5tnFnZjh8/TnFxMUFBQWWOBwUFkZKSYqOqarfS+3q+e75//35blFQrGIbB448/Tq9evWjTpg2ge12ZNm/eTPfu3cnLy8PLy4s5c+bQqlUr61/2useV4+uvv2b9+vXExcWdc04/z5WnW7dufPrpp0RHR3P06FFeeuklevTowdatW+3iPivcVBKLxVLmuWEY5xyTyqV7XrkeeughNm3axPLly885p3t96Zo3b05CQgKnTp1i9uzZ3HHHHcTGxlrP6x5fuoMHD/Loo4+yYMEC3Nzc/vI63etLN2TIEOvXMTExdO/enaZNmzJr1iwuu+wywLb3Wd1Sl6hBgwY4Ojqe00qTmpp6TmqVylE6Il/3vPI8/PDDzJ07lyVLltCoUSPrcd3ryuPi4kKzZs3o3LkzkydPpl27drz11lu6x5UoPj6e1NRUOnXqhJOTE05OTsTGxjJ9+nScnJys91P3uvJ5enoSExPD7t277eJnWuHmErm4uNCpUycWLlxY5vjChQvp0aOHjaqq3SIiIggODi5zzwsKCoiNjdU9v0CGYfDQQw/x/fffs3jxYiIiIsqc172uOoZhkJ+fr3tcifr378/mzZtJSEiwPjp37swtt9xCQkICkZGRutdVJD8/n+3btxMSEmIfP9PVMmy5lvv6668NZ2dn46OPPjK2bdtmjB8/3vD09DSSkpJsXVqNlZmZaWzYsMHYsGGDARjTpk0zNmzYYOzfv98wDMN45ZVXDF9fX+P77783Nm/ebNx8881GSEiIkZGRYePKa5YHHnjA8PX1NZYuXWocOXLE+sjJybFeo3t96Z599lnjjz/+MBITE41NmzYZ//znPw0HBwdjwYIFhmHoHlels2dLGYbudWV54oknjKVLlxr79u0zVq9ebVx11VWGt7e39feere+zwk0leffdd43w8HDDxcXF6Nixo3UqrVycJUuWGMA5jzvuuMMwDHOq4QsvvGAEBwcbrq6uRp8+fYzNmzfbtuga6Hz3GDBmzpxpvUb3+tKNGTPG+vdDQECA0b9/f2uwMQzd46r053Cje105brzxRiMkJMRwdnY2QkNDjZEjRxpbt261nrf1fbYYhmFUTxuRiIiISNXTmBsRERGpVRRuREREpFZRuBEREZFaReFGREREahWFGxEREalVFG5ERESkVlG4ERERkVpF4UZERERqFYUbETmvfv36MX78eFuXYdfuvPNOrrnmGluXISJ/onAjUkfdeeedWCyWcx579uyxdWnn+OSTT6hXr571+YQJE2jfvn21fX5SUhIWi4WEhIQyx9966y0++eSTaqtDRCrGydYFiIjtXHnllcycObPMsYCAABtVU/0KCwtxdna+6Nf7+vpWYjUiUlnUciNSh7m6uhIcHFzm4ejoeN5r09LSuP3226lfvz4eHh4MGTKE3bt3A2AYBgEBAcyePdt6ffv27QkMDLQ+X7VqFc7OzmRlZQFm60vjxo1xdXUlNDSURx55pEI1f/LJJ0ycOJGNGzdaW5tKW0/S09O59957CQwMxMfHhyuuuIKNGzdaX1va4vPxxx8TGRmJq6srhmEwb948evXqRb169fD39+eqq65i79691tdFREQA0KFDBywWC/369QPO7ZbKz8/nkUceITAwEDc3N3r16kVcXJz1/NKlS7FYLCxatIjOnTvj4eFBjx492Llzp/WajRs3cvnll+Pt7Y2Pjw+dOnVi3bp1Fbo3ImJSuBGRCrnzzjtZt24dc+fOZdWqVRiGwdChQyksLMRisdCnTx+WLl0KmEFo27ZtFBYWsm3bNsD8xd6pUye8vLz47rvveOONN5gxYwa7d+/mhx9+ICYmpkJ13HjjjTzxxBO0bt2aI0eOcOTIEW688UYMw2DYsGGkpKTw66+/Eh8fT8eOHenfvz8nT560vn7Pnj188803zJ4929rNlJ2dzeOPP05cXByLFi3CwcGBa6+9lpKSEgDWrl0LwO+//86RI0f4/vvvz1vbU089xezZs5k1axbr16+nWbNmDB48uMznAzz33HO8/vrrrFu3DicnJ8aMGWM9d8stt9CoUSPi4uKIj4/nmWeeuaTWJZE6qdr2HxcRu3LHHXcYjo6Ohqenp/Vx/fXXW8/37dvXePTRRw3DMIxdu3YZgLFixQrr+ePHjxvu7u7GN998YxiGYUyfPt1o06aNYRiG8cMPPxidO3c2Ro4cabz77ruGYRjGoEGDjKefftowDMN4/fXXjejoaKOgoKBCtc6cOdPw9fW1Pn/hhReMdu3alblm0aJFho+Pj5GXl1fmeNOmTY0ZM2ZYX+fs7GykpqaW+3mpqakGYGzevNkwDMNITEw0AGPDhg1lrrvjjjuMq6++2jAMw8jKyjKcnZ2NL774wnq+oKDACA0NNaZOnWoYhmEsWbLEAIzff//des0vv/xiAEZubq5hGIbh7e1tfPLJJ+XfEBEpl1puROqwyy+/nISEBOtj+vTp571u+/btODk50a1bN+sxf39/mjdvzvbt2wFzdtXWrVs5fvw4sbGx9OvXj379+hEbG0tRURErV66kb9++AIwaNYrc3FwiIyMZO3Ysc+bMoaio6JK+l/j4eLKysvD398fLy8v6SExMLNPFFB4efs64or179zJ69GgiIyPx8fGxdkMdOHCgwp+/d+9eCgsL6dmzp/WYs7MzXbt2td6jUm3btrV+HRISAkBqaioAjz/+OPfccw8DBgzglVdeKVO7iFSMwo1IHebp6UmzZs2sj9JftH9mGMZfHrdYLAC0adMGf39/YmNjreGmb9++xMbGEhcXR25uLr169QIgLCyMnTt38u677+Lu7s64cePo06cPhYWFF/29lJSUEBISUiasJSQksHPnTp588sky3/OfDR8+nBMnTvDhhx+yZs0a1qxZA0BBQUGFP7/0HpXej7OP//nY2d1MpedKu8AmTJjA1q1bGTZsGIsXL6ZVq1bMmTOnwnWIiMKNiFRAq1atKCoqsv7SBzhx4gS7du2iZcuWANZxNz/++CNbtmyhd+/exMTEUFhYyPvvv0/Hjh3x9va2vt7d3Z0RI0Ywffp0li5dyqpVq9i8eXOF6nFxcaG4uLjMsY4dO5KSkoKTk1OZwNasWTMaNGjwl+914sQJtm/fzr/+9S/69+9Py5YtSUtLO+fzgHM+82zNmjXDxcWF5cuXW48VFhaybt066z2qqOjoaB577DEWLFjAyJEjz5nRJiLlU7gRkb8VFRXF1VdfzdixY1m+fDkbN27k1ltvpWHDhlx99dXW6/r168eXX35J27Zt8fHxsQaeL774wjrDCMwZTx999BFbtmxh3759fPbZZ7i7uxMeHl6hepo0aUJiYiIJCQkcP36c/Px8BgwYQPfu3bnmmmuYP38+SUlJrFy5kn/961/lzjaqX78+/v7+fPDBB+zZs4fFixfz+OOPl7kmMDAQd3d35s2bx9GjR0lPTz/nfTw9PXnggQd48sknmTdvHtu2bWPs2LHk5ORw9913V+j7ys3N5aGHHmLp0qXs37+fFStWEBcXd8HhSKSuU7gRkQqZOXMmnTp14qqrrqJ79+4YhsGvv/5apovl8ssvp7i4uEyQ6du3L8XFxdbxNgD16tXjww8/pGfPnrRt25ZFixbx008/4e/vX6FarrvuOq688kouv/xyAgIC+Oqrr7BYLPz666/06dOHMWPGEB0dzU033URSUhJBQUF/+V4ODg58/fXXxMfH06ZNGx577DFeffXVMtc4OTkxffp0ZsyYQWhoaJlAd7ZXXnmF6667jttuu42OHTuyZ88e5s+fT/369Sv0fTk6OnLixAluv/12oqOjueGGGxgyZAgTJ06s0OtFxGQx/qozXURERKQGUsuNiIiI1CoKNyIiIlKrKNyIiIhIraJwIyIiIrWKwo2IiIjUKgo3IiIiUqso3IiIiEitonAjIiIitYrCjYiIiNQqCjciIiJSqyjciIiISK3y/4kRI8oLsqEvAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_qubits = 7\n", + "d = d_poly_spacing(n_qubits,best_degree[2])\n", + "step = 1e-2\n", + "iterations = 50\n", + "H_TFIM = hamiltonians.TFIM(nqubits=n_qubits, h=h)\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "d_optimized, loss, grad, diags = gradient_ascent(dbi, d,step, iterations,analytic=False)\n", + "\n", + "flows = 50\n", + "off_diagonal_norm = np.empty((flows+1,2))\n", + "off_diagonal_norm[0,:] = dbi.off_diagonal_norm\n", + "for i in range(flows):\n", + " step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_optimized)\n", + " dbi(step_poly,d=d_optimized)\n", + " off_diagonal_norm[i+1,0] = dbi.off_diagonal_norm\n", + "\n", + "d = d_poly_spacing(n_qubits,1)\n", + "dbi2 = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "d_optimized, loss, grad, diags = gradient_ascent(dbi2, d,step, iterations,analytic=False)\n", + "for i in range(flows):\n", + " step_poly = dbi2.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_optimized)\n", + " dbi2(step_poly,d=d_optimized)\n", + " off_diagonal_norm[i+1,1] = dbi2.off_diagonal_norm\n", + "\n", + "plt.figure()\n", + "plt.plot(off_diagonal_norm[:,0],label= 'optimal poly degree')\n", + "plt.plot(off_diagonal_norm[:,1],label= 'linear spacing')\n", + "plt.xlabel('Flows Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "def delta_to_d(delta):\n", + " d = np.empty(len(delta))\n", + " d[0] = 0\n", + " for i in range(len(d)-1):\n", + " d[i+1] = d[i] + delta[i]\n", + " return np.diag(d)\n", + "\n", + "def d_to_delta(d):\n", + " delta = np.empty(len(d)-1)\n", + " for i in range(len(d)-1):\n", + " delta[i] = d[i+1,i+1]-d[i,i]\n", + " return delta\n", + "\n", + "def polynomial(x,degree,coefficients):\n", + " y = np.empty(len(x))\n", + " for i in range(degree):\n", + " y += coefficients[i]*x**i\n", + " return y\n", + "\n", + "def gradient_delta_polynomial(dbi, degree, coefficients,h=1e-5):\n", + " grad = np.empty(degree)\n", + " dim = dbi.h.matrix.shape[0]\n", + " delta = polynomial(np.linspace(0,1,dim),degree,coefficients)\n", + " d = delta_to_d(delta)\n", + " dbi_eval = deepcopy(dbi)\n", + " angle = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n", + " dbi_eval(angle,d=d)\n", + " norm = dbi_eval.off_diagonal_norm\n", + " for i in range(len(grad)):\n", + " new_coeff = np.copy(coefficients)\n", + " new_coeff[i] += h\n", + " new_delta = polynomial(np.linspace(0,1,dim),degree,new_coeff)\n", + " new_d = delta_to_d(new_delta)\n", + " dbi_eval = deepcopy(dbi)\n", + " angle = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=new_d)\n", + " dbi_eval(angle,d=new_d)\n", + " new_norm = dbi_eval.off_diagonal_norm\n", + " grad[i] = (new_norm-norm)/h\n", + "\n", + " return grad\n", + "\n", + "\n", + "def optimize_poly(dbi, step, iterations, degree):\n", + " coefficients = np.random.rand(degree)\n", + " dim = dbi.h.matrix.shape[0]\n", + " delta = polynomial(np.linspace(0,1,dim),degree,coefficients)\n", + " d = delta_to_d(delta)\n", + " loss = np.empty(iterations)\n", + " grad = np.empty(degree)\n", + " for i in range(iterations):\n", + " dbi_eval = deepcopy(dbi)\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n", + " dbi_eval(step_poly,d=d)\n", + " loss[i] = dbi_eval.off_diagonal_norm\n", + " grad = gradient_delta_polynomial(dbi_eval, degree, coefficients)\n", + " coefficients -= step*grad\n", + " delta = polynomial(np.linspace(0,1,dim),degree,coefficients)\n", + " d = delta_to_d(delta)\n", + " return coefficients, loss, grad\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "H_TFIM = hamiltonians.TFIM(nqubits=7, h=5.0)\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "matrix = dbi.h.matrix\n", + "eigenenergies = np.diag(np.linalg.eigh(matrix)[0])\n", + "delta = d_to_delta(eigenenergies)\n", + "\n", + "plt.figure()\n", + "plt.plot(delta,'.')\n", + "plt.xlabel('Index')\n", + "plt.ylabel(r'$\\Delta$')\n", + "\n", + "d, loss, grad = optimize_poly(dbi, 1e-3, 100, 3)\n", + "plt.figure()\n", + "plt.plot(loss)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 3aebfddff2..bb781a50ef 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -153,6 +153,30 @@ def polynomial_step( else: return None +def d_ansatz(params, type = 'Full'): + r""" + Creates the $D$ operator for the double-bracket iteration ansatz depending on the type of parameterization. + Args: + params(np.array): parameters for the ansatz. + type(str): type of parameterization, 'Full' or 'Pauli' + (Full being each entry parametrized and Pauli being a linear combination of Z_i matrix). + """ + + if type == 'Full': + d = np.zeros((len(params), len(params))) + for i in range(len(params)): + d[i, i] = params[i] + + if type == 'Pauli': + d = np.zeros((2**len(params), 2**len(params))) + Z = np.array([[1, 0], [0, -1]]) + for i in range(len(params)): + I1 = np.eye(2**i) + I2 = np.eye(2**(len(params)-i-1)) + d += params[i]*np.kron(I1,np.kron(Z,I2)) + + return d + def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): if d is None: @@ -203,6 +227,8 @@ def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): coef = list(reversed(coef)) return coef + +# D GRADIENTS def dGamma_diDiagonal(dbi_object, d, H, n, i,dGamma, Gamma_list): # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) A = np.zeros(d.shape) @@ -227,34 +253,43 @@ def dpolynomial_diDiagonal(dbi_object, d,H,i): return derivative -def gradientDiagonal(dbi_object,d,H): +def gradientDiagonal(dbi_object, params, H, analytic = True, ansatz = 'Full', h = 1e-4): # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz) - grad = np.zeros(len(d)) - for i in range(len(d)): - derivative = dpolynomial_diDiagonal(dbi_object,d,H,i) - grad[i] = d[i,i]-derivative + grad = np.zeros(len(params)) + d = d_ansatz(params, ansatz) + if analytic == True: + for i in range(len(params)): + derivative = dpolynomial_diDiagonal(dbi_object,d,H,i) + grad[i] = d[i,i]-derivative + else: + for i in range(len(params)): + params_new = deepcopy(params) + params_new[i] += h + d_new = d_ansatz(params_new, ansatz) + grad[i] = (dbi_object.least_squares(d_new)-dbi_object.least_squares(d))/h return grad -def gradient_ascent(dbi_object, d, step, iterations): +def gradient_ascent(dbi_object, params, step, iterations, analytic = True, ansatz = 'Full'): H = dbi_object.h.matrix + d = d_ansatz(params,ansatz) loss = np.zeros(iterations+1) - grad = np.zeros((iterations,len(d))) + grad = np.zeros((iterations,len(params))) dbi_new = deepcopy(dbi_object) s = polynomial_step(dbi_object, n = 3, d=d) dbi_new(s,d=d) - loss[0] = dbi_new(d) - diagonals = np.empty((len(d),iterations+1)) - diagonals[:,0] = np.diag(d) + loss[0] = dbi_new.least_squares(d) + params_hist = np.empty((len(params),iterations+1)) + params_hist[:,0] = params for i in range(iterations): dbi_new = deepcopy(dbi_object) - grad[i,:] = gradientDiagonal(dbi_object, d, H) - for j in range(len(d)): - d[j,j] = d[j,j] - step*grad[i,j] + grad[i,:] = gradientDiagonal(dbi_object, params, H, analytic=analytic, ansatz=ansatz) + for j in range(len(params)): + params[j] = params[j] - step*grad[i,j] + d = d_ansatz(params,ansatz) s = polynomial_step(dbi_object, n = 3, d=d) dbi_new(s,d=d) loss[i+1] = dbi_new.least_squares(d) - diagonals[:,i+1] = np.diag(d) + params_hist[:,i+1] = params - - return d,loss,grad,diagonals \ No newline at end of file + return d,loss,grad,params_hist \ No newline at end of file From 4f6fe62606ba8db7f457e0f77a4b59eb426a15cd Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 26 Mar 2024 09:48:59 +0000 Subject: [PATCH 062/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/models/dbi/utils_scheduling.py | 65 ++++++++++++++----------- 1 file changed, 36 insertions(+), 29 deletions(-) diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 87ab83a60e..77b05f5900 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -155,7 +155,8 @@ def polynomial_step( else: return None -def d_ansatz(params, type = 'Full'): + +def d_ansatz(params, type="Full"): r""" Creates the $D$ operator for the double-bracket iteration ansatz depending on the type of parameterization. Args: @@ -164,19 +165,19 @@ def d_ansatz(params, type = 'Full'): (Full being each entry parametrized and Pauli being a linear combination of Z_i matrix). """ - if type == 'Full': + if type == "Full": d = np.zeros((len(params), len(params))) for i in range(len(params)): d[i, i] = params[i] - if type == 'Pauli': - d = np.zeros((2**len(params), 2**len(params))) + if type == "Pauli": + d = np.zeros((2 ** len(params), 2 ** len(params))) Z = np.array([[1, 0], [0, -1]]) for i in range(len(params)): I1 = np.eye(2**i) - I2 = np.eye(2**(len(params)-i-1)) - d += params[i]*np.kron(I1,np.kron(Z,I2)) - + I2 = np.eye(2 ** (len(params) - i - 1)) + d += params[i] * np.kron(I1, np.kron(Z, I2)) + return d @@ -238,7 +239,7 @@ def energy_fluctuation_polynomial_expansion_coef( # D GRADIENTS -def dGamma_diDiagonal(dbi_object, d, H, n, i,dGamma, Gamma_list): +def dGamma_diDiagonal(dbi_object, d, H, n, i, dGamma, Gamma_list): # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) A = np.zeros(d.shape) A[i, i] = 1 @@ -267,43 +268,49 @@ def dpolynomial_diDiagonal(dbi_object, d, H, i): return derivative -def gradientDiagonal(dbi_object, params, H, analytic = True, ansatz = 'Full', h = 1e-4): + +def gradientDiagonal(dbi_object, params, H, analytic=True, ansatz="Full", h=1e-4): # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz) grad = np.zeros(len(params)) d = d_ansatz(params, ansatz) if analytic == True: for i in range(len(params)): - derivative = dpolynomial_diDiagonal(dbi_object,d,H,i) - grad[i] = d[i,i]-derivative + derivative = dpolynomial_diDiagonal(dbi_object, d, H, i) + grad[i] = d[i, i] - derivative else: for i in range(len(params)): params_new = deepcopy(params) params_new[i] += h d_new = d_ansatz(params_new, ansatz) - grad[i] = (dbi_object.least_squares(d_new)-dbi_object.least_squares(d))/h + grad[i] = ( + dbi_object.least_squares(d_new) - dbi_object.least_squares(d) + ) / h return grad -def gradient_ascent(dbi_object, params, step, iterations, analytic = True, ansatz = 'Full'): + +def gradient_ascent(dbi_object, params, step, iterations, analytic=True, ansatz="Full"): H = dbi_object.h.matrix - d = d_ansatz(params,ansatz) - loss = np.zeros(iterations+1) - grad = np.zeros((iterations,len(params))) + d = d_ansatz(params, ansatz) + loss = np.zeros(iterations + 1) + grad = np.zeros((iterations, len(params))) dbi_new = deepcopy(dbi_object) - s = polynomial_step(dbi_object, n = 3, d=d) - dbi_new(s,d=d) + s = polynomial_step(dbi_object, n=3, d=d) + dbi_new(s, d=d) loss[0] = dbi_new.least_squares(d) - params_hist = np.empty((len(params),iterations+1)) - params_hist[:,0] = params + params_hist = np.empty((len(params), iterations + 1)) + params_hist[:, 0] = params for i in range(iterations): dbi_new = deepcopy(dbi_object) - grad[i,:] = gradientDiagonal(dbi_object, params, H, analytic=analytic, ansatz=ansatz) + grad[i, :] = gradientDiagonal( + dbi_object, params, H, analytic=analytic, ansatz=ansatz + ) for j in range(len(params)): - params[j] = params[j] - step*grad[i,j] - d = d_ansatz(params,ansatz) - s = polynomial_step(dbi_object, n = 3, d=d) - dbi_new(s,d=d) - loss[i+1] = dbi_new.least_squares(d) - params_hist[:,i+1] = params - - return d,loss,grad,params_hist \ No newline at end of file + params[j] = params[j] - step * grad[i, j] + d = d_ansatz(params, ansatz) + s = polynomial_step(dbi_object, n=3, d=d) + dbi_new(s, d=d) + loss[i + 1] = dbi_new.least_squares(d) + params_hist[:, i + 1] = params + + return d, loss, grad, params_hist From f4ddcfa7d91625da0a3748bd5516bb94d9a54227 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 2 Apr 2024 09:39:11 +0800 Subject: [PATCH 063/116] Update notebook --- examples/dbi/dbi_strategies_compare.ipynb | 215 +++++++++++++++++++++- 1 file changed, 207 insertions(+), 8 deletions(-) diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb index 0bb5642abf..1160babed3 100644 --- a/examples/dbi/dbi_strategies_compare.ipynb +++ b/examples/dbi/dbi_strategies_compare.ipynb @@ -24,7 +24,8 @@ "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", "from qibo.quantum_info import random_hermitian\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *" + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *" ] }, { @@ -58,7 +59,7 @@ "outputs": [], "source": [ "# backend\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "# initialize dbi object\n", "nqubits = 5\n", "h0 = random_hermitian(2**nqubits, seed=2)\n", @@ -76,7 +77,7 @@ "# iterations steps\n", "NSTEPS = 15\n", "# choose polynomial scheduling\n", - "scheduling = DoubleBracketScheduling.use_hyperopt" + "scheduling = DoubleBracketScheduling.simulated_annealing" ] }, { @@ -107,7 +108,7 @@ "steps_canonical_plot = [0]\n", "for s in range(NSTEPS):\n", " # same settings as iteration from list\n", - " step = dbi_canonical.choose_step(d=dbi.diagonal_h_matrix, max_evals=50)\n", + " step = dbi_canonical.choose_step(d=dbi.diagonal_h_matrix)\n", " dbi_canonical(step=step)\n", " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", " off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n", @@ -144,9 +145,9 @@ "# add in initial values for plotting\n", "off_diagonal_norm_history_pauli = [dbi_pauli.off_diagonal_norm]\n", "steps_pauli_plot = [0]\n", - "scheduling = DoubleBracketScheduling.use_hyperopt\n", + "scheduling = DoubleBracketScheduling.simulated_annealing\n", "for _ in range(NSTEPS):\n", - " dbi_pauli, idx, step, flip_sign = select_best_dbr_generator(dbi_pauli, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=50)\n", + " dbi_pauli, idx, step, flip_sign = select_best_dbr_generator(dbi_pauli, Z_ops, scheduling=scheduling, compare_canonical=False)\n", " off_diagonal_norm_history_pauli.append(dbi_pauli.off_diagonal_norm)\n", " steps_pauli_plot.append(steps_pauli_plot[-1]+step)\n", " if flip_sign < 0:\n", @@ -193,7 +194,7 @@ "off_diagonal_norm_history_gradient = [dbi_gradient.off_diagonal_norm]\n", "steps_gradient_plot= [0]\n", "for _ in range(NSTEPS):\n", - " step, d_coef, d = gradient_descent_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=50, n_taylor=5)\n", + " step, d_coef, d = gradient_descent_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops)\n", " dbi_gradient(d=d,step=step)\n", " off_diagonal_norm_history_gradient.append(dbi_gradient.off_diagonal_norm)\n", " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n", @@ -230,12 +231,210 @@ "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test on TFIM\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", + "# initialize dbi object\n", + "# hamiltonian parameters\n", + "# define the hamiltonian\n", + "nqubits = 5\n", + "h = 1\n", + "H_TFIM = SymbolicHamiltonian( - h*symbols.Z(nqubits-1), nqubits=nqubits)\n", + "# add linear interaction terms\n", + "for i in range(nqubits-1):\n", + " H_TFIM -= SymbolicHamiltonian(symbols.X(i)*symbols.X(i+1) + h*symbols.Z(i), nqubits=nqubits)\n", + "H_TFIM = H_TFIM.dense\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", + "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# iterations steps\n", + "NSTEPS = 15\n", + "# choose polynomial scheduling\n", + "scheduling = DoubleBracketScheduling.simulated_annealing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Canonical" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# initialize DBI class for the canonical case\n", + "dbi_canonical = DoubleBracketIteration(deepcopy(H_TFIM), mode=DoubleBracketGeneratorType.canonical, scheduling=scheduling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Canonical\n", + "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n", + "steps_canonical_plot = [0]\n", + "for s in range(NSTEPS):\n", + " # same settings as iteration from list\n", + " step = dbi_canonical.choose_step(d=dbi.diagonal_h_matrix)\n", + " dbi_canonical(step=step)\n", + " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", + " off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n", + " steps_canonical_plot.append(steps_canonical_plot[-1]+step)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pauli-Z" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize DBI class for the Pauli-Z strategy\n", + "dbi_pauli = DoubleBracketIteration(deepcopy(H_TFIM), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "generate_local_Z = generate_Z_operators(nqubits)\n", + "Z_ops = list(generate_local_Z.values())\n", + "Z_names = list(generate_local_Z.keys())\n", + "Z_optimal = []\n", + "# add in initial values for plotting\n", + "off_diagonal_norm_history_pauli = [dbi_pauli.off_diagonal_norm]\n", + "steps_pauli_plot = [0]\n", + "scheduling = DoubleBracketScheduling.simulated_annealing\n", + "for _ in range(NSTEPS):\n", + " dbi_pauli, idx, step, flip_sign = select_best_dbr_generator(dbi_pauli, Z_ops, scheduling=scheduling, compare_canonical=False)\n", + " off_diagonal_norm_history_pauli.append(dbi_pauli.off_diagonal_norm)\n", + " steps_pauli_plot.append(steps_pauli_plot[-1]+step)\n", + " if flip_sign < 0:\n", + " Z_optimal.append('-' + Z_names[idx])\n", + " else:\n", + " Z_optimal.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi_pauli.off_diagonal_norm}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Magnetic field" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize DBI class for the canonical case\n", + "dbi_gradient = DoubleBracketIteration(deepcopy(H_TFIM), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", + "d_coef = onsite_Z_decomposition(dbi_gradient.h.matrix, onsite_Z_ops)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "initial_s = polynomial_step(dbi_object=dbi, d=d, n=4)\n", + "print(initial_s)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "off_diagonal_norm_history_gradient = [dbi_gradient.off_diagonal_norm]\n", + "steps_gradient_plot= [0]\n", + "for _ in range(NSTEPS):\n", + " step, d_coef, d = gradient_descent_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops)\n", + " dbi_gradient(d=d,step=step)\n", + " off_diagonal_norm_history_gradient.append(dbi_gradient.off_diagonal_norm)\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n", + " steps_gradient_plot.append(steps_gradient_plot[-1]+step)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n", + "plt.plot(off_diagonal_norm_history_canonical, label='canonical', marker='o')\n", + "plt.plot(off_diagonal_norm_history_pauli, label='Pauli-Z', marker='o')\n", + "plt.plot(off_diagonal_norm_history_gradient, label='gradient', marker='o')\n", + "plt.legend()\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n", + "plt.plot(steps_canonical_plot, off_diagonal_norm_history_canonical, marker='o', label='canonical')\n", + "plt.plot(steps_pauli_plot, off_diagonal_norm_history_pauli, marker='o', label='Pauli-Z')\n", + "plt.plot(steps_gradient_plot,off_diagonal_norm_history_gradient, marker='o', label='gradient')\n", + "plt.legend()\n", + "plt.xlabel('Duration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] } ], "metadata": { From 8cc73f6066909bc3f0e7d7d09b8d8cf6bac1f3be Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 2 Apr 2024 10:04:10 +0800 Subject: [PATCH 064/116] Fix test error w energy fluctuation --- tests/test_models_dbi.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index b2716e4352..01f2cd7f0c 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -106,12 +106,9 @@ def test_energy_fluctuations(backend): h0 = np.array([[1, 0], [0, -1]]) h0 = backend.cast(h0, dtype=backend.dtype) - state = np.array([1, 0]) - state = backend.cast(state, dtype=backend.dtype) - dbi = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend)) - energy_fluctuation = dbi.energy_fluctuation(state=state) - assert energy_fluctuation == 1.0 + energy_fluctuation = dbi.energy_fluctuation() + assert energy_fluctuation == 0.0 @pytest.mark.parametrize( From 39dbe4e9e2cd1b5893b912d307a2494f24dd746c Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 2 Apr 2024 10:53:42 +0800 Subject: [PATCH 065/116] Update notebook to run --- examples/dbi/dbi_costs.ipynb | 235 ++++------------------------------- 1 file changed, 27 insertions(+), 208 deletions(-) diff --git a/examples/dbi/dbi_costs.ipynb b/examples/dbi/dbi_costs.ipynb index 558f74cff3..e772b94bce 100644 --- a/examples/dbi/dbi_costs.ipynb +++ b/examples/dbi/dbi_costs.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -39,20 +39,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-15 18:17:05]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "\n", "# hamiltonian parameters\n", "nqubits = 5\n", @@ -70,19 +62,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.02021181818181818\n", - "hyperopt_search step: 0.2796044748864459\n", - "polynomial_approximation step: 0.016462159944159827\n" - ] - } - ], + "outputs": [], "source": [ "# generate data for plotting sigma decrease of the first step\n", "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", @@ -108,37 +90,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.02021181818181818\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.figure()\n", @@ -172,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -194,30 +148,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure()\n", "plt.plot(range(iters+1), off_diagonal_norm_diff, label=r'Off-diagonal norm')\n", @@ -239,20 +172,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-15 18:17:12]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "\n", "# hamiltonian parameters\n", "nqubits = 3\n", @@ -271,19 +196,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.8585872727272726\n", - "hyperopt_search step: 0.3413442272248831\n", - "polynomial_approximation step: 0.028303853122485182\n" - ] - } - ], + "outputs": [], "source": [ "# generate data for plotting sigma decrease of the first step\n", "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", @@ -309,37 +224,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.8585872727272726\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.figure()\n", @@ -365,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -383,40 +270,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Energy fluctuation')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure()\n", "plt.plot(range(iters+1), off_diagonal_norm_diff)\n", @@ -431,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -450,30 +306,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Iterations')" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n", "plt.figure()\n", @@ -485,25 +320,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[20], line 8\u001b[0m\n\u001b[0;32m 5\u001b[0m step \u001b[39m=\u001b[39m \u001b[39m1e-2\u001b[39m\n\u001b[0;32m 6\u001b[0m iterations \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m----> 8\u001b[0m d, loss, grad, diags \u001b[39m=\u001b[39m gradient_ascent(dbi, d,step, iterations)\n\u001b[0;32m 10\u001b[0m n \u001b[39m=\u001b[39m \u001b[39m3\u001b[39m\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:253\u001b[0m, in \u001b[0;36mgradient_ascent\u001b[1;34m(dbi_object, d, step, iterations)\u001b[0m\n\u001b[0;32m 250\u001b[0m diagonals[:,\u001b[39m0\u001b[39m] \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mdiag(d)\n\u001b[0;32m 252\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(iterations):\n\u001b[1;32m--> 253\u001b[0m grad[i,:] \u001b[39m=\u001b[39m gradientDiagonal(dbi_object, d, H)\n\u001b[0;32m 254\u001b[0m \u001b[39mfor\u001b[39;00m j \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[0;32m 255\u001b[0m d[j,j] \u001b[39m=\u001b[39m d[j,j] \u001b[39m+\u001b[39m step\u001b[39m*\u001b[39mgrad[i,j] \u001b[39m# note the plus sign as we maximize the potential\u001b[39;00m\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:237\u001b[0m, in \u001b[0;36mgradientDiagonal\u001b[1;34m(dbi_object, d, H)\u001b[0m\n\u001b[0;32m 235\u001b[0m grad \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(\u001b[39mlen\u001b[39m(d))\n\u001b[0;32m 236\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[1;32m--> 237\u001b[0m derivative \u001b[39m=\u001b[39m dpolynomial_diDiagonal(dbi_object,d,H,i)\n\u001b[0;32m 238\u001b[0m grad[i] \u001b[39m=\u001b[39m derivative\u001b[39m-\u001b[39md[i,i]\n\u001b[0;32m 239\u001b[0m \u001b[39mreturn\u001b[39;00m grad\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:224\u001b[0m, in \u001b[0;36mdpolynomial_diDiagonal\u001b[1;34m(dbi_object, d, H, i)\u001b[0m\n\u001b[0;32m 220\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdpolynomial_diDiagonal\u001b[39m(dbi_object, d,H,i):\n\u001b[0;32m 221\u001b[0m \u001b[39m# Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz)\u001b[39;00m\n\u001b[0;32m 222\u001b[0m \u001b[39m# Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation\u001b[39;00m\n\u001b[0;32m 223\u001b[0m derivative \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m--> 224\u001b[0m s \u001b[39m=\u001b[39m polynomial_step(dbi_object, d, H, i)\n\u001b[0;32m 225\u001b[0m A \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(d\u001b[39m.\u001b[39mshape)\n\u001b[0;32m 226\u001b[0m Gamma_list \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mgenerate_Gamma_list(\u001b[39m4\u001b[39m, d)\n", - "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:127\u001b[0m, in \u001b[0;36mpolynomial_step\u001b[1;34m(dbi_object, n, n_max, d, coef, cost)\u001b[0m\n\u001b[0;32m 124\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 125\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m--> 127\u001b[0m \u001b[39mif\u001b[39;00m n \u001b[39m>\u001b[39;49m n_max:\n\u001b[0;32m 128\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 129\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mNo solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 130\u001b[0m )\n\u001b[0;32m 131\u001b[0m \u001b[39mif\u001b[39;00m coef \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", - "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" - ] - } - ], + "outputs": [], "source": [ "cost = DoubleBracketCostFunction.least_squares\n", "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", @@ -534,7 +353,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.11.7" }, "orig_nbformat": 4, "vscode": { From 1f22e0eb2f0b4bb4fd2df0c3febc13b68fb34323 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 4 Apr 2024 10:04:33 +0800 Subject: [PATCH 066/116] Code adding Ising model to magnetic field, remaining test --- examples/dbi/dbi_strategy_Ising_model.ipynb | 1177 +++++++++++++++++++ src/qibo/models/dbi/utils.py | 114 +- 2 files changed, 1243 insertions(+), 48 deletions(-) create mode 100644 examples/dbi/dbi_strategy_Ising_model.ipynb diff --git a/examples/dbi/dbi_strategy_Ising_model.ipynb b/examples/dbi/dbi_strategy_Ising_model.ipynb new file mode 100644 index 0000000000..159560f792 --- /dev/null +++ b/examples/dbi/dbi_strategy_Ising_model.ipynb @@ -0,0 +1,1177 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-Bracket Iteration Strategy: magnetic field (Ising model)\n", + "This notebook shows the diagonalization process of DBI using the magnetic field strategy, which varies the diagonal operator $D$ by gradient descent. To find the gradient with respect to $D$, parameterization of $D$ is required. For the purpose of this notebook, we represent it by the Ising model, i.e.\n", + "\n", + "$$ D = \\sum \\alpha_i Z_i +\\sum \\beta_{ij}Z_iZ_j$$\n", + "\n", + "\n", + "The gradients are calculated under the premise that the diagonalization gain curve can be fitted by a polynomial, and that the iteration step duration is taken at the first dip of the curve." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", + "from qibo.quantum_info import random_hermitian\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", + "from qibo.models.dbi.utils import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_matrix(matrix, title=\"\"):\n", + " \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n", + " fig, ax = plt.subplots(figsize=(5,5))\n", + " ax.set_title(title)\n", + " try:\n", + " im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n", + " except TypeError:\n", + " im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n", + " fig.colorbar(im, ax=ax)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test on random Hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-04-03 08:21:24]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 31.576176740060667\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", + "# initialize dbi object\n", + "nqubits = 5\n", + "h0 = random_hermitian(2**nqubits, seed=2)\n", + "scheduling = DoubleBracketScheduling.hyperopt\n", + "mode = DoubleBracketGeneratorType.single_commutator\n", + "n_taylor = 5\n", + "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", + "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Order 1: $D=\\sum \\alpha_iZ_i$" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 572.27trial/s, best loss: 27.607173414553387]\n", + "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j)]\n", + "Gradient: [-0.20481773 0.41841615 -0.03164361 0.18666951 -0.86436728]\n", + "s: 0.11659660342715238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pethidine/Documents/GitHub/qibo/src/qibo/models/dbi/utils.py:268: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " grad[i] = (\n" + ] + } + ], + "source": [ + "# generate pauli_operator_dict\n", + "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=1)\n", + "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n", + "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n", + "grad, s = gradient_Pauli(dbi, d=d, pauli_operator_dict=pauli_operator_dict)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 656.84trial/s, best loss: 27.607178280638898]\n", + "100%|██████████| 500/500 [00:00<00:00, 639.38trial/s, best loss: 24.351929237913915]\n", + "100%|██████████| 500/500 [00:00<00:00, 655.61trial/s, best loss: 22.089739447397726]\n", + "100%|██████████| 500/500 [00:00<00:00, 663.89trial/s, best loss: 20.346440770606122]\n", + "100%|██████████| 500/500 [00:00<00:00, 639.24trial/s, best loss: 18.946903760228178]\n", + "100%|██████████| 500/500 [00:00<00:00, 650.95trial/s, best loss: 17.7755177782418] \n", + "100%|██████████| 500/500 [00:00<00:00, 674.60trial/s, best loss: 16.785446486734276]\n", + "100%|██████████| 500/500 [00:00<00:00, 664.40trial/s, best loss: 15.933524819099162] \n", + "100%|██████████| 500/500 [00:00<00:00, 655.76trial/s, best loss: 15.195995775240494]\n", + "100%|██████████| 500/500 [00:00<00:00, 633.46trial/s, best loss: 14.474767679378404]\n", + "100%|██████████| 500/500 [00:00<00:00, 638.92trial/s, best loss: 14.025120975809307]\n", + "100%|██████████| 500/500 [00:00<00:00, 603.17trial/s, best loss: 13.622403395436098]\n", + "100%|██████████| 500/500 [00:00<00:00, 670.03trial/s, best loss: 13.244304046805466]\n", + "100%|██████████| 500/500 [00:00<00:00, 666.31trial/s, best loss: 12.938522658932913] \n", + "100%|██████████| 500/500 [00:00<00:00, 656.53trial/s, best loss: 12.622483913681776]\n", + "100%|██████████| 500/500 [00:00<00:00, 585.38trial/s, best loss: 12.260523262483813]\n", + "100%|██████████| 500/500 [00:00<00:00, 645.94trial/s, best loss: 11.863294969541887]\n", + "100%|██████████| 500/500 [00:00<00:00, 697.70trial/s, best loss: 11.477785002400976] \n", + "100%|██████████| 500/500 [00:00<00:00, 684.35trial/s, best loss: 11.090736331075858] \n", + "100%|██████████| 500/500 [00:00<00:00, 739.76trial/s, best loss: 10.686003198269908] \n", + "100%|██████████| 500/500 [00:00<00:00, 717.78trial/s, best loss: 10.057480301384102] \n", + "100%|██████████| 500/500 [00:00<00:00, 712.94trial/s, best loss: 10.058298967085108] \n", + "100%|██████████| 500/500 [00:00<00:00, 724.09trial/s, best loss: 10.059015434243745] \n", + "100%|██████████| 500/500 [00:00<00:00, 709.43trial/s, best loss: 10.060281060360927] \n", + "100%|██████████| 500/500 [00:00<00:00, 740.79trial/s, best loss: 10.060583338964047]\n", + "100%|██████████| 500/500 [00:00<00:00, 733.24trial/s, best loss: 10.061781462286367] \n", + "100%|██████████| 500/500 [00:00<00:00, 725.24trial/s, best loss: 10.06205592136255]\n", + "100%|██████████| 500/500 [00:00<00:00, 732.59trial/s, best loss: 10.06257005000825] \n", + "100%|██████████| 500/500 [00:00<00:00, 750.26trial/s, best loss: 10.063192908922257] \n", + "100%|██████████| 500/500 [00:00<00:00, 710.47trial/s, best loss: 10.063501140769239] \n" + ] + } + ], + "source": [ + "iters = 30\n", + "off_diagonal_norm_1 = [dbi.off_diagonal_norm]\n", + "s_step = [0]\n", + "for i in range(iters):\n", + " s, d_coef, d = gradient_descent_pauli(dbi, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n", + " dbi(step=s, d=d)\n", + " off_diagonal_norm_1.append(dbi.off_diagonal_norm)\n", + " s_step.append(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(str(nqubits) + ' spins random hamiltonian')\n", + "plt.plot(off_diagonal_norm_1)\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Order 2: $D=\\sum \\alpha_iZ_i + \\beta_{ij}Z_iZ_j$" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 692.10trial/s, best loss: 27.60718707087908]\n", + "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j), (0.15766557989586075+0j), (0.1267267343988193+0j), (0.10801310050393904+0j), (0.37981790024704787+0j), (0.25748679935414437+0j), (-0.2531727610451514+0j), (0.13345922163435078+0j), (-0.02961684041039575+0j), (0.36206828748686004+0j), (0.12254924877248492+0j)]\n", + "Gradient: [-0.07705712 0.15660998 -0.01151922 0.06967692 -0.32391798 -0.15885245\n", + " 0.16488954 0.11742344 0.44237635 0.39554303 -0.59878233 -0.03326744\n", + " 0.2060505 0.08567309 0.17837982]\n", + "s: 0.11627601978827411\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pethidine/Documents/GitHub/qibo/src/qibo/models/dbi/utils.py:268: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " grad[i] = (\n" + ] + } + ], + "source": [ + "# generate pauli_operator_dict\n", + "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n", + "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n", + "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n", + "grad, s = gradient_Pauli(dbi, d=d, pauli_operator_dict=pauli_operator_dict)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 693.59trial/s, best loss: 27.60716505293791] \n", + "100%|██████████| 500/500 [00:00<00:00, 739.77trial/s, best loss: 24.351930977389397] \n", + "100%|██████████| 500/500 [00:00<00:00, 685.07trial/s, best loss: 22.089870557907307] \n", + "100%|██████████| 500/500 [00:00<00:00, 674.17trial/s, best loss: 20.346996185055133]\n", + "100%|██████████| 500/500 [00:00<00:00, 717.27trial/s, best loss: 18.942039981805472]\n", + "100%|██████████| 500/500 [00:00<00:00, 747.61trial/s, best loss: 17.152907499929672] \n", + "100%|██████████| 500/500 [00:00<00:00, 738.25trial/s, best loss: 16.019645236154144]\n", + "100%|██████████| 500/500 [00:00<00:00, 744.74trial/s, best loss: 15.2613302219324] \n", + "100%|██████████| 500/500 [00:00<00:00, 742.43trial/s, best loss: 14.603236439507265] \n", + "100%|██████████| 500/500 [00:00<00:00, 747.77trial/s, best loss: 14.050749361766682] \n", + "100%|██████████| 500/500 [00:00<00:00, 665.47trial/s, best loss: 13.555811973998546] \n", + "100%|██████████| 500/500 [00:00<00:00, 741.86trial/s, best loss: 13.11437793825614] \n", + "100%|██████████| 500/500 [00:00<00:00, 730.33trial/s, best loss: 12.708028521672343] \n", + "100%|██████████| 500/500 [00:00<00:00, 696.14trial/s, best loss: 12.338996561474936] \n", + "100%|██████████| 500/500 [00:00<00:00, 745.68trial/s, best loss: 11.96195414708825] \n", + "100%|██████████| 500/500 [00:00<00:00, 729.21trial/s, best loss: 11.962452492607511] \n", + "100%|██████████| 500/500 [00:00<00:00, 730.13trial/s, best loss: 11.963468727156927] \n", + "100%|██████████| 500/500 [00:00<00:00, 735.49trial/s, best loss: 11.965058898358617] \n", + "100%|██████████| 500/500 [00:00<00:00, 735.24trial/s, best loss: 11.965394318636747] \n", + "100%|██████████| 500/500 [00:00<00:00, 729.17trial/s, best loss: 11.966117166464612] \n", + "100%|██████████| 500/500 [00:00<00:00, 728.15trial/s, best loss: 11.966425772210973] \n", + "100%|██████████| 500/500 [00:00<00:00, 723.59trial/s, best loss: 11.966970026858228] \n", + "100%|██████████| 500/500 [00:00<00:00, 732.31trial/s, best loss: 11.967330716148668] \n", + "100%|██████████| 500/500 [00:00<00:00, 734.26trial/s, best loss: 11.96780433370658] \n", + "100%|██████████| 500/500 [00:00<00:00, 733.15trial/s, best loss: 11.969207838189973] \n", + "100%|██████████| 500/500 [00:00<00:00, 732.58trial/s, best loss: 11.969502660368933] \n", + "100%|██████████| 500/500 [00:00<00:00, 696.01trial/s, best loss: 11.969798703907593] \n", + "100%|██████████| 500/500 [00:00<00:00, 734.39trial/s, best loss: 11.970102117939215] \n", + "100%|██████████| 500/500 [00:00<00:00, 733.83trial/s, best loss: 11.971312239622172] \n", + "100%|██████████| 500/500 [00:00<00:00, 737.13trial/s, best loss: 11.97187547672911] \n" + ] + } + ], + "source": [ + "iters = 30\n", + "off_diagonal_norm_2 = [dbi.off_diagonal_norm]\n", + "s_step = [0]\n", + "for i in range(iters):\n", + " s, d_coef, d = gradient_descent_pauli(dbi, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n", + " dbi(step=s, d=d)\n", + " off_diagonal_norm_2.append(dbi.off_diagonal_norm)\n", + " s_step.append(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(str(nqubits) + ' spins random hamiltonian')\n", + "plt.plot(off_diagonal_norm_1, label='order 1')\n", + "plt.plot(off_diagonal_norm_2, label='order 2')\n", + "plt.legend()\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test on TFIM\n", + "Here we choose to customize our TFIM in the X axis using `SymbolicHamiltonian`. It is also possible to use Hadamard gate to rotate the TFIM inbuilt in `qibo`.\n", + "\n", + "$$ H = -(\\sum X_i X_{i+1} + \\sum hZ_i)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-03 08:14:05]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# generate the Hamiltonian\n", + "nqubits = 5\n", + "h = 1\n", + "H_TFIM = SymbolicHamiltonian( - h*symbols.Z(nqubits-1), nqubits=nqubits)\n", + "# add linear interaction terms\n", + "for i in range(nqubits-1):\n", + " H_TFIM -= SymbolicHamiltonian(symbols.X(i)*symbols.X(i+1) + h*symbols.Z(i), nqubits=nqubits)\n", + "H_TFIM = H_TFIM.dense\n", + "visualize_matrix(H_TFIM.matrix, title=f'TFIM with L={nqubits} h={h}')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-04-03 08:14:05]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", + "# initialize dbi object\n", + "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Order 1: $D=\\sum \\alpha_iZ_i$" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 621.13trial/s, best loss: 8.145448855938055]\n", + "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n", + "Gradient: [-0.22522735 -0.52101222 -0.59635378 -0.52101222 -0.22522735]\n", + "s: 0.053751929537431395\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pethidine/Documents/GitHub/qibo/src/qibo/models/dbi/utils.py:268: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " grad[i] = (\n" + ] + } + ], + "source": [ + "dbi_TFIM_1 = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)\n", + "# generate pauli_operator_dict\n", + "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=1)\n", + "d_coef = decompose_into_Pauli_basis(dbi_TFIM_1.h.matrix, list(pauli_operator_dict.values()))\n", + "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n", + "grad, s = gradient_Pauli(dbi_TFIM_1, d=d, pauli_operator_dict=pauli_operator_dict)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 707.38trial/s, best loss: 8.144345846120405] \n", + "100%|██████████| 500/500 [00:00<00:00, 735.41trial/s, best loss: 7.604689171773317] \n", + "100%|██████████| 500/500 [00:00<00:00, 735.65trial/s, best loss: 7.4176027901243495]\n", + "100%|██████████| 500/500 [00:00<00:00, 755.09trial/s, best loss: 7.008137714268] \n", + "100%|██████████| 500/500 [00:00<00:00, 745.89trial/s, best loss: 5.961852278701001] \n", + "100%|██████████| 500/500 [00:00<00:00, 703.36trial/s, best loss: 5.293878968775635] \n", + "100%|██████████| 500/500 [00:00<00:00, 749.97trial/s, best loss: 4.82113561785614] \n", + "100%|██████████| 500/500 [00:00<00:00, 749.13trial/s, best loss: 4.326041032299924] \n", + "100%|██████████| 500/500 [00:00<00:00, 749.48trial/s, best loss: 3.608232108710637] \n", + "100%|██████████| 500/500 [00:00<00:00, 750.07trial/s, best loss: 2.9342878051864014] \n", + "100%|██████████| 500/500 [00:00<00:00, 749.53trial/s, best loss: 2.619767373811081] \n", + "100%|██████████| 500/500 [00:00<00:00, 757.24trial/s, best loss: 2.553595125371688] \n", + "100%|██████████| 500/500 [00:00<00:00, 757.78trial/s, best loss: 2.5450651469655488] \n", + "100%|██████████| 500/500 [00:00<00:00, 758.64trial/s, best loss: 2.5411137289688988] \n", + "100%|██████████| 500/500 [00:00<00:00, 758.68trial/s, best loss: 2.5071534830104416] \n" + ] + } + ], + "source": [ + "NSTEPS = 15\n", + "off_diagonal_norm_1 = [dbi_TFIM_1.off_diagonal_norm]\n", + "s_step = [0]\n", + "for i in range(NSTEPS):\n", + " s, d_coef, d = gradient_descent_pauli(dbi_TFIM_1, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n", + " dbi_TFIM_1(step=s, d=d)\n", + " off_diagonal_norm_1.append(dbi_TFIM_1.off_diagonal_norm)\n", + " s_step.append(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAHFCAYAAAD7ZFORAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJN0lEQVR4nO3dd3wUBf7G8Wd30ysQAiEQSOi99yIowgHKqSgIggKKgKASsaKeYAPB0wN/CIiCcBRFBfFEUUEBQXoPRXoVQoRAEkhI2/n9gYmEGpLdTHbzeb9e+8Kd3Z19FnLZ52a+M2MxDMMQAACAG7KaHQAAAMBZKDoAAMBtUXQAAIDbougAAAC3RdEBAABui6IDAADcFkUHAAC4LYoOAABwWxQdAADgtig6gIuKjIyUxWK56jZ48OCbvnb58uWyWCz66quvnJZv1apVGjBggBo1aiRvb29ZLBYdPnz4pq8bNWrUNT/Xlbd27dpJkvr163fd5yxatEiSdPjwYVksFv373//Ofp+svwOLxaIZM2ZcM8sdd9whi8WiyMjIfP5tOF6/fv0KVa7//ve/6tmzp6pVqyar1VqosqFo8zA7AIC8a9WqVY4vb0kqXbq0SWly+vnnn7V06VI1aNBAQUFBWr58ea5eN2DAAHXq1Cn7/smTJ9WtWzc99dRTeuihh7KXBwUFZf+3r6+vfvnll6vWVb169Zu+X2BgoKZNm6Z+/frlWH7o0CEtX748x/vg+mbNmqXY2Fg1bdpUdrtd6enpZkcCJFF0AJdWrFgxNW/e3OwY1/Svf/1LI0eOlCT9+9//znXRKVeunMqVK5d9P2srUPny5a/7Wa1Wa57/Hh588EF98skn2rdvn6pUqZK9fPr06Spbtqzq1KmjXbt25Wnd+ZGeni6LxSIPj4L5NZ2SkiJfX988v/7HH3+U1XppJ8Hdd9+tHTt2OCoakC/sugKcIGv3y86dO9WrVy8FBwerdOnSevTRR5WQkGB2vGzp6el65ZVXFB4erqCgIN15553as2ePQ9ad9aVX2HXo0EERERGaPn169jK73a6ZM2eqb9+++f4cO3bs0D333KPixYvLx8dH9evX18yZM3M8J2s32qxZs/Tss8+qbNmy8vb21v79+yVJM2bMULVq1eTt7a0aNWrov//97zXfKy0tTW+99ZaqV68ub29vhYaGqn///vrzzz9zPC8yMlJ33323FixYoAYNGsjHx0evv/56vj6nq/x7o+hhiw7gRPfff78efPBBPfbYY4qJidGIESMkKceXamZmpgzDuOm6rFbrVV8mv/76qwIDA3Xx4kVVqVJFjz32mKKjo2Wz2XKV7+WXX1arVq30ySefKDExUS+++KK6du2q3bt3Z6/DbrfLbrffdF0WiyXX7+sMGRkZOe7nNo/ValW/fv00bdo0vfXWW7LZbPrpp590/Phx9e/fX8OGDctzpj179qhly5YqVaqUPvjgA4WEhGj27Nnq16+fTp06pRdeeCHH80eMGKEWLVpoypQpslqtKlWqlGbMmKH+/fvrnnvu0XvvvaeEhASNGjVKqampOX4e7Ha77rnnHq1cuVIvvPCCWrZsqSNHjmjkyJFq166dNm7cmGOLzebNm7V79269+uqrioqKkr+/v6T8/TwChZIBwOFGjhxpSDLGjRuXY/mQIUMMHx8fw263Zy9r27atIemmt759+161runTpxsrVqwwFi5caPTu3duQZPTp0+em+ZYtW2ZIMrp06ZJj+RdffGFIMtasWXPVZ7nZrUKFCtd9v3fffdeQZBw6dOim2a506NAhQ5Lx7rvvXvPxvn37XjNPq1atbriOrL+DL7/80jh48KBhsViMRYsWGYZhGN27dzfatWtnGIZh3HXXXTf8bDfSs2dPw9vb2zh69GiO5Z07dzb8/PyMc+fO5chy22235XheZmamER4ebjRs2DDHz8zhw4cNT0/PHLk+++wzQ5Ixf/78HOvYsGGDIcmYNGlS9rIKFSoYNpvN2LNnz1WZ8/rzeLn8/J0BjsYWHcCJ/vnPf+a4X7duXV28eFFxcXHZQ8MfffSRkpKSbrqukiVL5rj/4Ycf5riftXtk4sSJGj58uBo0aJCnfJJ05MiR7JmXgQMH6u67777pury9vW/6HGfx9fXVr7/+mmNZYGBgrl8fFRWldu3aafr06WrevLm++eYbffLJJ/nO9csvv6h9+/aKiIjIsbxfv35avHix1qxZk2Pw+v7778/xvD179ujEiRMaPny4LBZL9vIKFSqoZcuWOY5iW7RokYoVK6auXbvm2LpVv359hYWFafny5XriiSeyl9etW1dVq1a9KnNefx6BwoqiAzhRSEhIjvtZZSAlJSV7WeXKlXO9q+Bm+vTpo4kTJ2rt2rW5Kjq5yRcWFqZSpUrddF2XfxEXNKvVqsaNG+drHY899pj69++v999/X76+vnrggQfynevMmTMqU6bMVcvDw8OzH7/clc/NejwsLOyqdYSFheUoOqdOndK5c+fk5eV1zSynT5++4XtlceTPI1AY8JMKmKx9+/by9PS86e3RRx+96bqyvqAc+SX0xhtv5CpfpUqVHPaeZujWrZv8/Pz0zjvvqGfPnvk6AilLSEiITp48edXyEydOSLp6q8iVZTGriMbGxl61jiuXlSxZUiEhIdqwYcM1b5MmTbrhe2Vx5M8jUBiwRQcwmSN3FWQdjePIQ85dYdeVI/j6+uq1117Tr7/+mmMXT360b99eX3/9tU6cOJG9FUe69O/k5+d303+natWqqUyZMvrss89y7L46cuSIVq9enWOdd999tz7//HNlZmaqWbNmec7Mriu4G4oOYLJq1ard8mvmzp2rBQsW6K677lKFChV07tw5ffnll/r888/Vr18/1atXz2H5wsPDc3yh5taff/6pFStWSJJiYmIkSYsXL1ZoaKhCQ0PVtm1bh2V0lOHDh2v48OE3fd6oUaP0+uuva9myZdlnaL6WkSNHatGiRbr99tv12muvqUSJEpozZ46+++47jRs3TsHBwTd8H6vVqjfffFMDBgzQfffdp8cff1znzp3TqFGjrtqd1bNnT82ZM0ddunTRsGHD1LRpU3l6eur48eNatmyZ7rnnHt133303/Wx5+XmUpF27dmWfbyg2NlbJycnZZ96uWbOmatasmaf1AvlF0QFcUMWKFXXu3Dm9/PLLOnPmjDw9PVWrVi1NmjRJgwYNMjueJGnnzp3q3r17jmVDhgyRJLVt2zbXJxAsjM6fPy+LxXLN2ZnLVatWTatXr9bLL7+soUOHKiUlRTVq1NCnn3561ZmYr+exxx6TJI0dO1bdunVTZGSkXn75Za1YsSLH36HNZtP//vc/TZgwQbNmzdKYMWPk4eGhcuXKqW3btqpTp05eP26ufPHFF1ediyfr33/kyJEaNWqUU98fuB6LkZupMwBAtqZNm6pChQr68ssvzY4C4CYoOgBwCxITExUaGqqtW7eqRo0aZscBcBMUHQAA4LY4vBwAALgtig4AAHBbFB0AAOC2KDoAAMBtFfnz6Njtdp04cUKBgYGmXqsHAADknmEYSkpKUnh4+A0ve1Pki86JEyeuurIwAABwDceOHVO5cuWu+3iRLzqBgYGSLv1FBQUFmZwGAADkRmJioiIiIrK/x6+nyBedrN1VQUFBFB0AAFzMzcZOGEYGAABui6IDAADcFkUHAAC4LYoOAABwWxQdAADgtig6AADAbVF0AACA26LoAAAAt0XRAQAAbouiAwAA3BZFBwAAuC2KDgAAcFsUHSdJzcjUpiNnZRiG2VEAACiyKDpOkJ5pV5O3lur+yat1ND7Z7DgAABRZFB0n8LRZVT0sSJK09uAZk9MAAFB0UXScpHnFEpKktQfjTU4CAEDRRdFxkuYVQyRd2qLDnA4AAOag6DhJg/LF5WWz6mTCReZ0AAAwCUXHSXy9bKofUUwSczoAAJiFouNEzOkAAGAuio4TMacDAIC5KDpOxJwOAADmoug4EXM6AACYi6LjZMzpAABgHoqOkzVjTgcAANNQdJysYfni8rRZmNMBAMAEFB0nY04HAADzUHQKwN+HmTOnAwBAQaLoFADOpwMAgDkoOgWAOR0AAMxB0SkAzOkAAGAOik4Bydp9tY45HQAACgxFp4AwpwMAQMGj6BSQrDmdEwkXdSw+xew4AAAUCRSdAsKcDgAABY+iU4Au330FAACcj6JTgJjTAQCgYFF0ChBzOgAAFCyKTgFiTgcAgIJF0SlgzOkAAFBwKDoFjDkdAAAKDkWngDGnAwBAwaHoFDDmdAAAKDgUHRMwpwMAQMGg6JiAOR0AAAoGRccEzOkAAFAwKDom8PWyqV65YpLYfQUAgDNRdEzCnA4AAM5H0TEJczoAADgfRcckDSsUY04HAAAno+iYxM/LgzkdAACcjKJjIuZ0AABwLoqOiZjTAQDAuSg6JmJOBwAA56LomIg5HQAAnIuiY7Ls3VeHKDoAADgaRcdkWUVn3cF45nQAAHAwio7JsuZ0/jiXouNnmdMBAMCRKDomu3xOZw1zOgAAOBRFpxDgfDoAADhHoS46v/76q7p27arw8HBZLBYtXLgwx+OGYWjUqFEKDw+Xr6+v2rVrp507d5oTNh+Y0wEAwDkKddG5cOGC6tWrp4kTJ17z8XHjxun999/XxIkTtWHDBoWFhalDhw5KSkoq4KT5w5wOAADO4WF2gBvp3LmzOnfufM3HDMPQ+PHj9corr6hbt26SpJkzZ6p06dKaO3euBg0aVJBR8yVrTmfjkbNac/CMIkr4mR0JAAC3UKi36NzIoUOHFBsbq44dO2Yv8/b2Vtu2bbV69errvi41NVWJiYk5boUBczoAADieyxad2NhYSVLp0qVzLC9dunT2Y9cyZswYBQcHZ98iIiKcmjO3mNMBAMDxXLboZLFYLDnuG4Zx1bLLjRgxQgkJCdm3Y8eOOTtirjCnAwCA47ls0QkLC5Okq7bexMXFXbWV53Le3t4KCgrKcSsMOJ8OAACO57JFJyoqSmFhYVqyZEn2srS0NK1YsUItW7Y0MVneMacDAIBjFeqjrs6fP6/9+/dn3z906JC2bt2qEiVKqHz58oqOjtbo0aNVpUoVValSRaNHj5afn58eeughE1PnXbOKJTRx2d9zOjfaBQcAAG6uUBedjRs36vbbb8++P3z4cElS3759NWPGDL3wwgtKSUnRkCFDdPbsWTVr1kw//fSTAgMDzYqcL40qFJeH9e85HQ4zBwAgfyxGET/EJzExUcHBwUpISCgU8zr3T16tTUfOatwDddWjceE4IgwAgMImt9/fLjuj466aVywhiTkdAAAcgaJTyHA+HQAAHIeiU8hcOacDAADyjqJTyPh5eaheRDFJnE8HAID8ougUQszpAADgGBSdQog5HQAAHIOiUwgxpwMAgGNQdAoh5nQAAHAMik4hxZwOAAD5R9EppC6f0wEAAHlD0SmkLp/TORafbHYcAABcEkWnkLp8TofdVwAA5A1FpxD7e06H3VcAAOQFRacQy5rTYYsOAAB5Q9EpxJjTAQAgfyg6hRhzOgAA5A9Fp5BjTgcAgLyj6BRyzOkAAJB3FJ1CjjkdAADyjqJTyPl5eahuuWBJbNUBAOBWUXRcwN+7r5jTAQDgVlB0XABzOgAA5A1FxwUwpwMAQN5QdFyAvzdzOgAA5AVFx0UwpwMAwK2j6LgI5nQAALh1FB0XwZwOAAC3jqLjIpjTAQDg1lF0XAhzOgAA3BqKjgthTgcAgFtD0XEhzOkAAHBrKDouhDkdAABuDUXHxTCnAwBA7lF0XExW0Vl3iC06AADcDEXHxWTN6Rw/y5wOAAA3Q9FxMZfP6aw7xO4rAABuhKLjgjjMHACA3KHouCCKDgAAuUPRcUHM6QAAkDsUHRfEnA4AALlD0XFR7L4CAODmKDouqhlFBwCAm6LouKjGFYrLxpwOAAA3RNFxUczpAABwcxQdF8acDgAAN0bRcWEUHQAAboyi48KY0wEA4MYoOi6MOR0AAG6MouPi2H0FAMD1UXRcHEUHAIDro+i4OOZ0AAC4PoqOi2NOBwCA66PouAF2XwEAcG0UHTdA0QEA4NooOm6AOR0AAK6NouMGmNMBAODaKDpugt1XAABcjaLjJrKKzrpDFB0AALJQdNxE1pzOsfgUHT/LnA4AABJFx23kmNM5yJwOAAASRcetMKcDAEBOHnl5UVRUlCwWyy2/Ljo6Wk8//XRe3hK50LxiiCYvP6C1zOkAACApj0VnxowZeXqzyMjIPL0OuXP5nM7WY+dUP6KY2ZEAADBVnopO27ZtHZ0DDuDv7aGWlUK0ct9p9ZiyRs/9o6oea11RNuutb30DAMAduPSMTkZGhl599VVFRUXJ19dXFStW1BtvvCG73W52NNO836O+2lcvpbRMu0Z//7t6fbyWsyUDAIosl57RGTt2rKZMmaKZM2eqVq1a2rhxo/r376/g4GANGzbMYe/jSkIDvfVJ38b6fMMxvblol9YfilfnCSs1smtNPdCoXJ7+3QAAcFUWwzCMW33RihUr8vRmkZGRqlChQp5eey133323SpcurWnTpmUvu//+++Xn56dZs2blah2JiYkKDg5WQkKCgoKCHJatMDhy5oKGf7FNm46clSR1rFlaY7rVUUiAt8nJAADIn9x+f7v0jE7r1q01ZcoU7d27V1WrVtW2bdu0atUqjR8/3uxohUKFEH99MaiFPvr1gP6zZK9+2nVKm4+e1Tvd6urOmqXNjgcAgNPlqegUFi+++KISEhJUvXp12Ww2ZWZm6u2331avXr2u+5rU1FSlpqZm309MTCyIqKaxWS0a0q6y2lYN1TPztmrvqfMa8N+N6tkkQq/eXVMB3i79IwAAwA05ZBg5PT1dx44d0549exQfX3Bn5Z03b55mz56tuXPnavPmzZo5c6b+/e9/a+bMmdd9zZgxYxQcHJx9i4iIKLC8ZqoVHqz/Pdlaj7eJksUifb7hmDpP+FUbDnMWZQCA+8rTjI4knT9/XnPmzNFnn32m9evX59hKUq5cOXXs2FEDBw5UkyZNHBb2ShEREXrppZc0dOjQ7GVvvfWWZs+erd9///2ar7nWFp2IiAi3nNG5njUHzui5L7fpj3MpslikQbdV0jMdqsjbw2Z2NAAAciW3Mzp52qLzn//8R5GRkfr44491xx13aMGCBdq6dav27NmjNWvWaOTIkcrIyFCHDh3UqVMn7du3L88f5EaSk5Nlteb8CDab7YaHl3t7eysoKCjHrahpUSlEi6Pb6P6G5WQY0pQVB3Tvh6u1JzbJ7GgAADhUnrbodO/eXa+99prq1Klzw+elpqZq2rRp8vLy0oABA/Ic8nr69eunpUuX6qOPPlKtWrW0ZcsWDRw4UI8++qjGjh2bq3W481FXufHDjli9/HWM4i+kyctm5SSDAACXkNvv7zzvuioMkpKS9K9//Utff/214uLiFB4erl69eum1116Tl5dXrtZR1IuOJMUlXdSI+TH6+fc4SVLTqBJ6r3s9RZTwMzkZAADX5pSi07lzZw0aNEhdu3aVzeYe8xwUnUsMw8g+yWByWqYCvD04ySAAoNByyozOCy+8oK+++kpVqlTRiBEjtH///nwHReFgsVjUq2l5LR7WRo0qFNf51Aw9/9V2DZq1SWfOp958BQAAFEJ52nWVkJCgOXPmaPr06QoODtbAgQN133335Xp3UWHCFp2rZdqN7JMMpmcaKhngpbH311X7GpxkEABQODhtRicjI0NJSUlKSkpSYmKili9frg8++EDx8fE6ffp0voMXNIrO9e08kZB9kkFJnGQQAFBoOKXo+Pj4qGTJkmrQoIECAgIUGBgof39/BQYGKjAwUM8//7xDwhckis6NXUzP1Hs/7dEnqw7JMKSIEr56v0d9NYksYXY0AEAR5pSiM3/+fE2fPl0XLlzQgAED1L17d3l7u/YFIik6uXPlSQYHt62kZ+6sKi8Ph5xcGwCAW+LUw8uPHz+uadOm6ZtvvtFtt92mgQMHqmbNmvkKbBaKTu4lXkzX6//bpfmbj0uSapQJ0vgH66taWKDJyQAARY3Tz6OTlpams2fPav78+frggw8UGhqqlStX5jmwWSg6t46TDAIAzJbb7+9bmiqNjIxUamqqDMOQn5+fgoKCFBgYqEqVKik4ODjfoeEaOtUOU8MKxbJPMjj6+9+1dHccJxkEABQ6t7RFJyUlRb6+vs7MU+DYopN3V55k0M/Lpk61wtS1XrhaVS7J/A4AwGmcuuuqT58+mjRpkoKCgvT9998rNTVV9913X74Cm4Wik39HzlzQs19s08YjZ7OXFfPzzC49zaJKyMNG6QEAOI5Ti07dunW1fft27dq1Sw888IDatGkjX19fjR8/Pj+ZTUHRcQy73dDmo2f17bYT+i4mVqcvO5tyyQAvdalTRnfXDVfjCsVlZZYHAJBPTi06jRo10saNG/Xiiy+qXr166t27txo1aqRNmzblK7QZKDqOl2k3tO7gGX27/YQW74jVueT07MfCgnx0V90y6lovXPXKBXMdLQBAnji16EydOlVTp05VfHy8YmJi5O/vr+rVq+v333/PV2gzUHScKz3TrlX7T2vRtpP6aWesklIzsh+LKOGru+uGq2vdcNUoE0jpAQDkmtMPLz937pw8PDwUEBCg/fv3680339TMmTPzHNgsFJ2CczE9U7/u/VPfbj+ppbtOKSU9M/uxiqH+6lo3XF3rlVHlUpyXBwBwY04vOpIUGxursLCwvL68UKDomCM5LUO//B6nRdtO6pc9cUrLsGc/Vj0sUF3rhevuumVUIcTfxJQAgMKqQIpO1lCyK6PomC/pYrqW7j6lb7ed1Mp9fyo98+8fyXrlgnV33XDdVbeMwou516kNAAB5VyBFp06dOoqJicnrywsFik7hci45TT/ujNW3205q9YHTsl/209m4QnF1rReuznXCVCrQx7yQAADTsUUnlyg6hdefSan6YcdJfbv9pDYcjlfWT6rVIjWvGKKu9cLVqVaYivt7mRsUAFDgKDq5RNFxDbEJF/VdzEl9u+2Eth47l73cw2pR26qhGvXPWlx+AgCKEKdc6wowS1iwjx5rHaXHWkfpWHyyFm0/qUXbT2jniUT9/Hucth0/p0/7NVWdclxzDQDwt3ydl9/Li10GKHgRJfz0RLtK+u7pNlo6/DbVKBOk0+fT9ODUNVq+J87seACAQiRfRWfjxo2OygHkSeVSgfpiUHO1rlxSyWmZGjBzo77ceMzsWACAQoIrLcLlBfp4anq/JrqvQVll2A09/9V2/d/P+5SP8TMAgJvId9FJSEjQwIEDVblyZdWoUUMnT550RC7glnh5WPV+j3p6ol0lSdJ7S/bq5a93KCPTfpNXAgDcWb6LzpAhQxQTE6Nx48bpyJEjSklJkSRFR0drwoQJ+Q4I5JbFYtGLnarrjXtqyWKRPlt/VINnb1JKWubNXwwAcEv5LjqLFy/WpEmT1K1bN9lstuzlnTp10qxZs/K7euCWPdIiUpN7N5K3h1VLd8ep18drdeZ8qtmxAAAmcMiMTkBAwFXLqlSpov379zti9cAt61Q7THMGNFMxP09tPXZOD0xZo6Nnks2OBQAoYPkuOl26dNHcuXOvWn7+/HlZLJb8rh7Is8aRJfTV4JYqW8xXh05fULfJv2n78XNmxwIAFKB8nzBwzJgxaty4sSTJMAxZLBalpKTojTfeUMOGDfMdEMiPyqUC9PWQlur36QbtOpmonlPX6sPeDXV7tVJmRwMAFIB8b9GJiIjQb7/9plWrVik5OVlNmzZV8eLFtXLlSo0dO9YRGYF8KRXko3mDmqtNlb/PtfMF59oBgCIhX9e6utLRo0e1bds2eXp6qlmzZipevLijVu00XOuq6EjLsOul+du1YMsfkqThHarqqTsqs4sVAFyQ0y/qmbWbytVRdIoWwzD07o97NGn5AUlSr6YRevOe2vKwce5MAHAlTr+oZ0BAgOrXr69GjRpl32rWrCmrlS8MFF4Wi0UvdKquMsV8NfKbHfps/THFJabq/x5qID8vrnELAO4mz1t0Jk2apM2bN2vTpk3auXOnMjMz5ePjo7p162YXn4YNG6pevXqOzuxQbNEpun7cGaunP9ui1Ay76kUU0/S+jRUS4G12LABALjh919XlUlNT5evrq5dfflnx8fHavHmztm/frtTUVGVmFu6z0lJ0irZNR+L12MyNOpecrsgQP818tKkqhPibHQsAcBMFWnQkyWq1auvWrapbt64kKTMzUzt37sy+X1hRdHDgz/PqO329jp9NUYi/l6b3a6J6EcXMjgUAuIHcfn87baDGZrMV+pIDSFKl0AAtGNJStcKDdOZCmnpOXatlv8eZHQsA4ABMDgOSSgX6aN6gFmpTpaRS0jM14L8bNW/DUbNjAQDyKc9F5/HHH9eUKVO0ceNGpaZeumCiOxxujqIrwNtD0/s1UbeGZZVpN/Ti/BiNX7pXDjzVFACggOX5eNo9e/boiy++UFJSkjw8Lq3m9ddfV7t27dSwYUPVr19ffn5+DgsKFARPm1Xvda+n8GBfTVy2X+OX7lNswkW9dS/n2gEAV5TvYeR9+/Zp06ZN2Yeab9myRefOnZPNZlPVqlW1c+dOR2V1CoaRcT2z1x7Ra9/skN2Q7qheShM51w4AFBoFftTV5Q4dOqSNGzdqy5YtGj16tKNX71AUHdzIkl2n9NRnm3Ux3a565YI1rV8TleRcOwBgOqcUnc6dO2vQoEHq2rWrbDabQ4KajaKDm9l05KwGzNygs8npqhDip5n9myqyJOfaAQAzOeXw8hdeeEFfffWVqlSpohEjRmj//v35DgoUdo0qFNf8J1oqooSvjpxJ1v2TV2vrsXNmxwIA5MItFZ3bb79ds2fP1pYtWxQREaGePXuqffv2mjdvntLS0pyVETBdxdAAzX+ipWqXvXSunV5T1+rn3afMjgUAuIlbntHJyMhQUlKSkpKSlJiYqOXLl+uDDz5QfHy8Tp8+7aycTsOuK9yK86kZGjJns37d+6esFundB+rp/kblzI4FAEWOU65e7uPjo5IlS6pBgwYKCAhQYGCg/P391bNnTwUGBuY7NFDYBXh7aFrfxhqxIEZfbTqu577aptQMux5qVt7saACAa7ilojNnzhxNnz5dSUlJevDBB9W9e3d5e3MECooWT5tV4+6vK38vm2auOaKXv45RWkam+rWKMjsaAOAKtzSjc//99+u7777T7NmzdeDAAbVo0ULR0dHatWuXs/IBhZLVatGof9bSwNsqSpJGfbtLH604YHIqAMCV8nSq13LlymnEiBFavHixqlatqm7duqlNmzaOzgYUahaLRSM6V9dTd1SWJI1Z/Ls++HmfyakAAJe7pV1XkZGRSk1NlWEY8vPzU1BQkAIDA1WpUiUFBwc7KyNQaFksFj3bsZq8Paz690979f6SvUrNyNRzHatx7TcAKARuqejs3r1bvr6+zsoCuKwn76gibw+b3v5+tz5cdkCp6Xa9clcNyg4AmOyWdl1llZw+ffooMTFRkvT999/r66+/dnwywMU8fltFvXFPLUnSJ6sO6bVvdspu58rnAGCmPM3obN++XUFBQdq1a5eee+45/fDDD4qOjnZwNMD1PNIiUu90qyOLRZq19ohGLIhRJmUHAEyTp0sxe3p6yjAMzZgxQ6+88op69+6tRo0aOTob4JJ6Ni0vb0+rnv1im+ZtPKbUjEz9u3s9edjy9P8rAAD5kKeiM2jQIDVp0kTx8fEaOXKkJOnChQsODQa4svsalJOXzaZhn2/Rwq0nlJZp14SeDeRJ2QGAApWnojNw4ED16NFDHh4e8vf31/79+9WsWTNHZwNc2l11y8jTZtHQuZv1fUys0jI268PeDeTtYTM7GgAUGbd8rSt3w7Wu4GzL9sRp8KxNSs2w67aqoZr6cCP5eFJ2ACA/cvv9ne/t6AkJCRo4cKAqV66sGjVq6OTJk/ldJeBWbq9WStP7NZGvp02/7v1T/T/doAupGWbHAoAiId9FZ8iQIYqJidG4ceN05MgRpaSkSJKio6M1YcKEfAcE3EGryiU189GmCvD20JqDZ9R3+nolXUw3OxYAuL18F53Fixdr0qRJ6tatm2y2vzfHd+rUSbNmzcrv6gG30TSqhGY91lSBPh7aeOSs+kxbr4Rkyg4AOJNDDgEJCAi4almVKlW0f/9+R6wecBsNyhfXZ483VzE/T207dk69Pl6r+AtpZscCALeV76LTpUsXzZ0796rl58+f5/T3wDXULhuszwc2V8kAL+06maieU9foz6RUs2MBgFvK0+HllxszZowaN24sSTIMQxaLRSkpKXrjjTfUsGHDfAcE3FH1sCB9PrCFHvp4rfaeOq8Hp67R3AHNFRbsY3Y0AHAr+d6iExERod9++02rVq1ScnKymjZtquLFi2vlypUaO3asIzICbqlyqQB9MaiFyhbz1cE/L6jHR2t0/Gyy2bEAwK04ZEancuXKWrJkiQ4fPqzp06dr4cKF2rNnT/aWHmf6448/1KdPH4WEhMjPz0/169fXpk2bnP6+gCNElvTXvEHNVb6En47GJ+vBj9bq8GnOMg4AjpKnonP06NFrLi9fvry6du2qTp06qXjx4tnL//jjj7ylu4mzZ8+qVatW8vT01OLFi7Vr1y699957KlasmFPeD3CGcsX99MWgFqpY0l9/nEvRg1PXaH/cebNjAYBbyFPRadKkiR5//HGtX7/+us9JSEjQxx9/rNq1a2vBggV5DngjY8eOVUREhD799FM1bdpUkZGRat++vSpVquSU9wOcJSzYR58Paq6qpQN0KjFVPaeu0e+xiWbHAgCXl6dLQMTHx2v06NGaPn26PD091bhxY4WHh8vHx0dnz57Vrl27tHPnTjVu3FivvvqqOnfu7Izsqlmzpv7xj3/o+PHjWrFihcqWLashQ4bo8ccfz/U6uAQECpP4C2nq88k67TqZqGJ+npr9WDPVLhtsdiwAKHRy+/2dr2tdXbx4Ud9//71Wrlypw4cPKyUlRSVLllSDBg30j3/8Q7Vr187rqnPFx+fSESrDhw9X9+7dtX79ekVHR+ujjz7SI488cs3XpKamKjX170N5ExMTFRERQdFBoZGQnK5Hpq/TtuMJCvTx0H8fbaoG5Yvf/IUAUIQUSNHJeiOzCoKXl5caN26s1atXZy97+umntWHDBq1Zs+aarxk1apRef/31q5ZTdFCYJF1MV/9PN2jjkbPy97Lp0/5N1TSqhNmxAKDQKLCLehYvXlzz58/P72rypEyZMqpZs2aOZTVq1LjusLQkjRgxQgkJCdm3Y8eOOTsmcMsCfTw189GmalExRBfSMtV3+nr9tv+02bEAwOXku+gYhqHJkyerWbNmat68uZ588kmtW7fOEdluqlWrVtqzZ0+OZXv37lWFChWu+xpvb28FBQXluAGFkb+3hz7t30S3VQ1VSnqm+s/YoGV74syOBQAuxSHn0dm2bZuaNm2qdu3aac+ePWrbtq2eeeYZR6z6hp555hmtXbtWo0eP1v79+zV37lxNnTpVQ4cOdfp7AwXBx9Omjx9ppDtrlFJahl2D/rtJP+2MNTsWALiMfM/oWK1W/fjjj+rQoUP2spiYGN17770aMmSInn322XyHvJFFixZpxIgR2rdvn6KiojR8+HCOuoLbScuwK3reFn0fEysPq0Wj76ujHk0izI4FAKYpsGHk0NBQrVy5UtWrV8+x/LvvvlN0dLT27duXn9U7HUUHriIj067nvtymhVtPSJJ6NS2vUf+sKW8Pm8nJAKDgFdgwcr169TRt2rSrlleuXJlBX8CBPGxWvd+jvoZ3qCqLRfps/VH1+GitTpxLMTsaABRa+S46b731liZOnKiHHnpIq1atUmJiok6dOqXRo0crKirKERkB/MVqtejp9lU0vV8TBft6atuxc+r6f6u0+gBHZAHAteS76DRv3lxr167ViRMn1K5dOxUvXlzh4eH66quv9N577zkiI4Ar3F6tlL59srVqlgnSmb/Opjz11wPK555oAHA7+Z7RuVxcXJw2bdoku92uZs2aqWTJko5atdMwowNXlpKWqVe+jtGCLZcunHtXnTIa+0BdBXh7mJwMAJyrwIaRXR1FB67OMAzNWntEb3y7Sxl2Q5VLBeijhxupUmiA2dEAwGkKbBgZgLksFoseaRGpeYOaq1Sgt/bHndc9E3/Tj5xvBwDytkUnKipKFovllt8sOjpaTz/99C2/zpnYogN3Epd0UU/O2aL1h+MlSUPaVdKzHavJZr31/70CQGHm1F1XK1asyFOoyMjIG16ewQwUHbib9Ey7Rn+/W5/+dliS1KZKSU3o2UAl/L3MDQYADsSMTi5RdOCuvtn6h16aH6OU9EyVLearjx5upNplg82OBQAOwYwOUMTdU7+svh7aUhVC/PTHuRR1m7xaX2zkJJ4AihZmdNiiAzeXkJKu4fO26uffL135/KFm5TWyK5eOAODamNHJJYoOigK73dD//bJf43/eK8OQ6kcU0+Q+DVUm2NfsaACQJ8zo5BJFB0XJsj1xGvbZFiVezFCIv5cmPtRQLSqFmB0LAG4ZMzoArnJ7tVL69qnWqpF16Yhp6/Txrwe5dAQAt0XRAYqYCiH+WvBES93XoKwy7Ybe/n63nvxsiy6kZpgdDQAcjqIDFEG+Xja936OeXv9nLXlYLfpu+0nd++FvOvjnebOjAYBDUXSAIspisahvy0h9PvDSpSP2/XXpiJ+4dAQAN0LRAYq4xpEltOip1moSWVxJqRkaOGuT3v3xd2XamdsB4PooOgBUKshHcx9vrv6tIiVJHy47oH6frtfZC2nmBgOAfKLoAJAkedqsGtm1lib0rC8fT6tW7jutrhNXaccfCWZHA4A8o+gAyOGe+mX19ZBWqhDip+NnU3T/5NX6kktHAHBRFB0AV6lRJkj/G9pad1QvpdQMu57/arte+TpGqRmZZkcDgFtC0QFwTcF+nvrkkcZ65s6qslikOeuOqsuElVp78IzZ0QAg1yg6AK7LarVo2J1VNL1vE5UM8NKBPy+o59S1evaLbTpzPtXseABwUxQdADd1e/VS+nl4Oz3UrLwkaf7m42r//grN23BUdg5DB1CIUXQA5Eqwn6dG31dH859oqephgTqXnK4X58fowalrtPdUktnxAOCaKDoAbkmjCsX17VOt9UqXGvL1tGnD4bPqMmGlxv7wu1LSGFYGULhQdADcMk+bVY/fVlFLn22rO2uUVobd0OTlB9ThPyu07Pc4s+MBQDaKDoA8K1vMV5/0baypDzdSeLCPjp9NUf8ZGzRkzibFJlw0Ox4AUHQA5F/HWmFaMrytHm8TJZvVou9jYtX+veWavuoQ18wCYCqLYRhF+rdQYmKigoODlZCQoKCgILPjAC5v14lEvfx1jLYeOydJql02SKPvq6O65YqZmguAe8nt9zdbdAA4VM3wIC14oqXeure2An08tOOPRN3z4W8a+c0OJV5MNzsegCKGogPA4axWi/o0r6Bfnm2ne+qHyzCkmWuO6M73VmjR9hMq4huSARQgig4ApwkN9NaEng00+7FmigzxU1xSqp6cu0X9Pt2go2eSzY4HoAig6ABwutZVSuqH6Ns0rH0VedmsWrH3T3X4zwp9uGy/0jLsZscD4MYoOgAKhI+nTc90qKrF0W3UslKIUjPsevfHPerywUqt40KhAJyEogOgQFUKDdCcAc30nwfrKcTfS/vjzuvBqWv13JfbFH8hzex4ANwMRQdAgbNYLLqvQTn98mw79Wp66UKhX206rjveW64vNhzjQqEAHIaiA8A0wX6eGtOtjuY/0SL7QqEvzN+unlPXcqFQAA5B0QFgukYVSujbp1prROfq8vW0af3heHWZsFLjuFAogHyi6AAoFDxtVg1qW0lLht+mO2uUUobd0KTlB9Rx/Ar9tv+02fEAuCiKDoBCpVxxP338SGN99HAjlQn20bH4FPWZtk5jvt/NoegAbhlFB0ChY7FY9I9aYVo6vK16NS0vw5A++vWguk3+TQf+PG92PAAuhKIDoNDy9/bQmG51NKVPIxXz89SOPxJ19wer9Nn6o1xGAkCuUHQAFHqdaofph2G3qWWlEKWkZ2rEghgNnr1JZznvDoCboOgAcAlhwT6a/VgzjehcXZ42i37ceUqdJvzKoDKAG6LoAHAZVqtFg9pW0oInWqliSX+dSkxlUBnADVF0ALicOuWCtejp1urVNCJ7UPn+yasZVAZwFYoOAJfk5+WhMd3qZg8qx/yRoLs/WKXPGVQGcBmKDgCXduWg8ksLYvTE7M06l8ygMgCKDgA3kDWo/FLn6vKwWvTDzlh1Gr9Sqw8wqAwUdRQdAG7BarVocNtK+nrIpUHl2MSL6v3JOr2z+HcGlYEijKIDwK1kDSr3bHJpUHnKigO6f/JqHWRQGSiSKDoA3I6fl4feub+uJvduqGDfS4PKdzGoDBRJFB0AbqtznTL6IbqNWlT8e1B5yBwGlYGihKIDwK2VCfbV7AHN9GKnS4PKi3cwqAwUJRQdAG7PZrXoiXaVtGBIS0VdNqg89gcGlQF3R9EBUGTULVdMi55qrQcbXxpUnrz8gB6YwqAy4M4oOgCKFH9vD4194O9B5e3HLw0qz9vAoDLgjig6AIqkznXKaPGwNmpesYRS0jP14nwGlQF3RNEBUGSFF/PVnAHNcwwqd56wUmsOnDE7GgAHoegAKNKyBpXnP3FpUPlkwkU99Mlajf3hd6VnMqgMuDqKDgBIqhdxaVC5R+Ny2YPKj0xbr/OpGWZHA5APFB0A+Iu/t4fGPVBPk3o3lL+XTWsOnlHvj9fq7AXmdgBXRdEBgCt0qVNGcx9vrmJ+ntp2PEE9Plqj2ISLZscCkAduVXTGjBkji8Wi6Ohos6MAcHH1Iorpi0EtVDrIW/vizqv7R6t15MwFs2MBuEVuU3Q2bNigqVOnqm7dumZHAeAmqpYO1FeDW6p8CT8di0/RA1PWaE9sktmxANwCtyg658+fV+/evfXxxx+rePHiZscB4EYiSvjpq8EtVK10oP5MSlWPj9Zoy9GzZscCkEtuUXSGDh2qu+66S3feeafZUQC4oVJBPpo3qLkalC+mhJR09f5knX7bz0VBAVfg8kXn888/1+bNmzVmzJhcPT81NVWJiYk5bgBwM8X8vDT7sWZqXbmkktMy1f/TDfphR6zZsQDchEsXnWPHjmnYsGGaPXu2fHx8cvWaMWPGKDg4OPsWERHh5JQA3IW/t4em9WusTrXClJZp15A5m/TVpuNmxwJwAxbDha9it3DhQt13332y2WzZyzIzM2WxWGS1WpWamprjMenSFp3U1NTs+4mJiYqIiFBCQoKCgoIKLDsA15WRaddLC2KyS87IrjXVv1WUyamAoiUxMVHBwcE3/f72KMBMDte+fXvFxMTkWNa/f39Vr15dL7744lUlR5K8vb3l7e1dUBEBuCEPm1Xj7q+rIB9PTf/tkF7/dpcSUtI1rH0VWSwWs+MBuIxLF53AwEDVrl07xzJ/f3+FhIRctRwAHMlqtehfd9dQsK+n/rN0r8Yv3aeElHT9666aslopO0Bh4dIzOgBgJovFomF3VtHIrjUlSZ/+dlgvzN+uDC4GChQaLr1F51qWL19udgQARUz/VlEK8vHUC/O366tNx5V0MV0f9Gogb4+rd58DKFhs0QEAB7i/UTlN6t1QXjarftx5So/N2KgLXPkcMB1FBwAc5B+1wvRp/yby87Jp1f7T6jNtnc4lc+VzwEwUHQBwoFaVS2rOgGYK9vXUlqPn9OBHaxWXyJXPAbNQdADAwRqUL64vBrVQqUBv7TmVpO4frdGx+GSzYwFFEkUHAJygWligvhzcQhElfHXkTLIemLJa+05x5XOgoFF0AMBJKoT466vBLVWlVIBOJV668vm2Y+fMjgUUKRQdAHCi0kE++mJQC9UrF6yzyel66OO1WnPgjNmxgCKDogMATlbc30tzHm+uFhVDdCEtU30/Xa+lu06ZHQsoEig6AFAAArw99Gn/JupQs7TSMuwaNHuTvt7Clc8BZ6PoAEAB8fG0aXLvhurWoKwy7YaembdN/11z2OxYgFuj6ABAAfKwWfXv7vXUt0UFSdJr3+zUxF/2yTAMk5MB7omiAwAFzGq1aNQ/a+npOypLkv79016N/n43ZQdwAooOAJjAYrFoeMdqevWuGpKkj1ce0kvzY5Rpp+wAjkTRAQATDWhTUeMeqCurRZq38Zie+myzUjMyzY4FuA2KDgCYrEfjiOwrn38fE6s+n6zTiXMpZscC3AJFBwAKgU61y2hav8by97Jpw+Gz6jxhpX7YEWt2LMDlUXQAoJBoUyVU3z3dRnXLBSshJV2DZ2/SqwtjdDGdXVlAXlF0AKAQiSx56fpYg26rKEmavfao/jlxlfbEckFQIC8oOgBQyHh5WDWiSw3999GmKhngrb2nzuufE1dp9tojHIIO3CKKDgAUUrdVDdXiYW3UtmqoUjPsenXhDj0xe7POJaeZHQ1wGRQdACjEQgO99Wm/Jnr1rhrytFn0w85YdZmwUusPxZsdDXAJFB0AKOSsVosGtKmoBU+0UmSIn04kXFTPqWs0fuleZWTazY4HFGoUHQBwEXXKBWvR0210f8NyshvS+KX79NDHnHMHuBGKDgC4kABvD73Xo57GP1hf/l42rT8czzl3gBug6ACAC7q3QVl9P6yN6nHOHeCGKDoA4KIqhPjry8EtNagt59wBroeiAwAuzMvDqhGdOecOcD0UHQBwA7dVDdUP0TnPuTN49ibOuYMij6IDAG6iZEDOc+78uPOUOk9YqXUHz5gdDTANRQcA3EjWOXe+HtJKUSX9dTLhonp9vFb/WcI5d1A0UXQAwA3VLhusRU+1zj7nzoSfL51z5w/OuYMihqIDAG7K/7Jz7gR4e2j94Xh1mbBSP+w4aXY0oMBQdADAzd3boKy+e7r1Zefc2axXvuacOygaKDoAUARknXNncNtKkqQ56zjnDooGig4AFBFeHla91Lm6Zj3WVKGBf59zZxbn3IEbo+gAQBHTpkqoFg9ro3bVLp1z518Ld2jQrE06fT7V7GiAw1mMIl7jExMTFRwcrISEBAUFBZkdBwAKjN1u6NPVh/XO4t1KzzRks1rUJLK4OtQMU8eapRVRws/siMB15fb7m6JD0QFQxO34I0Evfx2j7ccTciyvUSZIHWqWVseapVUrPEgWi8WkhMDVKDq5RNEBgEuOxSfrp12ntGRXrNYfipf9sm+HssV8s0tPk6gS8rQx+QBzUXRyiaIDAFeLv5CmX36P05JdsVqx909dTP/7rMrBvp66o3opdaxZWrdVDZW/t4eJSVFUUXRyiaIDADeWkpapVftPa8muWC3dHaf4C39fKNTLw6rWlUuqY83Sal+jtEIDvU1MiqKEopNLFB0AyL1Mu6FNR85qya5Y/bTrlI6cSc5+zGKRGpYvro41S6tjrTBFlfQ3MSncHUUnlyg6AJA3hmFo76nz2aXnymHmKqUCLs311ApT3bLBsloZZobjUHRyiaIDAI5xMiFFS3ed0k+7TmnNgTPKuGyauXSQt+6scan0tKgYIi8PhpmRPxSdXKLoAIDjJaSka/meOP2065SW/x6nC2l/X1cr0NtDbauFqmOtMLWrFqogH08Tk8JVUXRyiaIDAM6VmpGpNQfO/HXo+in9mfT3GZg9bRZFlfRXMT8vlfDzUnF/L5Xw91RxPy+V8P/rvp+Xivt5qbi/pwK8PTifDyRRdHKNogMABcduN7Tt+Dn9tOuUftoZqwN/Xril13vaLH+XoL/+LObnmeN+djn6qzD5edkoR26IopNLFB0AMM+RMxf0x9kUxSen6eyFNMVfSNfZ5DTFX0jT2eS/bhfSFX8hTSnpmTdf4TV4eViv2lpU3M9Lft42eVgtslmtf/1pyfmn7VrLrZc9fp3lVos8sh+7tA4P29/Pu3wm2yJL1n9c+iPHY1nLLDnuX/68rNdfq8dd+RxPm8WtCl9uv785yxMAwDQVQvxVISR3h6GnpGXmKEHxF9J0Ljk9x/1Lf6ZfKk3JaUrLsCstw67YxIuKTbzo5E9TuHnaLAoN8FZokI9KBXorNNBbpQK9VSrQ5+//DvJWyQBvtzrzNUUHAOASfL1s8vXyVXgx31w93zAMpaRnXipAF9Iv22p0qRBdTM9Uht1Qpt249GfmX3/a7Uq/4n6O59kvW5556X7Ox+w51pn+1/30THN3oKRnGjqRcFEnEm5e+Er4e2WXodAry1DWsiAfBbjAWbELf0IAAPLAYrHIz8tDfl4eKlfc7DSXZNoNZU2MZNWerAESQ38XoSuHSi6/n/W8v193+fOuvW4Z0vm0DMUlXtSfSamK++v2Z1Kq/ky6eNl/pyrDbij+r0L4e2zSDT+Pn5ctuwBdXoiu3FoU4u9l2nmUKDoAABQQm9WinNM2BSfYz1Nlb7I1zG43dDY5TX+eT1Vc4t9lKO6KMhSXeFEX0jKVnJapI2eSc5wh+1p+euY2VS0d6MiPk2sUHQAAIEmyWi0KCfBWSIC3qofd+LkXUjOytw5dWYbi/ipDp8+n6syFNIUGmHcNNIoOAAC4Zf7eHvL39lDkTa5plp5pl4eJl/+g6AAAAKcx+wgu9zl+DAAA4AoUHQAA4LYoOgAAwG1RdAAAgNui6AAAALdF0QEAAG6LogMAANwWRQcAALgtig4AAHBbFB0AAOC2KDoAAMBtUXQAAIDbougAAAC3VeSvXm4YhiQpMTHR5CQAACC3sr63s77Hr6fIF52kpCRJUkREhMlJAADArUpKSlJwcPB1H7cYN6tCbs5ut+vEiRMKDAyUxWJx2HoTExMVERGhY8eOKSgoyGHrLaz4vO6vqH1mPq974/O6PsMwlJSUpPDwcFmt15/EKfJbdKxWq8qVK+e09QcFBbnND1Vu8HndX1H7zHxe98bndW032pKThWFkAADgtig6AADAbVF0nMTb21sjR46Ut7e32VEKBJ/X/RW1z8zndW983qKjyA8jAwAA98UWHQAA4LYoOgAAwG1RdAAAgNui6AAAALdF0XGSSZMmKSoqSj4+PmrUqJFWrlxpdiSnGDNmjJo0aaLAwECVKlVK9957r/bs2WN2rAIzZswYWSwWRUdHmx3Faf744w/16dNHISEh8vPzU/369bVp0yazYzlFRkaGXn31VUVFRcnX11cVK1bUG2+8IbvdbnY0h/j111/VtWtXhYeHy2KxaOHChTkeNwxDo0aNUnh4uHx9fdWuXTvt3LnTnLAOcqPPnJ6erhdffFF16tSRv7+/wsPD9cgjj+jEiRPmBc6nm/0bX27QoEGyWCwaP358geUzA0XHCebNm6fo6Gi98sor2rJli9q0aaPOnTvr6NGjZkdzuBUrVmjo0KFau3atlixZooyMDHXs2FEXLlwwO5rTbdiwQVOnTlXdunXNjuI0Z8+eVatWreTp6anFixdr165deu+991SsWDGzoznF2LFjNWXKFE2cOFG7d+/WuHHj9O677+r//u//zI7mEBcuXFC9evU0ceLEaz4+btw4vf/++5o4caI2bNigsLAwdejQIfuagK7oRp85OTlZmzdv1r/+9S9t3rxZCxYs0N69e/XPf/7ThKSOcbN/4ywLFy7UunXrFB4eXkDJTGTA4Zo2bWoMHjw4x7Lq1asbL730kkmJCk5cXJwhyVixYoXZUZwqKSnJqFKlirFkyRKjbdu2xrBhw8yO5BQvvvii0bp1a7NjFJi77rrLePTRR3Ms69atm9GnTx+TEjmPJOPrr7/Ovm+3242wsDDjnXfeyV528eJFIzg42JgyZYoJCR3vys98LevXrzckGUeOHCmYUE50vc97/Phxo2zZssaOHTuMChUqGP/5z38KPFtBYouOg6WlpWnTpk3q2LFjjuUdO3bU6tWrTUpVcBISEiRJJUqUMDmJcw0dOlR33XWX7rzzTrOjONX//vc/NW7cWN27d1epUqXUoEEDffzxx2bHcprWrVvr559/1t69eyVJ27Zt06pVq9SlSxeTkznfoUOHFBsbm+N3l7e3t9q2bVskfndlSUhIkMVicdutlna7XQ8//LCef/551apVy+w4BaLIX9TT0U6fPq3MzEyVLl06x/LSpUsrNjbWpFQFwzAMDR8+XK1bt1bt2rXNjuM0n3/+uTZv3qwNGzaYHcXpDh48qMmTJ2v48OF6+eWXtX79ej399NPy9vbWI488YnY8h3vxxReVkJCg6tWry2azKTMzU2+//bZ69epldjSny/r9dK3fXUeOHDEjUoG7ePGiXnrpJT300ENudeHLy40dO1YeHh56+umnzY5SYCg6TmKxWHLcNwzjqmXu5sknn9T27du1atUqs6M4zbFjxzRs2DD99NNP8vHxMTuO09ntdjVu3FijR4+WJDVo0EA7d+7U5MmT3bLozJs3T7Nnz9bcuXNVq1Ytbd26VdHR0QoPD1ffvn3NjlcgiuLvLunSYHLPnj1lt9s1adIks+M4xaZNmzRhwgRt3ry5SPybZmHXlYOVLFlSNpvtqq03cXFxV/0/JXfy1FNP6X//+5+WLVumcuXKmR3HaTZt2qS4uDg1atRIHh4e8vDw0IoVK/TBBx/Iw8NDmZmZZkd0qDJlyqhmzZo5ltWoUcMtB+sl6fnnn9dLL72knj17qk6dOnr44Yf1zDPPaMyYMWZHc7qwsDBJKnK/u6RLJadHjx46dOiQlixZ4rZbc1auXKm4uDiVL18++/fXkSNH9OyzzyoyMtLseE5D0XEwLy8vNWrUSEuWLMmxfMmSJWrZsqVJqZzHMAw9+eSTWrBggX755RdFRUWZHcmp2rdvr5iYGG3dujX71rhxY/Xu3Vtbt26VzWYzO6JDtWrV6qrTBezdu1cVKlQwKZFzJScny2rN+WvRZrO5zeHlNxIVFaWwsLAcv7vS0tK0YsUKt/zdlSWr5Ozbt09Lly5VSEiI2ZGc5uGHH9b27dtz/P4KDw/X888/rx9//NHseE7DrisnGD58uB5++GE1btxYLVq00NSpU3X06FENHjzY7GgON3ToUM2dO1fffPONAgMDs//fYHBwsHx9fU1O53iBgYFXzR/5+/srJCTELeeSnnnmGbVs2VKjR49Wjx49tH79ek2dOlVTp041O5pTdO3aVW+//bbKly+vWrVqacuWLXr//ff16KOPmh3NIc6fP6/9+/dn3z906JC2bt2qEiVKqHz58oqOjtbo0aNVpUoVValSRaNHj5afn58eeughE1Pnz40+c3h4uB544AFt3rxZixYtUmZmZvbvsBIlSsjLy8us2Hl2s3/jK4ucp6enwsLCVK1atYKOWnDMPejLfX344YdGhQoVDC8vL6Nhw4Zue7i1pGvePv30U7OjFRh3PrzcMAzj22+/NWrXrm14e3sb1atXN6ZOnWp2JKdJTEw0hg0bZpQvX97w8fExKlasaLzyyitGamqq2dEcYtmyZdf832vfvn0Nw7h0iPnIkSONsLAww9vb27jtttuMmJgYc0Pn040+86FDh677O2zZsmVmR8+Tm/0bX6koHF5uMQzDKKBOBQAAUKCY0QEAAG6LogMAANwWRQcAALgtig4AAHBbFB0AAOC2KDoAAMBtUXQAAIDbougAKPIiIyM1fvx4s2MAcAKKDoAC1a9fP917772SpHbt2ik6OrrA3nvGjBkqVqzYVcs3bNiggQMHFlgOAAWHa10BcHlpaWn5ui5RaGioA9MAKEzYogPAFP369dOKFSs0YcIEWSwWWSwWHT58WJK0a9cudenSRQEBASpdurQefvhhnT59Ovu17dq105NPPqnhw4erZMmS6tChgyTp/fffV506deTv76+IiAgNGTJE58+flyQtX75c/fv3V0JCQvb7jRo1StLVu66OHj2qe+65RwEBAQoKClKPHj106tSp7MdHjRql+vXra9asWYqMjFRwcLB69uyppKQk5/6lAbhlFB0AppgwYYJatGihxx9/XCdPntTJkycVERGhkydPqm3btqpfv742btyoH374QadOnVKPHj1yvH7mzJny8PDQb7/9po8++kiSZLVa9cEHH2jHjh2aOXOmfvnlF73wwguSpJYtW2r8+PEKCgrKfr/nnnvuqlyGYejee+9VfHy8VqxYoSVLlujAgQN68MEHczzvwIEDWrhwoRYtWqRFixZpxYoVeuedd5z0twUgr9h1BcAUwcHB8vLykp+fn8LCwrKXT548WQ0bNtTo0aOzl02fPl0RERHau3evqlatKkmqXLmyxo0bl2Odl8/7REVF6c0339QTTzyhSZMmycvLS8HBwbJYLDne70pLly7V9u3bdejQIUVEREiSZs2apVq1amnDhg1q0qSJJMlut2vGjBkKDAyUJD388MP6+eef9fbbb+fvLwaAQ7FFB0ChsmnTJi1btkwBAQHZt+rVq0u6tBUlS+PGja967bJly9ShQweVLVtWgYGBeuSRR3TmzBlduHAh1++/e/duRUREZJccSapZs6aKFSum3bt3Zy+LjIzMLjmSVKZMGcXFxd3SZwXgfGzRAVCo2O12de3aVWPHjr3qsTJlymT/t7+/f47Hjhw5oi5dumjw4MF68803VaJECa1atUqPPfaY0tPTc/3+hmHIYrHcdLmnp2eOxy0Wi+x2e67fB0DBoOgAMI2Xl5cyMzNzLGvYsKHmz5+vyMhIeXjk/lfUxo0blZGRoffee09W66WN1V988cVN3+9KNWvW1NGjR3Xs2LHsrTq7du1SQkKCatSokes8AAoHdl0BME1kZKTWrVunw4cP6/Tp07Lb7Ro6dKji4+PVq1cvrV+/XgcPHtRPP/2kRx999IYlpVKlSsrIyND//d//6eDBg5o1a5amTJly1fudP39eP//8s06fPq3k5OSr1nPnnXeqbt266t27tzZv3qz169frkUceUdu2ba+5uwxA4UbRAWCa5557TjabTTVr1lRoaKiOHj2q8PBw/fbbb8rMzNQ//vEP1a5dW8OGDVNwcHD2lpprqV+/vt5//32NHTtWtWvX1pw5czRmzJgcz2nZsqUGDx6sBx98UKGhoVcNM0uXdkEtXLhQxYsX12233aY777xTFStW1Lx58xz++QE4n8UwDMPsEAAAAM7AFh0AAOC2KDoAAMBtUXQAAIDbougAAAC3RdEBAABui6IDAADcFkUHAAC4LYoOAABwWxQdAADgtig6AADAbVF0AACA26LoAAAAt/X/emj4EQsRpXoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(f'n={nqubits} h={h} TFIM, order=1')\n", + "plt.plot(off_diagonal_norm_1)\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# the final matrix\n", + "visualize_matrix(dbi_TFIM.h.matrix)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Order 2" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 722.72trial/s, best loss: 8.144335598357657]\n", + "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j]\n", + "Gradient: [-0.22563381 -0.52082675 -0.5963705 -0.52082675 -0.22563381 0.\n", + " 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. ]\n", + "s: 0.052813741396418624\n" + ] + } + ], + "source": [ + "dbi_TFIM_2 = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)\n", + "# generate pauli_operator_dict\n", + "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n", + "d_coef = decompose_into_Pauli_basis(dbi_TFIM_2.h.matrix, list(pauli_operator_dict.values()))\n", + "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n", + "grad, s = gradient_Pauli(dbi_TFIM_2, d=d, pauli_operator_dict=pauli_operator_dict)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 744.95trial/s, best loss: 8.144331648273518] \n", + "100%|██████████| 500/500 [00:00<00:00, 744.80trial/s, best loss: 7.604748514246744] \n", + "100%|██████████| 500/500 [00:00<00:00, 756.14trial/s, best loss: 7.420954791755261] \n", + "100%|██████████| 500/500 [00:00<00:00, 759.14trial/s, best loss: 7.016113259744297] \n", + "100%|██████████| 500/500 [00:00<00:00, 744.68trial/s, best loss: 5.989940711739217]\n", + "100%|██████████| 500/500 [00:00<00:00, 750.40trial/s, best loss: 5.307608116085456]\n", + "100%|██████████| 500/500 [00:00<00:00, 749.79trial/s, best loss: 4.822327887100122] \n", + "100%|██████████| 500/500 [00:00<00:00, 661.39trial/s, best loss: 4.30794767213952] \n", + "100%|██████████| 500/500 [00:00<00:00, 744.71trial/s, best loss: 3.5737486865622783]\n", + "100%|██████████| 500/500 [00:00<00:00, 742.92trial/s, best loss: 2.899168952313776] \n", + "100%|██████████| 500/500 [00:00<00:00, 749.93trial/s, best loss: 2.6126410200674473] \n", + "100%|██████████| 500/500 [00:00<00:00, 754.15trial/s, best loss: 2.5428845456217983] \n", + "100%|██████████| 500/500 [00:00<00:00, 761.81trial/s, best loss: 2.520820402680462] \n", + "100%|██████████| 500/500 [00:00<00:00, 700.04trial/s, best loss: 2.4881828281706038] \n", + "100%|██████████| 500/500 [00:00<00:00, 736.96trial/s, best loss: 2.4545260560650717] \n" + ] + } + ], + "source": [ + "NSTEPS = 15\n", + "off_diagonal_norm_2 = [dbi_TFIM_2.off_diagonal_norm]\n", + "s_step = [0]\n", + "for i in range(NSTEPS):\n", + " s, d_coef, d = gradient_descent_pauli(dbi_TFIM_2, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n", + " dbi_TFIM_2(step=s, d=d)\n", + " off_diagonal_norm_2.append(dbi_TFIM_2.off_diagonal_norm)\n", + " s_step.append(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(f'n={nqubits} h={h} TFIM')\n", + "plt.plot(off_diagonal_norm_1, label='order 1')\n", + "plt.plot(off_diagonal_norm_2, label='order 2')\n", + "plt.legend()\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Different initial `d`\n", + "Next, we show the effect of different choices of the initial direction of the gradient descent method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(-2.580645161290323+0j), (-1.2903225806451613+0j), (-0.6451612903225807+0j), (-0.32258064516129037+0j), (-0.16129032258064518+0j)]\n" + ] + } + ], + "source": [ + "H = H_TFIM.matrix\n", + "L = int(np.log2(H.shape[0]))\n", + "N = np.diag(np.linspace(np.min(np.diag(H)),np.max(np.diag(H)),2**L))\n", + "d_coef = onsite_Z_decomposition(N, onsite_Z_ops)\n", + "print(d_coef)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ4AAAGiCAYAAADXxKDZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0AUlEQVR4nO3df1hUZd4/8PeAMoLCJCrMkEikUilqG7SKZUIlV2SUmU+k/UDdfpA/imXLUp9nxS4V1zbT1sR0zR9Pkbbrj9zFTHoUrMtskUeL3OqhRKVk5CvqDKIOwdzfP4ipkV9nOIcz3PB+dd3X5Zw55z6fmfHq4/0597mPQQghQEREpBMfbwdARERdCxMPERHpiomHiIh0xcRDRES6YuIhIiJdMfEQEZGumHiIiEhXTDxERKQrJh4iItIVEw8REemKiYeIiBTLzMyEwWBwa2az2aM+urVTbERE1EkNHToUH3/8seu1r6+vR8cz8RARkUe6devm8SjH7XgNYyEiIp1cuXIFNTU1mvQlhIDBYHDbZjQaYTQam9y/pKQEYWFhMBqNGDlyJJYsWYLrr79e8fkMfCwCEZFcrly5gshIM6xWmyb99erVCxcvXnTbtmDBAmRmZjba98MPP8SlS5cQFRWFM2fOYNGiRfjmm29w7Ngx9OnTR9H5mHiIiCRjt9thMplw/OTrCAryV9nXZVwf8XuUlZUhKCjItb2lEc+vVVdXY+DAgZgzZw4yMjIUnZOlNiIiSQUF+atOPL/0FeSWeJTq2bMnhg0bhpKSEsXHcDo1EZGkhKjVpKnhcDjw9ddfw2KxKD6GIx4iIkkJUQch6lT34YkXXngBycnJGDBgACoqKrBo0SLY7XakpqYq7oOJh4iIFPvhhx8wefJknD17Fv369cOoUaNw6NAhREREKO6DiYeISFJOUQunylKZp8dv2bJF1fkAJh4iImlpcY1G7fFtwckFRESkK454iIgkVT+5QO2IR93khLZg4iEikpRw1kI4VSYelce3BUttRESkK454iIhkJWrrm9o+dMbEQ0QkKc5qIyIiUoAjHiIiWTlrAedP6vvQGRMPEZGk6kttnj12uqk+9MZSGxER6YqJRwcbN26EwWCAwWBAfn5+o/eFEBg0aBAMBgPi4+Pd3jMYDE0+BbCrOnHiBAwGAzZu3OjalpmZ2eixvZ1JU5/Z23JycrBixQqPjumIn0N6zlptms5YatNRYGAg1q9f3yi5FBQU4Pvvv0dgYGCjYz777DP0799fpwjl9OSTT+Kee+7xdhhdSk5ODr766iukp6crPsZiseCzzz7DwIED2y+wrsZZCzjVldq8kXg44tFRSkoKtm3bBrvd7rZ9/fr1iIuLw4ABAxodM2rUKCaeVvTv3x+jRo3ydhjUjLq6OjgcDhiNRowaNQr9+vXzdkjkZUw8Opo8eTIA4L333nNts9ls2LZtG6ZPn97kMVeX2hrKdvv378ezzz6Lvn37ok+fPpg4cSJOnz6tKI74+HhER0fjs88+w+jRo+Hv74/rrrsOGzZsAADk5ubilltuQUBAAIYNG4Y9e/a4Hf/dd99h2rRpGDx4MAICAnDttdciOTkZxcXFbvulpaWhR48eKCoqcm1zOp246667EBoaivLy8hbjPH36NB5++GEEBgbCZDIhJSUFVqu10X5Nldq2bt2KxMREWCwW+Pv746abbsLLL7+M6urqRsevW7cOUVFRMBqNGDJkCHJycjB16lRcd911bvudO3cOM2bMwLXXXgs/Pz9cf/31mD9/PhwOh9t+BoMBs2bNwn//93/jpptuQkBAAEaMGIF//vOfbfoelcrPz4fBYEBOTg5eeuklWCwW9OrVC8nJyThz5gyqqqrw9NNPo2/fvujbty+mTZuGixcvuvXx5ptv4o477kBISIjrkcbLli3DTz/9MnMqPj4eubm5OHnypKuE3PD9N5TTli1bhkWLFiEyMhJGoxH79+9vVGq7cuUKfvOb32DQoEGw2Wyu/q1WK8xmM+Lj41FXp/86YnKp++Um0rY2cK22Ti0oKAiTJk3C22+/jWeeeQZAfRLy8fFBSkqKRzXzJ598EuPHj0dOTg7Kysrw4osv4rHHHsO+ffsUHW+1WjFt2jTMmTMH/fv3x1/+8hdMnz4dZWVl+Pvf/4558+bBZDLhlVdewYQJE3D8+HGEhYUBqE8Iffr0wdKlS9GvXz+cO3cOmzZtwsiRI3HkyBHccMMNAIAVK1bg888/x8MPP4yioiJcc801WLhwIfLz87Fnz54WH5V7+fJl3H333Th9+jSysrIQFRWF3NxcpKSkKPp8JSUluPfee5Geno6ePXvim2++wZ/+9Cf861//cvuO1q5di2eeeQYPPfQQXn/9ddhsNixcuLBRMrly5QoSEhLw/fffY+HChRg+fDg++eQTZGVl4ejRo8jNzXXbPzc3F4WFhXjllVfQq1cvLFu2DA8++CC+/fZbXH/99R59j56aN28eEhISsHHjRpw4cQIvvPACJk+ejG7dumHEiBF47733cOTIEcybNw+BgYF44403XMd+//33mDJlCiIjI+Hn54cvvvgCixcvxjfffIO3334bALB69Wo8/fTT+P7777Fjx44mY3jjjTcQFRWFP//5zwgKCsLgwYMb7dOjRw+8//77iImJwfTp07Ft2zY4nU48+uijEELgvffeg6+vyjJSJ2dw1sLgVDd+MHih1AZB7W7Dhg0CgCgsLBT79+8XAMRXX30lhBDi1ltvFVOnThVCCDF06FAxduxYt2MBiAULFjTqa8aMGW77LVu2TAAQ5eXlrcYzduxYAUAcPnzYta2yslL4+voKf39/8eOPP7q2Hz16VAAQb7zxRrP91dbWipqaGjF48GDx+9//3u29kpISERQUJCZMmCA+/vhj4ePjI/7zP/+z1Rizs7MFAPHBBx+4bX/qqacEALFhwwbXtgULFoiW/io7nU7x008/iYKCAgFAfPHFF0IIIerq6oTZbBYjR4502//kyZOie/fuIiIiwrVtzZo1AoB4//333fb905/+JACIvXv3urYBEKGhocJut7u2Wa1W4ePjI7KyspqNs7nvsbS0tNFnbkrD363k5GS37enp6QKAeO6559y2T5gwQQQHBzfbX11dnfjpp5/E5s2bha+vrzh37pzrvfHjx7t9P1fHOnDgQFFTU9Pke1d/jq1btwoAYsWKFeKPf/yj8PHxcfs+qTGbzSYAiB++/52wVzyrqv3w/e8EAGGz2XSLn6U2nY0dOxYDBw7E22+/jeLiYhQWFjZbZmvJ/fff7/Z6+PDhAICTJ08CqC9p1dbWutrVJQuLxYKYmBjX6+DgYISEhODmm292jWwA4KabbnLrFwBqa2uxZMkSDBkyBH5+fujWrRv8/PxQUlKCr7/+2u08gwYNwrp167Bz507cd999GDNmjKJZevv370dgYGCjzzllypRWjwWA48ePY8qUKTCbzfD19UX37t0xduxYAHDF+O2338JqteLhhx92O3bAgAG47bbb3Lbt27cPPXv2xKRJk9y2T506FQDwP//zP27bExIS3CaLhIaGIiQkpM3foyfuu+8+t9cNv+H48eMbbT937pxbue3IkSO4//770adPH9f39sQTT6Curg7/93//pziG+++/H927d1e078MPP4xnn30WL774IhYtWoR58+Zh3Lhxis/VpUk6q42JR2cGgwHTpk3DO++8gzVr1iAqKgpjxozxuJ8+ffq4vTYajQDqS1QA8Morr6B79+6udvVMouDg4EZ9+vn5Ndru5+cHoL7U1CAjIwP/9V//hQkTJuAf//gHPv/8cxQWFmLEiBGu8//a+PHjERoaiitXriAjI0NR+aSyshKhoaGNtpvN5laPvXjxIsaMGYPPP/8cixYtQn5+PgoLC7F9+3YAv3xHlZWVANDkea7eVllZCbPZ3OhaUkhICLp16+bqq8HVvw9Q/xv9+vvx9HtUqrnfsLXf9tSpUxgzZgx+/PFHrFy5Ep988gkKCwvx5ptvAoBHMbVURm3K9OnT8dNPP6Fbt2547rnnPDq2S5M08fAajxdMnToVf/zjH7FmzRosXry4Xc7x9NNPu/3LtyExaeGdd97BE088gSVLlrhtP3v2LK655ppG+6elpaGqqgpDhw7Fc889hzFjxqB3794tnqNPnz7417/+1Wh7U5MLrrZv3z6cPn0a+fn5rlEOAFy4cKHROQDgzJkzrZ6nT58++PzzzyGEcEs+FRUVqK2tRd++fVuN62qefo/tbefOnaiursb27dsRERHh2n706FGP+/Lkvqrq6mo8/vjjiIqKwpkzZ/Dkk0/igw8+8PicJA+OeLzg2muvxYsvvojk5GSkpqa2yznCwsIQGxvrasOGDdOsb4PB0CiR5ebm4scff2y071//+le88847WLVqFXbt2oULFy5g2rRprZ4jISEBVVVV2LVrl9v2nJwcRfEBjZPtW2+95fb6hhtugNlsxvvvv++2/dSpUzh48KDbtrvuugsXL17Ezp073bZv3rzZ9b6nPPke9dDU9yaEwLp16xrte/XoTY20tDScOnUK27dvx/r167Fr1y68/vrrmvTd2RlErSZNbxzxeMnSpUu9HUKb3Xfffdi4cSNuvPFGDB8+HEVFRXj11Vcb3W9UXFyM5557Dqmpqa5ks379ekyaNAkrVqxo8ebDJ554Aq+//jqeeOIJLF68GIMHD8bu3bvx0UcftRrf6NGj0bt3b6SlpWHBggXo3r073n33XXzxxRdu+/n4+GDhwoV45plnMGnSJEyfPh0XLlzAwoULYbFY4OPzy7/LnnjiCbz55ptITU3FiRMnMGzYMHz66adYsmQJ7r33Xtx9990efIP1lH6Pehk3bhz8/PwwefJkzJkzB1euXEF2djbOnz/faN9hw4Zh+/btyM7ORkxMDHx8fBAbG+vxORv+YbJhwwYMHToUQ4cOxaxZs/DSSy/htttuw29/+1stPlrn5XQCTpXToZ1ObWLxAEc85LGVK1fiscceQ1ZWFpKTk7Fr1y5s377d7TpSdXU1Hn74YURGRmL16tWu7Q899BBmzpyJOXPmNFlKaxAQEIB9+/bh7rvvxssvv4xJkybhhx9+wJYtW1qNr0+fPsjNzUVAQAAee+wxTJ8+Hb169cLWrVsb7fv0009j7dq1+OKLL/Dggw9i4cKFePnll/Gb3/zGrdzVo0cP7N+/H48++iheffVVJCUlYePGjXjhhRdc1448peR71NONN96Ibdu24fz585g4cSJmz56Nm2++2W26dYPnn38ekyZNwrx58zBq1CjceuutHp/v1/8waZikAQB//vOfMXz4cKSkpDQqj1LnYBBCCG8HQdSRXLhwAVFRUZgwYQLWrl3r7XCIGrHb7TCZTDj91YMIClQ2e7DZvqp+Qlj0DthsNgQFBWkUYctYaqMuzWq1YvHixUhISECfPn1w8uRJvP7666iqqsLzzz/v7fCIWuasA1TeQKq6VNcGTDzUpRmNRpw4cQIzZszAuXPnEBAQgFGjRmHNmjUYOnSot8Mj6pSYeKhL6927N/7xj394OwyitnHWAk6VjwThfTxERKSUwVmnwVpt+pfaOKuNiIh01eFGPE6nE6dPn0ZgYGCnfqokEXUdQghUVVUhLCzM7f4w9R1rMLlAcHIBTp8+jfDwcG+HQUSkubKyMk1vEDY4napLZQYv3EDaboln9erVePXVV1FeXo6hQ4dixYoVihbDbFjR98SplQgK8m9x3+Br0jSJlYiofQkAosnH23dF7ZJ4tm7divT0dKxevRq33XYb3nrrLSQlJeHf//53k493/rWG8lpQkD+CggJaORNLcUQkC6H95QNnnQaz2jrJ5ILly5fjd7/7HZ588kncdNNNWLFiBcLDw5Gdnd0epyMi6pLqZ7Wpb3rTPPHU1NSgqKgIiYmJbtsTExMbrfgLAA6HA3a73a0REVHnpXniOXv2LOrq6ho9SCs0NLTJZ6lkZWXBZDK5GicWEBEp5KzTpums3e7jubqWefUDtBrMnTsXNpvN1crKytorJCKiTkXWUpvmkwv69u0LX1/fRqObioqKJh8xbDQaNX06JhERdWyaj3j8/PwQExODvLw8t+15eXkYPXq01qcjIuq6JC21tct06oyMDDz++OOIjY1FXFwc1q5di1OnTiEtjffdEBFpxeAUqm8ANTj1fyRbuySelJQUVFZW4pVXXkF5eTmio6Oxe/duREREKO6j/ubQluen26zTWu3HZN6g+JxERNT+2m3lghkzZmDGjBnt1T0RETnrALUr3nSWUhsREelAaJB4vLBIKB+LQEREuuKIh4hIUgbhhEGoW6vNIDrR6tRERNTOJL3Gw1IbERHpiiMeIiJZOZ0aPBaBpTYiIlKKiUd/Sm4OdXwWragvY9xXasMhIiIFpE48RERdmcHphEHlgEXtkjttwcRDRCQrp1ODWW36Jx7OaiMiIl1xxENEJCtJRzxMPEREspI08bDURkREuuKIh4hIVqIOUPsgN67VRkRESsk6nZqlNiIi0lWnH/EoXZHgpy0Bivbr/sglNeEQEWlH0skFnT7xEBF1WpImHpbaiIhIVxzxEBHJyinUj1jUzoprAyYeIiJZOYUGpTb9Ew9LbUREpCuOeIiIZKXJg+A44iEiIqWcTm2aCllZWTAYDEhPT1d8DBMPERG1SWFhIdauXYvhw4d7dBwTDxGRrJxCm9YGFy9exKOPPop169ahd+/eHh3Lazw/U7oiwZWl/or26/HyZTXhEBG1TjgBofIaj6hPPHa73W2z0WiE0Whs9rCZM2di/PjxuPvuu7Fo0SKPTskRDxERITw8HCaTydWysrKa3XfLli343//93xb3aQlHPEREshIa3Mfz84inrKwMQUFBrs3NjXbKysrw/PPPY+/evejRo0ebTsnEQ0QkKw1vIA0KCnJLPM0pKipCRUUFYmJiXNvq6upw4MABrFq1Cg6HA76+vi32wcRDRESK3XXXXSguLnbbNm3aNNx444146aWXWk06ABMPEZG8vLBkTmBgIKKjo9229ezZE3369Gm0vTlMPEREkhJO9U+u9sKTr5l4iIhInfz8fI/2Z+IhIpKVpKtTM/F4SOmNoednD2h1n95/OaU2HCLqypzQIPFoEYhneAMpERHpSvPEk5mZCYPB4NbMZrPWpyEiIqdGTWftUmobOnQoPv74Y9drJfO6iYjIQ+LnprYPnbVL4unWrZviUY7D4YDD4XC9vnqhOiIi6lza5RpPSUkJwsLCEBkZiUceeQTHjx9vdt+srCy3henCw8PbIyQiok5HOA2aNL1pnnhGjhyJzZs346OPPsK6detgtVoxevRoVFZWNrn/3LlzYbPZXK2srEzrkIiIOide46mXlJTk+vOwYcMQFxeHgQMHYtOmTcjIyGi0f2vPfCAios6l3e/j6dmzJ4YNG4aSkpL2PhURUdciDIDaUpkXJhe0+308DocDX3/9NSwWS3ufioioS5H1Go/mI54XXngBycnJGDBgACoqKrBo0SLY7XakpqZqfaoOTcmqBKWTYlrdBwAi/16kNhwiog5D88Tzww8/YPLkyTh79iz69euHUaNG4dChQ4iIiND6VEREXZtTg1JbZ5hcsGXLFq27JCKipghDfVPVhzaheIJrtRERka64OjURkaS0mBzAB8EREZFyTh8NrvHoX2tjqY2IiHTFEQ8Rkaw4q42IiPQkhAFC5aw2wVltRETU2XHE40VKVyQ4nDBO0X6x+/PUhENEspF0cgETDxGRpIQTGkyn5qw2IiLq5DjiISKSlSaPRegEq1MTEZE+tJnV1gkefU1ERNQSjniIiGTl9KlvqvrQJhRPMPEQEUlKm0VCWWojIqJOjiMeCSi9MfSfMf/R6j73Ff1NbThE1EHIOrmAiYeISFaSXuNhqY2IiHTFEQ8RkaRknVzAxENEJClZr/Gw1EZERLriiIeISFaSTi5g4iEikpSs13hYaiMiIl1xxENEJClZJxcw8XQiSlYlWHfjNEV9PfXNBrXhEFF7Expc49H/AaQstRERkb444iEikpSskwuYeIiIJCWE+ms0gqU2IiLq7DjiISKSlQalNrDURkRESgnhAyHUFa6EF2ptLLUREZGuOOIhIpKV06C+VMZSGxERKcWVC0gKSlckyIxIU7bfyTVqwiGiLsjjazwHDhxAcnIywsLCYDAYsHPnTrf3hRDIzMxEWFgY/P39ER8fj2PHjmkVLxER/azhBlK1TW8eJ57q6mqMGDECq1atavL9ZcuWYfny5Vi1ahUKCwthNpsxbtw4VFVVqQ6WiIh+0TCrTW3Tm8eltqSkJCQlJTX5nhACK1aswPz58zFx4kQAwKZNmxAaGoqcnBw888wz6qIlIiLpaZrqSktLYbVakZiY6NpmNBoxduxYHDx4sMljHA4H7Ha7WyMiotZ1mVJbS6xWKwAgNDTUbXtoaKjrvatlZWXBZDK5Wnh4uJYhERF1Wg2z2tQ2vbVLcc9gcP8gQohG2xrMnTsXNpvN1crKytojJCIi6iA0nU5tNpsB1I98LBaLa3tFRUWjUVADo9EIo9GoZRhERF2CrPfxaDriiYyMhNlsRl5enmtbTU0NCgoKMHr0aC1PRUTU5QmhwTUeGW4gvXjxIr777jvX69LSUhw9ehTBwcEYMGAA0tPTsWTJEgwePBiDBw/GkiVLEBAQgClTpmgaOBERycnjxHP48GEkJCS4XmdkZAAAUlNTsXHjRsyZMweXL1/GjBkzcP78eYwcORJ79+5FYGCgdlFTu1O6IsHT/WYq2m/t/3tTTThE1ARZV6f2OPHEx8e3GKjBYEBmZiYyMzPVxEVERK2Q9dHXfCwCERHpiouEEhFJStZZbUw8RESSkjXxsNRGRES6YuIhIpKUcGqxXptn58zOzsbw4cMRFBSEoKAgxMXF4cMPP/SoD5baiIgk5Y1SW//+/bF06VIMGjQIQP0TCB544AEcOXIEQ4cOVdQHEw8RESmWnJzs9nrx4sXIzs7GoUOHmHhIH0pvDB3fq/VHaede5GO0iTyhzQ2k9cdf/UgaJeto1tXV4W9/+xuqq6sRFxen+Jy8xkNEJCmnMGjSACA8PNztETVZWVnNnre4uBi9evWC0WhEWloaduzYgSFDhiiOmyMeIiJCWVkZgoKCXK9bGu3ccMMNOHr0KC5cuIBt27YhNTUVBQUFipMPEw8Rkay0eILoz8c3zFJTws/PzzW5IDY2FoWFhVi5ciXeeustRccz8RARSaqj3EAqhIDD4VC8PxMPEREpNm/ePCQlJSE8PBxVVVXYsmUL8vPzsWfPHsV9MPEQEUnKGyOeM2fO4PHHH0d5eTlMJhOGDx+OPXv2YNy4cYr7YOIhIpKUNxLP+vXrVZ0P4HRqIiLSGUc8RESScgofOFXeQKr2+LZg4iFdKFmV4OaAyYr6OnrpPbXhEHUKQmjwBFI+FoGIiDo7jniIiCTVUe7j8RQTDxGRpGRNPCy1ERGRrjjiISKS1K9Xl1bTh96YeIiIJMVSGxERkQIc8RARSUrWEQ8TDxGRpHiNh0glpSsS9O0Zo2i/s9VFasIhonbCxENEJCkh1JfKhNAoGA8w8RARSUrWazyc1UZERLriiIeISFJCg8kFnNVGRESKsdRGRESkAEc8RESSknXEw8RDRCQp3kBKpBOlN4b6+pha3afOaVMbDhF5iImHiEhSspbaPJ5ccODAASQnJyMsLAwGgwE7d+50e3/q1KkwGAxubdSoUVrFS0REP2sotaltevM48VRXV2PEiBFYtWpVs/vcc889KC8vd7Xdu3erCpKIiDoPj0ttSUlJSEpKanEfo9EIs9msqD+HwwGHw+F6bbfbPQ2JiKhLEjBAQGWpTeXxbdEu9/Hk5+cjJCQEUVFReOqpp1BRUdHsvllZWTCZTK4WHh7eHiEREXU6Ddd41Da9aZ54kpKS8O6772Lfvn147bXXUFhYiDvvvNNtVPNrc+fOhc1mc7WysjKtQyIiog5E81ltKSkprj9HR0cjNjYWERERyM3NxcSJExvtbzQaYTQatQ6DiKjT4308zbBYLIiIiEBJSUl7n4qIqEvpMtOpPVVZWYmysjJYLJb2PhUREUnA4xHPxYsX8d1337lel5aW4ujRowgODkZwcDAyMzPx0EMPwWKx4MSJE5g3bx769u2LBx98UNPAiVqjZFUCJasbKO2LSG9OaFBq88KsNo8Tz+HDh5GQkOB6nZGRAQBITU1FdnY2iouLsXnzZly4cAEWiwUJCQnYunUrAgMDtYuaiIik5XHiiY+Ph2jhId0fffSRqoCIiEgZWa/xcK02IiJJOWFQXSrzRqmND4IjIiJdccRDRCQrLVYeYKmNiIiUkvUGUpbaiIhIVxzxEBFJirPaiIhIV86fm9o+9MbEQ12a0hUJ+vaMUbTf2eoiNeEQdQlMPEREkmKpjYiIdOUU6melOZtfiKbdcFYbERHpiiMeIiJJCRggVC55o/b4tmDiISKSFG8gJSIiUoAjHiIiSdVPLlDfh96YeIiIJMVrPESdmNIbQ28OmKxov6OX3lMTDpHUmHiIiCQl6+QCJh4iIkkJUd/U9qE3zmojIiJdccRDRCQpAQOcnFxARER6kXWRUJbaiIhIVxzxEBFJirPaiIhIV+LnprYPvbHURkREuuKIh0hDSlckGN8rrdV9ci+uURsOdXIstRERka6cPze1feiNpTYiItIVRzxERJKS9T4eJh4iIknJeo2HpTYiItIVEw8RkaSERs0TWVlZuPXWWxEYGIiQkBBMmDAB3377rUd9MPEQEUmqodSmtnmioKAAM2fOxKFDh5CXl4fa2lokJiaiurpacR+8xkNERIrt2bPH7fWGDRsQEhKCoqIi3HHHHYr6YOIhIpKUlvfx2O12t+1GoxFGo7HV4202GwAgODhY8TmZeIi8QMmqBE/3m6mor7X/70214ZCktJxOHR4e7rZ9wYIFyMzMbOVYgYyMDNx+++2Ijo5WfE6PrvEouagkhEBmZibCwsLg7++P+Ph4HDt2zJPTEBGRzsrKymCz2Vxt7ty5rR4za9YsfPnll3jvPWVLRTXwKPEouai0bNkyLF++HKtWrUJhYSHMZjPGjRuHqqoqjwIjIqKWCfxSbmtra5jVFhQU5NZaK7PNnj0bu3btwv79+9G/f3+P4vao1NbaRSUhBFasWIH58+dj4sSJAIBNmzYhNDQUOTk5eOaZZzwKjoiImiegQanNw0dfCyEwe/Zs7NixA/n5+YiMjPT4nKqmU199Uam0tBRWqxWJiYmufYxGI8aOHYuDBw822YfD4YDdbndrRETUMc2cORPvvPMOcnJyEBgYCKvVCqvVisuXLyvuo82Jp6mLSlarFQAQGhrqtm9oaKjrvatlZWXBZDK52tUXuIiIqGlOoU3zRHZ2Nmw2G+Lj42GxWFxt69ativto86y2hotKn376aaP3DAb3oZsQotG2BnPnzkVGRobrtd1uZ/IhIlLAG08gFUL9M0vblHgaLiodOHDA7aKS2WwGUD/ysVgsru0VFRWNRkENlM4VJyKizsGjUpsQArNmzcL27duxb9++RheVIiMjYTabkZeX59pWU1ODgoICjB49WpuIiYgIgHeWzNGCRyOemTNnIicnBx988IHrohIAmEwm+Pv7w2AwID09HUuWLMHgwYMxePBgLFmyBAEBAZgyZUq7fACizkrpjaGZEa0/RhsAMk/yUdqdjaxPIPUo8WRnZwMA4uPj3bZv2LABU6dOBQDMmTMHly9fxowZM3D+/HmMHDkSe/fuRWBgoCYBExGR3DxKPEouKhkMBmRmZra61AIREanDJ5ASEZGuZC218Xk8RESkK454iIgkJUR9U9uH3ph4iIgk5YQBTg/XWmuqD72x1EZERLriiIeISFJtWWutqT70xsRDRCQrDa7xqF7srQ2YeIgkp3RFgnU3TlO031PfbFATDlGrmHiIiCQl6+QCJh4iIknJOp2as9qIiEhXHPEQEUlK1iVzmHiIiCQl63RqltqIiEhXHPEQEUlKQP1tOF4Y8DDxEBHJqr7UpnI6NUttRETU2XHEQ9RFKF2R4J8x/9HqPvcV/U1tOKQBWe/jYeIhIpKUrNOpWWojIiJdccRDRCQpltqIiEhXLLUREREpwBEPEZGkhAZL5rDURkREism6cgFLbUREpCuOeIjIjZKbQw8njFPUV+z+PLXhUAtkXZ2aiYeISFKyTqdmqY2IiHTFEQ8RkaRkvY+HiYeISFKyXuNhqY2IiHTFEQ8RkaRkvY+HiYeISFIstRERESnAEQ8RkaRkvY+HiYeIPKZ0RYLSSTGK9ov8e5GacLosWadTs9RGRES68ijxZGVl4dZbb0VgYCBCQkIwYcIEfPvtt277TJ06FQaDwa2NGjVK06CJiOjnEY9Q2bwQt0eJp6CgADNnzsShQ4eQl5eH2tpaJCYmorq62m2/e+65B+Xl5a62e/duTYMmIqJfplOrbXrz6BrPnj173F5v2LABISEhKCoqwh133OHabjQaYTabFfXpcDjgcDhcr+12uychERGRZFRd47HZbACA4OBgt+35+fkICQlBVFQUnnrqKVRUVDTbR1ZWFkwmk6uFh4erCYmIqMsQbS2v/apJtTq1EAIZGRm4/fbbER0d7dqelJSEd999F/v27cNrr72GwsJC3HnnnW6jml+bO3cubDabq5WVlbU1JCKiLqVhOrXaprc2T6eeNWsWvvzyS3z66adu21NSUlx/jo6ORmxsLCIiIpCbm4uJEyc26sdoNMJoNLY1DCIikkybEs/s2bOxa9cuHDhwAP37929xX4vFgoiICJSUlLQpQCIiapqs9/F4lHiEEJg9ezZ27NiB/Px8REZGtnpMZWUlysrKYLFY2hwkERE1Vj8dWl2trMM/+nrmzJnIycnBBx98gMDAQFitVgCAyWSCv78/Ll68iMzMTDz00EOwWCw4ceIE5s2bh759++LBBx9slw9ARB2X0hUJzs8e0Oo+vf9ySm041EF4lHiys7MBAPHx8W7bN2zYgKlTp8LX1xfFxcXYvHkzLly4AIvFgoSEBGzduhWBgYGaBU1ERF3ksQiilekP/v7++Oijj1QFREREymix8gAfi0BERJ0eV6cmIpKU+Pk/tX3ojYmHiEhSLLUREREpwBEPEZGkusQNpERE1HEIocE1Hi8s1sZSGxER6YojHiLyOiWrElxZ6q+orx4vX1YbjjRYaiMiIl2x1EZERKQARzxERJISUF8q6/BrtRERUcfhFEKDxyKw1EZERB3YgQMHkJycjLCwMBgMBuzcudPjPph4iIgkJTT6zxPV1dUYMWIEVq1a1ea4WWojIpKUN6ZTJyUlISkpSdU5mXiIiAh2u93ttdFohNFobJdzMfEQkRSU3hj605YARft1f+SSmnA6BCc0mFzw8/Hh4eFu2xcsWIDMzExVfTeHiYeISFJazmorKytDUFCQa3t7jXYAJh4iIgIQFBTklnjaExMPEZGk+ARSIiLSlZbXeJS6ePEivvvuO9fr0tJSHD16FMHBwRgwYICiPph4iIhIscOHDyMhIcH1OiMjAwCQmpqKjRs3KuqDiYeISFLeGPHEx8erXtGaiYeISFKyXuPhkjlERKQrjniIiCQlNCi1cVYbEZFKSlckcHwWrWg/Y9xXasJpV06DEwaDutXanF54+DVLbUREpCuOeIiIJOWEgEHnWW1aYOIhIpKU+HlCtdo+9MZSGxER6YojHiIiSTkBDUpt+mPiISKSFGe1ERERKcARDxGRpJxwwqByxOKNEQ8TDxGRpJh4iIgkonRFApt1Wqv7mMwb1IbTpXh0jSc7OxvDhw93PSI1Li4OH374oet9IQQyMzMRFhYGf39/xMfH49ixY5oHTUREv9zHo7bpzaPE079/fyxduhSHDx/G4cOHceedd+KBBx5wJZdly5Zh+fLlWLVqFQoLC2E2mzFu3DhUVVW1S/BERF2Z0+DUpOnNo8STnJyMe++9F1FRUYiKisLixYvRq1cvHDp0CEIIrFixAvPnz8fEiRMRHR2NTZs24dKlS8jJyWm2T4fDAbvd7taIiKjzavN06rq6OmzZsgXV1dWIi4tDaWkprFYrEhMTXfsYjUaMHTsWBw8ebLafrKwsmEwmVwsPD29rSEREXYqAU/V/Hb7UBgDFxcXo1asXjEYj0tLSsGPHDgwZMgRWqxUAEBoa6rZ/aGio672mzJ07FzabzdXKyso8DYmIqEsSqNOk6c3jWW033HADjh49igsXLmDbtm1ITU1FQUGB632DweC2vxCi0bZfMxqNMBqNnoZBRESS8jjx+Pn5YdCgQQCA2NhYFBYWYuXKlXjppZcAAFarFRaLxbV/RUVFo1EQERGpV38Pjnz38aheMkcIAYfDgcjISJjNZuTl5bneq6mpQUFBAUaPHq32NEREdBWnRld59ObRiGfevHlISkpCeHg4qqqqsGXLFuTn52PPnj0wGAxIT0/HkiVLMHjwYAwePBhLlixBQEAApkyZ0l7xExG1KyU3h9Y6N7X4vt1+CcHXPK1VSNLzKPGcOXMGjz/+OMrLy2EymTB8+HDs2bMH48aNAwDMmTMHly9fxowZM3D+/HmMHDkSe/fuRWBgYLsET0TUldVPDmj+GrrSPvRmEELoP85qgd1uh8lkQn0VUN0XSkSkB6UjHpvNhqCgINXna/j/ZFjPsfAxqFv5zClqcbq6QLPYlOBjEYiISFdcJJSISFJarLXmjRtImXiIiCTlRB3UXpJweuEaD0ttRESkK454iIgkxVIbERHpyik0KLUJCdZqa2+/zO7uULO8iYiaZbdfauX9ywB+/f+3rq3DJZ5fHhonwORDRDJQuipBVVXVz/cpaoOlNo2EhYWhrKwMgYGBrlWt7XY7wsPDUVZWptsNTlqT/TPIHj8g/2eQPX5A/s/Q1viFEKiqqkJYWJim8dQnHnWlMiYeAD4+Pujfv3+T7wUFBUn5l/XXZP8MsscPyP8ZZI8fkP8ztCV+LUc6sutwiYeIiJQRwgmn2rXaBEc8RESkUH2ZTO0ioRI+j0cPRqMRCxYskPpJpbJ/BtnjB+T/DLLHD8j/GWSPv6PocKtTExFRyxpWpzb1GAKDwVdVX0LUwXbl37quTs1SGxGRpOqv8LDURkRE1CKOeIiIJFU/I42z2oiISCdaPLbaG4++ZqmNiIh0JUXiWb16NSIjI9GjRw/ExMTgk08+8XZIimRmZsJgMLg1s9ns7bBadODAASQnJyMsLAwGgwE7d+50e18IgczMTISFhcHf3x/x8fE4duyYd4JtQmvxT506tdFvMmrUKO8E24SsrCzceuutCAwMREhICCZMmIBvv/3WbZ+O/hso+Qwd+XfIzs7G8OHDXasTxMXF4cMPP3S935G+fyEEhHCqbPpPbO7wiWfr1q1IT0/H/PnzceTIEYwZMwZJSUk4deqUt0NTZOjQoSgvL3e14uJib4fUourqaowYMQKrVq1q8v1ly5Zh+fLlWLVqFQoLC2E2mzFu3LhfLe7qXa3FDwD33HOP22+ye/duHSNsWUFBAWbOnIlDhw4hLy8PtbW1SExMRHV1tWufjv4bKPkMQMf9Hfr374+lS5fi8OHDOHz4MO6880488MADruTSkb7/hkVC1Tb9A+/gfvvb34q0tDS3bTfeeKN4+eWXvRSRcgsWLBAjRozwdhhtBkDs2LHD9drpdAqz2SyWLl3q2nblyhVhMpnEmjVrvBBhy66OXwghUlNTxQMPPOCVeNqioqJCABAFBQVCCPl+AyEafwYh5PsdevfuLf761792mO/fZrMJAMLf7zoRYLxeVfP3u04AEDabTbf4O/SIp6amBkVFRUhMTHTbnpiYiIMHD3opKs+UlJQgLCwMkZGReOSRR3D8+HFvh9RmpaWlsFqtbr+H0WjE2LFjpfk9ACA/Px8hISGIiorCU089hYqKCm+H1CybzQYACA4OBiDnb3D1Z2ggw+9QV1eHLVu2oLq6GnFxcR3u+xeiTpOmtw6deM6ePYu6ujqEhoa6bQ8NDYXVavVSVMqNHDkSmzdvxkcffYR169bBarVi9OjRqKys9HZobdLwncv6ewBAUlIS3n33Xezbtw+vvfYaCgsLceedd8LhcHg7tEaEEMjIyMDtt9+O6OhoAPL9Bk19BqDj/w7FxcXo1asXjEYj0tLSsGPHDgwZMqTDff/qr+84OZ26OQ3P5WkghGi0rSNKSkpy/XnYsGGIi4vDwIEDsWnTJmRkZHgxMnVk/T0AICUlxfXn6OhoxMbGIiIiArm5uZg4caIXI2ts1qxZ+PLLL/Hpp582ek+W36C5z9DRf4cbbrgBR48exYULF7Bt2zakpqaioKDA9b4s339H1aFHPH379oWvr2+jf0lUVFQ0+heHDHr27Ilhw4ahpKTE26G0ScOMvM7yewCAxWJBREREh/tNZs+ejV27dmH//v1uz6eS6Tdo7jM0paP9Dn5+fhg0aBBiY2ORlZWFESNGYOXKlR3u+5d1ckGHTjx+fn6IiYlBXl6e2/a8vDyMHj3aS1G1ncPhwNdffw2LxeLtUNokMjISZrPZ7feoqalBQUGBlL8HAFRWVqKsrKzD/CZCCMyaNQvbt2/Hvn37EBkZ6fa+DL9Ba5+hKR3td7iaEAIOh6PDff+ylto6/Ky2LVu2iO7du4v169eLf//73yI9PV307NlTnDhxwtuhteoPf/iDyM/PF8ePHxeHDh0S9913nwgMDOzQsVdVVYkjR46II0eOCABi+fLl4siRI+LkyZNCCCGWLl0qTCaT2L59uyguLhaTJ08WFotF2O12L0der6X4q6qqxB/+8Adx8OBBUVpaKvbv3y/i4uLEtdde22Hif/bZZ4XJZBL5+fmivLzc1S5duuTap6P/Bq19ho7+O8ydO1ccOHBAlJaWii+//FLMmzdP+Pj4iL179wohOsb33zCrrbtvqPDrZlHVuvuG6j6rrcMnHiGEePPNN0VERITw8/MTt9xyi9u0zI4sJSVFWCwW0b17dxEWFiYmTpwojh075u2wWrR//34BoFFLTU0VQtRP512wYIEwm83CaDSKO+64QxQXF3s36F9pKf5Lly6JxMRE0a9fP9G9e3cxYMAAkZqaKk6dOuXtsF2aih2A2LBhg2ufjv4btPYZOvrvMH36dNf/b/r16yfuuusuV9IRomN8/w2Jp5tvP9G9W6iq1s23n+6Jh8/jISKSTMPzeHx9gmEwqLtiIoQTdc5zuj6Pp0Nf4yEios5HiunURETUFAGonpWmf9GLiYeISFLaPI+Hi4QSEVEnxxEPEZGk6m/+VDniYamNiIiUU594vHGNh6U2IiLSFUc8RESy0mByAbwwuYCJh4hIUrJe42GpjYiIdMURDxGRtDi5gIiIdCXqr9GoaW1MPKtXr0ZkZCR69OiBmJgYfPLJJ4qPZeIhIiKPbN26Fenp6Zg/fz6OHDmCMWPGICkpCadOnVJ0PFenJiKSTMPq1IAvtCm11Xm0OvXIkSNxyy23IDs727XtpptuwoQJE5CVldXq8RzxEBFJrdlHICls9ex2u1tzOBxNnq2mpgZFRUVITEx0256YmIiDBw8qipiJh4hIMn5+fjCbzQDqNGm9evVCeHg4TCaTqzU3cjl79izq6uoQGhrqtj00NBRWq1VR/JzVRkQkmR49eqC0tBQ1NTWa9CeEgMHgXrIzGo0tHnP1/k310RwmHiIiCfXo0QM9evTQ/bx9+/aFr69vo9FNRUVFo1FQc1hqIyIixfz8/BATE4O8vDy37Xl5eRg9erSiPjjiISIij2RkZODxxx9HbGws4uLisHbtWpw6dQppaWmKjmfiISIij6SkpKCyshKvvPIKysvLER0djd27dyMiIkLR8byPh4iIdMVrPEREpCsmHiIi0hUTDxER6YqJh4iIdMXEQ0REumLiISIiXTHxEBGRrph4iIhIV0w8RESkKyYeIiLSFRMPERHp6v8D/thKNBd0ouMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_matrix(H, 'Initial hamiltonian')\n", + "visualize_matrix(N, 'Min-max diagonal matrix')\n", + "visualize_matrix(d, 'Min-max projection onsite-Z')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we see that the min-max diagonal operator can be correctly decomposed into onsite-Z operators. Then we generate the diagonalization curve and compare with other initializations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-03-26 16:08:28]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", + "# initialize dbi object\n", + "dbi_TFIM_MMH = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 688.27trial/s, best loss: 9.336239342915379]\n", + "New optimized step at iteration 1/15: 0.039240166337035656 with d_coef [(-2.3180340693309422+0j), (-0.9042157574954297+0j), (-0.6267094129284807+0j), (-0.37510402952816974+0j), (-0.16137910360026844+0j)], loss 9.263805656974093\n", + "100%|██████████| 500/500 [00:00<00:00, 654.86trial/s, best loss: 8.253271106315344] \n", + "New optimized step at iteration 2/15: 0.0636971166898561 with d_coef [(-2.8893154826347565+0j), (-1.3328071932958503+0j), (-0.5996311871447069+0j), (-0.38812640871658144+0j), (-0.16592899239661785+0j)], loss 8.248988639626276\n", + "100%|██████████| 500/500 [00:00<00:00, 705.90trial/s, best loss: 7.820911729728226] \n", + "New optimized step at iteration 3/15: 0.026774099108320803 with d_coef [(-3.9047191557345737+0j), (-1.3620955366051533+0j), (-1.094932722170599+0j), (-0.5744178736473565+0j), (-0.04727696085745736+0j)], loss 7.79237041903216\n", + "100%|██████████| 500/500 [00:00<00:00, 522.76trial/s, best loss: 7.506187222292692]\n", + "New optimized step at iteration 4/15: 0.029295596624437686 with d_coef [(-3.894655859483571+0j), (-1.866243073713661+0j), (-0.7092145648013096+0j), (-0.7039608847825699+0j), (-0.023283739763302808+0j)], loss 7.4962199726801755\n", + "100%|██████████| 500/500 [00:00<00:00, 576.24trial/s, best loss: 7.262455656549131]\n", + "New optimized step at iteration 5/15: 0.02836170693029348 with d_coef [(-3.9671435812064013+0j), (-1.748374386604198+0j), (-0.9350901630745362+0j), (-0.6281543245247632+0j), (-0.021512156595171472+0j)], loss 7.242940534826334\n", + "100%|██████████| 500/500 [00:00<00:00, 671.15trial/s, best loss: 7.044926289914773]\n", + "New optimized step at iteration 6/15: 0.027897015043668715 with d_coef [(-3.948390041694754+0j), (-1.8847156433519916+0j), (-0.8262997874928508+0j), (-0.6276868981090158+0j), (-0.03885078124692265+0j)], loss 7.026681601151195\n", + "100%|██████████| 500/500 [00:00<00:00, 690.94trial/s, best loss: 6.855318614477858] \n", + "New optimized step at iteration 7/15: 0.027095778110113995 with d_coef [(-3.9519653973013913+0j), (-1.911636257457286+0j), (-0.8907292589911223+0j), (-0.6344354980656255+0j), (-0.0239873577390306+0j)], loss 6.826359605831807\n", + "100%|██████████| 500/500 [00:00<00:00, 520.20trial/s, best loss: 6.6782408641935875]\n", + "New optimized step at iteration 8/15: 0.027670995126608866 with d_coef [(-3.9302491674477538+0j), (-1.9666365073691627+0j), (-0.8561543524586357+0j), (-0.6383800207112388+0j), (-0.004655769048021813+0j)], loss 6.636290444352086\n", + "100%|██████████| 500/500 [00:00<00:00, 576.02trial/s, best loss: 6.500633770102917]\n", + "New optimized step at iteration 9/15: 0.027675484066740867 with d_coef [(-3.910374644169554+0j), (-1.9831418560231258+0j), (-0.9056736621483122+0j), (-0.6540987589359828+0j), (0.02406147464053876+0j)], loss 6.447464047229631\n", + "100%|██████████| 500/500 [00:00<00:00, 686.99trial/s, best loss: 6.319748615035787]\n", + "New optimized step at iteration 10/15: 0.026930095210157 with d_coef [(-3.886824281463916+0j), (-1.99625546879924+0j), (-0.9414450075378732+0j), (-0.6563760409606512+0j), (0.03970055245590362+0j)], loss 6.2592485638502575\n", + "100%|██████████| 500/500 [00:00<00:00, 678.32trial/s, best loss: 6.1400705423264075]\n", + "New optimized step at iteration 11/15: 0.027416250931757133 with d_coef [(-3.8475665420145373+0j), (-2.037392997099672+0j), (-0.9264643353804642+0j), (-0.6830139042784837+0j), (0.08321313069136971+0j)], loss 6.056764516965165\n", + "100%|██████████| 500/500 [00:00<00:00, 729.97trial/s, best loss: 5.940597947808348] \n", + "New optimized step at iteration 12/15: 0.028200202317592835 with d_coef [(-3.82460449840812+0j), (-2.035906559623582+0j), (-0.9702033338205296+0j), (-0.6848609304443387+0j), (0.11118456157172787+0j)], loss 5.848596463276441\n", + "100%|██████████| 500/500 [00:00<00:00, 743.16trial/s, best loss: 5.72938416138] \n", + "New optimized step at iteration 13/15: 0.025525484486623708 with d_coef [(-3.8277137978993436+0j), (-2.0402358325723036+0j), (-0.9967614632890175+0j), (-0.6822006377994072+0j), (0.09661303923602668+0j)], loss 5.643243093952352\n", + "100%|██████████| 500/500 [00:00<00:00, 722.17trial/s, best loss: 5.532276668994669] \n", + "New optimized step at iteration 14/15: 0.028418788139760974 with d_coef [(-3.7489089984244486+0j), (-2.114017010442895+0j), (-0.9183197191620466+0j), (-0.7036125621442609+0j), (0.16285610695072883+0j)], loss 5.4057916657046725\n", + "100%|██████████| 500/500 [00:00<00:00, 739.76trial/s, best loss: 5.288910417094644] \n", + "New optimized step at iteration 15/15: 0.02625000676004677 with d_coef [(-3.789232226109539+0j), (-2.092494639505251+0j), (-1.0022140546781002+0j), (-0.6714823814533052+0j), (0.13551681944910254+0j)], loss 5.191808803025761\n" + ] + } + ], + "source": [ + "NSTEPS = 15\n", + "off_diagonal_norm_MMH = [dbi_TFIM_MMH.off_diagonal_norm]\n", + "s_step_MMH = [0]\n", + "# d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", + "# d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", + "for _ in range(NSTEPS):\n", + " d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", + " d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM_MMH, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " dbi_TFIM_MMH(d=d, step=s)\n", + " off_diagonal_norm_MMH.append(dbi_TFIM_MMH.off_diagonal_norm)\n", + " s_step_MMH.append(s)\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM_MMH.off_diagonal_norm}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", + "plt.plot(off_diagonal_norm_MMH, label='MMH')\n", + "plt.plot(off_diagonal_norm_delta, label='delta')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Effect of `n`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-03-26 16:08:41]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 31.576176740060667\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAGVCAYAAABAYd6wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABM40lEQVR4nO3deXhURdo28LuzdRaSQICkOywhICCERTYh7GskUURRR+WVAVFH2ebFgGj0c4ioBJFhcAZBeVUWEUUngDggEoUkOoAsgjBsggSIkLBESEKAbF3fH0xam4Q+T6cbc465f17nuszpp+tU90moruqqp0xKKQUiIiId86rpChAREWlhY0VERLrHxoqIiHSPjRUREekeGysiItI9NlZERKR7bKyIiEj32FgREZHu+dR0BYiIyHVXr15FSUmJR8ry8/ODv7+/R8q6WdhYEREZzNWrVxEdbUFubr5HyrNYLMjKytJ1g8XGiojIYEpKSpCbm4/j2W8gJCTArbIKCq6gWZP/RUlJCRsrIiLyvDp1zKhTx+xWGTabzUO1ubnYWBERGZRSZVCqzO0yjICzAYmISPfYsyIiMiilyqFUudtlGAEbKyIig7KpMtjcHMZz9/m/FQ4DEhGR7rFnRURkULVpggUbKyIig7r2nZW7jZUxvrPiMCAREekee1ZERAalbGVQNjd7Vm4+/7fCxoqIyKhU2bXD3TIMgMOARESke+xZEREZFGcDEhGR/tnKAFup+2UYAIcBiYhI99hY/cqSJUtgMpnsh4+PD6xWKx566CEcOXKkxuqVnJwMk8lUY9e/XsX7tHPnzpquil16ejpMJhPS09Pt56p63xYsWIAlS5b8JnXS233Tcvz4cZhMJof3Z8uWLUhOTsbFixcrxTdr1gx33XVXta9nMpkwceLEaj/fmf79+zv8LVccQ4cOvSnXqykVw4DuHkbAYcAqLF68GLfeeiuuXr2Kf//733j11VexefNmHDp0CPXq1avp6lEVOnfujK1bt6Jt27ZO4xYsWIAGDRpgzJgxN71Ojz/+uKH+cbRardi6dStatGhhP7dlyxa89NJLGDNmDOrWrVtzlauG5s2b44MPPnA4Z7TXoMlWBti83S/DANhYVaFdu3bo2rUrgGuf0MrLyzF9+nSsWbMGjz76aA3XjqoSEhKCHj161HQ1HDRu3BiNGzeu6WqImc1m3b2H7ggICPhdvZ7ajsOAAhUN15kzZ+znrl69iilTpuC2225DaGgowsLCEBsbi08//bTS8yuGO95//320adMGgYGB6NixI/71r39Vil23bh1uu+02mM1mREdHY86cOVXW6erVq0hKSkJ0dDT8/PzQqFEjTJgwodJwTcVQzb/+9S906tQJAQEBaNOmjf3aS5YsQZs2bRAUFITbb7/dpaG9wsJCjBs3Dg0aNED9+vUxYsQInD592iFm5cqViIuLg9VqtV/7ueeeQ1FRkUPcmDFjUKdOHRw6dAh33HEHgoKCYLVaMWvWLADAtm3b0Lt3bwQFBaFVq1ZYunSpw/OrGga8XrNmzbB//35kZGTYh4WaNWtmf/zkyZN45JFHEB4eDrPZjDZt2uCvf/2rw06qFUNlc+bMwdy5cxEdHY06deogNjYW27Ztc7heVcOArr4fR48eRUJCAurUqYMmTZpgypQpKC4uvuFrBIBnnnkGoaGhKC//JY3OpEmTYDKZ8Prrr9vP5eXlwcvLC//4xz8cXlvFMGBycjKeeeYZAEB0dLT9Pbv+Pd6wYQM6d+6MgIAA3HrrrXjvvfec1o88yFbmmcMA2FgJZGVlAQBatWplP1dcXIyff/4ZU6dOxZo1a/Dhhx+id+/eGDFiBJYtW1apjHXr1mH+/PmYMWMGUlNTERYWhnvvvRfHjh2zx3z11VcYPnw4goOD8dFHH+H111/Hxx9/jMWLFzuUpZTCPffcgzlz5mDUqFFYt24dEhMTsXTpUgwcOLDSP2bff/89kpKS8Oyzz2LVqlUIDQ3FiBEjMH36dLzzzjuYOXMmPvjgA+Tn5+Ouu+7ClStXRO/L448/Dl9fX6xYsQKzZ89Geno6HnnkEYeYI0eOICEhAe+++y42bNiAyZMn4+OPP8awYcMqlVdaWooRI0bgzjvvxKeffor4+HgkJSXh+eefx+jRozF27FisXr0arVu3xpgxY7Br1y5RPSusXr0azZs3R6dOnbB161Zs3boVq1evBgCcO3cOPXv2xMaNG/Hyyy9j7dq1GDx4MKZOnVrl9ypvvvkm0tLSMG/ePHzwwQcoKipCQkIC8vPzndbB1ffj7rvvxqBBg/Dpp59i7Nix+Nvf/obXXnvN6TUGDx6MgoICbN++3X7uyy+/REBAANLS0uznvvrqKyilMHjw4CrLefzxxzFp0iQAwKpVq+zvWefOne0x33//PaZMmYKnn34an376KTp06IDHHnsMmZmZTusoZbPZUFZWpnn8umGu8OOPPyIsLAw+Pj5o0aIFXnjhBfHvtnGU/7IwuLoHjJEbEIrsFi9erACobdu2qdLSUlVYWKg2bNigLBaL6tu3ryotLb3hc8vKylRpaal67LHHVKdOnRweA6AiIiJUQUGB/Vxubq7y8vJSKSkp9nPdu3dXkZGR6sqVK/ZzBQUFKiwsTP36Vm3YsEEBULNnz3a4zsqVKxUAtWjRIvu5qKgoFRAQoH766Sf7uT179igAymq1qqKiIvv5NWvWKABq7dq1ovdp/PjxDudnz56tAKicnJwqn2ez2VRpaanKyMhQANT3339vf2z06NEKgEpNTbWfKy0tVQ0bNlQA1HfffWc/n5eXp7y9vVViYqL93ObNmxUAtXnzZvu56dOnq+t/xWNiYlS/fv0q1e25555TANS3337rcH7cuHHKZDKpw4cPK6WUysrKUgBU+/btVVlZmT1u+/btCoD68MMPnV7f1ffj448/dnhOQkKCat269Q3LVEqpoqIi5efnp2bMmKGUUuqnn35SANSzzz6rAgIC1NWrV5VSSj3xxBMqMjLS/ryK17Z48WL7uddff10BUFlZWZWuExUVpfz9/dWJEyfs565cuaLCwsLUk08+6bSOSl37u5gwYYLTmIr3Qeu4/p6+8MILasGCBWrTpk1q3bp1auLEicrHx0f17dtXlZeXa9ZN7/Lz8xUAlZ31pMo/P8mtIzvrSQVA5efn1/TLcoo9qyr06NEDvr6+CA4OxtChQ1GvXj18+umn8PFx/Irvk08+Qa9evVCnTh34+PjA19cX7777Lg4ePFipzAEDBiA4ONj+c0REBMLDw3HixAkAQFFREXbs2IERI0bA39/fHhccHFzpU/emTZsAoNIkgQceeABBQUH46quvHM7fdtttaNSokf3nNm3aALj2fVxgYGCl8xV10nL33Xc7/NyhQ4dKzz927BhGjhwJi8UCb29v+Pr6ol+/fgBQ6X0ymUxISEiw/+zj44NbbrkFVqsVnTp1sp8PCwtzeO88YdOmTWjbti1uv/12h/NjxoyBUsr+nle488474e39yxfbVb32qrj6flx/7zt06KB5jcDAQMTGxuLLL78EAKSlpaFu3bp45plnUFJSgm+++QbAtd7WjXpVUrfddhuaNm1q/9nf3x+tWrXy2L1JTk7Gjh07NI+3337b4XmvvPIKxo0bhwEDBiAhIQH/+Mc/MGvWLGRmZlY5VG9UJluZRw4j4ASLKixbtgxt2rRBYWEhVq5cibfffhsPP/wwPv/8c3vMqlWr8Ic//AEPPPAAnnnmGVgsFvj4+GDhwoVVjtnXr1+/0jmz2Wwflrhw4QJsNhssFkuluOvP5eXlwcfHBw0bNnQ4bzKZYLFYkJeX53A+LCzM4Wc/Pz+n569evVqpDlW5/jWZzWYAsL+mS5cuoU+fPvD398crr7yCVq1aITAwENnZ2RgxYkSlIZnAwECHhrqiTtfXs+K8tJ4SeXl5Dt9fVYiMjLQ//mtar70qnng/zGaz6HUPHjwYL7/8MoqKivDll19i4MCBqF+/Prp06YIvv/wSzZs3R1ZWFl566SXNspzR+r12V9OmTUWTVCRLBB555BFMnToV27Ztw7333uuJ6tU8Wxlgc7PPwcbKuNq0aWOfVDFgwACUl5fjnXfewT//+U/cf//9AIDly5cjOjoaK1eudPhD0fry+0bq1asHk8mE3NzcSo9df65+/fooKyvDuXPnHBospRRyc3PRrVu3atXB0zZt2oTTp08jPT3d3nsAUOWanZpWv3595OTkVDpfMWGkQYMGbl/jt3w/Bg0ahBdffBGZmZn46quvMH36dPv5jRs3Ijo62v6zno0dO7bSZJqq9OvXz+nkml/z8uKAkhHxrgnMnj0b9erVw1/+8hf7zDCTyQQ/Pz+Hhio3N7faQwwVs/FWrVrl8Mm5sLAQn332mUNsxT8wy5cvdzifmpqKoqIi3fwDVPHeVPQ6Klw/ZPNbutGn/kGDBuHAgQP47rvvHM4vW7YMJpMJAwYMcPvav+X7cfvttyMkJATz5s1Dbm4uhgwZAuBaj2v37t34+OOP0bZtW3vP8UYkPcabqbrDgFWpaPR+V9PZa9FsQPasBOrVq4ekpCRMmzYNK1aswCOPPIK77roLq1atwvjx43H//fcjOzsbL7/8MqxWa7WzXbz88ssYOnQohgwZgilTpqC8vByvvfYagoKC8PPPP9vjhgwZgjvuuAPPPvssCgoK0KtXL+zduxfTp09Hp06dMGrUKE+9dLf07NkT9erVw1NPPYXp06fD19cXH3zwAb7//vsaq1P79u3x0UcfYeXKlWjevDn8/f3Rvn17PP3001i2bBnuvPNOzJgxA1FRUVi3bh0WLFiAcePGOcwEra7f8v3w9vZGv3798NlnnyE6Otq+0LdXr14wm8346quv8Oc//1mznPbt2wMA3njjDYwePRq+vr5o3bq1w/ev7vjxxx/xz3/+s9L5tm3bom3btmjWrFmVw7POfP3113j11Vdx7733onnz5rh69So+//xzLFq0CAMHDqxy5qVRmVQZTG5OPTAZJIMFe1ZCkyZNQtOmTTFjxgyUl5fj0UcfxaxZs/D5558jISEBr732Gp577jmMHDmy2tcYMmQI1qxZg4KCAjz44INITEzEfffdh7FjxzrEmUwmrFmzBomJiVi8eDESEhLs09g3bdpU6ZN7Talfvz7WrVuHwMBAPPLIIxg7dizq1KmDlStX1lidXnrpJfTr1w9PPPEEbr/9dvs/XA0bNsSWLVswcOBAJCUl4a677sIXX3yB2bNn29chueu3fj8qJk/8ehKF2WxG7969K52/kf79+yMpKQmfffYZevfujW7durm8ZMCZDRs24IEHHqh0fPzxx9Uu02q1wtvbGy+//DKGDRuGP/zhD/jmm28wY8YMrF+/nsOABmVSSqmargQREckVFBQgNDQUpw48gJBgX/fKKixFo7afID8/HyEhIR6qoedxGJCIyKCuTT13L1myUaausz9MRES6x54VEZFR2co9sM7KGOmW2FgRERmVrQxwcxjQKFPXOQxIRES6x54VEZFBmWzlMLk5DGjiMCAREd1UygPfWSk2VtVis9lw+vRpBAcHi5JTEhHpnVIKhYWFiIyM5KLkarppjdWCBQvw+uuvIycnBzExMZg3bx769Omj+bzTp0+jSZMmN6taREQ1Jjs7W5RFXspks7k9jGf61U7YenZTGquVK1di8uTJWLBgAXr16oW3334b8fHxOHDggMPeN1WpyDkWFtAZXiZvp7F3B3Z2+jgAHLlUIqrz/zSTxfVqc0AUt/VQG82YcYc3iMoqt8m2whhZTzsn4OErl0RlJbYqFcWtOlFPFNc2VPsP6qGuO0Vl/e3r7qK48V33aMYs2XObqKz/y9soiisuvSiK23+/9gey29ZcEJVV11f24e5iabYorrFvB82YD3oWiMq6dDlQOwjA3L1RmjFjW54TlXX/7n+J4qZEjtUOAtA9/LxmzNQjzt8PmyrDT5c3eyyn4i8Fl3tgNmAtHgacO3cuHnvsMTz++OMAgHnz5uGLL77AwoULkZKS4vS5FUN/XiZveJmcV8/PSzsHno/wPgY4bxftgn1lgYHefpoxJpNsOEA6HCp7P2SNcqDw/fA1ab9OAPD30v6DkL63ktcJAHV8tX+9zV6y+nv6Xkleq/SaWn8nrpbnbdJO31PHR3ZN5SNLBST5PQrylqYVkt0D6b0PFFzXS/CeAfLfDz1LSUnBqlWrcOjQIQQEBKBnz5547bXX0Lp16xs+Jz09vcqdCw4ePIhbb71VdF2PD56WlJRg165diIuLczgfFxeHLVu2VIovLi5GQUGBw0FERNquzQZ0/3BFRkYGJkyYgG3btiEtLQ1lZWWIi4tDUVGR5nMPHz6MnJwc+9GyZUvxdT3eszp//jzKy8sRERHhcD4iIqLKjQVTUlLc3q2UiKhWqoFhwA0bHL++WLx4McLDw7Fr1y707dvX6XPDw8NRt25dV2sI4CYuCr6+u6uUqrILnJSUhPz8fPuRnS0bVyciIs+5foRLuut5fn4+ACAsLEwztlOnTrBarRg0aBA2b97sUv083lg1aNAA3t7elXpRZ8+erdTbAq7trxMSEuJwEBGRNk8OAzZp0gShoaH2Q2t+AXCtE5KYmIjevXujXbt2N4yzWq1YtGgRUlNTsWrVKrRu3RqDBg1CZmam+LV6fBjQz88PXbp0QVpaGu699177+bS0NAwfPtzTlyMiqr08OAyYnZ3t0FmQbOI6ceJE7N27F998843TuNatWztMwIiNjUV2djbmzJmjOXRY4abMBkxMTMSoUaPQtWtXxMbGYtGiRTh58iSeeuqpm3E5IiJyk6sjW5MmTcLatWuRmZlZrbVjPXr0wPLly8XxN6WxevDBB5GXl4cZM2YgJycH7dq1w/r16xEVpb2WosLdgZ01pyi3DNZeC9Sijmykc+Np2fqHacdl06bvq6N905+2PCwqK8hHtmgvxFd7WrpSstc5+5BsPVael+w7xv7mhpoxMzf3EpX1z6Jtorh6u2/XjJmWIFs/5b8hXhTXy3JWFNdu9WHNmLbesk+cb3fTXgcEAIv2y0Y2Hm97VDPm+LnKQ/pVSTlQRxR30lv7/Vh9QnvtIgBEBvUUxa24+KMoLvfqLZoxj9av7/Txq7YSpGhPlnOZyabcXtRrsrm2WbxSCpMmTcLq1auRnp6O6Ojoal139+7dsFqt4viblsFi/PjxGD9+/M0qnoiIbOWAuwkoXJwNOGHCBKxYsQKffvopgoOD7fMTQkNDERAQAODaxLlTp05h2bJlAK6ttW3WrBliYmJQUlKC5cuXIzU1FampqeLr6i43IBER6dfChQsBAP3793c4v3jxYowZMwYAkJOTg5MnT9ofKykpwdSpU3Hq1CkEBAQgJiYG69atQ0JCgvi6bKyIiIxKeaBn5WLWdaW0hw2XLFni8PO0adMwbdo0l65zPTZWREQGZVI2mJR7swFNyhiJbJmrnoiIdI89KyIio6qBCRY1hY0VEZFR2WweWBTMYUAiIiKP0G3P6silEs29qCQLfsc9JJvH7x0g2+dpwht/FMUVCfYu3Fsg21Sxvo9sIfK6y//UjFnY8h5RWZ+d3COKOz6+cib9qpz70fmmmwDwyYbbRGVpbcpZIViwmLrdigaisvoKN0b7ucQiilt8q/b+R2uEG1s+v1228LZvuGy457nt2ps5hgj3qYoQbkE1qO6N90KqsPW8cEPQrkGiuFe/ayaKiwrSft9eOvm+08clM+iqpRb1rHTbWBERkXPXtrV3vwwj4DAgERHpHntWRERGZbN5YDagMXpWbKyIiIyqFjVWHAYkIiLdY8+KiMioalHPio0VEZFRqXLAxf2oKpdhjMaKw4BERKR77FkRERlUbVpnpdvG6n+alSBAI1GBZCt6aWYKy0ztVfsA8ErjYlHcqSt+mjE9w2Xd98ZB50Rx4SdHasY8+cMyUVlPW0aJ4j7/Il8Ut/VcXc2Yo17aW5sDwJTw20RxLYILNGP6/txZVNbdjS+J4g4VyLInTPjhlGbMGy1kAx+zj8gyesw5s0sUF2/urxkTZpZlTajnJ/uHsLfljGbMaznbRGU9tjNWFHdnPdn7e1DwK94ycLDTx8tVKY5e/kx0PZfUou+sOAxIRES6p9ueFRERaahFPSs2VkRERmVT7jc27s4m/I1wGJCIiHSPPSsiIqOyKQ8MAxqjZ8XGiojIqDyyn5UxGisOAxIRke6xZ0VEZFS1qGfFxoqIyKj4nVXN69XmAIJ9na/Mn3bcrFnOhDf+KLqeNDNFx/BcUdyew1GaMQfz/UVlNQ0KFMXFNijSjImzDhOV9caRq6K4cH9ZxoZAb+0/CG/lKypryzlZxoZyFaIZ06Ge7C89+3KAKO6DC8dEcdvuKtSMab36G1FZLzaKF8VdKu0viusZIcuYIvFjQago7s2DEZoxjfw6ispq66NdFgB8djFHFDc4OFIz5s/hDZw+fqW8BFN/FF2ObkC3jRUREWlQNkC5OQyo2LMiIqKbSXlgGNAgjRVnAxIRke6xZ0VEZFScYEFERLpXixorDgMSEZHusWdFRGRQynbtcLcMI2BjRURkVLVoGFC3jdXWQ20Q6O18a/j76mgv+iwqlV1Psg09IFvsCwDvX0zVjMl5XLbY97lU2aLPc8Xar+GL07Jrjm12WRQ386T29uwAUGrSXnT9bCPZe3u0ULau5GKJ9uLhV//ytqis4YmPi+J6+d0iinvj6xaaMWPryV7nonNHRXFtVTNRXJtQ7QXQRwpli8EP58tew1Ottbe1/9+Dsn+uRrU4L4qrGyD7x+G9Q9oxH2Y7/we/zCDTw/XM499ZJScnw2QyORwWi8XTlyEiIpuHDgO4KT2rmJgYfPnll/afvb1l6XGIiMgFnmhsanNj5ePjw94UERF5zE2Zun7kyBFERkYiOjoaDz30EI4dkyX3JCIiFygPHQbg8Z5V9+7dsWzZMrRq1QpnzpzBK6+8gp49e2L//v2oX79+pfji4mIUF//y5XtBQYGnq0RE9LukbCYoN/ezMsrUdY/3rOLj43Hfffehffv2GDx4MNatWwcAWLp0aZXxKSkpCA0NtR9NmjTxdJWIiMjgbnoGi6CgILRv3x5Hjhyp8vGkpCTk5+fbj+zs7JtdJSKi3wfOBvSc4uJiHDx4EH369KnycbPZDLNZexNFIiK6jjK5v629Qb6z8njPaurUqcjIyEBWVha+/fZb3H///SgoKMDo0aM9fSkiIqolPN6z+umnn/Dwww/j/PnzaNiwIXr06IFt27YhKkqWnaDCuMMbYDI5b0uftjysWc7eAtn27D3DZR8vpFvRS7JT9H5ftk13fIisbs8de08z5sWmT4jKqmuWvW+9/ZuJ4no11M6IsehEiagss/CjYIcQ7UwM360YLCqrVYjsT+X9/C2iuJ6l3TVjUnofEJW1PEOWscHbO1oUN/N4oWbMpvt3iMpa+20PUdySI9pb0YfatOsFAEWlst+Pb89VnvBVlUDBrW/g43x0qNTd3XxvoDZNsPB4Y/XRRx95ukgiIqqKzQPDgAZprLhFCBER6Z5uE9kSEZEGZbp2uFWGZ6pys7GxIiIyqNr0nRWHAYmISPfYsyIiMiqblwcmWBhjHJCNFRGRUXE2IBERkX6wZ0VEZFBKmaDcnA2ojDEKqN/Gqtx2FSaT85sQ5KPdf62vsbK8QuOgc6K4pkHamSkA4LnUeM0YaWaKP7SU7Qf25z7tNWP6rD8sKqvV+RaiuJgQURiiQvI1Yyze4aKykm8/Korrlv6tZszPxaNEZRWUlonigr1kryGmrvagxpMZsnvwQVvt7A8AUFhySRSXcSZSM2bcKtnmqgdtp0VxvQIaa8acKz8rKuvEpWaiuCtlsn/ku4YVacbMupTn9PFyVSq6lstq0XdWHAYkIiLd023PioiInFM2eGCdFXtWRER0M1VsEeLO4eJ3XikpKejWrRuCg4MRHh6Oe+65B4cPa3+9kJGRgS5dusDf3x/NmzfHW2+95dJ12VgREZFYRkYGJkyYgG3btiEtLQ1lZWWIi4tDUdGNv9vLyspCQkIC+vTpg927d+P555/Hn//8Z6Smpoqvy2FAIiKD8sxsQNeev2HDBoefFy9ejPDwcOzatQt9+/at8jlvvfUWmjZtinnz5gEA2rRpg507d2LOnDm47777RNdlz4qIyKhsXp453JCff22mb1hY2A1jtm7diri4OIdzd9xxB3bu3InSUtlMSfasiIgIBQUFDj+bzWaYzc6X/iilkJiYiN69e6Ndu3Y3jMvNzUVEhOMSi4iICJSVleH8+fOwWq2a9WPPiojIoCqyrrt7AECTJk0QGhpqP1JSUjSvP3HiROzduxcffvihZuz162bVf1cja62nraDbntXIeqPg5+W8VQ/x1d4Gfd3lf4quF35ypCgutoH2AkEAOFfspxkj2YYekC32BYAJ67W3Sm9aXiwq6+Fmsq55VIhsS/Vo6ynNmNhzDUVlDftW9homhv9RMyaz4GdRWfVRRxR3GRdEcXsulGvG/Ox1UVTWqwdkK7P32r4RxfXxGawZs9X2taiszzo3F8V9f1b7nia1vSgq6+PvRWHoHSG79zN+0P7H9IqX838XbJAtKneVJ7+zys7ORkjIL79LWr2qSZMmYe3atcjMzETjxs4XdVssFuTm5jqcO3v2LHx8fFC/fn1RPXXbWBER0W8nJCTEobG6EaUUJk2ahNWrVyM9PR3R0dGaz4mNjcVnn33mcG7jxo3o2rUrfH19RfXjMCARkVHVwASLCRMmYPny5VixYgWCg4ORm5uL3NxcXLlyxR6TlJSEP/7xl5GNp556CidOnEBiYiIOHjyI9957D++++y6mTp0qvi4bKyIig/Lkd1ZSCxcuRH5+Pvr37w+r1Wo/Vq5caY/JycnByZMn7T9HR0dj/fr1SE9Px2233YaXX34Zf//738XT1gEOAxIRkQuUIE37kiVLKp3r168fvvvuu2pfl40VEZFB1cSi4JrCxoqIyKg8sKiXOwUTERF5CHtWREQGVZ0JElWVYQRsrIiIDIrfWenA4SuX4GNynqFCqWDNcha2vEd0vSd/WCaKi7MOE8V9cTpQM+bFpk+IypJuRS/JTjGwgb+orNFJ74jixk7+kyju3mLnq+EBYO8Fb1FZ81s2EsW9e1Q7S8S/p27QjAGAf28YIIobv1+WheOg6UfNmC3Dz4jK2n+kpSju/r2yP3dfQfobi5fsmscu1BXFbcjRrtvxoi6ismJCL4vilv5YTxQXJfi13PFxutPHC4psqH+/6HJ0A7ptrIiISIPywAQLY2wUzMaKiMioatN3VpwNSEREuseeFRGRQSnl/gQJQUIKXWBjRURkVB4YBgSHAYmIiDyDPSsiIoNSygtKudfnkCSm1QM2VkRERmUzuT+Mx2FAIiIiz9BtzyqxVSkCNVaOzz50SbOcz07uEV3vacsoUdwbR66K4sY2015FX9csK6vV+RaiuIeblWrGSDNThP2pmShuQgPZEIKPl3Zq58IyWfrnGT/IPgmeNmnvnbPyk+Gisi6U+IniuvvJtuj2EbyEpVtk971pkCxjw6jQwaK4h1se14zJzpdlf3jx2HlRXKlJO/vKow1l2UGi6uWJ4k5ebi6K+/B8jmZM/xFDnT5epkoAyLLkuKI2pVtyuWeVmZmJYcOGITIyEiaTCWvWrHF4XCmF5ORkREZGIiAgAP3798f+/fs9VV8iIvqvmtgpuKa43FgVFRWhY8eOmD9/fpWPz549G3PnzsX8+fOxY8cOWCwWDBkyBIWFhW5XloiIaieXhwHj4+MRHx9f5WNKKcybNw8vvPACRowYAQBYunQpIiIisGLFCjz55JPu1ZaIiOxq02xAj06wyMrKQm5uLuLi4uznzGYz+vXrhy1btlT5nOLiYhQUFDgcRESkjcOA1ZSbmwsAiIiIcDgfERFhf+x6KSkpCA0NtR9NmjTxZJWIiOh34KZMXTddtx+OUqrSuQpJSUnIz8+3H9nZ2TejSkREvzsVswHdPYzAo1PXLRYLgGs9LKvVaj9/9uzZSr2tCmazGWaz9sZ8RETkiFPXqyk6OhoWiwVpaWn2cyUlJcjIyEDPnj09eSkiIqpFXO5ZXbp0CUePHrX/nJWVhT179iAsLAxNmzbF5MmTMXPmTLRs2RItW7bEzJkzERgYiJEjR3q04kREtZ1SHth80SA9K5cbq507d2LAgAH2nxMTEwEAo0ePxpIlSzBt2jRcuXIF48ePx4ULF9C9e3ds3LgRwcHBLl1n1Yl68DU5zxqQ56X9/dbx8VVP7Lje51/ki+LC/YNEcTNPntKM6e3fTFRWTIgoDFEh2tkCxk7+k6gsaWaK1069J4r7utkgzZiWwbIMBV1864riDuZ31YzxMhWJymrgL8s2klci+8PPLPtCM6b9lb6ish5tKsua8f+GbhLFjfy4l2bMBeH7dl6dEMUl+Gu/1q3nREVh+3lZdo2G5jJRnJ/Szl4SF+78q4yrNhO+vQlfx9emqesuN1b9+/d3+uJMJhOSk5ORnJzsTr2IiIjsdJsbkIiInPPEOimjrLNiY0VEZFCcDUhERKQj7FkRERlUbepZsbEiIjIoZXP/Oycl20auxnEYkIiIdI89KyIig+IwoA60DS2Hv1e505j+Zu1FpOd+bCq63tZzdUVxgd6yBXSSbbp7NZRtRx4VIluwHG3VXoh8b7EsD6NkG3pAttgXAIZ/d1oz5kq5bEfpH+6TrZL+/nArzZgJh2Wbgr4cVXVuy+s1CpD9SQ0tqXpPuF/bbjsoKuvubrLVslPWDtAOAnCHxfnfHQB8mqu9UBYALpVo/04CwD8eXa8Z031pjKgsqdktZYkK8s5oJxZYfc75fS9XJaJrucozi4KNMcBmjFoSEVGtptueFREROWdTJtjcHMZz9/m/FTZWRERG5Ymdfg2SwYLDgEREpHvsWRERGRRnAxIRke7VpsaKw4BERKR77FkRERlUbepZsbEiIjIom/KCzc1Fve4+/7ei28bqoa47Eezr7TRm5mbt7bc/2XCb6HpHvQ6L4ryVbAvxZxtFacYsOiFb1W7xDhfFxZ7Tzuix94Lz97RCYZksg4V0K3pJdoqJDRJEZR3J+kkU97+HrmjGLIoJEpX1xoFAUVznerL37YLg1o9v2FpU1h9Sm4vi/nr7j6K4lT+00IxpE1RHVNZjzYaL4o4d0M5w8u8Hj4rKStt+uyjuYrHsb+F/6rbXjNl30XnWjzKUYJ/oanQjum2siIjIOaU8sFMwhwGJiOhmqk3fWRljsJKIiGo19qyIiAyqNvWs2FgRERlUbUpky2FAIiLSPfasiIgMisOARESke7WpseIwIBER6Z5ue1Z/+7o7/LzMTmP+WbRNsxwvk2yV+pTw20RxW87JyjtaqP1pxQwlKiv5dtnK/WHfFmvGzG/ZSFTWjB9kn7a6+NYVxf1wX4hmjDQzRaCf9usEgFKT86wCAPD8vnqiso4gUxR3Z0CsKO5csb9mzNyz20VljWsgy9jwxl7tzBQAsLMkWzNmfowsk8sHR62iuKxL2nXbtSNaVNYOJXvfMvvJsnBs39VBM+aSrdTp42XK+ePVVZsmWOi2sSIiIueUcn8YT8k+M9c4DgMSEZHusWdFRGRQnGBBRES6p/77nZU7h6uNVWZmJoYNG4bIyEiYTCasWbPGaXx6ejpMJlOl49ChQy5dlz0rIiISKyoqQseOHfHoo4/ivvvuEz/v8OHDCAn5ZaJVw4ay7YUqsLEiIjKomhgGjI+PR3x8vMvXCQ8PR926dV1+XgUOAxIRGVRFY+XuAQAFBQUOR3GxbImIVKdOnWC1WjFo0CBs3rzZ5eezsSIiIjRp0gShoaH2IyUlxSPlWq1WLFq0CKmpqVi1ahVat26NQYMGITNTtnaxgm6HAcd33YM6vs6rV2+39mLIYB/ZNuMtggtEceVKe3ErAFws0V483CEkQFRWt/RvRXETw/+oGfPuUe2FsgBw2vSdKO5gfldR3PeHW2nGSLahB2SLfQHg5KV0zZiQwHtFZZ195Ygo7j//ihTFRQXX1YzZfkC2rf0LkxaL4p7/21hR3EDfppoxq46LisL2Yu3t6q/FacckhMoWGAde6iGKu3jphCjub5OWacbcO2uk08fLbtJiJk8uCs7Oznb4Tslsdp6UQap169Zo3fqX3+XY2FhkZ2djzpw56Nu3r7gcl3tWWjNBxowZU2nWR48esl8eIiKS8+QwYEhIiMPhqcaqKj169MCRI7IPgBVcbqwqZoLMnz//hjFDhw5FTk6O/Vi/fr2rlyEiot+p3bt3w2qV9ZQruDwMKJkJYjabYbFYXC2aiIhcUBO5AS9duoSjR3/JV5qVlYU9e/YgLCwMTZs2RVJSEk6dOoVly64Nn86bNw/NmjVDTEwMSkpKsHz5cqSmpiI1NdWl696U76zS09Pt0xT79euHV199FeHh4TfjUkREtZaCCQpuTl138fk7d+7EgAED7D8nJiYCAEaPHo0lS5YgJycHJ0+etD9eUlKCqVOn4tSpUwgICEBMTAzWrVuHhIQEl67r8cYqPj4eDzzwAKKiopCVlYUXX3wRAwcOxK5du6ocAy0uLnaYIllQIJvoQEREv73+/ftDOZkwsmTJEoefp02bhmnTprl9XY83Vg8++KD9/9u1a4euXbsiKioK69atw4gRIyrFp6Sk4KWXXvJ0NYiIfveYG9CDrFYroqKibjjzIykpCfn5+fYjO1t7Lx0iIoLbeQE98Z3Xb+Wmr7PKy8tDdnb2DWd+mM3mmzpFkoiIjM/lxsrZTJCwsDAkJyfjvvvug9VqxfHjx/H888+jQYMGuPde2eJLIiKSqU3DgC43Vs5mgixcuBD79u3DsmXLcPHiRVitVgwYMAArV65EcHCwS9dZsuc2mL38nMZMS9ioWU67FQ1E1+v7c2dRXId6sowYr/7lbc2Y71YMFpX1c/EoUVxmwc+aMf+eukFU1spPhovivExForgJhws1YxbFBInKkm5FL8lOcaxclqlj7ZIHRHH782UZTur7lWnGDK3v/Pe/wn8+7yOK+6RQtiXDw6G3asZMf+xDUVkrPr5HFLfohPb7MaTRGVFZO87Jsnkn7ZSt82l5UDszTHKXH50+XlRWii+3iC5HN+ByY6U1E+SLL75wq0JERCRjgwfWWbk59f23otvcgERE5FxtGgZk1nUiItI99qyIiAzKBpPbw3gcBiQiopvLA8OA4DAgERGRZ7BnRURkUDWRdb2msLEiIjIozgYkIiLSEd32rP4vbyNMJudtqf8G55tAAkBfH9mnhrsbXxLFZV8OEMUNT3xcM6ZViOztLyjVXt0PAPVRRzPm3xsGaMYAwIUSWfaEBv5XRXEvR0VoxrxxIFBU1hFkiuLOvqK9bbY0M8XD+2WL3fuZK+8sUJXUJ7QziXR/p4uoLO+jt4jiostLRHENzdq/bwe/7ioq65kTO0Rxx/90UTOm9TuNRWVdLNkqiovx6S+K6xymHfO/O5zv11emZO+9q2z/Pdwtwwh021gREZFzHAYkIiLSEfasiIgMyqbcn81nu3GqV11hY0VEZFAKJig3M1C4+/zfCocBiYhI99izIiIyKC4KJiIi3bv2nZX7ZRgBhwGJiEj3dNuzKi69CJPJefe0l+WsZjk/l1hE1ztUINtS/YMLx0Rxvfy0F2q+ny/b5zrYy/mCwwqXcUEzZvx+2Zbf3f18RXF5JbIhhEYB2r9qnevJlifeGRArivvPvyI1Y6Tb0EsX+w6JkH3+++lwc82YWH/ZItgzsnXZmHKrbOH7wh/qasZ8dUa7/gDwp7CWorh27x7QjHmpseyaI4edEMV9+/UVUdyj+09rxoSa6jt9vBylomu5qjZNsNBtY0VERM7Vpu+sOAxIRES6x54VEZFBKXXtcLcMI2BjRURkUMoD29ob5TsrDgMSEZHusWdFRGRQtSnrOhsrIiKD4mxAIiIiHWHPiojIoNR/D3fLMALdNlb772+CYF9vpzHtVh/WLGfxrbJMDBN+OCWK23ZXoSjuja9baMb0LO0uKiumrqwDvOdCuWbMQdOPorJ8hCMDmWWy7d6HlsRrxlwQ7vx9rthfFBcVXFczpr6f9hbugGwbekCWmQIAdmU304zJviJ7Q+p4y/6M/3OhrijumXZnNGNe2yfLqrL3ovbvJABMbxKtGTM3WztDCwAMOtJUFDdvf4QobkQd7UwoPxQ6/z0qQwkOia7mGg4DEhER6Yhue1ZEROSc7b+Hu2UYARsrIiKDqk1T1zkMSEREuseeFRGRQdWmCRZsrIiIDKo2TV3nMCAREekee1ZERAbFYUAiItI9Tl3XgdvWXIDJ5HyUsq13X81y1pyoJ7reGy1kI6KtV38jihtbT/vTSkrvA6KynszQzoYBAD97XdSM2TJcOzsBACzdIrtm+yva9wAAttsOasaMb9haVNbcs9tl1zygXd7Q+n6isrq/00UUF+vfWBQnyU6x4Z33RWX1fOwBUdyeC8GiuGKbVTPmgJf2/QSA5uWy36NPTmpnmrGo+qKyXvlaO+MEAGSWbRTFlRQM0IwZFOH87/2qDfjyhOhydAMufWeVkpKCbt26ITg4GOHh4bjnnntw+LBjyiOlFJKTkxEZGYmAgAD0798f+/fv92iliYjol3VW7h5G4FJjlZGRgQkTJmDbtm1IS0tDWVkZ4uLiUFRUZI+ZPXs25s6di/nz52PHjh2wWCwYMmQICgtlOfWIiEhG4ZehwOoeRpkN6NIw4IYNjsk8Fy9ejPDwcOzatQt9+/aFUgrz5s3DCy+8gBEjRgAAli5dioiICKxYsQJPPvmk52pORES1hltT1/Pz8wEAYWFhAICsrCzk5uYiLi7OHmM2m9GvXz9s2bKlyjKKi4tRUFDgcBARkTYFDwwD4nc4DPhrSikkJiaid+/eaNeuHQAgNzcXABAR4Zh6PyIiwv7Y9VJSUhAaGmo/mjRpUt0qERHVKjblmcMIqt1YTZw4EXv37sWHH35Y6TGTybGlVkpVOlchKSkJ+fn59iM7O7u6VSIiot+pak1dnzRpEtauXYvMzEw0bvzLVF2LxQLgWg/Lav1l+uvZs2cr9bYqmM1mmM3m6lSDiKhWY7qlG1BKYeLEiVi1ahU2bdqE6GjH3T2jo6NhsViQlpZmP1dSUoKMjAz07NnTMzUmIiIAv2SwcPcwApd6VhMmTMCKFSvw6aefIjg42P49VGhoKAICAmAymTB58mTMnDkTLVu2RMuWLTFz5kwEBgZi5MiRLlWsrm8TeJmcV+/tbuc1y3l+ex3R9WYf8RbFvdhIe3t2AFh07qhmzPIM7foDwAdtZdtvv3ogRDNm/5GWorKaBl0WxT3aVHsxJwDc3e2cZswfUmVbwo9rcLso7oVJizVj/vN5H1FZ3kdvEcWduSoKE21FL13se8rruCju/vptRHFrcoo1Y/y8AkRlRQf4i+J+uHJJM8bqGygq6/PiHbK4rq1EcdO/0+57NAp0fuOvlGsvAifnXGqsFi5cCADo37+/w/nFixdjzJgxAIBp06bhypUrGD9+PC5cuIDu3btj48aNCA6WrZ4nIiIZplu6AaW0P2GYTCYkJycjOTm5unUiIiIB7hRMRESkI7pNZEtERM7VpmFA9qyIiAxKKc8crsjMzMSwYcMQGRkJk8mENWvWaD4nIyMDXbp0gb+/P5o3b4633nrL5dfKxoqIiMSKiorQsWNHzJ8/XxSflZWFhIQE9OnTB7t378bzzz+PP//5z0hNTXXpuhwGJCIyKBtMsLmZ28/V58fHxyM+XraEBwDeeustNG3aFPPmzQMAtGnTBjt37sScOXNw3333icthz4qIyKCMkBtw69atDsnNAeCOO+7Azp07UVpaKi6HPSsiIqq044WnUuHl5uZWmdy8rKwM58+fd0jN54xuG6uLpdma29ov2j9cs5y+4eWi6805s0sUd6m0vyiurWqmGePtHa0ZAwCFJdqr+wFgr+0bzZj798pu+ajQwaK4/zd0kyhuylrtrcH/evuPorLe2CvbKv35v43VjPmk8JCorGhhBoIpt8ru1X8u1NWMkW5DL81M8eyxRaK4JxpO0IzxuuTZQZkJLbTnpLVuIPv96LPltChu95kOorheDbT/ZvI0kn5ctd2ktUzVmCBRVRkAKu14MX36dI+tl60quXlV553RbWNFRETOefI7q+zsbISE/JKyzVMJxi0WS6Utos6ePQsfHx/Ur19fXA4bKyIiQkhIiENj5SmxsbH47LPPHM5t3LgRXbt2ha+vLLcowAkWRESGVRPrrC5duoQ9e/Zgz549AK5NTd+zZw9OnjwJ4NoehX/84x/t8U899RROnDiBxMREHDx4EO+99x7effddTJ061aXrsmdFRGRQNZHBYufOnRgw4JfvoBMTEwEAo0ePxpIlS5CTk2NvuIBrW0etX78eTz/9NN58801ERkbi73//u0vT1gE2VkRE5IL+/fs7TWq+ZMmSSuf69euH7777zq3rsrEiIjIoT6yTutnrrDyFjRURkUFxW3siIiIdYc+KiMigrg0DurnOyiBdK902Vo19O8Db5HwO/uNtj2qW89z2JpoxABBv7i+K6xlxThTXJjRAM2bm8UJRWRlnIkVxfXy0s074CleMP9zyuChu5Me9RHF3WLQziaz8QZaZYmdJtihuoG9TzZiHQ28VldXQXCaKW/hDXVHcM+3OaMYU22RpaNbkaKRP+C9JZgoASC3SzoQyLKC3qKx9Vy6I4nYe034ND11qLirrnsBbRHEFpbLsNsOaa2fO+Ck/zOnjl8vlOfBcUZ2p51WVYQQcBiQiIt3Tbc+KiIicq007BbOxIiIyKA4DEhER6Qh7VkREBsVhQCIi0j3lgQwWHAYkIiLyEPasiIgMqjalW9JtY/VBzwLU8XFevePnIjTLCfGRbe4VZvbsttNHCoM0Yzbdv0NU1rhVFlHcVtvXmjEWr5aisrLz64niLpiKRHGf5vppxrQJqiMqa36M7J6uOq4dM/2xD0VlHfy6qyjuqzOyhauv7QvXjDngdVBUlp+X9gJ0QL4VvWTB7/CmeaKyln2/ShTXMUB7u4i+kadEZX1xpqEoLqnVMVHcjG1tNWM6hzlfYHzVViK6lqtqUyJbDgMSEZHu6bZnRUREztWmdVZsrIiIDKo2TV3nMCAREekee1ZERAZVmyZYsLEiIjKo2jR1ncOARESke+xZEREZFIcBiYhI9zh1XQcuXQ6E0sg+kXJAO+NBhCzZAer5ySZw/lgQKoo7nK+dEWPttz1EZR20nRbFfdZZO3vCsQt1RWW9eOy8KO68OiGKu1SinX3gsWbDRWV9cFS23fv2Yu33bcXH94jKeuaELNvIn8JkGUL2XtTeUr15eQtRWdEB/qI4KclW9NLMFE2D+orilvfW/v1IzLxVVNbMzrK/l0O5jURxy59dqhkT/BfnGVqUMsoEcf1y6TurlJQUdOvWDcHBwQgPD8c999yDw4cPO8SMGTMGJpPJ4ejRQ/aPMhERydk8dBiBS41VRkYGJkyYgG3btiEtLQ1lZWWIi4tDUZFjfrihQ4ciJyfHfqxfv96jlSYiov82NsrNo6ZfhJBLw4AbNmxw+Hnx4sUIDw/Hrl270LfvL919s9kMi0WWfJWIiEiLW1PX8/PzAQBhYWEO59PT0xEeHo5WrVrhiSeewNmzZ925DBERVUF56DCCak+wUEohMTERvXv3Rrt27ezn4+Pj8cADDyAqKgpZWVl48cUXMXDgQOzatQtms7lSOcXFxSguLrb/XFBQUN0qERHVKsoDw3i/+9mAEydOxN69e/HNN984nH/wwQft/9+uXTt07doVUVFRWLduHUaMGFGpnJSUFLz00kvVrQYREdUC1RoGnDRpEtauXYvNmzejcePGTmOtViuioqJw5MiRKh9PSkpCfn6+/cjOzq5OlYiIap2KdVbuHkbgUs9KKYVJkyZh9erVSE9PR3R0tOZz8vLykJ2dDau16rUxZrO5yuFBIiJyjluE3MCECROwfPlyrFixAsHBwcjNzUVubi6uXLkCALh06RKmTp2KrVu34vjx40hPT8ewYcPQoEED3HvvvTflBRAR0e+fSz2rhQsXAgD69+/vcH7x4sUYM2YMvL29sW/fPixbtgwXL16E1WrFgAEDsHLlSgQHB7tUsbl7o+Brcr4q/KT3YaePA8Cguq1F1+ttOSOKe/NghCjuqdba5S05IiurV4DzodYK358t1ozZkCO75aUm7bIAIMFflqHgH49qr7U7dkCWeSDrkiyzw3bBS1h0okxU1vE/XRTFtXv3gChuehPtUYlPTsrSr/xw5ZIobkIL2Wfonce037iOAfeJypJkpgCAlG/ba8ZEBoiKQr8tX4rizjzWRBT3h5RRmjHPRjrPWFNsK8GcU4tE13PFtXVS7o3j/S5zAyqNwc2AgAB88cUXblWIiIhkuEUIERGRjug2kS0RETnniXRJv8thQCIi0g/13//cLcMIOAxIRES6x54VEZFBcRiQiIh0j4uCiYiIdIQ9KyIig1LKAxMsDJIcULeN1diW5xDk7XwF/+oTbTTL2Xq+VHS913K2ieIa+XUUxf3vQe23NtRWKCrrXLlsP7Ckthc1Y44XdRGV9WjDhqK4redEYei+NEYz5t8PHhWVtWuHdvYHAEgIrTof5a8NaSTLXNL6HVkWkZcaNxfFzc2+oBljUfVFZVl9A0VxrRv8KIp76JL2a+gbKctMkZh5qyhOkp2iXPhv6uiwx0RxD68oEcWdRZ5mTLPScKePl9icZ7ioLg4DEhER6Yhue1ZEROQchwGJiEj3FDywU7AnKvIb4DAgERHpHntWREQGZVPKA1uEGKNvxcaKiMigmBuQiIhIR9izIiIyqNq0zkq3jdX9u/8FwPlCusignprlrOoaJLreYztjRXFtfWRb0Y9qcV4zpqhU1v0+camZKO7j77VjYkIvi8qKqqe9EBIAtp+vJ4qTSNt+uyhuh9ouigu81EO7rHOyxc8XS7aK4kYOOyGKG3SkqWbMK19Hisr6vHiHKK7PltOiuHsCb9GM+eKM7H2b2Vl2TclW9NLFvu9fWC6KGx32iCium7/2a72osb649Ca1CDZ44DsrDgMSERF5hm57VkRE5BxnAxIRke5xNiAREZGOsGdFRGRQnGBBRES6V9FYuXtUx4IFCxAdHQ1/f3906dIFX3/99Q1j09PTYTKZKh2HDh0SX4+NFRERuWTlypWYPHkyXnjhBezevRt9+vRBfHw8Tp486fR5hw8fRk5Ojv1o2bKl+JpsrIiIDEp56D9XzZ07F4899hgef/xxtGnTBvPmzUOTJk2wcOFCp88LDw+HxWKxH97e3uJrsrEiIjIo5YEhwIrGqqCgwOEoLi6u8polJSXYtWsX4uLiHM7HxcVhy5YtTuvbqVMnWK1WDBo0CJs3b3bptep2gsWUyLEwe/k5jVlxUXub7le/aya63p31ZO32ZxdzRHF1A0o1Y749J9u2/EqZbEvs3hE/a8Ys/VGWceLkZdn27A3NZaK42S2DNWMuFss+ZWX2qyOKu3hJO5tE0k6rqKwYn/6iuG+/viKKm7dfOxNKZtlGUVmfd20litt9poMorqC0XDMmqdUxUVmHchuJ4s481kQzRroNvTQzhcVf1qMoE4QVaGSjESarqVFNmjjeg+nTpyM5OblS3Pnz51FeXo6ICMff4YiICOTm5lZZttVqxaJFi9ClSxcUFxfj/fffx6BBg5Ceno6+ffuK6qfbxoqIiJyzmWwwmdzL5WT7b3bA7OxshISE2M+bzWanzzOZHD9EK6UqnavQunVrtG7d2v5zbGwssrOzMWfOHHFjxWFAIiKD8uRswJCQEIfjRo1VgwYN4O3tXakXdfbs2Uq9LWd69OiBI0eOiOPZWBERkZifnx+6dOmCtLQ0h/NpaWno2VM7uXiF3bt3w2qVDcMDHAYkIjKsir6Ru2W4KjExEaNGjULXrl0RGxuLRYsW4eTJk3jqqacAAElJSTh16hSWLVsGAJg3bx6aNWuGmJgYlJSUYPny5UhNTUVqaqr4mmysiIgMygbA5HYGC9c9+OCDyMvLw4wZM5CTk4N27dph/fr1iIqKAgDk5OQ4rLkqKSnB1KlTcerUKQQEBCAmJgbr1q1DQkKC+JpsrIiIyGXjx4/H+PHjq3xsyZIlDj9PmzYN06ZNc+t6bKyIiAzKk7MB9Y6NFRGRQdlgg8nNxsYojRVnAxIRke651LNauHAhFi5ciOPHjwMAYmJi8Je//AXx8fEAri0Ke+mll7Bo0SJcuHAB3bt3x5tvvomYmBiXK9Y9/DwCvX2dxuRevUWznKgg7dX4AHAwXxSGwcGRorj3BMmEA4XvftewIlHcjB+0M11ECVNxfXhelqnDTznPMlIh70zVK9t/7X/qtheVtX2XLBPD3yYt04xpefCPorI6h4nC8Oj+06K4EXW0f49KCgaIypr+newL9l4NZL9ww5prZ4aZsa2tqKzlzy4Vxf0hZZRmzFnkicrq5t9QFCfJTAEA/7yYpRkTZXOeqaNMybJvuIo9qxto3LgxZs2ahZ07d2Lnzp0YOHAghg8fjv379wMAZs+ejblz52L+/PnYsWMHLBYLhgwZgsLCwptSeSKi2swzS4J/h43VsGHDkJCQgFatWqFVq1Z49dVXUadOHWzbtg1KKcybNw8vvPACRowYgXbt2mHp0qW4fPkyVqxYcbPqT0REtUC1v7MqLy/HRx99hKKiIsTGxiIrKwu5ubkOmXjNZjP69eunmYmXiIhcZzPZPHIYgcuzAfft24fY2FhcvXoVderUwerVq9G2bVt7g1RVJt4TJ26c/bq4uNghFX1BQYGrVSIiqpUUbG5/5/S7HAYErmXP3bNnD7Zt24Zx48Zh9OjROHDggP1xVzLxAkBKSgpCQ0Ptx/Vp6omIiFxurPz8/HDLLbega9euSElJQceOHfHGG2/AYrEAgMuZeJOSkpCfn28/srOzXa0SEVGtpFDukcMI3F5npZRCcXExoqOjYbFYHDLxlpSUICMjw2kmXrPZXCk1PRERabN56D8jcOk7q+effx7x8fFo0qQJCgsL8dFHHyE9PR0bNmyAyWTC5MmTMXPmTLRs2RItW7bEzJkzERgYiJEjR96s+hMRUS3gUmN15swZjBo1Cjk5OQgNDUWHDh2wYcMGDBkyBMC1ZIVXrlzB+PHj7YuCN27ciOBg7S3Nrzf1SAG8TM4XBT9aX3tb+JdOvi+6XsvAwaK4P4c3EMV9mK294rCBj/OdOCvMuiRbDHnFS3vx8I6P00Vl9R8xVBQXFy57DavPaf+q7bsoG464ZCsVxd07S/tDUnIX7QWwAPC/O8JFcaEm7d9JAPihsEwzZlCE9iJvAGgUeFUUl1esHQMAP+Vrr4DuHCa7V8F/kS0afzZS+7U2K5Xdg4vC9bdaW9FX0FrwCwBpRX2cX6vgMsLqLhZdzxXXNk50d1Gwe1nbfysuNVbvvvuu08dNJhOSk5ORnJzsTp2IiEjg2ndOsg81zsowAuYGJCIi3WPWdSIig7o2OaJ25AZkY0VEZFA1ta19TeAwIBER6R57VkREBmVDOeDmBAubQSZYsLEiIjIoDgMSERHpCHtWREQGZVMeGAZUxhgGNCmldLV8OT8/H3Xr1kV2djbzBBLR70JBQQGaNGmCixcvIjQ01CPlhYaGon5gF3iZ3Otz2FQZ8i7vQn5+vq7/zdVdz6qwsBAAuFUIEf3uFBYWeqSxqo1011hFRkYiOzsbwcHB9n2wKj6VGLm3ZfTXYPT6A8Z/DUavP2D811Dd+iulUFhYiMjISI/W59oEC/eG8YwywUJ3jZWXlxcaN25c5WO/hy1EjP4ajF5/wPivwej1B4z/GqpT/5vRo1LKBpu7uQGVMRorzgYkIiLd013PioiIZK4N4bmbdd0YPStDNFZmsxnTp0+H2SzbO0mPjP4ajF5/wPivwej1B4z/GvRWf+WBaeeeKOO3oLup60RE5FzF1PVQ/7YwmbzdKkupcuRfPcCp60REdHNcm17BYUAiItKxazP5OBuQiIhIFwzRWC1YsADR0dHw9/dHly5d8PXXX9d0lUSSk5NhMpkcDovFUtPVciozMxPDhg1DZGQkTCYT1qxZ4/C4UgrJycmIjIxEQEAA+vfvj/3799dMZaugVf8xY8ZUuic9evSomcpWISUlBd26dUNwcDDCw8Nxzz334PDhww4xer8Hkteg5/uwcOFCdOjQwb6WKjY2Fp9//rn9cT29/wrlHjmMQPeN1cqVKzF58mS88MIL2L17N/r06YP4+HicPHmypqsmEhMTg5ycHPuxb9++mq6SU0VFRejYsSPmz59f5eOzZ8/G3LlzMX/+fOzYsQMWiwVDhgyxp8mqaVr1B4ChQ4c63JP169f/hjV0LiMjAxMmTMC2bduQlpaGsrIyxMXFoaioyB6j93sgeQ2Afu9D48aNMWvWLOzcuRM7d+7EwIEDMXz4cHuDpKf3XykFpWxuHgaZY6d07vbbb1dPPfWUw7lbb71VPffcczVUI7np06erjh071nQ1qg2AWr16tf1nm82mLBaLmjVrlv3c1atXVWhoqHrrrbdqoIbOXV9/pZQaPXq0Gj58eI3UpzrOnj2rAKiMjAyllPHugVKVX4NSxrsP9erVU++8845u3v/8/HwFQAX6NVdB5lvcOgL9misAKj8//zerf3XoumdVUlKCXbt2IS4uzuF8XFwctmzZUkO1cs2RI0cQGRmJ6OhoPPTQQzh27FhNV6nasrKykJub63A/zGYz+vXrZ5j7AQDp6ekIDw9Hq1at8MQTT+Ds2bM1XaUbys/PBwCEhYUBMOY9uP41VDDCfSgvL8dHH32EoqIixMbG6u79r9h80d3DCHTdWJ0/fx7l5eWIiIhwOB8REYHc3NwaqpVc9+7dsWzZMnzxxRf4v//7P+Tm5qJnz57Iy8ur6apVS8V7btT7AQDx8fH44IMPsGnTJvz1r3/Fjh07MHDgQBQXF9d01SpRSiExMRG9e/dGu3btABjvHlT1GgD934d9+/ahTp06MJvNeOqpp7B69Wq0bdtWd++/UuUeOYzAEFPXK7KvV1BKVTqnR/Hx8fb/b9++PWJjY9GiRQssXboUiYmJNVgz9xj1fgDAgw8+aP//du3aoWvXroiKisK6deswYsSIGqxZZRMnTsTevXvxzTffVHrMKPfgRq9B7/ehdevW2LNnDy5evIjU1FSMHj0aGRkZ9seN8v7/nui6Z9WgQQN4e3tX+sRy9uzZSp9sjCAoKAjt27fHkSNHaroq1VIxk/H3cj8AwGq1IioqSnf3ZNKkSVi7di02b97ssAuBke7BjV5DVfR2H/z8/HDLLbega9euSElJQceOHfHGG2/o7v13f3KFjeusPMHPzw9dunRBWlqaw/m0tDT07NmzhmpVfcXFxTh48CCsVmtNV6VaoqOjYbFYHO5HSUkJMjIyDHk/ACAvLw/Z2dm6uSdKKUycOBGrVq3Cpk2bEB0d7fC4Ee6B1muoit7uw/WUUiguLtbd+1+bvrPS/WzAjz76SPn6+qp3331XHThwQE2ePFkFBQWp48eP13TVNE2ZMkWlp6erY8eOqW3btqm77rpLBQcH67ruhYWFavfu3Wr37t0KgJo7d67avXu3OnHihFJKqVmzZqnQ0FC1atUqtW/fPvXwww8rq9WqCgoKarjm1zirf2FhoZoyZYrasmWLysrKUps3b1axsbGqUaNGuqn/uHHjVGhoqEpPT1c5OTn24/Lly/YYvd8Drdeg9/uQlJSkMjMzVVZWltq7d696/vnnlZeXl9q4caNSSh/vf8VsQD8fqzL7NnLr8POxGmI2oO4bK6WUevPNN1VUVJTy8/NTnTt3dpgCq2cPPvigslqtytfXV0VGRqoRI0ao/fv313S1nNq8ebMCUOkYPXq0Uura1Onp06cri8WizGaz6tu3r9q3b1/NVvpXnNX/8uXLKi4uTjVs2FD5+vqqpk2bqtGjR6uTJ0/WdLXtqqo7ALV48WJ7jN7vgdZr0Pt9GDt2rP3fm4YNG6pBgwbZGyql9PH+VzRWvt4Rys/H6tbh6x1hiMaKWdeJiAymIuu6j3dDmEzufZujlA1l5ed0n3Vd199ZERERAQaZuk5ERJVdWyPl3uCYUWYDsrEiIjIsBbg9m88Y3wRxGJCIiHSPPSsiIoPyzOaLxuhZsbEiIjKoawt63d3W3hiNFYcBiYhI99izIiIyLPd7VkaZYMHGiojIqDzwnRUM8p0VhwGJiEj32LMiIjKo2jTBgo0VEZFh1Z7vrDgMSEREuseeFRGRYSkPdIyM0bNiY0VEZFie+MaJjRUREd10xmhs3MXvrIiIDMbPzw8WiwVAuUcOi8UCPz+/3/pluIQ7BRMRGdDVq1dRUlLikbL8/Pzg7+/vkbJuFjZWRESkexwGJCIi3WNjRUREusfGioiIdI+NFRER6R4bKyIi0j02VkREpHtsrIiISPf+P4Ec4x9MZsspAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# backend\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", + "# initialize dbi object\n", + "nqubits = 5\n", + "h0 = random_hermitian(2**nqubits, seed=2)\n", + "scheduling = DoubleBracketScheduling.hyperopt\n", + "mode = DoubleBracketGeneratorType.single_commutator\n", + "n_1 = 5\n", + "n_2 = 3\n", + "dbi_1 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", + "dbi_2 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", + "print(\"Initial off diagonal norm\", dbi_1.off_diagonal_norm)\n", + "visualize_matrix(dbi_1.h.matrix, title=f'Random hamiltonian with L={nqubits}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 697.70trial/s, best loss: 9.558186537868679] \n", + "The initial D coefficients: [(-3.321354431855655-1.7961649980378765e-16j), (-0.7143725995296772+3.608986798092513e-17j), (0.472710854506152+9.347215093087467e-17j), (-0.5707798509274735-1.3813111045761499e-17j), (0.34536980200226214-1.1499770144849896e-16j)]\n", + "Gradient: [ 0.65534217 0.16603388 -0.31270245 0.27247095 0.60904527]\n", + "s: 0.024282460160549718\n" + ] + } + ], + "source": [ + "# generate the onsite Z operators\n", + "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", + "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", + "grad, s = gradient_onsite_Z(dbi,d,n=5, onsite_Z_ops=onsite_Z_ops)\n", + "print('The initial D coefficients:', d_coef)\n", + "print('Gradient:', grad)\n", + "print('s:', s)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 596.09trial/s, best loss: 27.467491165569765]\n", + "100%|██████████| 500/500 [00:00<00:00, 689.73trial/s, best loss: 27.469650148347917] \n", + "100%|██████████| 500/500 [00:00<00:00, 684.87trial/s, best loss: 23.138955844687388] \n", + "100%|██████████| 500/500 [00:00<00:00, 680.99trial/s, best loss: 23.147351603039073]\n", + "100%|██████████| 500/500 [00:00<00:00, 709.00trial/s, best loss: 20.03558303567074] \n", + "100%|██████████| 500/500 [00:00<00:00, 638.55trial/s, best loss: 20.01446017712839] \n", + "100%|██████████| 500/500 [00:00<00:00, 659.72trial/s, best loss: 18.534762036988734]\n", + "100%|██████████| 500/500 [00:00<00:00, 702.62trial/s, best loss: 18.511235299525854]\n", + "100%|██████████| 500/500 [00:00<00:00, 716.91trial/s, best loss: 17.667631299146947] \n", + "100%|██████████| 500/500 [00:00<00:00, 717.85trial/s, best loss: 17.623675374778802] \n", + "100%|██████████| 500/500 [00:00<00:00, 626.07trial/s, best loss: 17.043867777621116]\n", + "100%|██████████| 500/500 [00:00<00:00, 662.03trial/s, best loss: 16.99411319096819] \n", + "100%|██████████| 500/500 [00:00<00:00, 694.96trial/s, best loss: 16.644107561332255]\n", + "100%|██████████| 500/500 [00:00<00:00, 712.76trial/s, best loss: 16.467189206952877] \n", + "100%|██████████| 500/500 [00:00<00:00, 713.76trial/s, best loss: 16.046314213095602]\n", + "100%|██████████| 500/500 [00:00<00:00, 699.95trial/s, best loss: 15.878928292681035] \n", + "100%|██████████| 500/500 [00:00<00:00, 691.24trial/s, best loss: 15.62141427589626] \n", + "100%|██████████| 500/500 [00:00<00:00, 667.73trial/s, best loss: 15.306325490043811] \n", + "100%|██████████| 500/500 [00:00<00:00, 694.90trial/s, best loss: 15.001484687547642] \n", + "100%|██████████| 500/500 [00:00<00:00, 709.52trial/s, best loss: 14.685062151226393] \n", + "100%|██████████| 500/500 [00:00<00:00, 710.15trial/s, best loss: 14.382216679135025] \n", + "100%|██████████| 500/500 [00:00<00:00, 710.67trial/s, best loss: 14.119940441735679] \n", + "100%|██████████| 500/500 [00:00<00:00, 708.88trial/s, best loss: 13.78053626699668] \n", + "100%|██████████| 500/500 [00:00<00:00, 626.04trial/s, best loss: 13.454854914663409] \n", + "100%|██████████| 500/500 [00:00<00:00, 703.66trial/s, best loss: 13.234269890734126] \n", + "100%|██████████| 500/500 [00:00<00:00, 718.00trial/s, best loss: 12.91970011325924] \n", + "100%|██████████| 500/500 [00:00<00:00, 720.73trial/s, best loss: 12.720794188076404] \n", + "100%|██████████| 500/500 [00:00<00:00, 707.81trial/s, best loss: 12.318517501084749] \n", + "100%|██████████| 500/500 [00:00<00:00, 681.10trial/s, best loss: 12.239079499566277]\n", + "100%|██████████| 500/500 [00:00<00:00, 725.63trial/s, best loss: 11.84799809909737] \n", + "100%|██████████| 500/500 [00:00<00:00, 718.62trial/s, best loss: 11.791868030395284] \n", + "100%|██████████| 500/500 [00:00<00:00, 720.66trial/s, best loss: 11.327252333996837]\n", + "100%|██████████| 500/500 [00:00<00:00, 714.03trial/s, best loss: 11.399156998591792] \n", + "100%|██████████| 500/500 [00:00<00:00, 716.52trial/s, best loss: 10.930539957425072] \n", + "100%|██████████| 500/500 [00:00<00:00, 677.71trial/s, best loss: 11.030749112814767]\n", + "100%|██████████| 500/500 [00:00<00:00, 722.09trial/s, best loss: 10.541671026174445] \n", + "100%|██████████| 500/500 [00:00<00:00, 651.08trial/s, best loss: 10.710765125494259] \n", + "100%|██████████| 500/500 [00:00<00:00, 721.96trial/s, best loss: 10.218781456526894] \n", + "100%|██████████| 500/500 [00:00<00:00, 714.29trial/s, best loss: 10.415667907517046] \n", + "100%|██████████| 500/500 [00:00<00:00, 710.97trial/s, best loss: 9.86363032877] \n", + "100%|██████████| 500/500 [00:00<00:00, 719.97trial/s, best loss: 10.15401395656047] \n", + "100%|██████████| 500/500 [00:00<00:00, 723.84trial/s, best loss: 9.562300454021948] \n", + "100%|██████████| 500/500 [00:00<00:00, 718.29trial/s, best loss: 9.907794571609012] \n", + "100%|██████████| 500/500 [00:00<00:00, 674.37trial/s, best loss: 9.224080650038678]\n", + "100%|██████████| 500/500 [00:00<00:00, 697.77trial/s, best loss: 9.68514825302649] \n", + "100%|██████████| 500/500 [00:00<00:00, 725.93trial/s, best loss: 8.950894937315692] \n", + "100%|██████████| 500/500 [00:00<00:00, 722.83trial/s, best loss: 9.467012864418232]\n", + "100%|██████████| 500/500 [00:00<00:00, 720.74trial/s, best loss: 8.647047841471467] \n", + "100%|██████████| 500/500 [00:00<00:00, 722.07trial/s, best loss: 9.264932438521221] \n", + "100%|██████████| 500/500 [00:00<00:00, 724.61trial/s, best loss: 8.403247837651655] \n", + "100%|██████████| 500/500 [00:00<00:00, 686.26trial/s, best loss: 9.063835314892646]\n", + "100%|██████████| 500/500 [00:00<00:00, 717.35trial/s, best loss: 8.149990124972552] \n", + "100%|██████████| 500/500 [00:00<00:00, 715.79trial/s, best loss: 8.87960896954228] \n", + "100%|██████████| 500/500 [00:00<00:00, 726.35trial/s, best loss: 7.913881055204248]\n", + "100%|██████████| 500/500 [00:00<00:00, 724.78trial/s, best loss: 8.697803369655396] \n", + "100%|██████████| 500/500 [00:00<00:00, 687.97trial/s, best loss: 7.678966990725647] \n", + "100%|██████████| 500/500 [00:00<00:00, 720.81trial/s, best loss: 8.529279658079181] \n", + "100%|██████████| 500/500 [00:00<00:00, 728.49trial/s, best loss: 7.4907779318523815]\n", + "100%|██████████| 500/500 [00:00<00:00, 721.37trial/s, best loss: 8.367946297589626] \n", + "100%|██████████| 500/500 [00:00<00:00, 723.56trial/s, best loss: 7.305839659415738] \n" + ] + } + ], + "source": [ + "iters = 30\n", + "d_coef_1, d_1 = d_coef, d\n", + "d_coef_2, d_2 = d_coef, d\n", + "\n", + "off_diagonal_norm_1 = [dbi_1.off_diagonal_norm]\n", + "off_diagonal_norm_2 = [dbi_2.off_diagonal_norm]\n", + "s_step_1 = [0]\n", + "s_step_2 = [0]\n", + "for i in range(iters):\n", + " s_1, d_coef_1, d_1 = gradient_descent_onsite_Z(dbi_1, d_coef_1, d_1, onsite_Z_ops=onsite_Z_ops, n=n_1, max_evals=100)\n", + " s_2, d_coef_2, d_2 = gradient_descent_onsite_Z(dbi_2, d_coef_2, d_2, onsite_Z_ops=onsite_Z_ops, n=n_2, max_evals=100)\n", + " dbi_1(step=s_1, d=d_1)\n", + " dbi_2(step=s_2, d=d_2)\n", + " off_diagonal_norm_1.append(dbi_1.off_diagonal_norm)\n", + " off_diagonal_norm_2.append(dbi_2.off_diagonal_norm)\n", + " s_step_1.append(s_1)\n", + " s_step_2.append(s_2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAHFCAYAAAD7ZFORAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABwo0lEQVR4nO3dd3wUdf7H8dem95CQTiokoYdi6E1AqnIgqHA2EHs55TzlLOcJ6tFU1Dvr+VNAxXaeoCcoUqT3jvQSCCUhtFTSM78/FqIhARZIMpvk/Xw89hF2dnbms5OBffOd73y/FsMwDERERERqIQezCxARERGpKgo6IiIiUmsp6IiIiEitpaAjIiIitZaCjoiIiNRaCjoiIiJSaynoiIiISK2loCMiIiK1loKOiIiI1FoKOlJtFi9ejMViqfCxevXqaq3l4MGDWCwWpk+fXq37rQuOHTvGuHHj2Lx5c7nXxo0bh8ViqbR9ffXVVzRv3hx3d3csFgubN2++pn1cyXujo6MZNWrUVe2novOvso+NvanoM0+fPh2LxcLBgwerZJ9z585l3LhxFb52Lb8/qVmczC5A6p4JEybQs2fPMstatGhRrTWEhoayatUqGjVqVK37rQuOHTvG+PHjiY6OpnXr1mVeu+++++jfv3+l7OfEiRPcdddd9O/fn3fffRdXV1fi4+MrdR/VqabWfS1uvPFGVq1aRWhoaJVsf+7cubzzzjsVhp1Zs2bh4+NTJfsV+6KgI9UuLi6Ojh07mlqDq6ur6TXUReHh4YSHh1fKtvbs2UNhYSF33nknPXr0KF3u4eFRafuoTpV5bGqKwMBAAgMDTdl3mzZtTNmvVD9dupIa48CBA4wYMYKwsDBcXV0JDg6md+/eZS6RREdHc9NNNzFr1iwSEhJwc3OjYcOG/POf/yyzrUtdOti+fTt//OMf8fX1JTg4mNGjR5ORkVHm/f/5z3/o0KEDvr6+eHh40LBhQ0aPHn3Zz2CxWHjssceYNm0ajRs3xt3dncTERFavXo1hGLz66qvExMTg5eVFr1692LdvX5n3z58/n8GDBxMeHo6bmxuxsbE8+OCDnDx5sty+vvvuOxISEnB1daVhw4a89dZbFV4eOV/Tp59+StOmTfHw8KBVq1b88MMP5ba5d+9ebr/9doKCgnB1daVp06a88847pa8vXryYdu3aAXDPPfeUXpo8/z/qi12e+fzzz+nUqRNeXl54eXnRunVrPvroo4sex1GjRtG1a1cAhg8fjsVi4frrr7/kPr766is6deqEp6cnXl5e9OvXj02bNl10H+cVFhYyduxYQkJC8PDwoGvXrqxdu/ay7zvv2LFj3HbbbXh7e+Pr68vw4cNJTU0tt15FdX/11Vf07duX0NBQ3N3dadq0Kc888ww5OTnl3v/hhx8SHx+Pq6srzZo14/PPP2fUqFFER0eXWe/06dM88sgjNGjQABcXFxo2bMjzzz9Pfn5+mfVsPS/27dvHPffcQ1xcHB4eHjRo0IBBgwaxbdu2yx6bCy9dXery9u8/hy3HZdSoUaXn5u+3c35fFV26Sk5O5s477yxzfr/++uuUlJSUrnP+347XXnuNqVOnlv597dSpU7VfghfbqEVHqt2jjz7KiBEj8PDwoFOnTrzwwgulX1qXMnDgQIqLi5kyZQqRkZGcPHmSlStXkp6eXma9zZs3M2bMGMaNG0dISAgzZ87kiSeeoKCggKeeeuqy+xk2bBjDhw/n3nvvZdu2bTz77LMAfPzxxwCsWrWK4cOHM3z4cMaNG4ebmxuHDh1i0aJFNn3+H374gU2bNjFp0iQsFgt//etfufHGGxk5ciQHDhzg7bffJiMjgyeffJJhw4axefPm0i/A/fv306lTJ+677z58fX05ePAgU6dOpWvXrmzbtg1nZ2cAfvrpJ4YOHUr37t356quvKCoq4rXXXuP48eMV1jRnzhzWrVvHSy+9hJeXF1OmTOHmm29m9+7dNGzYEIAdO3bQuXNnIiMjef311wkJCWHevHk8/vjjnDx5khdffJG2bdsybdo07rnnHv72t79x4403AlyypeLvf/87L7/8MkOHDuUvf/kLvr6+/Prrrxw6dOii73nhhRdo3749jz76aOml0EtdhpgwYQJ/+9vfSusqKCjg1VdfpVu3bqxdu5ZmzZpd9L33338/n3zyCU899RR9+vTh119/ZejQoWRlZV30Pefl5uZyww03cOzYMSZOnEh8fDxz5sxh+PDhl30vWIPlwIEDGTNmDJ6enuzatYvJkyezdu3aMufbv//9bx588EGGDRvGG2+8QUZGBuPHjy8XXvLy8ujZsyf79+9n/PjxJCQksGzZMiZOnMjmzZuZM2dOmfVtOS+OHTtG/fr1mTRpEoGBgZw+fZoZM2bQoUMHNm3aROPGjW36rABt27Zl1apV5Y7BvffeS/Pmza/ouLzwwgvk5OTwzTfflNnmxS6TnThxgs6dO1NQUMDLL79MdHQ0P/zwA0899RT79+/n3XffLbP+O++8Q5MmTXjzzTdL9zdw4ECSkpLw9fW1+TNLNTBEqsnGjRuNJ554wpg1a5axdOlS4+OPPzaaNm1qODo6Gj/99NMl33vy5EkDMN58881LrhcVFWVYLBZj8+bNZZb36dPH8PHxMXJycgzDMIykpCQDMKZNm1a6zosvvmgAxpQpU8q895FHHjHc3NyMkpISwzAM47XXXjMAIz093daPXgowQkJCjOzs7NJls2fPNgCjdevWpfswDMN48803DcDYunVrhdsqKSkxCgsLjUOHDhmA8d1335W+1q5dOyMiIsLIz88vXZaVlWXUr1/fuPCvPWAEBwcbmZmZpctSU1MNBwcHY+LEiaXL+vXrZ4SHhxsZGRll3v/YY48Zbm5uxunTpw3DMIx169aVO7bnnT/G5x04cMBwdHQ07rjjjgo/46X88ssvBmD85z//ueQ+kpOTDScnJ+NPf/pTmfWysrKMkJAQ47bbbrvoe3fu3GkAxp///Ocy7505c6YBGCNHjrxkje+99165341hGMb9999/0fPvYs7/vpcsWWIAxpYtWwzDMIzi4mIjJCTE6NChQ5n1Dx06ZDg7OxtRUVGly95//30DML7++usy606ePNkAjJ9//rl0ma3nxYWKioqMgoICIy4ursxxq+jv3LRp0wzASEpKqnBbx48fNxo2bGg0b97cOHPmzBUdF8MwjEcfffSixzQqKqrM7++ZZ54xAGPNmjVl1nv44YcNi8Vi7N69u8znaNmypVFUVFS63tq1aw3A+OKLLyrcn5hHl66k2rRp04Y333yTIUOG0K1bN+655x5WrlxJaGgoY8eOveR7/f39adSoEa+++ipTp05l06ZNZZqTf6958+a0atWqzLLbb7+dzMxMNm7ceNk6//CHP5R5npCQQF5eHmlpaQCll2Zuu+02vv76a44ePXrZbf5ez5498fT0LH3etGlTAAYMGFDm0sX55b9v2UhLS+Ohhx4iIiICJycnnJ2diYqKAmDnzp0A5OTksH79eoYMGYKLi0vpe728vBg0aNBFa/L29i59HhwcTFBQUOm+8/LyWLhwITfffDMeHh4UFRWVPgYOHEheXt5VNdvPnz+f4uJiHn300St+r63mzZtHUVERd999d5m63dzc6NGjB4sXL77oe3/55RcA7rjjjjLLb7vtNpycLt8g/ssvv+Dt7V3unLr99tttqv3AgQPcfvvthISE4OjoiLOzc2l/pPO/7927d5Oamsptt91W5r2RkZF06dKlzLJFixbh6enJLbfcUmb5+Us4CxcuLLP8cucFQFFRERMmTKBZs2a4uLjg5OSEi4sLe/fuLa3xauTk5HDjjTeSl5fHjz/+SL169Upfs+W4XKlFixbRrFkz2rdvX2b5qFGjMAyjXIvtjTfeiKOjY+nzhIQEgEu2RIo5FHTEVPXq1eOmm25i69at5ObmXnQ9i8XCwoUL6devH1OmTKFt27YEBgby+OOPl7uEEBISUu7955edOnXqsjXVr1+/zHNXV1eA0vq6d+/O7NmzS788w8PDadGiBV988cVltw3W0PZ758PIxZbn5eUBUFJSQt++ffn2228ZO3YsCxcuZO3ataUB43x9Z86cwTAMgoODy+27omUVfebzn/v8Nk+dOkVRURH/+te/cHZ2LvMYOHAgQIX9hC7nxIkTwKUvbV2r85fr2rVrV672r7766pJ1nz9fLjynnJycKjxmFb2/omNe0Tl6oezsbLp168aaNWt45ZVXWLx4MevWrePbb78FKPO7gYp/txcuO3XqFCEhIeX6AgUFBeHk5FTu78flzguAJ598khdeeIEhQ4bwv//9jzVr1rBu3TpatWp1yb/Tl1JUVMQtt9zCnj17mDt3LhEREaWv2XpcrtSpU6cqvKwVFhZW+vrvXe7fCbEf6qMjpjMMA+CyY4hERUWVdlDds2cPX3/9NePGjaOgoID333+/dL2KOnqeX2bLl5MtBg8ezODBg8nPz2f16tVMnDiR22+/nejoaDp16lQp+7jQr7/+ypYtW5g+fTojR44sXX5hh2U/Pz8sFkuF/XEqOja28PPzw9HRkbvuuuuirS8xMTFXvN3zd9wcOXKkzJdZZQoICADgm2++KW39stX58yU1NZUGDRqULi8qKrI5NFfUcdmW38OiRYs4duwYixcvLnNX2YV90s7XaMvvu379+qxZswbDMMr8fUtLS6OoqKj0WF2Jzz77jLvvvpsJEyaUWX7y5MkyrTBX4oEHHmDhwoXMnTu3XOusrcflStWvX5+UlJRyy48dOwZwVcdG7INadMRUZ86c4YcffqB169a4ubnZ/L74+Hj+9re/0bJly3KXo7Zv386WLVvKLPv888/x9vambdu2lVL3ea6urvTo0YPJkycD2HQXz9U6/8V0/n+O533wwQdlnnt6epKYmMjs2bMpKCgoXZ6dnV3hnVS28PDwoGfPnmzatImEhAQSExPLPc5/4V7J/2z79u2Lo6Mj77333lXVZYt+/frh5OTE/v37K6w7MTHxou89fyfXzJkzyyz/+uuvKSoquuy+e/bsSVZWFt9//32Z5Z9//vll32vr77tx48aEhITw9ddfl1menJzMypUryyzr3bs32dnZzJ49u8zyTz75pPT1K2WxWMrVOGfOnCu+pHve3/72N6ZNm8b//d//ccMNN1S4P7j8cfn9Oraci71792bHjh3l/j355JNPsFgs5cb+kppDLTpSbW6//XYiIyNJTEwkICCAvXv38vrrr3P8+PHLjlC8detWHnvsMW699Vbi4uJwcXFh0aJFbN26lWeeeabMumFhYfzhD39g3LhxhIaG8tlnnzF//nwmT56Mh4fHNX+Ov//97xw5coTevXsTHh5Oeno6b731Vpl+AlWhSZMmNGrUiGeeeQbDMPD39+d///sf8+fPL7fuSy+9xI033ki/fv144oknKC4u5tVXX8XLy4vTp09f1f7feustunbtSrdu3Xj44YeJjo4mKyuLffv28b///a+0D0OjRo1wd3dn5syZNG3aFC8vL8LCwkovAfxedHQ0zz33HC+//DK5ubmlt/Xv2LGDkydPMn78+Kuq9cJ9vPTSSzz//PMcOHCA/v374+fnx/Hjx1m7di2enp4X3U/Tpk258847efPNN3F2duaGG27g119/5bXXXrNpsLm7776bN954g7vvvpt//OMfxMXFMXfuXObNm3fZ93bu3Bk/Pz8eeughXnzxRZydnZk5c2a5EO/g4MD48eN58MEHueWWWxg9ejTp6emMHz+e0NBQHBx++//s3XffzTvvvMPIkSM5ePAgLVu2ZPny5UyYMIGBAwdWGCwu56abbmL69Ok0adKEhIQENmzYwKuvvnpVlyP/85//8I9//INbbrmF+Pj4Mv2+XF1dadOmjc3HBaBly5YATJ48mQEDBuDo6EhCQkKZvmvn/fnPf+aTTz7hxhtv5KWXXiIqKoo5c+bw7rvv8vDDDxMfH3/Fn0fshKldoaVOmThxotG6dWvD19fXcHR0NAIDA42bb77ZWLt27WXfe/z4cWPUqFFGkyZNDE9PT8PLy8tISEgw3njjjTJ3PkRFRRk33nij8c033xjNmzc3XFxcjOjoaGPq1Klltnepu65OnDhRZt0L7wz54YcfjAEDBhgNGjQwXFxcjKCgIGPgwIHGsmXLLvs5AOPRRx+tsJZXX321zPKK7irasWOH0adPH8Pb29vw8/Mzbr31ViM5OdkAjBdffLHM+2fNmmW0bNnScHFxMSIjI41JkyYZjz/+uOHn53fZmgyj/F0p52sdPXq00aBBA8PZ2dkIDAw0OnfubLzyyitl1vviiy+MJk2aGM7OzmVqu9idRZ988onRrl07w83NzfDy8jLatGlT4V1blzs+l9rH7NmzjZ49exo+Pj6Gq6urERUVZdxyyy3GggULLvne/Px84y9/+YsRFBRkuLm5GR07djRWrVpV4fGpyJEjR4xhw4YZXl5ehre3tzFs2DBj5cqVNt11tXLlSqNTp06Gh4eHERgYaNx3333Gxo0bK7yr7d///rcRGxtruLi4GPHx8cbHH39sDB482GjTpk2Z9U6dOmU89NBDRmhoqOHk5GRERUUZzz77rJGXl1dmPVvPizNnzhj33nuvERQUZHh4eBhdu3Y1li1bZvTo0cPo0aNH6Xq23HV1/hhU9Pj93WO2Hpf8/HzjvvvuMwIDAw2LxVJmXxX9/g4dOmTcfvvtRv369Q1nZ2ejcePGxquvvmoUFxeX+xwX/n09f8wu/Hso5rMYxrkOEiK1QHR0NC1atLjqSzS1WWFhIa1bt6ZBgwb8/PPPZpcjVSw9PZ34+HiGDBnCv//9b7PLETGNLl2J1FL33nsvffr0ITQ0lNTUVN5//3127tzJW2+9ZXZpUslSU1P5xz/+Qc+ePalfvz6HDh3ijTfeICsriyeeeMLs8kRMpaAjUktlZWXx1FNPceLECZydnWnbti1z5869qn4YYt9cXV05ePAgjzzyCKdPn8bDw4OOHTvy/vvvlxlRWKQu0qUrERERqbV0e7mIiIjUWgo6IiIiUmsp6IiIiEitVec7I5eUlHDs2DG8vb0vOwWBiIiI2AfDMMjKyiIsLKzMwJgXqvNB59ixY1U2x46IiIhUrcOHD19yJO46H3S8vb0B64GyZUh3ERERMV9mZiYRERGl3+MXU+eDzvnLVT4+Pgo6IiIiNczlup2oM7KIiIjUWgo6IiIiUmsp6IiIiEitVef76IiISM1RXFxMYWGh2WVINXB2dsbR0fGat6OgIyIids8wDFJTU0lPTze7FKlG9erVIyQk5JrGuVPQERERu3c+5AQFBeHh4aEBXms5wzA4e/YsaWlpAISGhl71thR0RETErhUXF5eGnPr165tdjlQTd3d3ANLS0ggKCrrqy1jqjCwiInbtfJ8cDw8PkyuR6nb+d34t/bIUdEREpEbQ5aq6pzJ+5wo6IiIiUmsp6IiIiNQho0aNYsiQIWaXUW0UdEREROyQxWJh9uzZZpdRacaNG4fFYinzCAkJqfL96q6rKpKfd5akLctp3O4GLA7KkyIiUjsYhkFxcTFOTlceIZo3b86CBQtKn1fGgICXo2/gKlCQn0f+pFia/Hgrxw7uNLscERExyfXXX8/jjz/O2LFj8ff3JyQkhHHjxl32fdHR0QDcfPPNWCyW0uf79+9n8ODBBAcH4+XlRbt27coEh5deeomWLVuW2951113H3//+9wr3lZ+fz+OPP05QUBBubm507dqVdevWlb6+ePFiLBYL8+bNIzExEVdXV5YtW2b7QfgdJycnQkJCSh+BgYFXtZ0roaBTBVxc3Tji0hCAIxt+NLkaEZHaxTAMzhYUmfIwDOOK650xYwaenp6sWbOGKVOm8NJLLzF//vxLvud80Jg2bRopKSmlz7Ozsxk4cCALFixg06ZN9OvXj0GDBpGcnAzA6NGj2bFjR5mgsnXrVjZt2sSoUaMq3NfYsWP573//y4wZM9i4cSOxsbH069eP06dPl1tv4sSJ7Ny5k4SEBJYtW4aXl9clHxMmTCizjb179xIWFkZMTAwjRozgwIEDV3Qsr4YuXVWRjJDOkLwN50NLgKfMLkdEpNbILSym2d/nmbLvHS/1w8Plyr46ExISePHFFwGIi4vj7bffZuHChfTp0+ei7znf0nF+CoTzWrVqRatWrUqfv/LKK8yaNYvvv/+exx57jPDwcPr168e0adNo164dYA1LPXr0oGHDhuX2k5OTw3vvvcf06dMZMGAAAB9++CHz58/no48+4umnny5d96WXXipTc2JiIps3b77kZ/f39y/9c4cOHfjkk0+Ij4/n+PHjvPLKK3Tu3Jnt27dX6UCQCjpVxK9FH0j+gIbZGykpLsahGq5DioiI/UlISCjzPDQ0tHRqgyuVk5PD+PHj+eGHHzh27BhFRUXk5uaWtugA3H///YwePZqpU6fi6OjIzJkzef311yvc3v79+yksLKRLly6ly5ydnWnfvj07d5btepGYmFjmubu7O7GxsTbXfj5IAbRs2ZJOnTrRqFEjZsyYwZNPPmnzdq6Ugk4VadS6O9lz3KlnyWbfr6uIbdXV7JJERGoFd2dHdrzUz7R9XylnZ+cyzy0WCyUlJVe1/6effpp58+bx2muvERsbi7u7O7fccgsFBQWl6wwaNAhXV1dmzZqFq6sr+fn5DBs2rMLtnb8Ud+HAfIZhlFvm6elZ5vmyZcvKhJeKPPfcczz33HMVvubp6UnLli3Zu3fvJbdxrRR0qoiziyvbPVrROnc1J7fMU9AREakkFovlii8f1UTOzs4UFxeXWbZs2TJGjRrFzTffDFj77Bw8eLDMOk5OTowcOZJp06bh6urKiBEjLjp9RmxsLC4uLixfvpzbb78dsE63sH79esaMGXPJ+q700tWF8vPz2blzJ926dbvkNq5V7T9TTJQX0Q32rMbj2AqzSxERkRomOjqahQsX0qVLF1xdXfHz8yM2NpZvv/2WQYMGYbFYeOGFFypsHbrvvvto2rQpACtWXPw7yNPTk4cffpinn34af39/IiMjmTJlCmfPnuXee++9ZH1XeunqqaeeYtCgQURGRpKWlsYrr7xCZmYmI0eOtHkbV0N3XVWhkNbWptW43G3k5501uRoREalJXn/9debPn09ERARt2rQB4I033sDPz4/OnTszaNAg+vXrR9u2bcu9Ny4ujs6dO9O4cWM6dOhwyf1MmjSJYcOGcdddd9G2bVv27dvHvHnz8PPzq9TPc+TIEf74xz/SuHFjhg4diouLC6tXryYqKqpS93Mhi3E198rVIpmZmfj6+pKRkYGPj0+lbtsoKeH0SzHUJ53tfT6neZcbK3X7IiJ1QV5eHklJScTExODm5mZ2OTWCYRg0adKEBx98sEo7+la1S/3ubf3+VotOFbI4OJDkY+2lnrnj0mMmiIiIVIa0tDSmTp3K0aNHueeee8wux3QKOlWsJKYHAP7HV5pciYiI2IuZM2dedJC95s2bX9O2g4ODmTRpEv/+978r/fJTTaTOyFUs8roBsOUFYgv3kJl+Cp96VTcokoiI1Ax/+MMfLtp35sLb0a9UHe+RUo6CThULiYzjsCWMCI6xf+2PtOl7p9kliYiIyby9vfH29ja7jDpBl66qwTH/9gAU7FlkciUiIiJ1i4JONXCJ7wVAyOm1JlciIiJStyjoVIOG7QZSYliIKjlM2tEks8sRERGpMxR0qoGvfyD7na2jRx5aN9fkakREROoOBZ1qcjKok/UPSUvMLURERKQOsdug895775GQkICPjw8+Pj506tSJH3/8sfR1wzAYN24cYWFhuLu7c/3117N9+3YTK74076Y3ABCVsQ7jKmetFRERuVajRo1iyJAhZpdRbew26ISHhzNp0iTWr1/P+vXr6dWrF4MHDy4NM1OmTGHq1Km8/fbbrFu3jpCQEPr06UNWVpbJlVcs9rre5BvOBHGa5D2bzS5HRETsnMViYfbs2WaXUWku14BRVew26AwaNIiBAwcSHx9PfHw8//jHP/Dy8mL16tUYhsGbb77J888/z9ChQ2nRogUzZszg7NmzfP7552aXXiE3Dy/2ullHu0zdPM/kakRERK6OYRgUFRVd8fsu14BRVew26PxecXExX375JTk5OXTq1ImkpCRSU1Pp27dv6Tqurq706NGDlSvtd6qF7LAuALgkLzW5EhERqQ7XX389jz/+OGPHjsXf35+QkBDGjRt32fdFR0cDcPPNN2OxWEqf79+/n8GDBxMcHIyXlxft2rVjwYIFpe976aWXaNmyZbntXXfddfz973+vcF/5+fk8/vjjBAUF4ebmRteuXVm3bl3p64sXL8ZisTBv3jwSExNxdXVl2bJlth+Ecy7VgFGV7DrobNu2DS8vL1xdXXnooYeYNWsWzZo1IzU1FbDO5/F7wcHBpa9dTH5+PpmZmWUe1cW/ZT8AGuVspqiwoNr2KyJSqxgGFOSY87iK6RVmzJiBp6cna9asYcqUKbz00kvMn3/piZ7PB41p06aRkpJS+jw7O5uBAweyYMECNm3aRL9+/Rg0aBDJyckAjB49mh07dpQJKlu3bmXTpk2MGjWqwn2NHTuW//73v8yYMYONGzcSGxtLv379OH36dLn1Jk6cyM6dO0lISGDZsmUXna/r/GPChAkV7vPCBoyqZNdTQDRu3JjNmzeTnp7Of//7X0aOHMmSJb/dtWSxWMqsbxhGuWUXmjhxIuPHj6+Sei+nUUIXMr/3xMeSw+4ty2mc2MuUOkREarTCszAhzJx9P3cMXDyv6C0JCQm8+OKLAMTFxfH222+zcOFC+vTpc9H3BAYGAlCvXj1CQkJKl7dq1YpWrVqVPn/llVeYNWsW33//PY899hjh4eH069ePadOm0a5dO8Aalnr06EHDhg3L7ScnJ4f33nuP6dOnM2DAAAA+/PBD5s+fz0cffcTTTz9duu5LL71UpubExEQ2b958yc/u7+9f5vm2bdvo1KkTeXl5eHl5lTZgVCW7btFxcXEhNjaWxMREJk6cSKtWrXjrrbdKf+kXtt6kpaWVa+W50LPPPktGRkbp4/Dhw1VW/4UcnZzY79kGgNO//lxt+xUREfMkJCSUeR4aGkpaWtpVbSsnJ4exY8fSrFkz6tWrh5eXF7t27Spt0QG4//77+eKLL8jLy6OwsJCZM2cyevToCre3f/9+CgsL6dKlS+kyZ2dn2rdvz86dO8usm5iYWOa5u7s7sbGxl3xcGHTON2CsXr2ahx9+mJEjR7Jjx46rOha2susWnQsZhkF+fj4xMTGEhIQwf/582rSxBoeCggKWLFnC5MmTL7kNV1dXXF1dq6PcChVEdoedy/E5Zr99iURE7Jqzh7Vlxax9X+lbLpiN3GKxUHKVw4w8/fTTzJs3j9dee43Y2Fjc3d255ZZbKCj4rTvEoEGDcHV1ZdasWbi6upKfn8+wYcMq3N75mc5tuULi6Vm2JWvZsmWlrUAX89xzz/Hcc8+VPj/fgAHW4LRu3TreeustPvjgg8t88qtnt0HnueeeY8CAAURERJCVlcWXX37J4sWL+emnn7BYLIwZM4YJEyYQFxdHXFwcEyZMwMPDg9tvv93s0i8prG1/2DmBuPzt5OZk4e6p2WtFRK6IxXLFl49qImdnZ4qLi8ssW7ZsGaNGjeLmm28GrH12Dh48WGYdJycnRo4cybRp03B1dWXEiBF4eFQc0GJjY3FxcWH58uWl35+FhYWsX7+eMWPGXLK+q7l0daHzDRhVyW6DzvHjx7nrrrtISUnB19eXhIQEfvrpp9Lrg2PHjiU3N5dHHnmEM2fO0KFDB37++We7n/Y+vFFLjlOfYMsptq2fT8seQ80uSURE7FB0dDQLFy6kS5cuuLq64ufnR2xsLN9++y2DBg3CYrHwwgsvVNg6dN9999G0aVMAVqxYcdF9eHp68vDDD/P000/j7+9PZGQkU6ZM4ezZs9x7772XrO/8pStbXaoBoyrZbdD56KOPLvm6xWJh3LhxNt2mZ08sDg4k12tPcPqPZO9aCAo6IiJSgddff50nn3ySDz/8kAYNGnDw4EHeeOMNRo8eTefOnQkICOCvf/1rhXcPx8XF0blzZ06dOkWHDh0uuZ9JkyZRUlLCXXfdRVZWFomJicybNw8/P79K/TyXa8CoKhbDuIp75WqRzMxMfH19ycjIwMfHp1r2uf7790nc+Ff2OTYi9oWN1bJPEZGaKi8vj6SkJGJiYnBzczO7nBrBMAyaNGnCgw8+yJNPPml2OVftUr97W7+/7fquq9oqOtHaeath0QHST1563B8REZErkZaWxtSpUzl69Cj33HOP2eWYTkHHBAFhURx0iMTBYnBgXdXP8yEiIvZl5syZFx1kr3nz5te07eDgYCZNmsS///3vSr/8VBPZbR+d2i41oCPRackU7vsFUOIWEalL/vCHP1y078yFt6NfqTreI6UcBR2TuMX3grSvaXB6jdmliIhINfP29rb7u4RrC126Mkmjdv0oMhwIN1I5dnC32eWIiIjUSgo6JvH29WefS2MAjmxQPx0Rkcu52tGEpeaqjN+5Ll2ZKD24MxzZicPBpcAYs8sREbFLLi4uODg4cOzYMQIDA3FxcbnsBM5SsxmGQUFBASdOnMDBwQEXF5er3paCjol8mveBIx/RMGsdJcXFODg6ml2SiIjdcXBwICYmhpSUFI4dM2mOKzGFh4cHkZGRODhc/QUoBR0TxbbtydmfXPG3ZHJg53oatrj06JUiInWVi4sLkZGRFBUVlZv/SWonR0dHnJycrrn1TkHHRC6ubuxyTyAhbx1pW+Yp6IiIXILFYsHZ2fmab7+WukWdkU12NrwrAO5HlplciYiISO2joGOywIS+AMSd3UJBfp7J1YiIiNQuCjomi2negTP44GHJZ9+mJWaXIyIiUqso6JjMwdGRA97XAZCxfb7J1YiIiNQuCjp2oDiqOwD1UleYXImIiEjtoqBjB8KvGwhAbMFusjPPmFyNiIhI7aGgYwfCYppwzBKMs6WY/evnmV2OiIhIraGgYyeO+LUHIHfXIpMrERERqT0UdOyEY2xPAIJPrjG5EhERkdpDQcdONGw3AICYkoOcSE02uRoREZHaQUHHTvgFhrHfsSEAh9b/ZHI1IiIitYOCjh05EdgJgJJ9v5hciYiISO2goGNHPJr0AiAyfS1GSYnJ1YiIiNR8Cjp2JDaxDwWGIyGc5MiBHWaXIyIiUuMp6NgRDy9f9ro2A+DYxh9NrkZERKTmU9CxM1mhXQBwPrTU5EpERERqPgUdO1OvRR8AGuZspLioyORqREREajYFHTsT27o72YY79cjmwK+rzC5HRESkRlPQsTNOzi7s92gJwKkdi80tRkREpIZT0LFDZ0PaAeBydK3JlYiIiNRsCjp2qF6T7gBE5mzVeDoiIiLXQEHHDsUkdKPAcCKAdI5qPB0REZGrpqBjh9zcPdnvEg9AyrZFJlcjIiJScyno2Kn0gEQAjEO680pERORqKejYKfdY68CBoRmbzS1ERESkBlPQsVMxbXoDEGEc49TxIyZXIyIiUjMp6NgpX/9AkhyiAEjerH46IiIiV0NBx46l+bUBIP/ACpMrERERqZkUdOyYY1QnAPxPbTS5EhERkZpJQceONWjVC4CGhfs4m51hcjUiIiI1j4KOHQuJjCOVAJwsJRzYvMTsckRERGocBR07ZrFYOOLdCoDsPctMrkZERKTmUdCxc8XhHQHwOr7O5EpERERqHgUdOxfYvAcADfN2UFRYYHI1IiIiNYuCjp2LappIJh54WPJJ2r7G7HJERERqFAUdO+fo6EiSewsATu1YbG4xIiIiNYyCTg1wNqQ9AC7H1ppciYiISM2ioFMD+DbuDkBU9laMkhKTqxEREak5FHRqgIatulJgOFGfdI4l7TC7HBERkRpDQacGcHP3ZL9LPADHtv5icjUiIiI1h4JODXEmINH6h0OrzC1ERESkBlHQqSHcG3UBICRjk8mViIiI1BwKOjVEw7bWCT4jjGOcPn7E5GpERERqBgWdGsLXP4gkhygADm1eZHI1IiIiNYOCTg1y3K8NAAUHVphciYiISM2goFODOEZ3AsDv1EaTKxEREakZFHRqkAYJ1n46DQv3cTY7w+RqRERE7J+CTg0SGhlHKgE4WUpI2rzY7HJERETsnt0GnYkTJ9KuXTu8vb0JCgpiyJAh7N69u8w6o0aNwmKxlHl07NjRpIqrnsVi4bB3awCy9iw3txgREZEawG6DzpIlS3j00UdZvXo18+fPp6ioiL59+5KTk1Nmvf79+5OSklL6mDt3rkkVV4/i8A4AeB1fZ3IlIiIi9s/J7AIu5qeffirzfNq0aQQFBbFhwwa6d+9eutzV1ZWQkJDqLs80gc17wM5/0DBvB0WFBTg5u5hdkoiIiN2y2xadC2VkWDvf+vv7l1m+ePFigoKCiI+P5/777yctLe2S28nPzyczM7PMoyaJbppIpuGJhyWfg9tXm12OiIiIXasRQccwDJ588km6du1KixYtSpcPGDCAmTNnsmjRIl5//XXWrVtHr169yM/Pv+i2Jk6ciK+vb+kjIiKiOj5CpXF0dOSAh/UYnNqxxORqRERE7JvFMAzD7CIu59FHH2XOnDksX76c8PDwi66XkpJCVFQUX375JUOHDq1wnfz8/DJBKDMzk4iICDIyMvDx8an02qvCqhnP0ynpbTZ5dafNU/8zuxwREZFql5mZia+v72W/v+22j855f/rTn/j+++9ZunTpJUMOQGhoKFFRUezdu/ei67i6uuLq6lrZZVYrn/hukPQ2kdlbMUpKsDjUiIY5ERGRame335CGYfDYY4/x7bffsmjRImJiYi77nlOnTnH48GFCQ0OroULzNGrdjQLDifqkk5K0w+xyRERE7JbdBp1HH32Uzz77jM8//xxvb29SU1NJTU0lNzcXgOzsbJ566ilWrVrFwYMHWbx4MYMGDSIgIICbb77Z5Oqrlpu7J/tcGgNwdOsvJlcjIiJiv+w26Lz33ntkZGRw/fXXExoaWvr46quvAGun3G3btjF48GDi4+MZOXIk8fHxrFq1Cm9vb5Orr3rpAddZ/5C8ytxCRERE7Jjd9tG5XB9pd3d35s2bV03V2B/3Rl0g5RNC0jeZXYqIiIjdstsWHbm0mDa9KDEsRBjHOH38sNnliIiI2CUFnRqqXv0gDjpGApC8Wf10REREKqKgU4Ol+bUBIP/ACpMrERERsU8KOjWYQ1QnAPxObTS5EhEREfukoFODhbfqBUDDwn3kZtesObtERESqg4JODRYaGUcKAThZSjiwebHZ5YiIiNgdBZ0azGKxcMS7FQDZe5aZXI2IiIj9UdCp4YrDOwLgmbbe5EpERETsj4JODRfQvAcADXO3U1xUaHI1IiIi9kVBp4aLaZpIpuGJhyWfpF81HYSIiMjvKejUcI6OjhxwbwHA6R1LTK5GRETEvijo1AJnQ9oB4HxsrcmViIiI2BcFnVrAt3E3ACKzt2KUlJhcjYiIiP1Q0KkFGrbqTr7hTH3SST24w+xyRERE7IaCTi3g7uHBfpd4AI5u0QSfIiIi5yno1BLpAdcBYCTrzisREZHzFHRqCfdGXQAIydhsbiEiIiJ2REGnlohu04sSw0JEyVHOpB0xuxwRERG7oKBTS/jVD+KgYyQAyZsXmVyNiIiIfVDQqUXS/NoAkLd/hcmViIiI2Aenq3lTTEwMFovlit83ZswYHn/88avZpdjAIaoTnJqN/6mNZpciIiJiF64q6EyfPv2qdhYdHX1V7xPbhLfqDRshpnAfudkZuHv5ml2SiIiIqa4q6PTo0aOy65BKEBoZSwoBhFpOsmvdPFr0vM3skkREREylPjq1iMVi4UBATwAKN840uRoRERHzqY9OLRPQdTTM/g/NM5eReTIVn4AQs0sSERExjfro1DLxrTqx93+NiCvez+YFH9F+xPNmlyQiImIa9dGpZSwWCydjbyVu9yQC9v4HUNAREZG6S310aqGmfUaTbzjTsDiJ/Vs1po6IiNRdlRJ0CgsLOXz4MLt37+b06dOVsUm5BvUCgtnm0w2Ak0s/MrkaERER81x10MnOzuaDDz7g+uuvx9fXl+joaJo1a0ZgYCBRUVHcf//9rFu3rjJrlSvgkng3AE1O/kRebo7J1YiIiJjjqoLOG2+8QXR0NB9++CG9evXi22+/ZfPmzezevZtVq1bx4osvUlRURJ8+fejfvz979+6t7LrlMpp3GUQqAfiSw7aFX5hdjoiIiCmuqjPyypUr+eWXX2jZsmWFr7dv357Ro0fz/vvv89FHH7FkyRLi4uKuqVC5Mo5OTiRFDCHk8P/huu1zuOk+s0sSERGpdhbDMAyzizBTZmYmvr6+ZGRk4OPjY3Y5lepY0i7CZnSgxLCQOnotYVHxZpckIiJSKWz9/r6iS1cDBgxg9uzZFBcXX3OBUvXCYpqw3bUVDhaDpIX/Z3Y5IiIi1e6Kgs7YsWP55ptviIuL49lnn2Xfvn1VVZdUkrwWfwQgOlkBVURE6p4rCjo9e/bks88+Y9OmTURERDBixAh69+7NV199RUFBQVXVKNegee87ycKdBhzn15VzzC5HRESkWl3xXVdFRUWUlJRw0003MX36dG6++WZeeOEFwsLCqqI+uUZuHt7sqt8XgLy1n5hcjYiISPW6oruu3NzcCAgIoE2bNnh5eeHt7Y2npycjRozA29u7qmqUa1S/270w+zsSMpdw5vRJ/PwDzC5JRESkWlxR0Jk5cyYff/wxWVlZDB8+nFtvvRVXV9eqqk0qScNW3Tn0v0iiipPZ+PM0uox42uySREREqsUVXboaNmwYc+bM4bPPPmP//v106tSJMWPGsGPHjqqqTyqDxUJa7K0A+O/9D3V8RAEREalDrmpk5PDwcJ599ll+/PFH4uPjGTp0KN26davs2qQSNb7hPgoNR5oW72b3Nk3NISIidcMVXbqKjo4mPz8fwzDw8PDAx8cHb29vGjVqhK+vb1XVKJXAJzCMLd6daZW9jBPLPqJJQnuzSxIREalyVxR0du7cibu7e1XVIlXMJfFuWLyMZmlzyc3Nw93dzeySREREqtQVXbo6H3LuvPNOMjMzAZg7dy6zZs2q/Mqk0jXuejOn8KO+JZPNi74yuxwREZEqd1V9dLZu3YqPjw87duzgqaee4qeffmLMmDGVXJpUNgcnZ5LCBwHgvHWmydWIiIhUvasKOs7OzhiGwfTp03n++ef54IMPWLZsWWXXJlUgstf9ALTOW8fhQ0kmVyMiIlK1riroPPjgg7Rr145vvvmGIUOGAJCTk1OZdUkVCWqYwF6XZjhZStiviT5FRKSWu6qg88ADD7BgwQK2bt2Kp6cn+/bto0OHDpVdm1SR3Ba3AxCVPIuiIk30KSIitddVBR2AevXqkZ2dDUBsbCwzZsyotKKkajXpfTe5uBLDUTavnm92OSIiIlXmqoMOQN++fSurDqlGLp6+7K5/AwC5axRQRUSk9rqmoKOpBGou/66jAWiTuYgTp0+bXI2IiEjVuKagY7FYKqsOqWaRrXtzzDEML0sev87/xOxyREREqsQ1BR2pwSwW0hrdAoD/nq/VOiciIrWSgk4dFnvDfRQbFloVb2f7tk1mlyMiIlLprinouLi4VFYdYgKvoCj2eFsn90xb9rHJ1YiIiFS+awo669evr6w6xCRO190FQLO0OeTk5ptcjYiISOXSpas6LrbrrWTgTYjlNBsWfWt2OSIiIpXqmoNORkYGDzzwALGxsTRt2pSUlJTKqEuqicXZjYMNbgLASRN9iohILXPNQeeRRx5h27ZtTJkyhUOHDpGbmwvAmDFjeOutt656uxMnTqRdu3Z4e3sTFBTEkCFD2L17d5l1DMNg3LhxhIWF4e7uzvXXX8/27duv6fPURRHnJvpMzFvJgUPJJlcjIiJSea456Pz444+8++67DB06FEdHx9Ll/fv359NPP73q7S5ZsoRHH32U1atXM3/+fIqKiujbt2+ZyUOnTJnC1KlTefvtt1m3bh0hISH06dOHrKysa/pMdY1/o+s46BKPi6WY/QvVKVlERGqPSumj4+XlVW5ZXFwc+/btu+pt/vTTT4waNYrmzZvTqlUrpk2bRnJyMhs2bACsrTlvvvkmzz//PEOHDqVFixbMmDGDs2fP8vnnn1/1fuuqs81HABCV/C2FmuhTRERqiWsOOgMHDqwwWGRnZ1fqyMkZGRkA+Pv7A5CUlERqamqZ+bZcXV3p0aMHK1euvOh28vPzyczMLPMQiOt9D/k4E88hFvw0y+xyREREKoXTtW5g4sSJJCYmAtZWFovFQm5uLi+99BJt27a95gLPb/fJJ5+ka9eutGjRAoDU1FQAgoODy6wbHBzMoUOHLlnv+PHjK6Wu2sTZy589DW4i/ugsWqx7hj0tOxIfFW52WSIiItfkmlt0IiIiWLFiBcuXL+fs2bO0b98ePz8/li1bxuTJkyujRh577DG2bt3KF198Ue61C1uNzoeti3n22WfJyMgofRw+fLhSaqwN4u58kxNOIURYTnDk04fJzS8yuyQREZFrcs0tOgCxsbHMnz+f5ORktmzZgrOzMx06dMDPz++at/2nP/2J77//nqVLlxIe/lsLQ0hICGBt2QkNDS1dnpaWVq6V5/dcXV1xdXW95rpqI4t7PVxu+5iiz2+iV9FSvvlsKrfcO9bsskRERK7aVbfoVDQJZGRkJIMGDaJ///7XHHIMw+Cxxx7j22+/ZdGiRcTExJR5PSYmhpCQEObPn1+6rKCggCVLltC5c+dr2ndd5hvfhSOtxgAwIPk1lq5abW5BIiIi1+CqW3S8vLxo3bo11113XemjWbNmODhUzmDLjz76KJ9//jnfffcd3t7epX1yfH19cXd3x2KxMGbMGCZMmEBcXBxxcXFMmDABDw8Pbr/99kqpoa6KHvw3Dh34haisTdSf9wgpjX8h1N/X7LJERESumMWoqGnGBu+++y4bN25kw4YNbN++neLiYtzc3EhISCgNPm3btqVVq1ZXV9hF+tlMmzaNUaNGAdZWn/Hjx/PBBx9w5swZOnTowDvvvFPaYdkWmZmZ+Pr6kpGRgY+Pz1XVWhsVnEom/+1OeBvZfOd5Kzf95UMcHSrvLjoREZFrYev391UHnd/Lz8/H3d2d5557jtOnT7Nx40a2bt1Kfn4+xcX2PSaLgs7FHV/zDcE/3gvA7JbvMGTYnSZXJCIiYmXr93eldEY+37n3tttuIyEhAYDi4mJNx1DDBXe4hf075tHo0Nd03vo8W1p0pFXjWLPLEhERsVmVzV7u6OhYGnqk5mp4x5ukuEQTZEkn+6sHyMwtMLskERERm1VZ0JHaweLiic+dM8jHmS4lG5g37eUK77gTERGxR1cddO6//37ef/991q9fT35+PnDxDsRSs3lGtiat4/MA/OH4e8z/ZaHJFYmIiNjmqjsjd+/enS1btpCVlYWTkxNFRUUMHTqU66+/nrZt29K6dWs8PDwqu95Kp87INjIMDv7rJqJPL2efEY7jg4uJCQs0uyoREamjqu2uq71797Jhw4bSW803bdpEeno6jo6OxMfH232HZAUd2xVnnSDzjXb4lZxhrusAej89E1cnR7PLEhGROqhaby+/UFJSEuvXr2fTpk1MmDChsjdfqRR0rszprfPw//Y2AL6Jncgtdz5ickUiIlIX2fr9fUV9dAYMGMDs2bMvOzZOTEwMt956q92HHLly/gn9SGpsHVun995/sGrzVpMrEhERubgrCjpjx47lm2++IS4ujmeffZZ9+/ZVVV1ix2JuncQR9yb4WbJx/u4hTmaeNbskERGRCl1R0OnZsyefffYZmzZtIiIighEjRtC7d2+++uorCgo0vkqd4eRC4KhPycWNRGM7iz9+jpIS3XIuIiL254pvLy8qKqKkpISbbrqJ6dOnc/PNN/PCCy8QFhZWFfWJnXINjie950QAhpyZwQ8/fm9yRSIiIuVd0RQQbm5uBAQE0KZNG7y8vPD29sbT05MRI0bg7e1dVTWKnQrtfg9JO38mJvVH2qx9ih3N2tIsJsLsskREREpdUdCZOXMmH3/8MVlZWQwfPpxbb721dJ4rqYMsFqJHvs/J1zsQUZTKgpmP0ODJ/+Lr4WJ2ZSIiIsAVXroaNmwYc+bM4bPPPmP//v106tSJMWPGsGPHjqqqT+ycxb0eLrd9TBEO3FC0lIVvjGJfarrZZYmIiABXOQVEeHg4zz77LD/++CPx8fEMHTqUbt26VXZtUkP4xHfhROdxAAwtnMPJ925iyeZd5hYlIiLCFV66io6OJj8/H8Mw8PDwwMfHB29vbxo1aoSvr29V1Sg1QGjfJ8gMjMDl+4fpyDYOzRrE54f/xR9v6qc50ERExDRXNDJybm4u7u7uVVlPtdPIyJWr8Ng2sqbfin9BCtmGG5+FPc9dox7B0/WKMrWIiMglVcnIyOdDzp133klmZiYAc+fOZdasWddQqtQmzmEt8X9iBcfrt8fLksdDKS/wzRtPcPhUjtmliYhIHXRVfXS2bt2Kj48PO3bs4KmnnuKnn35izJgxlVya1Fie9Ql+ZC7Hm9wNwMi8z9j5r2Gs2pVscmEiIlLXXFXQcXZ2xjAMpk+fzvPPP88HH3zAsmXLKrs2qckcnQke8S/Sb3iNQpzoyyp8Pr+Jr+avoArmkRUREanQVQWdBx98kHbt2vHNN98wZMgQAHJydGlCyqvX9X5K7v6eLMd6NHc4RO/lI3hn+qfkFV56YlgREZHKcFVB54EHHmDBggVs3boVT09P9u3bR4cOHSq7NqklXBt2wetPyzjp3YQASyYPHhzDx2/9ndSMPLNLExGRWu6K7rqqjXTXVTUqOMuJz+4lMHkuAN849CPmrn9xXUywyYWJiEhNUyV3XVUkIyODBx54gNjYWJo2bUpKSsq1blJqKxcPAu/5nPSOzwBwS8k8CqcN4dvlW0wuTEREaqtrDjqPPPII27ZtY8qUKRw6dIjc3FwAxowZw1tvvXXNBUotY7FQr/+z5N3yGXkWdzo67KDdz8N4+4vZ6rcjIiKV7pqDzo8//si7777L0KFDcXR0LF3ev39/Pv3002vdvNRSbi0G4fLgItLdwolwOMHoXQ/w/qSn+H7jIUpK6vTVVBERqUTXHHQAvLy8yi2Li4tj3759lbF5qaUcQppR7/FlnA7ujIclnzHFH9No9iD++s+P2XDotNnliYhILXDNQWfgwIF8/vnn5ZZnZ2drjiO5PA9//B+cQ+GAqeQ5edPc4RCTz/yF3R/ey9OfLubw6bNmVygiIjXYNU9ANHHiRBITEwEwDAOLxUJubi4vvfQSbdu2veYCpQ5wcMC5w704N/8DuT8+j/v2r7jdaRF9963n1TfuwK/TSB7tFYu3m7PZlYqISA1TKbeX79u3j4cffpiFCxdSv359srKy8PHxYe7cuaUhyF7p9nI7dHAFed+Nwe3MHgDWlDThNacHGdKvN8MTI3ByrJQrriIiUoPZ+v1dqePoJCcns2XLFpydnenQoQN+fn6Vtekqo6Bjp4oKMFa9Q8niyTgW51JoOPJR8UDm+t/NUze1oXt8oNkVioiIiao06CQnJxMZGWnz+kePHqVBgwZXuptqoaBj59KTKZk7Foc9PwJwxAhgfOHdFMYN4G83NiU2yNvkAkVExAxVOmBgu3btuP/++1m7du1F18nIyODDDz+kRYsWfPvtt1ezGxGoF4nD7V/CiC8o8Qkn3HKSD12mcseBvzL6zW/5+3e/cjqnwOwqRUTETl1Vi87p06eZMGECH3/8Mc7OziQmJhIWFoabmxtnzpxhx44dbN++ncTERP72t78xYMCAqqi9UqhFpwYpyIGlr2Ks/BeWkiJyDRf+WTSUL53+wJDEaO7oEKkWHhGROqJa+ujk5eUxd+5cli1bxsGDB8nNzSUgIIA2bdrQr18/WrRocbWbrjYKOjVQ2i6Y8xc4tByAvSUNeLXoNn4uSaR9TH3u6BBJ/xYhuDo5XmZDIiJSU1VbZ+TMzMwaHRAUdGoow4AtX2L8/DcsZ08CsK0khteLbmFxSWv8PV259bpw/tg+kugAT5OLFRGRylZtQcfR0ZGvv/6aYcOGXctmTKOgU8PlnoEV/4Q1H0BhDgDbLPFMyh/GipIWgIWusQHc0SGSG5oF46xb00VEaoVqCzoODg706tWLrKwsLBYLiYmJ3HXXXXTo0OFaNlttFHRqiZyTsOJNWPt/UGSdWHaXa0vGZQ1hdUlTAAK9XRmeGMGI9hGE+3mYWKyIiFyrag069evXZ8SIEXh6erJhwwaWLVvGww8/zBtvvHEtm64WCjq1TFYqLH8D1k+D4nwADvm2Y1z2zfySEw2AxQI9Gwdxe/tIejYJwtFBU5WIiNQ01Rp05s2bR58+fUqXbdu2jSFDhvDII4/wl7/85Vo2X+UUdGqpjKOw7HXY+AmUFAKQFtydfxq38lly/dLVwnzdeLhnLMMTI3Bx0mUtEZGaotqCTmBgIMuWLaNJkyZlls+ZM4cxY8awd+/ea9l8lVPQqeXOHIKlr8Lmz8EoBiAnui9feN7BOzs9OHPWGoIi/N358w3xDG7dQC08IiI1QJUOGPh7rVq14qOPPiq3PDY2lsOHD1/r5kWujV8UDH4b/rQeWv0RLA54HvyZ+7aPZH38J7zV25UAL1cOn87lya+30P/Npfz0ayqVODOKiIiY6JpbdFavXk3Pnj25+eabeeSRR0hISCA3N5exY8eydu1adu7cWVm1Vgm16NQxJ/bAksnw638BA7BQ1OIWvvS8kylr8snMKwKgVbgvT/VrTNfYACwWtfCIiNibap3Uc8uWLTzxxBMsX7689H/Cbm5u/Oc//2HgwIHXuvkqpaBTRx3fAYsnws7vrc8dnMlvdRcfO9zCv9ZlcbbAepmrY0N/nu7XhOui7H+CWhGRusSU2cvT0tLYsGEDJSUldOjQgYCAgMradJVR0Knjjm2ChS/B/kXW507unG37AP/KH8BH69MpKC4BoHeTIJ7q15imoTpHRETsgSlBpyZS0BEAkpbBwvFwZJ31uZsvGdc9xqtnrufzTScoOfe35A+twvhzn3hiNNqyiIipFHRspKAjpQwDdv8Ii16GtB3WZV7BnGj7OK+ktOO7bdapJhwdLNyWGM6fesURVs/dxIJFROquKg06MTExV9VBc8yYMTz++ONX/L6qpKAj5ZQUw7Zv4Jd/QPoh6zK/aI60HsOLB5qycPcpAFycHBieGMGDPRpqpGURkWpWpUFnyZIlV1VUdHQ0UVFRV/XeqqKgIxdVVAAbZ8CSKZCTZl0W1Iy9Lf/M89vDWXvwDABODhaGtm3Aw9fH6pKWiEg10aUrGynoyGUV5MCa92HFW5CXAYAR3p4dzf7MhB3+rNhnbeFxsMBNCWE82jOWxiHeZlYsIlLrKejYSEFHbJZ7xhp2Vr9fOnEosTewo9kYXtvqxqJdaaWr9msezGM942gZ7mtSsSIitZv66NhIQUeuWFaqdVqJDdOhxDrAIC2GsafZE7y5qYgff03l/N+qHvGB/KlXLInR/qaVKyJSG6mPjo0UdOSqnT4Av0yEbf8BDHBwgjZ3caD5o/xrXQ7fbT5aelt6x4b+/KlXHJ0b1ddIyyIilUCXrmykoCPXLHUbLHwZ9s6zPndyhw4PcrjZA7y75hTfbDhCYbH1r1nriHr8qVcsvZoEKfCIiFwDBR0bKehIpTm0EhaMh8Orrc/dfKHLGFKajOSDVal8sTaZ/CLrSMvNQn14sk88vZsq8IiIXA0FHRsp6EilMgzY+7M18KRtty7zCoEeYzkRN5z/W3WYT1cdKp1LKzHKj78OaEI79eEREbkiCjo2UtCRKlFSbJ0hfdErvxt0MAZ6/Y0zMTfxwbKDTFuRVNrC06tJEE9rLi0REZsp6NhIQUeqVOmgg5Mh54R1WXBLuOFFUgO78taifXy9/jDFJQYWCwxp3YAn+8QT4a+RlkVELsXW72+Haqzpii1dupRBgwYRFhaGxWJh9uzZZV4fNWoUFoulzKNjx47mFCtSEScXaH8/PL4Zev0NXH3g+DaYeQsh393GxE4lzP9zd25MCMUwYNamo/R6fTHjvt/Oiax8s6sXEanx7Dro5OTk0KpVK95+++2LrtO/f39SUlJKH3Pnzq3GCkVs5OoF3Z+GJ7ZA5z+BoyskLYUPetBw+dO8c1MI3z/WhW5xARQWG0xfeZAer/7C1Pl7yMorNLt6EZEaq8ZcurJYLMyaNYshQ4aULhs1ahTp6enlWnquhC5diSnOHIKFL8Gv31ifO7lbA1CXJ1hxOI/JP+1i6xHrdBP+ni482jOWOztG4urkaGLRIiL2o1ZcurLF4sWLCQoKIj4+nvvvv5+0tLRLrp+fn09mZmaZh0i184uCWz6C+xZBREfrlBJLp8C/2tIlYw7fPdyRd+9oS8MAT07nFPDyDzvo9doSvtlwhOKSGvF/ExERu1CjW3S++uorvLy8iIqKIikpiRdeeIGioiI2bNiAq6trhdsZN24c48ePL7dcLTpiGsOAnf+D+X+HM0nWZUHNoO/LFMX04psNR3hzwV5SM/MAiA/2Ymy/JhqDR0TqtFp311VFQedCKSkpREVF8eWXXzJ06NAK18nPzyc//7dOnpmZmURERCjoiPmKCmDd/1nv0MpLty5r1Bv6vkKef2NmrDzIu4v3k5Fr7bPTIcafZwc2pXVEPdNKFhExS525dPV7oaGhREVFsXfv3ouu4+rqio+PT5mHiF1wcoFOj8Djm6Djo+DgDPsXwvtdcPvxzzzY1oulY3vyUI9GuDg5sCbpNEPeWcFjn2/k0Kkcs6sXEbFLtSronDp1isOHDxMaGmp2KSJXz8Mf+k+Ax9ZC0z+AUWIdi+dfbfFd+ybP9I7kl6euZ1jbcCwW+GFrCjdMXcL4/23ndE6B2dWLiNgVu750lZ2dzb59+wBo06YNU6dOpWfPnvj7++Pv78+4ceMYNmwYoaGhHDx4kOeee47k5GR27tyJt7e3TfvQXVdi95JXw7zn4eh663PvMOjxNLS+kx1peUz6aRdL91gHI/R2deLhno0Y3SUGN2fdoSUitVet6KOzePFievbsWW75yJEjee+99xgyZAibNm0iPT2d0NBQevbsycsvv0xERITN+1DQkRrBMKxTSiwYDxnJ1mU+4dDtz9DmLpYlZTJx7i52pFjvIgz1dePJPvEMbRuOo4M6LItI7VMrgk51UNCRGqUwz3oZa9lUyE61LvNpAF3/TEnrO/lu+ylem7eHo+m5ADQJ8eaZAU3oER+oO7REpFZR0LGRgo7USIV5sPETWP4GZB2zLvMOg65/Ji/hDj5Zl8rbi/aRmVcEQJfY+jw7oCktGviaWLSISOVR0LGRgo7UaIV5sOlTa+DJPGpd5h0KXcaQ3vSPvLP8KDNWHqKg2DpL+pDWYfylb2NNGioiNZ6Cjo0UdKRWKMq3Bp5lb0DmEesyr2DoMoYjjYbz2qJkZm+2tvy4ODpwZ8coHusVi7+ni4lFi4hcPQUdGynoSK1SlA+bZ1r78GQcti7zDIIuT/Br2C1MXHCQFftOAeDl6sSD3Rtyb7cYPFycTCxaROTKKejYSEFHaqWiAtjyOSx7HdLP3aXlGWidNNRvCBPmH2T7MesdWoHerjzRO47h7SJwdqxVQ2uJSC2moGMjBR2p1YoLYcsXsPTV3wKPXzQl/V/lh7wWvDZvN8mnzwIQE+DJU30bM7BliO7QEhG7p6BjIwUdqROKC2HLl/DLhN/u0mr6Bwr6TOCLXcX8c+FeTp0bVblVuC9/7d+EzrEBJhYsInJpCjo2UtCROiU/CxZPgtXvgVEMLl5w/bNkt7mP/1uRzIdLD5BTUAxA9/hA/tq/Mc3DdEu6iNgfBR0bKehInZT6K/zwZziy1vo8uAXcOJWT/q15e9E+Zq45RGGx9Z+Gwa3D+EufxkTW1y3pImI/FHRspKAjdVZJifWW9AUvQu4Z67K2d8MN40nOdeP1+bv57twt6c6OFu7oEMWjPWMJ9HY1sWgRESsFHRsp6Eidl3MK5v8dNn9mfe5RH/q8BK1u59eULCb/tItle08C4ObswF0do3iwRyMCvBR4RMQ8Cjo2UtAROefQKuvlrBM7rc8jO8GNUyG4GSv2neTVebvZfDgdAHdnR+7qFMUD3Rsq8IiIKRR0bKSgI/I7xYWw+l1rh+XCs+DgBB0fgeufwXD2YPGeE7y5YC9bfhd47u4Uxf0KPCJSzRR0bKSgI1KB9MPw0zOw6wfrc59wGDAZmtyIASzefYI3F+xhy5EM4Fzg6RzFA90aUl+BR0SqgYKOjRR0RC5h90/w49O/DTYY1RWufwZiumEYBot3n+CNBXvYei7weLg4cnenaB7o3lDzaIlIlVLQsZGCjshlFJy1jqy86m0otg4qeGHg+WV3Gm8u2Fsm8IzsHM393RR4RKRqKOjYSEFHxEYZR2D5G7Dxk4sGnkW7rIFn21EFHhGpWgo6NlLQEblCGUfPBZ4ZFw08C3em8ebCPfx61DpxqKeLI3d2jGJ01xiCfdxMLF5EagsFHRsp6IhcJRsCz4Kdaby5YE/pTOkujg4MbduAB7o3pGGgl4nFi0hNp6BjIwUdkWtUYeDpYg080d0wgEW70nh/yX7WHbSOwGyxQP/mITzUoxGtIuqZVrqI1FwKOjZS0BGpJJcJPFgsbDh0mvcWH2DBzuOlb+vcqD4PX9+IrrEBWCwWk4oXkZpGQcdGCjoilSzjKKx4EzZMLxt4ev0NojoDsOd4Fh8sOcB3m49SVGL9J6h5mA8P9WjEwJahODoo8IjIpSno2EhBR6SKVBR44gfADS9CUFMAjqbn8tGyJL5Ym0xuYTEAUfU9eKB7Q4a1DcfN2dGc2kXE7ino2EhBR6SKZRy1jsOz8RMwisHiAK1vh+ufA98GAJzJKeCTVYeYvjKJM2cLAQjwcuWeLtHc2TEKX3dnMz+BiNghBR0bKeiIVJOTe2HhS7Dze+tzJzfo8BB0/TO41wPgbEERX687zIfLkjianguAl6sTw9tFMLJTNJH1PUwqXkTsjYKOjRR0RKrZ4XUw/++QvNL63K0edH8K2t0PztYxdgqLS/hh6zHeX3yA3cezAOudWr2bBHNPl2g6N6qvjssidZyCjo0UdERMYBiwZx4sGAcndlqX+UZAz+ch4TZwcDy3msGSPSeYvvIgi3efKH17XJAXo7pEc3ObBni4OJnwAUTEbAo6NlLQETFRSTFs+QJ+mQCZR63LglvADeMg9gZrM845+09k88nKg3yz4Qg5BdaOy77uzoxoF8GdHaOI8NdlLZG6REHHRgo6InagMBfWfADLpkK+dZ4sortBn/HQ4Loyq2bmFfLN+iPMWHWQQ6fOAuBggT7NghnVOYaODf11WUukDlDQsZGCjogdOXsalk+FNf+G4nzrsuY3Q/exENyszKrFJQaLd6cxfeVBlu09Wbq8SYg393SJZnDrBro9XaQWU9CxkYKOiB1KP2y9nLXlC+DcP1Ex3aH9g9B4QGkfnvP2Hs9i+sqDfLvxaOl4PPU8nPlj+0ju7BhFg3ru1fwBRKSqKejYSEFHxI4d3w5LJsPOH6xj8ADUi7TeodX2LnD3K7N6xtlCvl5/mBmrDnLkjPX2dAcL9GwcxJ0do+geH6hRl0VqCQUdGynoiNQA6Ydh/UfWUZZzrROD4uwBCcOhw4OlIy2fV1xisGDncWasPMjK/adKl4f7ufPH9pHclhhBoLdrNX4AEalsCjo2UtARqUEKc2Hbf6wdl4//+tvymB7WwBPfv9xlrf0nsvl8TTLfbDhCRq511GVnRwv9modwZ8coOsSo87JITaSgYyMFHZEayDDg0EpY8z7s+gGMEuvyepHQ/gFoc2e5y1p5hcX8sDWFz1YfYvPh9NLlsUFe3NEhkqFtwzXVhEgNoqBjIwUdkRouPRnWfQQbZ9h0WQvg16MZzFyTzHebj3L23Jg87s6O/KFVGHd0jCQhvF41fgARuRoKOjZS0BGpJQrO/nZZK237b8tjb4BuT0FUp3JvycwrZPamo3y2+hB7jmeXLk8I9+XODlHc1CpUIy+L2CkFHRsp6IjUMoYBB5fD2g9g15zfLmtFdYFuf4FGvcqMuGx9i8H6Q2f4bPUhftyWSkGx9T0eLo70ax7CzW0a0CU2QHdsidgRBR0bKeiI1GKn9sOKt2Dz51Bi7YhMWBtrC0/jgeDgUP4t2fn8Z8MRvlybzMFzIy8DBHq7MrhVGEPaNKB5mI86MIuYTEHHRgo6InVAxlFY+S/r7elF1vF1CGwK3Z6E5kPBsfzlKcMw2HQ4nVkbj/LD1mOcOVtY+lp8sBc3twlncOswwjQYoYgpFHRspKAjUofknITV78LaDyE/07rMLwa6joFWfwSnisfWKSgqYcmeE8zedJT5O49TUGS9tGWxQMeY+tzcpgH9W4bg46a7tkSqi4KOjRR0ROqg3HRY9yGsfg/OnhtQ0DsMOv8JrhsJLp4XfWtGbiE//ZrCtxuPsibpdOlyVycHbmgWzNA2DegeH4izY/nLYiJSeRR0bKSgI1KHFeTAhhmw8p+QlWJd5lEfOj4C7e8HN99Lvv1oei6zNx1l1qaj7Ev77a4tf08XBrYM4aaEMNpF+6sTs0gVUNCxkYKOiFCUb+2wvOJNOHPQuszVB1rfAa1vh9CES77dMAy2H8tk1qajfLf5GCez80tfC/J2ZWDLUG5KCKVtpB8OCj0ilUJBx0YKOiJSqrgItn8Ly16HE7t+Wx7c0hp4Em4Dz4BLbqKouIQV+08xZ+sxfvo1lcy8otLXwnzdrKGnVRitwn1155bINVDQsZGCjoiUU1IC+xbA5pmwey4UF1iXOzhBXD9r6InrC04ul9xMQVEJy/ed4IctKfy84zjZ+b+FnnA/d25MCGVQQphuVxe5Cgo6NlLQEZFLOnsafv2v9dLWsY2/LfeoDy1vgzZ3QEjLy24mr7CYJXtO8MPWFBbuPF469QRAdH0PbkoI46ZWoTQO9lboEbGBgo6NFHRExGZpO62BZ+tXkH38t+UhLa39eVreetlLWwC5BcUs2pXGnG3HWLgzjfxzt6uDdZLR/s1D6NU0iNbh9dSnR+QiFHRspKAjIlesuAj2L7rmS1sAOflFLNh5nB+2prBk94nS6ScAArxcuL5xEDc0DaJrXCBerpp3S+Q8BR0bKeiIyDW52KUtdz9oNhha3GKdZ6uC6SYulJlXyMKdx1mwM42lu0+Q9bs+Pc6OFjo2rE/vJkH0bhpMhL9HVXwakRpDQcdGCjoiUmkudmnLOxRaDLM+wtqUm1S0IoXFJaxLOs3CXWks3Hm8zLxbAHFBXvRuGkzvpkG0jfTTWD1S5yjo2EhBR0QqXUmxdQb1bf+Bnd9DXsZvr/k3tPblaXELBMbbvMn9J7JZtDONBTuPs/7QGYpLfvun28/DmesbB9G7aRDdYgPx9dBUFFL7KejYSEFHRKpUUT7sW2gNPbt//G1SUbB2Ym55q7Wlxzfc5k1mnC1kyd4TLNx5nMW7T5CR+9uEow4WaBlej26xAXSNC6BtpB8uTpqOQmofBR0bKeiISLXJz7aGnW3/gf0LoeS3PjhEdoKWt0CzITbduXVeUXEJGw6dYdGuNBbuSiszFQWAh4sjHWL86RoXSLe4AOKCvHT7utQKCjo2UtAREVOcPQ07voNt38ChFcC5f4otjhDdBeIHQHw/qN/oijabkpHLsr0nWb73JCv2neRUTkGZ14N9XOkSG0C3uAC6xAYQ5O1WSR9IpHop6NhIQUdETJd5DH791trSk7K57GsB8dbAEz8AIjqAo+23mJeUGOxMzWT53pMs33eStUmny4zZA9AkxJuu5y5ztY/xx8NFt7BLzaCgYyMFHRGxK6f2w555sOdHOLSy7OUtN1+I7QONB0Bsb+st7Fcgr7CY9QfPsGzfCZbvPcn2Y5llXndysNCigS8dYvxpH+NPYpS/OjaL3VLQsZGCjojYrbwM68CEu3+CvT9D7unfXrM4QmRHiO9vfQTE2XTb+u+dys5nxf5TLN97ghX7TnE0PbfM6xYLNAnxoX20H+1j6tMuxk+XusRu1Iqgs3TpUl599VU2bNhASkoKs2bNYsiQIaWvG4bB+PHj+fe//82ZM2fo0KED77zzDs2bN7d5Hwo6IlIjlBTDkfXWlp498yBtR9nX/WKsLT1NbrR2bHZwvOJdHDlzlrVJp0sfB07mlFunYYAn7c+1+LSP8SfcTwMXijlqRdD58ccfWbFiBW3btmXYsGHlgs7kyZP5xz/+wfTp04mPj+eVV15h6dKl7N69G29vb5v2oaAjIjXSmYOw52fY8xMcXPbbNBQAnoHQ5CbryMzR3a6oX8/vpWXlsS7pDOsOnmZN0ml2pWZy4TdGg3ru1stc0X60jfQjPthbgxdKtagVQef3LBZLmaBjGAZhYWGMGTOGv/71rwDk5+cTHBzM5MmTefDBB23aroKOiNR4+VlwYLH11vVdcyAv/bfX3P2trTzNhkBMd5vm37qYjLOFrD9kbe1Zk3SaX49mUFRS9ivEy9WJNpH1aBPpx3VRfrSOqIevu/r5SOWr9UHnwIEDNGrUiI0bN9KmTZvS9QYPHky9evWYMWOGTdtV0BGRWqW4EJKWWkdk3vk/OHvqt9fcfKHxQGtLT8Oe4Hxt/W3OFhSxKTmdNUmn2XjoDJuSz5BTUFxmHYvFOl3FdVHWFp+2UX40DPDUWD5yzWz9/q6x9xGmpqYCEBwcXGZ5cHAwhw4duuj78vPzyc/PL32emZl50XVFRGocR2frHVmxvWHg65C80jpez87/Weff2vKF9eHiDY37W0NP7A3g7H7Fu/JwcaJLrHU8HoDiEoPdqVlsTD7DxkNn2JB8hkOnzrLneDZ7jmfzxdrDgHXKivOhp22kHwnhvnhqZnapIjX+zLrwfwWGYVzyfwoTJ05k/PjxVV2WiIj5HJ2sl6tiusOAKXB4jTX07Pgeso5Zx+3Z9h9w9oT4vtD4RmjU84pGZi6zOwcLzcJ8aBbmw50dowA4mZ1fGno2HUpny5F0zpwttE5WuisNsE5bERvkRUJ4PVqF+9IyvB5NQ71xdbryDtUiF6pzl64qatGJiIjQpSsRqTtKSuDoBtgx2xp6MpJ/96LFOsN67A3WR4Prrrozc0UKikrYkZJZGn42HjpDSkZeufWcHS00CfEhIdz33KMecUFeODlq3i6xqvV9dM53Rv7zn//M2LFjASgoKCAoKEidkUVEbGUYcGyTtU/PvgWQuq3s626+1v48sTdYL4f5hFV6CWmZeWw9ksHWI+lsOffzzNnCcuu5OTvQPMwafFqF1yMh3Jfo+p446C6vOqlWBJ3s7Gz27dsHQJs2bZg6dSo9e/bE39+fyMhIJk+ezMSJE5k2bRpxcXFMmDCBxYsX6/ZyEZGrlZVqHaRw3wLrz9wzZV8Pag6xvazBJ7ITOLlWegmGYXDkTO7vwk86vx7NJDu/qNy63q5ONG/gQ0J4PVo08CWhgS9R9T3U2bkOqBVBZ/HixfTs2bPc8pEjRzJ9+vTSAQM/+OCDMgMGtmjRwuZ9KOiIiFxESbG1tWfvfGvwObqB0slHAZw9rP1/Ym+AuD7gF111pZQYHDiZw9Yj6Ww9ksGWI+nsOJZZbu4uAG83J1qca/lp0cD6M9Jf4ae2qRVBpzoo6IiI2Ojs6XOtPQutwScnrezrQc3Pjc48EELbgEPV9qcpLC5h7/Fsfj2awdaj6Ww7msnOlEwKKgg/Pm5OtGjgS8twX1o2sD4Ufmo2BR0bKeiIiFyFkhI4/ivsX2ht8UleBcbvAoZXiPX29cY3Wlt9rnHMHlsVFpew53iWNfwcyeDXoxnsTMmioLjilp9moda7xM7/jAvyxsVJHZ5rAgUdGynoiIhUgrOnrYFn9xxri09B9m+vOXta+/U0Hghx/cCzfrWWVlD0u/Bz1Bp+dl0k/Dg5WIgN8ioTfpqF+lDP4+pHlJaqoaBjIwUdEZFKVpRvnX9r11zrtBRZx357zeIAER1/m4C0fiNTSiwoKmFfWjY7UjLZccx6yWtHSiYZueXv9gLrnF5Nf9/6E+pDuJ+77vgykYKOjRR0RESqkGFAyhZr4Nk9p/zt6wHxENsHGvaw3sXlZt6/w4ZhcCwjjx3HrOFnR0oGO1IyOXw6t8L1vVydaBLiTdNQn3MPb5qE+ODuooEOq4OCjo0UdEREqlH6YeuM67vmwMHlUPK7FhSLo3WAwvOjOUd0qLa+PZeSmVfIrpQsdhyzBp/txzLZezy7wktfFgvE1PcsDT7NwqwhKMTHTR2fK5mCjo0UdERETJKXYe3Pk7QEDiyBM0llX3d0hcgO54LP9dYRmytxlOZrUVhcwoETOexM+e2y186ULE5m51e4fj0PZ5qGWENPk1BvGgd7ExfshYeLfXyemkhBx0YKOiIidiI9GZKWWYNP0lLISin7uos3RHW2XuaK6W69nb2Kb2G/Uiey8i8IP5nsP5FDcUnFX7UR/u40DvYm/nePRkGemufLBgo6NlLQERGxQ4YBp/bBgcXW0HNwWflRmt39raGnUS/rNBX1Ikwp9XLyCotLOz7vTMlkz/EsdqdmX7T1x9HBQnR9j9Lg0zjE+jO6vofm+vodBR0bKeiIiNQAJSVwfJs19CQthUMry97CDlA/zhp6GvWC6C7gattUQGY5nVPAnuNZ54JPFnuPZ7P7eNZF7/xycXSgYaAnccHexAV5ER/sRWxQ3Q1ACjo2UtAREamBigutU1IcWGwdrfnIejCKf3vdwcnamblRT2vwCW0NDvZ/OcgwDNKy8kvDjzUIZbP3eBY5BcUVvsfF0YGYAE/igr2IC/ImPtiLuGAvoup74lyLA5CCjo0UdEREaoHcdOvlrf2LYP8v5Ts2u/tBTI/fWnzs9DLXxZSUGBxNz2VvmrXlZ8/xbPalZbE3LZuzFwlAzo6WcwHI2gIUF2Tt/xNd3xM3Z/sPfZejoGMjBR0RkVro9AFr4Nm/yHqpKz+z7Ov14yCmm3XsnogOUC/Sem94DVNSYnAsI5e9x7PZm3au9Sctm32XaAGyWCDCz4NGgZ40CvSiUZCX9WegJ/6eLjXmNngFHRsp6IiI1HLFRXBs47nWngoucwF4h1oDT2RH68+QBLu5lf1qnB/8cM/xLPYdz2bP8Sz2n8hmX1o2mXlFF32fr7tzhQEo0t/++gEp6NhIQUdEpI45f5nr0Co4vNo6cnPJBV/+zp4Qfp11uorIDhDe3tRRmyuLYRicyilgf1o2+0/ksC8tm/0nrI+j6blcLBE4OViIrO9BwwBPYgI8iQnwIibAk0aBngR6u5rSCqSgYyMFHRGROq7grLXFJ3m19XFkrXUwwzIsENzCGnrOhx/fiBp5ueticguKSTqZUxp89p/IYX9aNgdOZpNXWH4U6PM8XRyJCSwbfmICPIkO8MTHzbnK6lXQsZGCjoiIlFFSAid2WVt7ktdYf545WH497zCIaH/uclf7c5e7qu6L3SwlJQYpmXkkncgh6WQ2B07mkHTucfj0WS4yFiIAAV6uNAzwZNKwljQM9KrUuhR0bKSgIyIil5WVam3tObzG+jN1a/nLXU7u1rm6zrf6hCeCh7859VaTgqISkk+fJelkDgdOZFt/ngtBJ7J+GxBx7fO9CfKu3HnLFHRspKAjIiJX7PeXuw6vtQagvPTy6wU2sbb2RJzr5Fy/Ua263HUpWXmFHDx5lqRTOQxKCK30fjwKOjZS0BERkWtWUgKn9v4u+Ky2TmFxIY/61sATnmjt4NygLbh4Vn+9tYCCjo0UdEREpErknPwt9BxeC0c3QvEF81tZHCG4mTX0RLSH8Hbg37DOtPpcCwUdGynoiIhItSjKt97KfmSdNfgcWQeZR8uv51HfGnhKW32uA9fK7chbGyjo2EhBR0RETJNx1Bp4zj+Oba6g1ccBgpqdCz/trMEnIK5GzN1VlRR0bKSgIyIidqMoH1J/tY7lc3itdRTnjOTy67l4Q1hrax+fBtdZHz4N6tQlLwUdGynoiIiIXctMOdfic66fz7HNUJhTfj3PoN9CT4O2ENamVt/erqBjIwUdERGpUUqK4cRuOLrB+ji2EY5vLz+uD1g7Np8PP6GtrR2f3XyrveSqoKBjIwUdERGp8QpzIXXbufCz0frz9P6K1/WNsPb5CW5mndYiqJm1z08NG9VZQcdGCjoiIlIrnT0NxzZZW3yObIDjv0LG4YrXdXCGgHgIbm4NQEHNrX/2CbPbfj8KOjZS0BERkTojNx3SdlpDT9oOOL7D+jM/s+L13XzPhZ5m1lGeA5tAUFPwDKjWsiuioGMjBR0REanTDMPa0nN8B6Rtt/b3Ob7DOtJzRf1+ADwCrIEnsAkENYHAptbn1dj5WUHHRgo6IiIiFSjKh5N7fmv1ObHL2hqUfuji7/EM+l3w+d1Pd79KL8/W72+nSt+ziIiI1HxOrhDS0vr4vYIc611f54PPiV2Qtss63k9OGiSlQdLSsu95YLH1dncTKOiIiIiI7Vw8zw1U2Lbs8vxsOLnbGnpO7Dz3cxdkHIH6cebUioKOiIiIVAZXr9/G7Pm9/GxT5+pyMG3PIiIiUvuZPCGpgo6IiIjUWgo6IiIiUmsp6IiIiEitpaAjIiIitZaCjoiIiNRaCjoiIiJSaynoiIiISK2loCMiIiK1loKOiIiI1FoKOiIiIlJrKeiIiIhIraWgIyIiIrWWgo6IiIjUWk5mF2A2wzAAyMzMNLkSERERsdX57+3z3+MXU+eDTlZWFgAREREmVyIiIiJXKisrC19f34u+bjEuF4VquZKSEo4dO4a3tzcWi6XStpuZmUlERASHDx/Gx8en0rZbG+lY2U7H6sroeNlOx8p2Ola2q8pjZRgGWVlZhIWF4eBw8Z44db5Fx8HBgfDw8Crbvo+Pj/4i2EjHynY6VldGx8t2Ola207GyXVUdq0u15JynzsgiIiJSaynoiIiISK2loFNFXF1defHFF3F1dTW7FLunY2U7Hasro+NlOx0r2+lY2c4ejlWd74wsIiIitZdadERERKTWUtARERGRWktBR0RERGotBR0RERGptRR0qsi7775LTEwMbm5uXHfddSxbtszskuzOuHHjsFgsZR4hISFml2UXli5dyqBBgwgLC8NisTB79uwyrxuGwbhx4wgLC8Pd3Z3rr7+e7du3m1OsyS53rEaNGlXuPOvYsaM5xZps4sSJtGvXDm9vb4KCghgyZAi7d+8us47OLStbjpXOLav33nuPhISE0kEBO3XqxI8//lj6utnnlIJOFfjqq68YM2YMzz//PJs2baJbt24MGDCA5ORks0uzO82bNyclJaX0sW3bNrNLsgs5OTm0atWKt99+u8LXp0yZwtSpU3n77bdZt24dISEh9OnTp3TutrrkcscKoH///mXOs7lz51ZjhfZjyZIlPProo6xevZr58+dTVFRE3759ycnJKV1H55aVLccKdG4BhIeHM2nSJNavX8/69evp1asXgwcPLg0zpp9ThlS69u3bGw899FCZZU2aNDGeeeYZkyqyTy+++KLRqlUrs8uwe4Axa9as0uclJSVGSEiIMWnSpNJleXl5hq+vr/H++++bUKH9uPBYGYZhjBw50hg8eLAp9di7tLQ0AzCWLFliGIbOrUu58FgZhs6tS/Hz8zP+7//+zy7OKbXoVLKCggI2bNhA3759yyzv27cvK1euNKkq+7V3717CwsKIiYlhxIgRHDhwwOyS7F5SUhKpqallzjFXV1d69Oihc+wiFi9eTFBQEPHx8dx///2kpaWZXZJdyMjIAMDf3x/QuXUpFx6r83RulVVcXMyXX35JTk4OnTp1sotzSkGnkp08eZLi4mKCg4PLLA8ODiY1NdWkquxThw4d+OSTT5g3bx4ffvghqampdO7cmVOnTpldml07fx7pHLPNgAEDmDlzJosWLeL1119n3bp19OrVi/z8fLNLM5VhGDz55JN07dqVFi1aADq3LqaiYwU6t35v27ZteHl54erqykMPPcSsWbNo1qyZXZxTdX728qpisVjKPDcMo9yyum7AgAGlf27ZsiWdOnWiUaNGzJgxgyeffNLEymoGnWO2GT58eOmfW7RoQWJiIlFRUcyZM4ehQ4eaWJm5HnvsMbZu3cry5cvLvaZzq6yLHSudW79p3LgxmzdvJj09nf/+97+MHDmSJUuWlL5u5jmlFp1KFhAQgKOjY7mkmpaWVi7RSlmenp60bNmSvXv3ml2KXTt/Z5rOsasTGhpKVFRUnT7P/vSnP/H999/zyy+/EB4eXrpc51Z5FztWFanL55aLiwuxsbEkJiYyceJEWrVqxVtvvWUX55SCTiVzcXHhuuuuY/78+WWWz58/n86dO5tUVc2Qn5/Pzp07CQ0NNbsUuxYTE0NISEiZc6ygoIAlS5boHLPBqVOnOHz4cJ08zwzD4LHHHuPbb79l0aJFxMTElHld59ZvLnesKlKXz60LGYZBfn6+fZxT1dLluY758ssvDWdnZ+Ojjz4yduzYYYwZM8bw9PQ0Dh48aHZpduUvf/mLsXjxYuPAgQPG6tWrjZtuusnw9vbWcTIMIysry9i0aZOxadMmAzCmTp1qbNq0yTh06JBhGIYxadIkw9fX1/j222+Nbdu2GX/84x+N0NBQIzMz0+TKq9+ljlVWVpbxl7/8xVi5cqWRlJRk/PLLL0anTp2MBg0a1Mlj9fDDDxu+vr7G4sWLjZSUlNLH2bNnS9fRuWV1uWOlc+s3zz77rLF06VIjKSnJ2Lp1q/Hcc88ZDg4Oxs8//2wYhvnnlIJOFXnnnXeMqKgow8XFxWjbtm2ZWxLFavjw4UZoaKjh7OxshIWFGUOHDjW2b99udll24ZdffjGAco+RI0cahmG9DfjFF180QkJCDFdXV6N79+7Gtm3bzC3aJJc6VmfPnjX69u1rBAYGGs7OzkZkZKQxcuRIIzk52eyyTVHRcQKMadOmla6jc8vqcsdK59ZvRo8eXfp9FxgYaPTu3bs05BiG+eeUxTAMo3rajkRERESql/roiIiISK2loCMiIiK1loKOiIiI1FoKOiIiIlJrKeiIiIhIraWgIyIiIrWWgo6IiIjUWgo6IlLnRUdH8+abb5pdhohUAQUdEalWo0aNYsiQIQBcf/31jBkzptr2PX36dOrVq1du+bp163jggQeqrQ4RqT5OZhcgInKtCgoKcHFxuer3BwYGVmI1ImJP1KIjIqYYNWoUS5Ys4a233sJisWCxWDh48CAAO3bsYODAgXh5eREcHMxdd93FyZMnS997/fXX89hjj/Hkk08SEBBAnz59AJg6dSotW7bE09OTiIgIHnnkEbKzswFYvHgx99xzDxkZGaX7GzduHFD+0lVycjKDBw/Gy8sLHx8fbrvtNo4fP176+rhx42jdujWffvop0dHR+Pr6MmLECLKysqr2oInIFVPQERFTvPXWW3Tq1In777+flJQUUlJSiIiIICUlhR49etC6dWvWr1/PTz/9xPHjx7ntttvKvH/GjBk4OTmxYsUKPvjgAwAcHBz45z//ya+//sqMGTNYtGgRY8eOBaBz5868+eab+Pj4lO7vqaeeKleXYRgMGTKE06dPs2TJEubPn8/+/fsZPnx4mfX279/P7Nmz+eGHH/jhhx9YsmQJkyZNqqKjJSJXS5euRMQUvr6+uLi44OHhQUhISOny9957j7Zt2zJhwoTSZR9//DERERHs2bOH+Ph4AGJjY5kyZUqZbf6+v09MTAwvv/wyDz/8MO+++y4uLi74+vpisVjK7O9CCxYsYOvWrSQlJREREQHAp59+SvPmzVm3bh3t2rUDoKSkhOnTp+Pt7Q3AXXfdxcKFC/nHP/5xbQdGRCqVWnRExK5s2LCBX375BS8vr9JHkyZNAGsrynmJiYnl3vvLL7/Qp08fGjRogLe3N3fffTenTp0iJyfH5v3v3LmTiIiI0pAD0KxZM+rVq8fOnTtLl0VHR5eGHIDQ0FDS0tKu6LOKSNVTi46I2JWSkhIGDRrE5MmTy70WGhpa+mdPT88yrx06dIiBAwfy0EMP8fLLL+Pv78/y5cu59957KSwstHn/hmFgsVguu9zZ2bnM6xaLhZKSEpv3IyLVQ0FHREzj4uJCcXFxmWVt27blv//9L9HR0Tg52f5P1Pr16ykqKuL111/HwcHaWP31119fdn8XatasGcnJyRw+fLi0VWfHjh1kZGTQtGlTm+sREfugS1ciYpro6GjWrFnDwYMHOXnyJCUlJTz66KOcPn2aP/7xj6xdu5YDBw7w888/M3r06EuGlEaNGlFUVMS//vUvDhw4wKeffsr7779fbn/Z2dksXLiQkydPcvbs2XLbueGGG0hISOCOO+5g48aNrF27lrvvvpsePXpUeLlMROybgo6ImOapp57C0dGRZs2aERgYSHJyMmFhYaxYsYLi4mL69etHixYteOKJJ/D19S1tqalI69atmTp1KpMnT6ZFixbMnDmTiRMnllmnc+fOPPTQQwwfPpzAwMBynZnBeglq9uzZ+Pn50b17d2644QYaNmzIV199VemfX0SqnsUwDMPsIkRERESqglp0REREpNZS0BEREZFaS0FHREREai0FHREREam1FHRERESk1lLQERERkVpLQUdERERqLQUdERERqbUUdERERKTWUtARERGRWktBR0RERGotBR0RERGptf4fQ2sdeTWmQyYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", + "plt.plot(off_diagonal_norm_1, label=f'n_taylor={n_1}')\n", + "plt.plot(off_diagonal_norm_2, label=f'n_taylor={n_2}')\n", + "plt.legend()\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DBF_qibo", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index f478777e93..0aeb738cf0 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -1,6 +1,6 @@ import math from copy import deepcopy -from itertools import product +from itertools import combinations, product from typing import Optional import hyperopt @@ -152,26 +152,21 @@ def cs_angle_sgn(dbi_object, d): return np.sign(norm) -def dGamma_di_onsite_Z( - dbi_object: DoubleBracketIteration, n: int, i: int, d: np.array, onsite_Z_ops=None +def dGamma_di_Pauli( + dbi_object: DoubleBracketIteration, n: int, Z_i: np.array, d: np.array ): """Computes the derivatives $\frac{\\partial \\Gamma_n}{\\partial \alpha_i}$ where the diagonal operator $D=\\sum \alpha_i Z_i$. Args: dbi_object (DoubleBracketIteration): the target dbi object n (int): the number of nested commutators in `Gamma` - i (int): the index of onsite-Z coefficient + i (int/tupple): the index of onsite-Z coefficient d (np.array): the diagonal operator Returns: (list): [dGamma_0_di, dGamma_1_di, ..., dGamma_n_di] """ nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) - if onsite_Z_ops is None: - Z_i_str = "I" * (i) + "Z" + "I" * (nqubits - i - 1) - Z_i = SymbolicHamiltonian(str_to_symbolic(Z_i_str)).dense.matrix - else: - Z_i = onsite_Z_ops[i] dGamma_di = [np.zeros((2**nqubits, 2**nqubits))] * (n + 1) Gamma_list = dbi_object.generate_Gamma_list(n=n + 2, d=d) W = dbi_object.commutator(d, dbi_object.h.matrix) @@ -188,13 +183,11 @@ def dGamma_di_onsite_Z( return dGamma_di -def ds_di_onsite_Z( +def ds_di_Pauli( dbi_object: DoubleBracketIteration, d: np.array, - i: int, - n: int = 3, + Z_i: np.array, taylor_coef: Optional[list] = None, - onsite_Z_ops: Optional[list] = None, ): r"""Return the derivatives of the first 3 polynomial coefficients with respect to onsite Pauli-Z coefficients\ Args: @@ -207,10 +200,7 @@ def ds_di_onsite_Z( floats da, db, dc, ds """ # generate the list of derivatives w.r.t ith Z operator coefficient - nqubits = int(np.log2(d.shape[0])) - if onsite_Z_ops is None: - onsite_Z_ops = generate_onsite_Z_ops(nqubits) - dGamma_di = dGamma_di_onsite_Z(dbi_object, n=4, i=i, d=d, onsite_Z_ops=onsite_Z_ops) + dGamma_di = dGamma_di_Pauli(dbi_object, n=4, Z_i=Z_i, d=d) Gamma_list = dbi_object.generate_Gamma_list(n=4, d=d) def derivative_product(k1, k2): @@ -238,10 +228,10 @@ def derivative_product(k1, k2): return da, db, dc, ds -def gradient_onsite_Z( +def gradient_Pauli( dbi_object: DoubleBracketIteration, d: np.array, - onsite_Z_ops: list, + pauli_operator_dict: dict, use_ds=False, n=3, **kwargs, @@ -257,11 +247,10 @@ def gradient_onsite_Z( """ # n is the highest order for calculating s - # initialize gradient - nqubits = int(np.log2(d.shape[0])) - if onsite_Z_ops is None: - onsite_Z_ops = generate_onsite_Z_ops(nqubits) - grad = np.zeros(nqubits) + # pauli_index is the list of positions \mu + pauli_operators = list(pauli_operator_dict.values()) + num_paul = len(pauli_operators) + grad = np.zeros(num_paul) coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n=n) s = dbi_object.choose_step( d=d, @@ -269,9 +258,10 @@ def gradient_onsite_Z( ) a, b, c = coef[len(coef) - 3 :] - for i in range(nqubits): - da, db, dc, ds = ds_di_onsite_Z( - dbi_object, d=d, i=i, n=n, taylor_coef=[a, b, c], onsite_Z_ops=onsite_Z_ops + + for i, operator in enumerate(pauli_operators): + da, db, dc, ds = ds_di_Pauli( + dbi_object, d=d, Z_i=operator, taylor_coef=[a, b, c] ) if use_ds is True: ds = 0 @@ -288,33 +278,44 @@ def gradient_onsite_Z( return grad, s -def onsite_Z_decomposition(h_matrix: np.array, onsite_Z_ops=None): +def decompose_into_Pauli_basis(h_matrix: np.array, pauli_operators: list): """finds the decomposition of hamiltonian `h_matrix` into Pauli-Z operators""" nqubits = int(np.log2(h_matrix.shape[0])) - if onsite_Z_ops is None: - onsite_Z_ops = generate_onsite_Z_ops(nqubits) + decomposition = [] - for Z_i in onsite_Z_ops: + for Z_i in pauli_operators: expect = np.trace(h_matrix @ Z_i) / 2**nqubits decomposition.append(expect) return decomposition -def generate_onsite_Z_ops(nqubits): - """generate the list of Pauli-Z operators of an `nqubit` system in the form of np.array""" - onsite_Z_str = ["I" * (i) + "Z" + "I" * (nqubits - i - 1) for i in range(nqubits)] - onsite_Z_ops = [ - SymbolicHamiltonian(str_to_symbolic(Z_i_str)).dense.matrix - for Z_i_str in onsite_Z_str +def generate_pauli_index(nqubits, order): + if order == 1: + return list(range(nqubits)) + elif order > 1: + indices = list(range(nqubits)) + return indices + [ + comb for i in range(2, order + 1) for comb in combinations(indices, i) + ] + else: + raise ValueError("Order must be a positive integer") + + +def generate_pauli_operator_dict(nqubits: int, parameterization_order: int): + pauli_index = generate_pauli_index(nqubits, order=parameterization_order) + pauli_operators = [ + generate_Pauli_operators(nqubits, symbols.Z, index) for index in pauli_index ] - return onsite_Z_ops + return {index: operator for index, operator in zip(pauli_index, pauli_operators)} -def gradient_descent_onsite_Z( +def gradient_descent_pauli( dbi_object: DoubleBracketIteration, d_coef: list, d: Optional[np.array] = None, - n: int = 2, + pauli_operator_dict: dict = None, + parameterization_order: int = 1, + n: int = 3, onsite_Z_ops: Optional[list] = None, lr_min: float = 1e-5, lr_max: float = 1, @@ -345,12 +346,13 @@ def gradient_descent_onsite_Z( """ nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) - if onsite_Z_ops is None: - onsite_Z_ops = generate_onsite_Z_ops(nqubits) - if d is None: - d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) - grad, s = gradient_onsite_Z( - dbi_object, d, n=n, onsite_Z_ops=onsite_Z_ops, use_ds=use_ds + if pauli_operator_dict is None: + pauli_operator_dict = generate_pauli_operator_dict( + nqubits, parameterization_order + ) + + grad, s = gradient_Pauli( + dbi_object, d, n=n, pauli_operator_dict=pauli_operator_dict, use_ds=use_ds ) # optimize gradient descent step with hyperopt if space is None: @@ -360,7 +362,12 @@ def gradient_descent_onsite_Z( def func_loss_to_lr(lr): d_coef_eval = [d_coef[j] - grad[j] * lr for j in range(nqubits)] - d_eval = sum([d_coef_eval[i] * onsite_Z_ops[i] for i in range(nqubits)]) + d_eval = sum( + [ + d_coef_eval[i] * list(pauli_operator_dict.values())[i] + for i in range(nqubits) + ] + ) return dbi_object.loss(step=s, d=d_eval) best = hyperopt.fmin( @@ -373,7 +380,7 @@ def func_loss_to_lr(lr): lr = best["lr"] d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)] - d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) + d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)]) return s, d_coef, d @@ -405,3 +412,14 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) return coef + + +def generate_Pauli_operators(nqubits, symbols_pauli, positions): + # generate matrix of an nqubit-pauli operator with `symbols_pauli` at `positions` + if isinstance(positions, int): + return SymbolicHamiltonian( + symbols_pauli(positions), nqubits=nqubits + ).dense.matrix + else: + terms = [symbols_pauli(pos) for pos in positions] + return SymbolicHamiltonian(math.prod(terms), nqubits=nqubits).dense.matrix From eca3446f7774e280a29c4e1d825232e33787844b Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Thu, 4 Apr 2024 07:07:40 +0200 Subject: [PATCH 067/116] adding tests notebook after talking to Sam --- .../dbi/Tests evolution oracles and gci.ipynb | 1101 +++++++++++++++++ 1 file changed, 1101 insertions(+) create mode 100644 src/qibo/models/dbi/Tests evolution oracles and gci.ipynb diff --git a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb new file mode 100644 index 0000000000..357efe11d3 --- /dev/null +++ b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb @@ -0,0 +1,1101 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2dae9ffe", + "metadata": {}, + "source": [ + "## This compares to DoubleBracketIteration whenever possible" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "85d61fc0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-04-04 06:37:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "from qibo.hamiltonians import SymbolicHamiltonian\n", + "from qibo import symbols\n", + "from double_bracket_evolution_oracles import *\n", + "from group_commutator_iteration_transpiler import *\n", + "from numpy.linalg import norm\n", + "def test_dbi_evolution_oracle(t_step, eps):\n", + "\n", + " \n", + " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + " h_input = h_x + d_0\n", + " \n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + " \n", + " evolution_oracle.eps_trottersuzuki = eps\n", + " \n", + " U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary()\n", + " V_target = h_input.exp(t_step)\n", + " \n", + " assert norm(U_hamiltonian_simulation-V_target) < eps\n", + " \n", + "test_dbi_evolution_oracle( 1, 1e-3) " + ] + }, + { + "cell_type": "markdown", + "id": "2f42fae3", + "metadata": {}, + "source": [ + "`DoubleBracketRotationType.group_commutator_other_sorting` is the same as currently `DoubleBracketIteration` group commutator" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8a03c568", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-04-04 06:55:29]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-04-04 06:55:29]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "from double_bracket import *\n", + "\n", + "def test_group_commutator_other_sorting_dbi_vs_gci(t_step, eps):\n", + "\n", + " \n", + " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + " h_input = h_x + d_0 \n", + "\n", + "\n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + " dbi.mode = DoubleBracketGeneratorType.group_commutator\n", + "\n", + " def wrapper_gc(self,step, d):\n", + " return (\n", + " self.h.exp(-step)\n", + " @ self.backend.calculate_matrix_exp(-step, d)\n", + " @ self.h.exp(step)\n", + " @ self.backend.calculate_matrix_exp(step, d)\n", + " )\n", + " V_dbi = wrapper_gc(dbi, np.sqrt(t_step), d_0.dense.matrix)\n", + " \n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", + " evolution_oracle.eps_trottersuzuki = eps\n", + " \n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + " \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", + " \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", + " U_gci = unitary_gc_from_oracles['forwards']\n", + " \n", + " assert norm(U_gci.unitary() - unitary_gc_from_oracles['backwards'].unitary().conj().T) < 1e-12\n", + " \n", + " assert norm(U_gci.unitary() - V_dbi ) < 5*eps\n", + " \n", + " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", + " U_gci = unitary_gc_from_oracles['forwards']\n", + " \n", + " assert norm(U_gci - unitary_gc_from_oracles['backwards'].conj().T) < 1e-12\n", + " \n", + " assert norm(U_gci - V_dbi ) < 5*eps\n", + " \n", + " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + " \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", + " U_gci = unitary_gc_from_oracles['forwards']\n", + " \n", + " assert isinstance(U_gci, str)\n", + "\n", + " \n", + "test_group_commutator_dbi_vs_gci(.1, 1e-5)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "44c7918c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "72461e27", + "metadata": {}, + "source": [ + "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "abb3cca7", + "metadata": {}, + "source": [ + "# Show that double bracket iteration group commutator and gci are numerically exact\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "4d7bade7", + "metadata": {}, + "source": [ + "# Show that double bracket iteration and gci gc and gc_reduced converge for small s BHMM\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba532fb6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "61699387", + "metadata": {}, + "outputs": [], + "source": [ + "dbi(t_step, d = d_0.dense.matrix)\n" + ] + }, + { + "cell_type": "markdown", + "id": "09ab7a86", + "metadata": {}, + "source": [ + "#### 2. Evolution oracle hamiltonian simulation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c9a9b4ef", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3a4b6a36", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e20f72df", + "metadata": {}, + "outputs": [], + "source": [ + "t_step = 1\n", + "def check_hs_eps(eps):\n", + " evolution_oracle_hamiltonian_simulation.eps_trottersuzuki = eps\n", + " U_hamiltonian_simulation = evolution_oracle_hamiltonian_simulation.circuit(t_step).unitary()\n", + " V_target = h_input.exp(t_step)\n", + " print(eps,norm(U_hamiltonian_simulation-V_target))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "32f515a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1 0.08786496042239604\n" + ] + } + ], + "source": [ + "check_hs_eps(0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3640b862", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.001 0.0003373755363091052\n" + ] + } + ], + "source": [ + "check_hs_eps(.001)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "51de5892", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0001 8.43397274693628e-05\n" + ] + } + ], + "source": [ + "check_hs_eps(1e-4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acb49e83", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "da441e93", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "26b4c66a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.h" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "72bdc7a7", + "metadata": {}, + "outputs": [], + "source": [ + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6635da98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "single_commutator\n", + "group_commutator\n", + "group_commutator_other_sorting\n", + "group_commutator_reduced\n", + "group_commutator_imperfect\n", + "group_commutator_reduced_imperfect\n" + ] + } + ], + "source": [ + "for a in DoubleBracketRotationType:\n", + " print(a.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d4407257", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "e1: 0.08786496042239604\n", + "e2: 6.280369834735101e-16\n", + "Testing inversion forwards: 0.08786496042239617\n", + "Testing inversion backwards: 0.08786496042239596\n", + "e1: 8.43397274693628e-05\n", + "e2: 6.280369834735101e-16\n", + "Testing inversion forwards: 8.433972746973065e-05\n", + "Testing inversion backwards: 8.433972746997873e-05\n" + ] + } + ], + "source": [ + "def test_gc_numerical_vs_circuit(eps):\n", + " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", + " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", + " \n", + " gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = False\n", + " evolution_oracle_diagonal_target.please_be_verbose = False\n", + " \n", + "\n", + " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_reduced\n", + "\n", + " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", + "\n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "\n", + " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),d_0.dense.matrix)\n", + "\n", + " bckwd = unitary_gc_from_oracles['backwards']\n", + " fwd = unitary_gc_from_oracles['forwards']\n", + "\n", + " e1 = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step))\n", + " e2 = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step))\n", + "\n", + " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + "\n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "\n", + " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),d_0.dense.matrix)\n", + "\n", + " bckwdhs = unitary_gc_from_oracles['backwards'].unitary()\n", + " fwdhs = unitary_gc_from_oracles['forwards'].unitary()\n", + "\n", + " e1hs = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step)).unitary()\n", + " e2hs = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step)).unitary()\n", + "\n", + " print(\"e1:\", norm( e1hs-e1))\n", + " print(\"e2:\", norm(e2hs-e2))\n", + " print(\"Testing inversion forwards:\", norm(bckwd-bckwdhs))\n", + " print(\"Testing inversion backwards:\", norm(fwd - fwdhs))\n", + "\n", + "test_gc_numerical_vs_circuit(0.1)\n", + "\n", + "test_gc_numerical_vs_circuit(0.0001)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "2a173296", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.0\n", + "1.1365570924547864e-05\n", + "1.1365570924508396e-05\n", + "3.178573543740718e-05\n", + "3.178573543738423e-05\n", + "2.331929054986953e-05\n", + "2.3319290550395577e-05\n", + "5.051045765082015e-05\n", + "5.051045765141829e-05\n", + "0.0\n", + "0.0\n", + "1.1365570924450749e-05\n", + "1.1365570924571942e-05\n", + "3.178573543667143e-05\n", + "3.178573543684212e-05\n", + "2.3319290550074785e-05\n", + "2.3319290550369457e-05\n", + "5.051045765037518e-05\n", + "5.051045764960636e-05\n", + "0.0\n", + "0.0\n", + "3.67220292448543e-05\n", + "3.672202924482476e-05\n", + "6.462333424612395e-05\n", + "6.462333424677995e-05\n", + "4.47483584471007e-05\n", + "4.474835844733171e-05\n", + "8.433972746997873e-05\n", + "8.433972746973065e-05\n" + ] + } + ], + "source": [ + "def test_group_commutator_against_itself(gci, evolution_diagonal,eps = 0.0001):\n", + " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", + " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", + " for s in np.linspace(0,1,5):\n", + " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + " evolution_diagonal.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + " gc_hs = gci.group_commutator(s,evolution_diagonal)\n", + " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " evolution_diagonal.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " gc_np = gci.group_commutator(s,evolution_diagonal)\n", + " print(norm(gc_np['forwards']-gc_hs['forwards'].unitary()))\n", + " print(norm(gc_np['backwards']-gc_hs['backwards'].unitary()))\n", + "\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator \n", + "test_group_commutator_against_itself(gci, evolution_oracle_diagonal_target)\n", + "\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting \n", + "test_group_commutator_against_itself(gci, evolution_oracle_diagonal_target)\n", + "\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_reduced \n", + "test_group_commutator_against_itself(gci, evolution_oracle_diagonal_target)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93ee9d5e", + "metadata": {}, + "outputs": [], + "source": [ + "def test_gc_numerical_vs_bracket(eps = 0.3):\n", + " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", + " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", + " \n", + " gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = False\n", + " evolution_oracle_diagonal_target.please_be_verbose = False\n", + " \n", + "\n", + " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "\n", + " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", + "\n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "\n", + " import scipy\n", + " unitary_gc_existing1 = scipy.linalg.expm( t_step * (d_0.dense.matrix @ h_x.dense.matrix\n", + " -h_x.dense.matrix@d_0.dense.matrix))\n", + "\n", + " bckwd = unitary_gc_from_oracles['backwards']\n", + " fwd = unitary_gc_from_oracles['forwards']\n", + "\n", + " e1 = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step))\n", + " e2 = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step))\n", + "\n", + " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + "\n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "\n", + " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),-d_0.dense.matrix)\n", + "\n", + " bckwdhs = unitary_gc_from_oracles['backwards'].unitary()\n", + " fwdhs = unitary_gc_from_oracles['forwards'].unitary()\n", + "\n", + " e1hs = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step)).unitary()\n", + " e2hs = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step)).unitary()\n", + " print(\"Test:\", norm(unitary_gc_existing-unitary_gc_existing1))\n", + " print(\"e1:\", norm( e1hs-e1))\n", + " print(\"e2:\", norm(e2hs-e2))\n", + " print(\"Testing inversion forwards:\", norm(bckwd-bckwdhs))\n", + " print(\"Testing inversion backwards:\", norm(fwd - fwdhs))\n", + "\n", + "test_gc_numerical_vs_bracket(0.1)\n", + "\n", + "test_gc_numerical_vs_bracket(0.0001)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "d2f19ef9", + "metadata": {}, + "outputs": [], + "source": [ + "def gc_hs_eps(eps):\n", + " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", + " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", + " \n", + " gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = True\n", + " evolution_oracle_diagonal_target.please_be_verbose = False\n", + " \n", + " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", + "\n", + " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + " \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + " \n", + " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),-d_0.dense.matrix)\n", + " \n", + " bckwd = unitary_gc_from_oracles['backwards']\n", + " fwd = unitary_gc_from_oracles['forwards']\n", + " \n", + " e1 = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step))\n", + " e2 = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step))\n", + " \n", + " print(\"Backwards:\", norm( bckwd - unitary_gc_existing))\n", + " print(\"Forwards:\", norm(fwd - unitary_gc_existing))\n", + " print(\"Testing inversion forwards:\", norm(fwd - e2.conj().T @ e1.conj().T @ e2 @e1))\n", + " print(\"Testing inversion backwards:\", norm(bckwd - e2.conj().T @ e1.conj().T @ e2 @e1))\n", + " print(\"Testing inversion forwards:\", norm(fwd - e1.conj().T @ e2.conj().T @ e1 @e2))\n", + " print(\"Testing inversion backwards:\", norm(bckwd - e1.conj().T @ e2.conj().T @ e1 @e2))\n", + " print(\"Testing inversion forwards:\", norm(fwd - e1@e2@ e1.conj().T @ e2.conj().T ))\n", + " print(\"Testing inversion backwards:\", norm(bckwd - e1@e2@e1.conj().T @ e2.conj().T ))\n", + " print(\"Testing inversion forwards:\", norm(fwd - e1.conj().T@e2@ e1 @ e2.conj().T ))\n", + " print(\"Testing inversion backwards:\", norm(bckwd - e1.conj().T@e2@e1 @ e2.conj().T ))\n", + " print(\"Testing reversal:\", norm(bckwd@fwd - unitary_gc_existing @unitary_gc_existing.T.conj() ))\n", + " print(\"Testing reversal:\", norm(bckwd@fwd - e1@e1.conj().T ))" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ae8e83bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Backwards: 4.705144430384231\n", + "Forwards: 0.001440854728059234\n", + "Testing inversion forwards: 3.30970601135848\n", + "Testing inversion backwards: 3.3448906768858175\n", + "Testing inversion forwards: 3.344890676885818\n", + "Testing inversion backwards: 3.3097060113584806\n", + "Testing inversion forwards: 3.2769939636040615\n", + "Testing inversion backwards: 4.146762372604833\n", + "Testing inversion forwards: 1.8387684917953713e-15\n", + "Testing inversion backwards: 4.705576215718977\n", + "Testing reversal: 3.759252603260064e-15\n", + "Testing reversal: 3.632964118172524e-15\n" + ] + } + ], + "source": [ + "gc_hs_eps(0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "5dcc9f04", + "metadata": {}, + "source": [ + "We may improve the discrepancy by setting smaller eps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1bf92e2", + "metadata": {}, + "outputs": [], + "source": [ + "gc_hs_eps(0.0001)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f12288b0", + "metadata": {}, + "outputs": [], + "source": [ + "norm(unitary_gc_from_oracles['forwards'].unitary() - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77579bc5", + "metadata": {}, + "outputs": [], + "source": [ + "norm(unitary_gc_from_oracles['backwards'].unitary() - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0128e99d", + "metadata": {}, + "outputs": [], + "source": [ + "stop" + ] + }, + { + "cell_type": "markdown", + "id": "a3504871", + "metadata": {}, + "source": [ + "#### Test more explicitly\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "642cbce1", + "metadata": {}, + "outputs": [], + "source": [ + "u_h = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", + "u_d = evolution_oracle_diagonal_target.circuit( np.sqrt(t_step)).unitary()\n", + "u_h_reversed = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", + "u_d_reversed = evolution_oracle_diagonal_target.circuit( -np.sqrt(t_step)).unitary()\n", + "norm( u_h_reversed @ u_d_reversed @ u_h @ u_d - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6edaa7bb", + "metadata": {}, + "outputs": [], + "source": [ + "u_h = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step))\n", + "u_d = evolution_oracle_diagonal_target.circuit( np.sqrt(t_step))\n", + "u_h_reversed = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step))\n", + "u_d_reversed = evolution_oracle_diagonal_target.circuit( -np.sqrt(t_step))\n", + "norm( (u_h_reversed + u_d_reversed + u_h + u_d).unitary() - unitary_gc_existing)" + ] + }, + { + "cell_type": "markdown", + "id": "b56f305f", + "metadata": {}, + "source": [ + "#### 3. Evolution oracle numpy\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b6f6c17", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_numerical = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_numerical ))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3bec576", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.numerical)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f14d3133", + "metadata": {}, + "outputs": [], + "source": [ + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" + ] + }, + { + "cell_type": "markdown", + "id": "6256dc33", + "metadata": {}, + "source": [ + "Compared to the group commutator using Hamiltonian simulation there will be small deviations that arise from Trotter-Suzuki decomposition" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ab01c82", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "norm(unitary_gc_from_oracles['backwards'] - unitary_gc_existing)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d3354a8", + "metadata": {}, + "outputs": [], + "source": [ + "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" + ] + }, + { + "cell_type": "markdown", + "id": "26dfc6ac", + "metadata": {}, + "source": [ + "We may check by switching the group commutator flag that the difference comes from ordering and inversions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e43555b", + "metadata": {}, + "outputs": [], + "source": [ + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", + "\n", + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" + ] + }, + { + "cell_type": "markdown", + "id": "d6a735d4", + "metadata": {}, + "source": [ + "#### 4. Check gci rotation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5471e516", + "metadata": {}, + "outputs": [], + "source": [ + "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a7ac8f4", + "metadata": {}, + "outputs": [], + "source": [ + "type(gci.iterated_hamiltonian_evolution_oracle)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d30c7558", + "metadata": {}, + "outputs": [], + "source": [ + "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fe303d2", + "metadata": {}, + "outputs": [], + "source": [ + "type(gci.iterated_hamiltonian_evolution_oracle)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ab13137", + "metadata": {}, + "outputs": [], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca82a687", + "metadata": {}, + "outputs": [], + "source": [ + "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd4f541d", + "metadata": {}, + "outputs": [], + "source": [ + "norm( dbi.h.exp(t_step) - u_frame_shifted)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67257043", + "metadata": {}, + "outputs": [], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "feb5fde9", + "metadata": {}, + "outputs": [], + "source": [ + "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95de4c31", + "metadata": {}, + "outputs": [], + "source": [ + "dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2bcc8f07", + "metadata": {}, + "outputs": [], + "source": [ + "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eafa1770", + "metadata": {}, + "outputs": [], + "source": [ + "norm( dbi.h.exp(t_step) - u_frame_shifted)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05e94ce8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed2b81e1", + "metadata": {}, + "outputs": [], + "source": [ + "for k in range(3):\n", + " gci(t_step, diagonal_association=evolution_oracle_diagonal_target)\n", + " dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)\n", + " print(norm( dbi.h.exp(t_step) - u_frame_shifted))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15d96e82", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3fdf49bd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9130482b", + "metadata": {}, + "outputs": [], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de46b823", + "metadata": {}, + "outputs": [], + "source": [ + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + "gc_numpy = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4f78e3a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4d23962", + "metadata": {}, + "outputs": [], + "source": [ + "## Test more fancy functionalities\n", + "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", + "d_ev = EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "\n", + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + "query_list = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle= d_ev )\n", + "\n", + "norm(query_list['forwards'].unitary() -query_list['backwards'].unitary().conj().T)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e69dc0b", + "metadata": {}, + "outputs": [], + "source": [ + "norm(query_list['forwards'] -query_list['backwards'].T.conj())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfee7994", + "metadata": {}, + "outputs": [], + "source": [ + "#Test file entry\n", + "u = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", + "u2 = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", + "norm(u-u2.T.conj())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "527bb789", + "metadata": {}, + "outputs": [], + "source": [ + "d_0.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + "query_list = gci.group_commutator( np.sqrt(t_step*2),\n", + " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\"))\n", + "\n", + "\n", + "query_list['forwards']" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 359d33a68cf479a9397a918092770d7e674b89dc Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Thu, 4 Apr 2024 09:59:53 +0200 Subject: [PATCH 068/116] largely simplified code but not everything tested. Will need to also change the group commutator tests of dbi gc because that wasn't tested --- .../dbi/Tests evolution oracles and gci.ipynb | 273 +++++++--------- src/qibo/models/dbi/double_bracket.py | 11 +- .../group_commutator_iteration_transpiler.py | 296 +++++------------- 3 files changed, 194 insertions(+), 386 deletions(-) diff --git a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb index 357efe11d3..a7b1bf6e71 100644 --- a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb +++ b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "85d61fc0", "metadata": {}, "outputs": [ @@ -18,7 +18,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-04-04 06:37:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|INFO|2024-04-04 09:58:46]: Using qibojit (numba) backend on /CPU:0\n", + "[Qibo 0.2.5|WARNING|2024-04-04 09:58:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -60,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 3, "id": "8a03c568", "metadata": {}, "outputs": [ @@ -68,8 +69,20 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-04-04 06:55:29]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-04-04 06:55:29]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-04-04 09:58:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-04-04 09:58:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_52591/732875884.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mtest_group_commutator_other_sorting_dbi_vs_gci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_52591/732875884.py\u001b[0m in \u001b[0;36mtest_group_commutator_other_sorting_dbi_vs_gci\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0munitary_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'backwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mV_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " ] } ], @@ -106,10 +119,9 @@ " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", " \n", " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", + " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", " U_gci = unitary_gc_from_oracles['forwards']\n", " \n", " assert norm(U_gci.unitary() - unitary_gc_from_oracles['backwards'].unitary().conj().T) < 1e-12\n", @@ -130,37 +142,97 @@ " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.text_strings\n", " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", " U_gci = unitary_gc_from_oracles['forwards']\n", " \n", " assert isinstance(U_gci, str)\n", "\n", " \n", - "test_group_commutator_dbi_vs_gci(.1, 1e-5)" + "test_group_commutator_other_sorting_dbi_vs_gci(.1, 1e-5)" ] }, { "cell_type": "code", - "execution_count": 22, - "id": "44c7918c", + "execution_count": null, + "id": "01f2f61c", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "72461e27", + "id": "05fa44ac", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", "\n", - "\n" + "This is testing the following:\n", + "\n", + "`dbi` runs $V = e^{-sW}$ and rotates $H_1 = V^\\dagger H_0 V$.\n", + "\n", + "`gci` runs $Q = GC$ and rotates $J_1 = Q^\\dagger H_0 Q$.\n", + "\n", + "`dbi2` runs $R = GC$ and rotates $K_1 = R^\\dagger H_0 R$.\n", + "\n", + "We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", + "$$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", + "\n", + "We assert that gci and dbi should be within the approximation bound of the GC\n", + "$$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8ed231a", + "metadata": {}, + "outputs": [], + "source": [ + "from double_bracket import *\n", + "\n", + "def test_dbi_vs_gci(t_step, eps):\n", + " if t_step > 1:\n", + " t_step = 0.1\n", + " \n", + " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + " h_input = h_x + d_0 \n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + " dbi.mode = DoubleBracketGeneratorType.group_commutator\n", + " dbi(t_step, d = d_0.dense.matrix )\n", + " \n", + " dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + " dbi2.mode = DoubleBracketGeneratorType.single_commutator\n", + " dbi2(t_step, d = d_0.dense.matrix )\n", + " \n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", + " evolution_oracle.eps_trottersuzuki = eps\n", + " \n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + " \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", + " \n", + " assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", + " assert norm(gci.h.matrix - dbi2.h.matrix) < 20 * norm(h_input) * t_step\n", + " \n", + " dbi(t_step, d = d_0.dense.matrix ) \n", + " dbi2(t_step, d = d_0.dense.matrix ) \n", + " gci(t_step, diagonal_association=evolution_oracle_diagonal_target) \n", + " assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", + " assert norm(gci.h.matrix - dbi2.h.matrix) < (20 * norm(h_input) * t_step)**2\n", + " \n", + " \n", + "test_dbi_vs_gci(.1, 1e-5)" ] }, { "cell_type": "markdown", - "id": "abb3cca7", + "id": "b36a4faa", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and gci are numerically exact\n", @@ -169,7 +241,7 @@ }, { "cell_type": "markdown", - "id": "4d7bade7", + "id": "50190fd5", "metadata": {}, "source": [ "# Show that double bracket iteration and gci gc and gc_reduced converge for small s BHMM\n", @@ -180,14 +252,14 @@ { "cell_type": "code", "execution_count": null, - "id": "ba532fb6", + "id": "c1bde682", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "61699387", "metadata": {}, "outputs": [], @@ -205,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "c9a9b4ef", "metadata": {}, "outputs": [], @@ -216,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "3a4b6a36", "metadata": {}, "outputs": [], @@ -228,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "e20f72df", "metadata": {}, "outputs": [], @@ -243,54 +315,30 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "32f515a0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1 0.08786496042239604\n" - ] - } - ], + "outputs": [], "source": [ "check_hs_eps(0.1)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "3640b862", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.001 0.0003373755363091052\n" - ] - } - ], + "outputs": [], "source": [ "check_hs_eps(.001)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "51de5892", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0001 8.43397274693628e-05\n" - ] - } - ], + "outputs": [], "source": [ "check_hs_eps(1e-4)" ] @@ -305,7 +353,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "da441e93", "metadata": {}, "outputs": [], @@ -317,28 +365,17 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "26b4c66a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "gci.iterated_hamiltonian_evolution_oracle.h" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "72bdc7a7", "metadata": {}, "outputs": [], @@ -349,23 +386,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "6635da98", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single_commutator\n", - "group_commutator\n", - "group_commutator_other_sorting\n", - "group_commutator_reduced\n", - "group_commutator_imperfect\n", - "group_commutator_reduced_imperfect\n" - ] - } - ], + "outputs": [], "source": [ "for a in DoubleBracketRotationType:\n", " print(a.name)" @@ -373,25 +397,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "d4407257", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "e1: 0.08786496042239604\n", - "e2: 6.280369834735101e-16\n", - "Testing inversion forwards: 0.08786496042239617\n", - "Testing inversion backwards: 0.08786496042239596\n", - "e1: 8.43397274693628e-05\n", - "e2: 6.280369834735101e-16\n", - "Testing inversion forwards: 8.433972746973065e-05\n", - "Testing inversion backwards: 8.433972746997873e-05\n" - ] - } - ], + "outputs": [], "source": [ "def test_gc_numerical_vs_circuit(eps):\n", " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", @@ -443,47 +452,10 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "id": "2a173296", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n", - "0.0\n", - "1.1365570924547864e-05\n", - "1.1365570924508396e-05\n", - "3.178573543740718e-05\n", - "3.178573543738423e-05\n", - "2.331929054986953e-05\n", - "2.3319290550395577e-05\n", - "5.051045765082015e-05\n", - "5.051045765141829e-05\n", - "0.0\n", - "0.0\n", - "1.1365570924450749e-05\n", - "1.1365570924571942e-05\n", - "3.178573543667143e-05\n", - "3.178573543684212e-05\n", - "2.3319290550074785e-05\n", - "2.3319290550369457e-05\n", - "5.051045765037518e-05\n", - "5.051045764960636e-05\n", - "0.0\n", - "0.0\n", - "3.67220292448543e-05\n", - "3.672202924482476e-05\n", - "6.462333424612395e-05\n", - "6.462333424677995e-05\n", - "4.47483584471007e-05\n", - "4.474835844733171e-05\n", - "8.433972746997873e-05\n", - "8.433972746973065e-05\n" - ] - } - ], + "outputs": [], "source": [ "def test_group_commutator_against_itself(gci, evolution_diagonal,eps = 0.0001):\n", " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", @@ -567,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "id": "d2f19ef9", "metadata": {}, "outputs": [], @@ -611,29 +583,10 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "id": "ae8e83bf", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Backwards: 4.705144430384231\n", - "Forwards: 0.001440854728059234\n", - "Testing inversion forwards: 3.30970601135848\n", - "Testing inversion backwards: 3.3448906768858175\n", - "Testing inversion forwards: 3.344890676885818\n", - "Testing inversion backwards: 3.3097060113584806\n", - "Testing inversion forwards: 3.2769939636040615\n", - "Testing inversion backwards: 4.146762372604833\n", - "Testing inversion forwards: 1.8387684917953713e-15\n", - "Testing inversion backwards: 4.705576215718977\n", - "Testing reversal: 3.759252603260064e-15\n", - "Testing reversal: 3.632964118172524e-15\n" - ] - } - ], + "outputs": [], "source": [ "gc_hs_eps(0.1)" ] diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index b09ca8bbee..d13f22168d 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -10,7 +10,6 @@ grid_search_step, hyperopt_step, polynomial_step, - simulated_annealing_step, ) @@ -35,8 +34,6 @@ class DoubleBracketScheduling(Enum): """Use greedy grid search.""" polynomial_approximation = polynomial_step """Use polynomial expansion (analytical) of the loss function.""" - simulated_annealing = simulated_annealing_step - """Use simulated annealing algorithm""" class DoubleBracketCostFunction(Enum): @@ -111,10 +108,10 @@ def __call__( if d is None: d = self.diagonal_h_matrix operator = ( - self.h.exp(-step) - @ self.backend.calculate_matrix_exp(-step, d) - @ self.h.exp(step) - @ self.backend.calculate_matrix_exp(step, d) + self.h.exp(-np.sqrt(step)) + @ self.backend.calculate_matrix_exp(-np.sqrt(step), d) + @ self.h.exp(np.sqrt(step)) + @ self.backend.calculate_matrix_exp(np.sqrt(step), d) ) operator_dagger = self.backend.cast( np.matrix(self.backend.to_numpy(operator)).getH() diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 815f93ea02..b1166c67f0 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -20,15 +20,14 @@ class DoubleBracketRotationType(Enum): group_commutator = auto() """Use group commutator approximation""" - group_commutator_other_sorting = auto() - """Use group commutator approximation""" group_commutator_reduced = auto() """Use group commutator approximation with a reduction using symmetry """ - ## Reserving for later development + exact_GWW = auto() + """ $e^{-s [\Delta(H),H]}$""" group_commutator_imperfect = auto() """Use group commutator approximation""" @@ -78,244 +77,103 @@ def __init__( def __call__( self, - step_duration: float = None, - diagonal_association: EvolutionOracle = None, - mode_double_bracket_rotation: DoubleBracketRotationType = None, + step_duration: float, + diagonal_association: EvolutionOracle, + mode_dbr: DoubleBracketRotationType = None, ): # Set rotation type - if mode_double_bracket_rotation is None: - mode_double_bracket_rotation = self.mode_double_bracket_rotation - - # Setup diagonal association - if diagonal_association is None: - if ( - self.mode_diagonal_association - is DoubleBracketDiagonalAssociationType.dephasing - ): - raise_error( - NotImplementedError, - "diagonal_h_matrix is np.array but need to cast to SymbolicHamiltonian; need to find a way to take the diagonal of the internal matrix self. h and create a SymbolicHamiltonian out of that", - ) - diagonal_association = EvolutionOracle( - SymbolicHamiltonian(self.diagonal_h_matrix), - "Dephasing", - mode_evolution_oracle=self.input_hamiltonian_evolution_oracle.mode_evolution_oracle, - ) - else: - raise_error( - ValueError, - f"Cannot use group_commutator without specifying the diagonal association. Did you want to set to canonical mode?", - ) + if mode_dbr is None: + mode_dbr = self.mode_double_bracket_rotation - else: - self.mode_diagonal_association = ( - DoubleBracketDiagonalAssociationType.prescribed + if (mode_dbr is DoubleBracketRotationType.single_commutator): + raise_error( + ValueError, + "single_commutator DBR mode doesn't make sense with EvolutionOracle", ) + + # This will run the appropriate group commutator step + double_bracket_rotation_step = self.group_commutator(step_duration, diagonal_association) + before_circuit = double_bracket_rotation_step["backwards"] + after_circuit = double_bracket_rotation_step["forwards"] - # Perform the rotation if ( - self.mode_double_bracket_rotation - is DoubleBracketRotationType.single_commutator + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.numerical ): - raise_error( - NotImplementedError, - "Keeping track of single commutator DBRs not implemented", - ) - double_bracket_rotation_step = self.single_commutator_query_list( - step, diagonal_association - ) - else: - # This will run the appropriate group commutator step - double_bracket_rotation_step = self.group_commutator( - step_duration, diagonal_association - ) - - if ( - self.input_hamiltonian_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.numerical - ): - before_circuit = double_bracket_rotation_step["backwards"] - after_circuit = double_bracket_rotation_step["forwards"] - self.h.matrix = before_circuit @ self.h.matrix @ after_circuit - - elif ( - self.input_hamiltonian_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.hamiltonian_simulation - ): - before_circuit = double_bracket_rotation_step["backwards"] - after_circuit = double_bracket_rotation_step["forwards"] - self.iterated_hamiltonian_evolution_oracle = ( - FrameShiftedEvolutionOracle( - deepcopy(self.iterated_hamiltonian_evolution_oracle), - str(step_duration), - before_circuit, - after_circuit, - ) + self.h.matrix = before_circuit @ self.h.matrix @ after_circuit + + elif ( + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.hamiltonian_simulation + ): + self.iterated_hamiltonian_evolution_oracle = ( + FrameShiftedEvolutionOracle( + deepcopy(self.iterated_hamiltonian_evolution_oracle), + str(step_duration), + before_circuit, + after_circuit, ) + ) + self.h.matrix = before_circuit.unitary() @ self.h.matrix @ after_circuit.unitary() - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: - raise_error(NotImplementedError) - else: - super().__call__(step, d) + elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: + raise_error(NotImplementedError) + else: + super().__call__(step, d) def group_commutator( self, s_step: float, - diagonal_association_evolution_oracle: EvolutionOracle = None, - iterated_hamiltonian_evolution_oracle: EvolutionOracle = None, + eo1: EvolutionOracle, + eo2: EvolutionOracle = None, + mode_dbr: DoubleBracketRotationType = None ): + + if eo2 is None: + eo2 = self.iterated_hamiltonian_evolution_oracle - if iterated_hamiltonian_evolution_oracle is None: + assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value - iterated_hamiltonian_evolution_oracle = ( - self.iterated_hamiltonian_evolution_oracle - ) + eo_mode = eo1.mode_evolution_oracle - if ( - self.mode_double_bracket_rotation - is DoubleBracketRotationType.group_commutator - ): - assert ( - diagonal_association_evolution_oracle.mode_evolution_oracle.value - is self.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value - ) + if mode_dbr is None: + gc_type = self.mode_double_bracket_rotation + else: + gc_type = mode_dbr - if ( - diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.text_strings - or diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.hamiltonian_simulation - ): - return { - "forwards": ( - iterated_hamiltonian_evolution_oracle.circuit(-s_step) - + diagonal_association_evolution_oracle.circuit(s_step) - + iterated_hamiltonian_evolution_oracle.circuit(s_step) - + diagonal_association_evolution_oracle.circuit(-s_step) - ), - "backwards": ( # in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step) - + iterated_hamiltonian_evolution_oracle.circuit(-s_step) - + diagonal_association_evolution_oracle.circuit(-s_step) - + iterated_hamiltonian_evolution_oracle.circuit(s_step) - ), - } - elif ( - diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.numerical - ): - return { - "forwards": ( - iterated_hamiltonian_evolution_oracle.circuit(-s_step) - @ diagonal_association_evolution_oracle.circuit(s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(s_step) - @ diagonal_association_evolution_oracle.circuit(-s_step) - ), - "backwards": ( # in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) - @ diagonal_association_evolution_oracle.circuit(-s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(s_step) - ), - } - elif ( - self.mode_double_bracket_rotation - is DoubleBracketRotationType.group_commutator_other_sorting - ): - assert ( - diagonal_association_evolution_oracle.mode_evolution_oracle - is iterated_hamiltonian_evolution_oracle.mode_evolution_oracle + if gc_type is DoubleBracketRotationType.single_commutator: + raise_error( + ValueError, + "You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!", ) - if ( - diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.text_strings - or diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.hamiltonian_simulation - ): - return { - "forwards": ( - iterated_hamiltonian_evolution_oracle.circuit(-s_step) - + diagonal_association_evolution_oracle.circuit(-s_step) - + iterated_hamiltonian_evolution_oracle.circuit(s_step) - + diagonal_association_evolution_oracle.circuit(s_step) - ), - "backwards": ( # in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(-s_step) - + iterated_hamiltonian_evolution_oracle.circuit(-s_step) - + diagonal_association_evolution_oracle.circuit(s_step) - + iterated_hamiltonian_evolution_oracle.circuit(s_step) - ), + if gc_type is DoubleBracketRotationType.group_commutator: + query_list_forward = [ eo1.circuit(-s_step), eo2.circuit(s_step), eo1.circuit(s_step), eo2.circuit(-s_step) ] + query_list_backward = [ eo2.circuit(s_step), eo1.circuit(-s_step), eo2.circuit(-s_step), eo1.circuit(s_step) ] + elif gc_type is DoubleBracketRotationType.group_commutator_reduced: + query_list_forward = [ eo2.circuit(s_step), eo1.circuit(s_step), eo2.circuit(-s_step) ] + query_list_backward = [ eo2.circuit(s_step), eo1.circuit(-s_step), eo2.circuit(-s_step) ] + else: + raise_error( + ValueError, + "You are in the group commutator query list but your dbr mode is not recognized") + + from functools import reduce + if eo_mode is EvolutionOracleType.text_strings: + return { + "forwards": reduce(str.__add__, query_list_forward), + "backwards": reduce(str.__add__, query_list_backward) } - elif ( - diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.numerical - ): - return { - "forwards": ( - iterated_hamiltonian_evolution_oracle.circuit(-s_step) - @ diagonal_association_evolution_oracle.circuit(-s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(s_step) - @ diagonal_association_evolution_oracle.circuit(s_step) - ), - "backwards": ( # in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(-s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) - @ diagonal_association_evolution_oracle.circuit(s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(s_step) - ), + elif eo_mode is EvolutionOracleType.hamiltonian_simulation: + return { + "forwards": reduce(Circuit.__add__, query_list_forward[::-1]), + "backwards": reduce(Circuit.__add__, query_list_backward[::-1]) } - elif ( - self.mode_double_bracket_rotation - is DoubleBracketRotationType.group_commutator_reduced - ): - if ( - diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.text_strings - or diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.hamiltonian_simulation - ): - return { - "forwards": ( - diagonal_association_evolution_oracle.circuit(s_step) - + iterated_hamiltonian_evolution_oracle.circuit(s_step) - + diagonal_association_evolution_oracle.circuit(-s_step) - ), - "backwards": ( # in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step) - + iterated_hamiltonian_evolution_oracle.circuit(-s_step) - + diagonal_association_evolution_oracle.circuit(-s_step) - ), + elif eo_mode is EvolutionOracleType.numerical: + return { + "forwards": reduce(np.array.__matmul__, query_list_forward), + "backwards": reduce(np.array.__matmul__, query_list_backward) } - elif ( - diagonal_association_evolution_oracle.mode_evolution_oracle - is EvolutionOracleType.numerical - ): - return { - "forwards": ( - diagonal_association_evolution_oracle.circuit(s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(s_step) - @ diagonal_association_evolution_oracle.circuit(-s_step) - ), - "backwards": ( # in general an evolution oracle might have imperfect time reversal - diagonal_association_evolution_oracle.circuit(s_step) - @ iterated_hamiltonian_evolution_oracle.circuit(-s_step) - @ diagonal_association_evolution_oracle.circuit(-s_step) - ), - } - else: - if ( - self.mode_double_bracket_rotation - is DoubleBracketRotationType.single_commutator - ): - raise_error( - ValueError, - "You are in the group commutator query list but your dbr mode is a perfect bracket and not an approximation by means of a group commutator!", - ) - else: - raise_error( - ValueError, - "You are in the group commutator query list but your dbr mode is not recognized", - ) + raise_error(ValueError, "Your EvolutionOracleType is not recognized") From 150dd9512f7ee113b9e488fb8d4166315cf33e5f Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 04:55:29 +0200 Subject: [PATCH 069/116] wip fix the commutator conventions --- examples/dbi/dbi_costs.ipynb | 10 +- .../dbi/Tests evolution oracles and gci.ipynb | 133 +++++++++++++++--- .../group_commutator_iteration_transpiler.py | 3 +- 3 files changed, 118 insertions(+), 28 deletions(-) diff --git a/examples/dbi/dbi_costs.ipynb b/examples/dbi/dbi_costs.ipynb index 2170ce8c9b..000fffd14f 100644 --- a/examples/dbi/dbi_costs.ipynb +++ b/examples/dbi/dbi_costs.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -28,7 +27,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -171,7 +169,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -236,7 +233,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -530,7 +526,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -659,7 +654,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -673,9 +668,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18 (main, Sep 11 2023, 14:09:26) [MSC v.1916 64 bit (AMD64)]" + "version": "3.10.12" }, - "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4" diff --git a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb index a7b1bf6e71..4b0421ba10 100644 --- a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb +++ b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "85d61fc0", "metadata": {}, "outputs": [ @@ -18,8 +18,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-04-04 09:58:46]: Using qibojit (numba) backend on /CPU:0\n", - "[Qibo 0.2.5|WARNING|2024-04-04 09:58:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|INFO|2024-04-05 04:49:29]: Using qibojit (numba) backend on /CPU:0\n", + "[Qibo 0.2.5|WARNING|2024-04-05 04:49:29]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -69,8 +69,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|WARNING|2024-04-04 09:58:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-04-04 09:58:48]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] }, { @@ -80,8 +80,8 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_52591/732875884.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mtest_group_commutator_other_sorting_dbi_vs_gci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/tmp/ipykernel_52591/732875884.py\u001b[0m in \u001b[0;36mtest_group_commutator_other_sorting_dbi_vs_gci\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0munitary_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'backwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mV_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mtest_group_commutator_dbi_vs_gci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36mtest_group_commutator_dbi_vs_gci\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0munitary_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'backwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mV_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mAssertionError\u001b[0m: " ] } @@ -89,7 +89,97 @@ "source": [ "from double_bracket import *\n", "\n", - "def test_group_commutator_other_sorting_dbi_vs_gci(t_step, eps):\n", + "def test_group_commutator_dbi_vs_gci_numerical(t_step, eps):\n", + "\n", + " \n", + " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + " h_input = h_x + d_0 \n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + " dbi.mode = DoubleBracketGeneratorType.group_commutator\n", + "\n", + " def wrapper_gc(self,step, d):\n", + " return (\n", + " self.h.exp(-step)\n", + " @ self.backend.calculate_matrix_exp(-step, d)\n", + " @ self.h.exp(step)\n", + " @ self.backend.calculate_matrix_exp(step, d)\n", + " )\n", + " V_dbi = wrapper_gc(dbi, np.sqrt(t_step), d_0.dense.matrix)\n", + " \n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", + " evolution_oracle.eps_trottersuzuki = eps\n", + " \n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + " \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + " \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", + " U_gci = unitary_gc_from_oracles['forwards']\n", + " \n", + " assert norm(U_gci.unitary() - unitary_gc_from_oracles['backwards'].unitary().conj().T) < 1e-12\n", + " \n", + " assert norm(U_gci.unitary().conj().T - V_dbi ) < 5*eps\n", + " \n", + " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", + " \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", + " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", + " U_gci = unitary_gc_from_oracles['forwards']\n", + " \n", + " assert norm(U_gci - unitary_gc_from_oracles['backwards'].conj().T) < 1e-12\n", + " \n", + " assert norm(U_gci.conj().T - V_dbi ) < 5*eps\n", + " \n", + " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.text_strings\n", + " \n", + " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", + " U_gci = unitary_gc_from_oracles['forwards']\n", + " \n", + " assert isinstance(U_gci, str)\n", + "\n", + " \n", + "test_group_commutator_dbi_vs_gci(.1, 1e-5)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "79452419", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mtest_group_commutator_dbi_vs_gci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36mtest_group_commutator_dbi_vs_gci\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0munitary_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'backwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mV_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "from double_bracket import *\n", + "\n", + "def test_group_commutator_dbi_vs_gci(t_step, eps):\n", "\n", " \n", " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", @@ -116,7 +206,7 @@ " evolution_oracle.eps_trottersuzuki = eps\n", " \n", " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", " \n", " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", @@ -126,7 +216,7 @@ " \n", " assert norm(U_gci.unitary() - unitary_gc_from_oracles['backwards'].unitary().conj().T) < 1e-12\n", " \n", - " assert norm(U_gci.unitary() - V_dbi ) < 5*eps\n", + " assert norm(U_gci.unitary().conj().T - V_dbi ) < 5*eps\n", " \n", " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", @@ -137,7 +227,7 @@ " \n", " assert norm(U_gci - unitary_gc_from_oracles['backwards'].conj().T) < 1e-12\n", " \n", - " assert norm(U_gci - V_dbi ) < 5*eps\n", + " assert norm(U_gci.conj().T - V_dbi ) < 5*eps\n", " \n", " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.text_strings\n", @@ -148,20 +238,25 @@ " assert isinstance(U_gci, str)\n", "\n", " \n", - "test_group_commutator_other_sorting_dbi_vs_gci(.1, 1e-5)" + "test_group_commutator_dbi_vs_gci(.1, 1e-5)" ] }, { "cell_type": "code", "execution_count": null, - "id": "01f2f61c", + "id": "c5c30773", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import inspect\n", + "\n", + "from tests import *\n", + "\n" + ] }, { "cell_type": "markdown", - "id": "05fa44ac", + "id": "85ffae5d", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", @@ -184,7 +279,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b8ed231a", + "id": "3fd8d6ce", "metadata": {}, "outputs": [], "source": [ @@ -232,7 +327,7 @@ }, { "cell_type": "markdown", - "id": "b36a4faa", + "id": "d8e8f049", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and gci are numerically exact\n", @@ -241,7 +336,7 @@ }, { "cell_type": "markdown", - "id": "50190fd5", + "id": "fe1b99df", "metadata": {}, "source": [ "# Show that double bracket iteration and gci gc and gc_reduced converge for small s BHMM\n", @@ -252,7 +347,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c1bde682", + "id": "95e327da", "metadata": {}, "outputs": [], "source": [] diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index b1166c67f0..bbb8318c8c 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -124,11 +124,12 @@ def __call__( def group_commutator( self, - s_step: float, + t_step: float, eo1: EvolutionOracle, eo2: EvolutionOracle = None, mode_dbr: DoubleBracketRotationType = None ): + s_step = np.sqrt(t_step) if eo2 is None: eo2 = self.iterated_hamiltonian_evolution_oracle From 2911d697b690114d7a1b069d25cca630ee740a4e Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 07:58:09 +0200 Subject: [PATCH 070/116] continuing tests --- .../dbi/Tests evolution oracles and gci.ipynb | 24 +++++++------------ 1 file changed, 9 insertions(+), 15 deletions(-) diff --git a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb index 4b0421ba10..0f1035e26f 100644 --- a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb +++ b/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb @@ -100,14 +100,8 @@ " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", " dbi.mode = DoubleBracketGeneratorType.group_commutator\n", "\n", - " def wrapper_gc(self,step, d):\n", - " return (\n", - " self.h.exp(-step)\n", - " @ self.backend.calculate_matrix_exp(-step, d)\n", - " @ self.h.exp(step)\n", - " @ self.backend.calculate_matrix_exp(step, d)\n", - " )\n", - " V_dbi = wrapper_gc(dbi, np.sqrt(t_step), d_0.dense.matrix)\n", + "\n", + " V_dbi = dbi.eval_dbr_unitary(t_step, d_0.dense.matrix)\n", " \n", " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", @@ -152,7 +146,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "79452419", + "id": "b50b89c2", "metadata": {}, "outputs": [ { @@ -244,7 +238,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c5c30773", + "id": "57c1f441", "metadata": {}, "outputs": [], "source": [ @@ -256,7 +250,7 @@ }, { "cell_type": "markdown", - "id": "85ffae5d", + "id": "aed34a7e", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", @@ -279,7 +273,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3fd8d6ce", + "id": "983b1b58", "metadata": {}, "outputs": [], "source": [ @@ -327,7 +321,7 @@ }, { "cell_type": "markdown", - "id": "d8e8f049", + "id": "d5bbb9ae", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and gci are numerically exact\n", @@ -336,7 +330,7 @@ }, { "cell_type": "markdown", - "id": "fe1b99df", + "id": "0d32d9f0", "metadata": {}, "source": [ "# Show that double bracket iteration and gci gc and gc_reduced converge for small s BHMM\n", @@ -347,7 +341,7 @@ { "cell_type": "code", "execution_count": null, - "id": "95e327da", + "id": "0bd1fc52", "metadata": {}, "outputs": [], "source": [] From 39eff87bd8fd247627ecc299f8d215eebd416a35 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 08:17:50 +0200 Subject: [PATCH 071/116] cleared example files --- ...volution_oracles_and_gci_transpiling.ipynb | 26 +- ...rrect number of Trotter-Suzuki steps.ipynb | 355 -------- ...h evolution oracles vs existing dbi .ipynb | 860 ------------------ 3 files changed, 19 insertions(+), 1222 deletions(-) rename src/qibo/models/dbi/Tests evolution oracles and gci.ipynb => examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb (99%) delete mode 100644 src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb delete mode 100644 src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb diff --git a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb similarity index 99% rename from src/qibo/models/dbi/Tests evolution oracles and gci.ipynb rename to examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 0f1035e26f..e2e3fc0b56 100644 --- a/src/qibo/models/dbi/Tests evolution oracles and gci.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -8,6 +8,18 @@ "## This compares to DoubleBracketIteration whenever possible" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "380ed537", + "metadata": {}, + "outputs": [], + "source": [ + "import inspect\n", + "import ../\n", + "inspect.getsourcelines(qibo.symbols.Z) " + ] + }, { "cell_type": "code", "execution_count": 1, @@ -146,7 +158,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "b50b89c2", + "id": "75fa98fc", "metadata": {}, "outputs": [ { @@ -238,7 +250,7 @@ { "cell_type": "code", "execution_count": null, - "id": "57c1f441", + "id": "2030892e", "metadata": {}, "outputs": [], "source": [ @@ -250,7 +262,7 @@ }, { "cell_type": "markdown", - "id": "aed34a7e", + "id": "7f4d7a01", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", @@ -273,7 +285,7 @@ { "cell_type": "code", "execution_count": null, - "id": "983b1b58", + "id": "0f86c490", "metadata": {}, "outputs": [], "source": [ @@ -321,7 +333,7 @@ }, { "cell_type": "markdown", - "id": "d5bbb9ae", + "id": "8db582f1", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and gci are numerically exact\n", @@ -330,7 +342,7 @@ }, { "cell_type": "markdown", - "id": "0d32d9f0", + "id": "5381e44f", "metadata": {}, "source": [ "# Show that double bracket iteration and gci gc and gc_reduced converge for small s BHMM\n", @@ -341,7 +353,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0bd1fc52", + "id": "2e97f0c6", "metadata": {}, "outputs": [], "source": [] diff --git a/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb b/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb deleted file mode 100644 index f60fca73dc..0000000000 --- a/src/qibo/models/dbi/Test evolution oracles and selecting correct number of Trotter-Suzuki steps.ipynb +++ /dev/null @@ -1,355 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "c4be28eb", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-02-08 04:16:31]: Using qibojit (numba) backend on /CPU:0\n", - "[Qibo 0.2.5|WARNING|2024-02-08 04:16:31]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ZX0.1\n", - "3 0.5264075362294286\n", - "6 0.12267264894892986\n", - "12 0.03018952498939946\n", - "\n", - "q0: ───U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U ...\n", - "q1: ─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U─U ...\n", - "q2: ─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U─────U─U──── ...\n", - "\n", - "q0: ... ─────U─U─────U─U─────U─U───\n", - "q1: ... ─U─U─U─U─U─U─U─U─U─U─U─U─U─\n", - "q2: ... ─U─U─────U─U─────U─U─────U─\n", - "3.651778047740365\n", - "3.651778047740365\n" - ] - } - ], - "source": [ - "run -i 'test_dbi_evolution_oracles.py'" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "4ed280d7", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-08 04:26:52]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ZX0.1\n", - "3 0.43947054352187015\n", - "6 0.10267893936993515\n", - "12 0.025341696660493532\n", - "0.02534169666049345\n" - ] - } - ], - "source": [ - "from qibo.hamiltonians import SymbolicHamiltonian\n", - "from qibo import symbols\n", - "from double_bracket_evolution_oracles import *\n", - "from group_commutator_iteration_transpiler import *\n", - "\n", - "\"\"\"Test create evolution oracle\"\"\"\n", - "\n", - "h_input = SymbolicHamiltonian( symbols.Z(0)+symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - "\n", - "## Test initialization of evolution oracles\n", - "#By default EvolutionOracle initializes with text_strings oracle type\n", - "input_hamiltonian_evolution_oracle_text_strings = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.text_strings)\n", - "\n", - "c1 = input_hamiltonian_evolution_oracle_text_strings.circuit(0.1)\n", - "if input_hamiltonian_evolution_oracle_text_strings.mode_evolution_oracle is EvolutionOracleType.text_strings:\n", - " assert isinstance( c1, str), \"Should be a string here\"\n", - "print( c1 )\n", - "\n", - "# Initialize with EvolutionOracleType hamiltonian_simulation\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = True\n", - "c2 = input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2)\n", - "assert np.linalg.norm( c2.unitary() - input_hamiltonian_evolution_oracle_hamiltonian_simulation.h.exp(2) ) < 1\n", - "\n", - "##For some reason running this makes the norm check below blow up to large value\n", - "# if input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:\n", - "# print(type(c2))\n", - "# assert isinstance( c2, type(h_input.circuit(0.1)) ), \"Should be a qibo.Circuit here\"\n", - "# print(c2.draw())\n", - "\n", - "\n", - "# Initialize with EvolutionOracleType numerical\n", - "input_hamiltonian_evolution_oracle_numerical = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical )\n", - "\n", - "c3 = input_hamiltonian_evolution_oracle_numerical.circuit(2)\n", - "if input_hamiltonian_evolution_oracle_numerical.mode_evolution_oracle is EvolutionOracleType.numerical:\n", - " assert isinstance( c3, type(h_input.exp(0.1)) ), \"Should be a np.array here\"\n", - "print(np.linalg.norm( c2.unitary() - c3 ))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "id": "8a03c568", - "metadata": {}, - "outputs": [], - "source": [ - "from double_bracket import *\n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.group_commutator" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "id": "e31a8298", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "32.0" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dbi.off_diagonal_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "id": "fe1e3816", - "metadata": {}, - "outputs": [], - "source": [ - "d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2)+symbols.Z(0), nqubits = 3 )" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "61699387", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-08 04:32:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "ename": "TypeError", - "evalue": "Hamiltonian.exp() missing 1 required positional argument: 'a'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/test_dbi_evolution_oracles.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.51\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moff_diagonal_norm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/double_bracket.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 79\u001b[0m operator = (\n\u001b[1;32m 80\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 82\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_matrix_exp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibo/backends/numpy.py\u001b[0m in \u001b[0;36mcalculate_matrix_exp\u001b[0;34m(self, a, matrix, eigenvectors, eigenvalues)\u001b[0m\n\u001b[1;32m 737\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 739\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mexpm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 740\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 741\u001b[0m \u001b[0mexpd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiag\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1j\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0meigenvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/scipy/linalg/_matfuncs.py\u001b[0m in \u001b[0;36mexpm\u001b[0;34m(A)\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 283\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: Hamiltonian.exp() missing 1 required positional argument: 'a'" - ] - } - ], - "source": [ - "dbi(0.51, d = d_0.dense)\n", - "dbi.off_diagonal_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "d648a983", - "metadata": {}, - "outputs": [], - "source": [ - "## Test more fancy functionalities\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", - "\n", - "\n", - "query_list = gci.group_commutator_query_list( 0.2, d_0, input_hamiltonian_evolution_oracle_hamiltonian_simulation )\n", - "gci(0.51, d_0)\n", - "u_dagger = gci.iterated_hamiltonian_evolution_oracle.before_circuit.unitary()\n", - "\n", - "dbi_from_gci = u_dagger @ h_input.matrix @ u_dagger.T.conj()" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "84427469", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[ 0.37873495-7.23646444e-17j, -0.61455831+6.61914883e-01j,\n", - " 1.65379471-4.82329292e-01j, -1.96431484+8.48346097e-01j,\n", - " -0.66648988-6.34914954e-01j, 0.72872705+1.92520016e-01j,\n", - " 0.46450583-3.48735459e-01j, -0.34937171+7.29602858e-01j],\n", - " [-0.61455831-6.61914883e-01j, 1.3880865 +1.65819142e-16j,\n", - " 1.7100767 -2.63880526e-01j, 1.22172438-4.00032815e-01j,\n", - " -1.71509717-2.99995268e-01j, 0.06517562-7.21879491e-02j,\n", - " 0.05236784-8.00791699e-01j, 0.37782571+6.27793798e-02j],\n", - " [ 1.65379471+4.82329292e-01j, 1.7100767 +2.63880526e-01j,\n", - " 0.9379625 -9.61058031e-17j, -0.31832345+1.01913826e+00j,\n", - " 0.50572804-3.07643806e-01j, -0.60181522-3.91004322e-02j,\n", - " 0.33658616+6.18667086e-01j, -0.44629897+6.13539951e-02j],\n", - " [-1.96431484-8.48346097e-01j, 1.22172438+4.00032815e-01j,\n", - " -0.31832345-1.01913826e+00j, 3.00438693-1.10863074e-16j,\n", - " -0.45113968-1.38908374e+00j, 0.32741828+2.43527104e-02j,\n", - " 0.67878057+8.08157792e-01j, 0.9625186 -2.19948229e-01j],\n", - " [-0.66648988+6.34914954e-01j, -1.71509717+2.99995268e-01j,\n", - " 0.50572804+3.07643806e-01j, -0.45113968+1.38908374e+00j,\n", - " -1.8665001 -8.51001034e-17j, -0.22381594+7.50684558e-01j,\n", - " -1.63817676-3.86048532e-01j, -1.70605432-4.35426293e-01j],\n", - " [ 0.72872705-1.92520016e-01j, 0.06517562+7.21879491e-02j,\n", - " -0.60181522+3.91004322e-02j, 0.32741828-2.43527104e-02j,\n", - " -0.22381594-7.50684558e-01j, 0.05587245-2.20303099e-17j,\n", - " 1.90215343+7.12211017e-01j, -1.21518609-4.71886551e-01j],\n", - " [ 0.46450583+3.48735459e-01j, 0.05236784+8.00791699e-01j,\n", - " 0.33658616-6.18667086e-01j, 0.67878057-8.08157792e-01j,\n", - " -1.63817676+3.86048532e-01j, 1.90215343-7.12211017e-01j,\n", - " -2.46589296+6.93276168e-17j, -0.39503053+4.25721571e-01j],\n", - " [-0.34937171-7.29602858e-01j, 0.37782571-6.27793798e-02j,\n", - " -0.44629897-6.13539951e-02j, 0.9625186 +2.19948229e-01j,\n", - " -1.70605432+4.35426293e-01j, -1.21518609+4.71886551e-01j,\n", - " -0.39503053-4.25721571e-01j, -1.43265026+2.31760624e-17j]])" - ] - }, - "execution_count": 59, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dbi_from_gci - dbi.h.matrix" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "776341ed", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-08 04:27:03]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "data": { - "text/plain": [ - "3.626108312062859" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dbi(0.2, d = d_0.dense)\n", - "np.linalg.norm(dbi.h.matrix - h_input.dense.matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "90a8b161", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ─U─────U───U─U─────U─U─────U─U───U─────U───U─U─────U─U─────U─U───\n", - "q1: ─U─────U─U─U─U─U─U─U─U─U─U─U─U─U─U─────U─U─U─U─U─U─U─U─U─U─U─U─U─\n", - "q2: ───U─U───U─────U─U─────U─U─────U───U─U───U─────U─U─────U─U─────U─\n", - "q0: ───U─U─────U─U─────U─U───U─────U───U─U─────U─U─────U─U───U─────U─\n", - "q1: ─U─U─U─U─U─U─U─U─U─U─U─U─U─────U─U─U─U─U─U─U─U─U─U─U─U─U─U─────U─\n", - "q2: ─U─────U─U─────U─U─────U───U─U───U─────U─U─────U─U─────U───U─U───\n", - "9.519346834291838\n", - "4.144980851654998\n" - ] - } - ], - "source": [ - "from functools import reduce\n", - "before_circuit = reduce(Circuit.__add__, query_list['backwards'])\n", - "after_circuit = reduce(Circuit.__add__, query_list['forwards'])\n", - "print( before_circuit.draw() )\n", - "print( after_circuit.draw() )\n", - "\n", - "u_before = before_circuit.unitary()\n", - "u_after = after_circuit.unitary()\n", - "\n", - "print( np.linalg.norm( u_before @ input_hamiltonian_evolution_oracle_hamiltonian_simulation.h.matrix@ u_after -gci.h.matrix ))\n", - "frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( \n", - " input_hamiltonian_evolution_oracle_hamiltonian_simulation, 'Step 1', before_circuit, after_circuit)\n", - "\n", - "print( np.linalg.norm( gci.h.exp(0.3) - frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3).unitary()))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "024e0a4a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb b/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb deleted file mode 100644 index 10f3e44093..0000000000 --- a/src/qibo/models/dbi/Test gci with evolution oracles vs existing dbi .ipynb +++ /dev/null @@ -1,860 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "238be0ba", - "metadata": {}, - "source": [ - "## This compares to DoubleBracketIteration whenever possible" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "4ed280d7", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-02-28 09:05:06]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], - "source": [ - "from qibo.hamiltonians import SymbolicHamiltonian\n", - "from qibo import symbols\n", - "from double_bracket_evolution_oracles import *\n", - "from group_commutator_iteration_transpiler import *\n", - "from numpy.linalg import norm\n", - "\"\"\"Test create evolution oracle\"\"\"\n", - "\n", - "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - "# Initialize with EvolutionOracleType hamiltonian_simulation so that d_0 is Delta\n", - "h_input = h_x + d_0\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "adb26c5e", - "metadata": {}, - "outputs": [], - "source": [ - "t_step = 0.0051#0.98#dbi.hyperopt_step()" - ] - }, - { - "cell_type": "markdown", - "id": "1fda11ae", - "metadata": {}, - "source": [ - "#### 1. DoubleBracketIteration and group commutator" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8a03c568", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 09:05:06]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], - "source": [ - "from double_bracket import *\n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.group_commutator" - ] - }, - { - "cell_type": "markdown", - "id": "9b120dcf", - "metadata": {}, - "source": [ - "DoubleBracketIteration only rotates the hamiltonian h, and currently doesn't give access to the unitary" - ] - }, - { - "cell_type": "markdown", - "id": "fe8d0ee3", - "metadata": {}, - "source": [ - "Instead, we can wrap around the code executed in __call__" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "2b85bdfa", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-28 09:05:06]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], - "source": [ - "def wrapper_gc(self,step, d):\n", - " return (\n", - " self.h.exp(-step)\n", - " @ self.backend.calculate_matrix_exp(-step, d)\n", - " @ self.h.exp(step)\n", - " @ self.backend.calculate_matrix_exp(step, d)\n", - " )\n", - "unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),d_0.dense.matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "61699387", - "metadata": {}, - "outputs": [], - "source": [ - "dbi(t_step, d = d_0.dense.matrix)\n" - ] - }, - { - "cell_type": "markdown", - "id": "b3b2d4bd", - "metadata": {}, - "source": [ - "#### 2. Evolution oracle hamiltonian simulation\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "c9a9b4ef", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "76844c6d", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "edc1fc41", - "metadata": {}, - "outputs": [], - "source": [ - "assert evolution_oracle_diagonal_target.mode_evolution_oracle.value is gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle.value\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "72bdc7a7", - "metadata": {}, - "outputs": [], - "source": [ - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "4dc00e21", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.007068588046085704" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(unitary_gc_from_oracles['forwards'].unitary() - unitary_gc_existing)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "46c4b173", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.05706730540522153" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(unitary_gc_from_oracles['backwards'].unitary() - unitary_gc_existing)" - ] - }, - { - "cell_type": "markdown", - "id": "e6bc1b3d", - "metadata": {}, - "source": [ - "We may improve the discrepancy by setting smaller eps" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "c65c042b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185439878e-05\n", - "6 1.425710829003397e-05\n", - "12 3.5641435459211722e-06\n", - "24 8.910275418042565e-07\n", - "48 2.2275636394665562e-07\n", - "96 5.568905837658941e-08\n", - "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185442657e-05\n", - "6 1.4257108290027298e-05\n", - "12 3.5641435458984836e-06\n", - "24 8.910275417724017e-07\n", - "48 2.2275636393673975e-07\n", - "96 5.568905839345736e-08\n", - "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185439878e-05\n", - "6 1.425710829003397e-05\n", - "12 3.5641435459211722e-06\n", - "24 8.910275418042565e-07\n", - "48 2.2275636394665562e-07\n", - "96 5.568905837658941e-08\n", - "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185442657e-05\n", - "6 1.4257108290027298e-05\n", - "12 3.5641435458984836e-06\n", - "24 8.910275417724017e-07\n", - "48 2.2275636393673975e-07\n", - "96 5.568905839345736e-08\n" - ] - }, - { - "data": { - "text/plain": [ - "0.00706869515351788" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = 0.0000001\n", - "evolution_oracle_diagonal_target.eps_trottersuzuki = 0.00000001\n", - "gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = True\n", - "evolution_oracle_diagonal_target.please_be_verbose = False\n", - "\n", - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - "norm(unitary_gc_from_oracles['forwards'].unitary() - unitary_gc_existing)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "067d7288", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185439878e-05\n", - "6 1.425710829003397e-05\n", - "12 3.5641435459211722e-06\n", - "24 8.910275418042565e-07\n", - "48 2.2275636394665562e-07\n", - "96 5.568905837658941e-08\n", - "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185442657e-05\n", - "6 1.4257108290027298e-05\n", - "12 3.5641435458984836e-06\n", - "24 8.910275417724017e-07\n", - "48 2.2275636393673975e-07\n", - "96 5.568905839345736e-08\n", - "Calling circuit in Hamiltonian simulation mode for time t=-0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185439878e-05\n", - "6 1.425710829003397e-05\n", - "12 3.5641435459211722e-06\n", - "24 8.910275418042565e-07\n", - "48 2.2275636394665562e-07\n", - "96 5.568905837658941e-08\n", - "Calling circuit in Hamiltonian simulation mode for time t=0.07141428428542851 and next running discretization adjustment to reach precision eps = 1e-07\n", - "3 5.703698185442657e-05\n", - "6 1.4257108290027298e-05\n", - "12 3.5641435458984836e-06\n", - "24 8.910275417724017e-07\n", - "48 2.2275636393673975e-07\n", - "96 5.568905839345736e-08\n" - ] - }, - { - "data": { - "text/plain": [ - "0.009965571871141131" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - "norm(unitary_gc_from_oracles['backwards'].unitary() - unitary_gc_existing)" - ] - }, - { - "cell_type": "markdown", - "id": "fe089127", - "metadata": {}, - "source": [ - "#### 3. Evolution oracle numpy\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "5d92342a", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_numerical = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_numerical ))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "c7dfce82", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.numerical)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1c7abdf1", - "metadata": {}, - "outputs": [], - "source": [ - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" - ] - }, - { - "cell_type": "markdown", - "id": "994704b9", - "metadata": {}, - "source": [ - "Compared to the group commutator using Hamiltonian simulation there will be small deviations that arise from Trotter-Suzuki decomposition" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "7a289f6b", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0040927048339044324" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(unitary_gc_from_oracles['backwards'] - unitary_gc_existing)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "b51b35e0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.057357576681930346" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" - ] - }, - { - "cell_type": "markdown", - "id": "254a2d48", - "metadata": {}, - "source": [ - "We may check by switching the group commutator flag that the difference comes from ordering and inversions" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "c95fe6a2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", - "\n", - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" - ] - }, - { - "cell_type": "markdown", - "id": "32ae7052", - "metadata": {}, - "source": [ - "#### 4. Check gci rotation" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "11b5bcd2", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "cc65f36b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "qibo.models.dbi.double_bracket_evolution_oracles.EvolutionOracle" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(gci.iterated_hamiltonian_evolution_oracle)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "ed9fc128", - "metadata": {}, - "outputs": [], - "source": [ - "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "d096b97f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "qibo.models.dbi.double_bracket_evolution_oracles.FrameShiftedEvolutionOracle" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(gci.iterated_hamiltonian_evolution_oracle)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "24d7c169", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "2977472f", - "metadata": {}, - "outputs": [], - "source": [ - "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "ee01d03d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2.599372836877071e-06" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( dbi.h.exp(t_step) - u_frame_shifted)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "eb70162a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "a3a57fbe", - "metadata": {}, - "outputs": [], - "source": [ - "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "1dba0755", - "metadata": {}, - "outputs": [], - "source": [ - "dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "a22a77e0", - "metadata": {}, - "outputs": [], - "source": [ - "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "6d8b5fe7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2.6001822532601247e-06" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( dbi.h.exp(t_step) - u_frame_shifted)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "56b3e69c", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "a1e61678", - "metadata": {}, - "outputs": [ - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_207231/3626348486.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mu_frame_shifted\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, step_duration, diagonal_association, mode_double_bracket_rotation)\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[0;31m# This will run the appropriate group commutator step\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 130\u001b[0;31m double_bracket_rotation_step = self.group_commutator(\n\u001b[0m\u001b[1;32m 131\u001b[0m \u001b[0mstep_duration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiagonal_association\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 132\u001b[0m )\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36mgroup_commutator\u001b[0;34m(self, s_step, diagonal_association_evolution_oracle, iterated_hamiltonian_evolution_oracle)\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 163\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 165\u001b[0m if (diagonal_association_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings or\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], - "source": [ - "for k in range(3):\n", - " gci(t_step, diagonal_association=evolution_oracle_diagonal_target)\n", - " dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)\n", - " norm( dbi.h.exp(t_step) - u_frame_shifted)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4ca65c6d", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c20a4c48", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9d722192", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "389d7bbe", - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "matmul: Input operand 0 does not have enough dimensions (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_207231/916023419.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m gc_numpy = gci.group_commutator( np.sqrt(t_step),\n\u001b[0m\u001b[1;32m 3\u001b[0m diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/src/qibo/models/dbi/group_commutator_iteration_transpiler.py\u001b[0m in \u001b[0;36mgroup_commutator\u001b[0;34m(self, s_step, diagonal_association_evolution_oracle, iterated_hamiltonian_evolution_oracle)\u001b[0m\n\u001b[1;32m 178\u001b[0m ) }\n\u001b[1;32m 179\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m return {'forwards': ( iterated_hamiltonian_evolution_oracle.circuit(-s_step)@\n\u001b[0m\u001b[1;32m 181\u001b[0m \u001b[0mdiagonal_association_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m@\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m@\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibo/models/dbi/double_bracket_evolution_oracles.py\u001b[0m in \u001b[0;36mcircuit\u001b[0;34m(self, t_duration)\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"(\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_duration\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\")\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbefore_circuit\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_duration\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mafter_circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 120\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhamiltonian_simulation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbefore_circuit\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbase_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_duration\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mafter_circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: matmul: Input operand 0 does not have enough dimensions (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)" - ] - } - ], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - "gc_numpy = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d4f78e3a", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e4d23962", - "metadata": {}, - "outputs": [], - "source": [ - "## Test more fancy functionalities\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", - "d_ev = EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "\n", - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - "query_list = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle= d_ev )\n", - "\n", - "norm(query_list['forwards'].unitary() -query_list['backwards'].unitary().conj().T)\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2e69dc0b", - "metadata": {}, - "outputs": [], - "source": [ - "norm(query_list['forwards'] -query_list['backwards'].T.conj())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bfee7994", - "metadata": {}, - "outputs": [], - "source": [ - "#Test file entry\n", - "u = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", - "u2 = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", - "norm(u-u2.T.conj())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "527bb789", - "metadata": {}, - "outputs": [], - "source": [ - "d_0.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - "query_list = gci.group_commutator( np.sqrt(t_step*2),\n", - " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\"))\n", - "\n", - "\n", - "query_list['forwards']" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 4d079ba79e3e7b9dc2946fbf534e63a6a7177d1f Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 08:31:51 +0200 Subject: [PATCH 072/116] example notebook now gets test code and runs the test to show the example - hype :) --- ...volution_oracles_and_gci_transpiling.ipynb | 98 +++---------------- tests/test_models_dbi.py | 26 ++++- 2 files changed, 37 insertions(+), 87 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index e2e3fc0b56..8c4b3edd85 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -10,56 +10,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "380ed537", "metadata": {}, - "outputs": [], - "source": [ - "import inspect\n", - "import ../\n", - "inspect.getsourcelines(qibo.symbols.Z) " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "85d61fc0", - "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-04-05 04:49:29]: Using qibojit (numba) backend on /CPU:0\n", - "[Qibo 0.2.5|WARNING|2024-04-05 04:49:29]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.5|INFO|2024-04-05 08:30:50]: Using qibojit (numba) backend on /CPU:0\n", + "[Qibo 0.2.5|WARNING|2024-04-05 08:30:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], "source": [ - "from qibo.hamiltonians import SymbolicHamiltonian\n", - "from qibo import symbols\n", - "from double_bracket_evolution_oracles import *\n", - "from group_commutator_iteration_transpiler import *\n", - "from numpy.linalg import norm\n", - "def test_dbi_evolution_oracle(t_step, eps):\n", - "\n", - " \n", - " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - " h_input = h_x + d_0\n", - " \n", + "import inspect\n", + "import sys\n", + "sys.path.append(\"../../tests\")\n", + "from test_models_dbi import *\n", "\n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - " \n", - " evolution_oracle.eps_trottersuzuki = eps\n", - " \n", - " U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary()\n", - " V_target = h_input.exp(t_step)\n", - " \n", - " assert norm(U_hamiltonian_simulation-V_target) < eps\n", - " \n", + "from qibo.hamiltonians import SymbolicHamiltonian\n", + "inspect.getsourcelines(test_dbi_evolution_oracle) \n", "test_dbi_evolution_oracle( 1, 1e-3) " ] }, @@ -73,34 +44,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "8a03c568", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mtest_group_commutator_dbi_vs_gci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36mtest_group_commutator_dbi_vs_gci\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0munitary_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'backwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mV_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "from double_bracket import *\n", - "\n", "def test_group_commutator_dbi_vs_gci_numerical(t_step, eps):\n", "\n", " \n", @@ -157,31 +106,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "75fa98fc", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-04-05 04:50:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mtest_group_commutator_dbi_vs_gci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/tmp/ipykernel_65292/1926919443.py\u001b[0m in \u001b[0;36mtest_group_commutator_dbi_vs_gci\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0munitary_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'backwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mU_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mV_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_evolution_oracle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvolutionOracleType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumerical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "from double_bracket import *\n", "\n", diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index cf69c73fb1..3c914158fa 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -11,6 +11,8 @@ DoubleBracketScheduling, ) from qibo.quantum_info import random_hermitian +from qibo.models.dbi.double_bracket_evolution_oracles import EvolutionOracle +from qibo.models.dbi.group_commutator_iteration_transpiler import * NSTEPS = 1 seed = 10 @@ -63,6 +65,27 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): assert np.linalg.norm( u - v ) < 10 * s * np.linalg.norm(h0) * np.linalg.norm(d) + +from qibo import symbols +from numpy.linalg import norm +@pytest.mark.parametrize("nqubits", [3]) +def test_dbi_evolution_oracle(t_step, eps): + h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + + symbols.Y(1) * symbols.Y(2), nqubits = 3 ) + d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 ) + h_input = h_x + d_0 + + evolution_oracle = EvolutionOracle(h_input, "ZX", + mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) + + evolution_oracle.eps_trottersuzuki = eps + + U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary() + V_target = h_input.exp(t_step) + + assert norm(U_hamiltonian_simulation-V_target) < eps + + @pytest.mark.parametrize("nqubits", [1, 2]) def test_double_bracket_iteration_single_commutator(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) @@ -75,7 +98,6 @@ def test_double_bracket_iteration_single_commutator(backend, nqubits): # test first iteration with default d dbi(mode=DoubleBracketGeneratorType.single_commutator, step=0.01) - for _ in range(NSTEPS): dbi(step=0.01, d=d) @@ -133,7 +155,7 @@ def test_energy_fluctuations(backend): [ DoubleBracketScheduling.grid_search, DoubleBracketScheduling.hyperopt, - DoubleBracketScheduling.simulated_annealing, + # DoubleBracketScheduling.simulated_annealing, ], ) @pytest.mark.parametrize("nqubits", [3, 4, 5]) From c0a89cff32b6d024c9ac5a1fddda780c2ddb5dd4 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 08:50:54 +0200 Subject: [PATCH 073/116] removing unnecessary file --- .../models/dbi/test_dbi_evolution_oracles.py | 105 ------------------ 1 file changed, 105 deletions(-) delete mode 100644 src/qibo/models/dbi/test_dbi_evolution_oracles.py diff --git a/src/qibo/models/dbi/test_dbi_evolution_oracles.py b/src/qibo/models/dbi/test_dbi_evolution_oracles.py deleted file mode 100644 index 86b3cd52b9..0000000000 --- a/src/qibo/models/dbi/test_dbi_evolution_oracles.py +++ /dev/null @@ -1,105 +0,0 @@ -from double_bracket_evolution_oracles import * -from group_commutator_iteration_transpiler import * - -from qibo import symbols -from qibo.hamiltonians import SymbolicHamiltonian - - -def test_evolution_oracle_gci_classes(): - return 0 - - -"""Test create evolution oracle""" - -h_input = SymbolicHamiltonian( - symbols.X(0) - + symbols.Z(0) * symbols.X(1) - + symbols.Y(2) - + symbols.Y(1) * symbols.Y(2), - nqubits=3, -) - -## Test initialization of evolution oracles -# By default EvolutionOracle initializes with text_strings oracle type -input_hamiltonian_evolution_oracle_text_strings = EvolutionOracle( - h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.text_strings -) - -c1 = input_hamiltonian_evolution_oracle_text_strings.circuit(0.1) -if ( - input_hamiltonian_evolution_oracle_text_strings.mode_evolution_oracle - is EvolutionOracleType.text_strings -): - assert isinstance(c1, str), "Should be a string here" -print(c1) - -# Initialize with EvolutionOracleType hamiltonian_simulation -input_hamiltonian_evolution_oracle_hamiltonian_simulation = EvolutionOracle( - h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation -) -input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = True -c2 = input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2) -if ( - input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle - is EvolutionOracleType.hamiltonian_simulation -): - print(type(c2)) - assert isinstance(c2, type(h_input.circuit(0.1))), "Should be a qibo.Circuit here" -print(c2.draw()) - -# Initialize with EvolutionOracleType numerical -input_hamiltonian_evolution_oracle_numerical = EvolutionOracle( - h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.numerical -) - -c3 = input_hamiltonian_evolution_oracle_numerical.circuit(2) -if ( - input_hamiltonian_evolution_oracle_numerical.mode_evolution_oracle - is EvolutionOracleType.numerical -): - assert isinstance(c3, type(h_input.exp(0.1))), "Should be a np.array here" -print(np.linalg.norm(c2.unitary() - c3)) -U2 = c2.unitary() -input_hamiltonian_evolution_oracle_hamiltonian_simulation.mode_evolution_oracle = ( - EvolutionOracleType.numerical -) -print( - np.linalg.norm( - U2 - input_hamiltonian_evolution_oracle_hamiltonian_simulation.circuit(2) - ) -) - -if 0: - - ## Test more fancy functionalities - - gci = GroupCommutatorIterationWithEvolutionOracles( - input_hamiltonian_evolution_oracle_hamiltonian_simulation - ) - d_0 = SymbolicHamiltonian(symbols.Z(0) * symbols.Z(1) + symbols.Z(2), nqubits=3) - - query_list = gci.group_commutator_query_list( - 0.2, d_0, input_hamiltonian_evolution_oracle_hamiltonian_simulation - ) - gci(0.2, d_0) - - from functools import reduce - - before_circuit = reduce(Circuit.__add__, query_list["backwards"]) - after_circuit = reduce(Circuit.__add__, query_list["forwards"]) - print(before_circuit.draw()) - print(after_circuit.draw()) - - frame_shifted_input_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - input_hamiltonian_evolution_oracle_hamiltonian_simulation, - "Step 1", - before_circuit, - after_circuit, - ) - - print( - np.linalg.norm( - gci.h.exp(0.3) - - frame_shifted_input_hamiltonian_evolution_oracle.circuit(0.3).unitary() - ) - ) From 61a83db91422f047e2dcd6a084bea2b51c7d4026 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 09:02:37 +0200 Subject: [PATCH 074/116] adding an import line --- ...volution_oracles_and_gci_transpiling.ipynb | 115 ++++++++++++++++-- tests/test_models_dbi.py | 2 + 2 files changed, 106 insertions(+), 11 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 8c4b3edd85..5cee9c0aba 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -10,27 +10,120 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "380ed537", + "execution_count": 12, + "id": "597b15f0", + "metadata": {}, + "outputs": [], + "source": [ + "import inspect\n", + "import sys\n", + "sys.path.append(\"../../tests\")\n", + "from test_models_dbi import *\n", + "def print_function_source_code( func ):\n", + " out = inspect.getsourcelines(func) \n", + " from functools import reduce\n", + " print(reduce(str.__add__, out[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b62a7d85", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "[Qibo 0.2.5|INFO|2024-04-05 08:30:50]: Using qibojit (numba) backend on /CPU:0\n", - "[Qibo 0.2.5|WARNING|2024-04-05 08:30:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "@pytest.mark.parametrize(\"nqubits\", [3])\n", + "def test_dbi_evolution_oracle(t_step, eps): \n", + " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + " h_input = h_x + d_0 \n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + " \n", + " evolution_oracle.eps_trottersuzuki = eps\n", + " \n", + " U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary()\n", + " V_target = h_input.exp(t_step)\n", + " \n", + " assert norm(U_hamiltonian_simulation-V_target) < eps\n", + "\n" ] } ], "source": [ - "import inspect\n", - "import sys\n", - "sys.path.append(\"../../tests\")\n", - "from test_models_dbi import *\n", + "print_function_source_code(test_dbi_evolution_oracle)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "edb6b734", + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "import * only allowed at module level (1007073018.py, line 3)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_8278/1007073018.py\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m from qibo.symbols import *\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m import * only allowed at module level\n" + ] + } + ], + "source": [ + "def test_dbi_evolution_oracle(t_step, eps): \n", + " from qibo.hamiltonians import SymbolicHamiltonian\n", + " from qibo.symbols \n", + " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + " h_input = h_x + d_0 \n", "\n", - "from qibo.hamiltonians import SymbolicHamiltonian\n", - "inspect.getsourcelines(test_dbi_evolution_oracle) \n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + " \n", + " evolution_oracle.eps_trottersuzuki = eps\n", + " \n", + " U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary()\n", + " V_target = h_input.exp(t_step)\n", + " \n", + " assert norm(U_hamiltonian_simulation-V_target) < eps" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "380ed537", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "ename": "SystemError", + "evalue": "initialization of _internal failed without raising an exception", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mSystemError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_8278/1431874961.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_dbi_evolution_oracle\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_8278/2759485688.py\u001b[0m in \u001b[0;36mtest_dbi_evolution_oracle\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_dbi_evolution_oracle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n\u001b[0m\u001b[1;32m 3\u001b[0m + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n\u001b[1;32m 4\u001b[0m \u001b[0md_0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSymbolicHamiltonian\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnqubits\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mh_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mh_x\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/hamiltonians/hamiltonians.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, form, nqubits, symbol_map, backend)\u001b[0m\n\u001b[1;32m 359\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mqibo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackends\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m_check_backend\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 360\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 361\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_check_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 362\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 363\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mform\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/backends/__init__.py\u001b[0m in \u001b[0;36m_check_backend\u001b[0;34m(backend)\u001b[0m\n\u001b[1;32m 198\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_check_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 199\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbackend\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 200\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mGlobalBackend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 201\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/backends/__init__.py\u001b[0m in \u001b[0;36m__new__\u001b[0;34m(cls)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_default_order\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_instance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconstruct_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mModuleNotFoundError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mImportError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/backends/__init__.py\u001b[0m in \u001b[0;36mconstruct_backend\u001b[0;34m(backend, **kwargs)\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mCuQuantumBackend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mplatform\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"numba\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mNumbaBackend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 23\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pragma: no cover\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibojit/backends/cpu.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpsutil\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m__version__\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnumba_version\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mqibojit\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m__version__\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mqibojit_version\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/numba/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;31m# Re-export vectorize decorators and the thread layer querying function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 42\u001b[0;31m from numba.np.ufunc import (vectorize, guvectorize, threading_layer,\n\u001b[0m\u001b[1;32m 43\u001b[0m \u001b[0mget_num_threads\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset_num_threads\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0mset_parallel_chunksize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mget_parallel_chunksize\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/numba/np/ufunc/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# -*- coding: utf-8 -*-\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecorators\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mVectorize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGUVectorize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvectorize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mguvectorize\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_internal\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mPyUFunc_None\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPyUFunc_Zero\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPyUFunc_One\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m_internal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marray_exprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/numba/np/ufunc/decorators.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0minspect\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m_internal\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparallel\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mParallelUFuncBuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mParallelGUFuncBuilder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mSystemError\u001b[0m: initialization of _internal failed without raising an exception" + ] + } + ], + "source": [ "test_dbi_evolution_oracle( 1, 1e-3) " ] }, diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 3c914158fa..6d00d29f8e 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -70,6 +70,8 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): from numpy.linalg import norm @pytest.mark.parametrize("nqubits", [3]) def test_dbi_evolution_oracle(t_step, eps): + from qibo.hamiltonians import SymbolicHamiltonian + from qibo import symbols h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 ) d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 ) From 972e5ad1490e173d1aa51861cff019ccbf7f7a6f Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 09:14:15 +0200 Subject: [PATCH 075/116] reshuffle test file --- ...volution_oracles_and_gci_transpiling.ipynb | 68 ++++++++----------- tests/test_models_dbi.py | 3 +- 2 files changed, 31 insertions(+), 40 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 5cee9c0aba..b306551982 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -10,8 +10,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "597b15f0", + "execution_count": 1, + "id": "765f8da6", "metadata": {}, "outputs": [], "source": [ @@ -27,8 +27,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "b62a7d85", + "execution_count": 2, + "id": "cdf50e7c", "metadata": {}, "outputs": [ { @@ -37,6 +37,8 @@ "text": [ "@pytest.mark.parametrize(\"nqubits\", [3])\n", "def test_dbi_evolution_oracle(t_step, eps): \n", + " from qibo.hamiltonians import SymbolicHamiltonian\n", + " from qibo import symbols\n", " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", @@ -61,23 +63,34 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "edb6b734", + "execution_count": 7, + "id": "8688a26d", "metadata": {}, "outputs": [ { - "ename": "SyntaxError", - "evalue": "import * only allowed at module level (1007073018.py, line 3)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_8278/1007073018.py\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m from qibo.symbols import *\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m import * only allowed at module level\n" + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-04-05 09:12:55]: Using numpy backend on /CPU:0\n" ] } ], + "source": [ + "from qibo import set_backend\n", + "set_backend('numpy')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1add4aa2", + "metadata": {}, + "outputs": [], "source": [ "def test_dbi_evolution_oracle(t_step, eps): \n", " from qibo.hamiltonians import SymbolicHamiltonian\n", - " from qibo.symbols \n", + " from qibo import symbols \n", + "\n", " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", @@ -96,30 +109,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "id": "380ed537", "metadata": { "scrolled": true }, "outputs": [ { - "ename": "SystemError", - "evalue": "initialization of _internal failed without raising an exception", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mSystemError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_8278/1431874961.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_dbi_evolution_oracle\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/tmp/ipykernel_8278/2759485688.py\u001b[0m in \u001b[0;36mtest_dbi_evolution_oracle\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_dbi_evolution_oracle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n\u001b[0m\u001b[1;32m 3\u001b[0m + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n\u001b[1;32m 4\u001b[0m \u001b[0md_0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSymbolicHamiltonian\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnqubits\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mh_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mh_x\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/hamiltonians/hamiltonians.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, form, nqubits, symbol_map, backend)\u001b[0m\n\u001b[1;32m 359\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mqibo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackends\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m_check_backend\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 360\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 361\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_check_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 362\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 363\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mform\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/backends/__init__.py\u001b[0m in \u001b[0;36m_check_backend\u001b[0;34m(backend)\u001b[0m\n\u001b[1;32m 198\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_check_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 199\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbackend\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 200\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mGlobalBackend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 201\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/backends/__init__.py\u001b[0m in \u001b[0;36m__new__\u001b[0;34m(cls)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_default_order\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_instance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconstruct_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mModuleNotFoundError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mImportError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/backends/__init__.py\u001b[0m in \u001b[0;36mconstruct_backend\u001b[0;34m(backend, **kwargs)\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mCuQuantumBackend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mplatform\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"numba\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mNumbaBackend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 23\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pragma: no cover\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/qibojit/backends/cpu.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpsutil\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m__version__\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnumba_version\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mqibojit\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m__version__\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mqibojit_version\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/numba/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;31m# Re-export vectorize decorators and the thread layer querying function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 42\u001b[0;31m from numba.np.ufunc import (vectorize, guvectorize, threading_layer,\n\u001b[0m\u001b[1;32m 43\u001b[0m \u001b[0mget_num_threads\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset_num_threads\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0mset_parallel_chunksize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mget_parallel_chunksize\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/numba/np/ufunc/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# -*- coding: utf-8 -*-\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecorators\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mVectorize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGUVectorize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvectorize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mguvectorize\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_internal\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mPyUFunc_None\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPyUFunc_Zero\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPyUFunc_One\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m_internal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marray_exprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/lib/python3.10/site-packages/numba/np/ufunc/decorators.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0minspect\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0m_internal\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumba\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparallel\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mParallelUFuncBuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mParallelGUFuncBuilder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mSystemError\u001b[0m: initialization of _internal failed without raising an exception" + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-05 09:13:00]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -127,14 +127,6 @@ "test_dbi_evolution_oracle( 1, 1e-3) " ] }, - { - "cell_type": "markdown", - "id": "2f42fae3", - "metadata": {}, - "source": [ - "`DoubleBracketRotationType.group_commutator_other_sorting` is the same as currently `DoubleBracketIteration` group commutator" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 6d00d29f8e..781f528437 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -66,12 +66,11 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): assert np.linalg.norm( u - v ) < 10 * s * np.linalg.norm(h0) * np.linalg.norm(d) -from qibo import symbols -from numpy.linalg import norm @pytest.mark.parametrize("nqubits", [3]) def test_dbi_evolution_oracle(t_step, eps): from qibo.hamiltonians import SymbolicHamiltonian from qibo import symbols + from numpy.linalg import norm h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits = 3 ) d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 ) From 9f38a48ca9ce56e3c599d515e4cd5cb32606e9d6 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 09:22:44 +0200 Subject: [PATCH 076/116] imporoving testing notebook --- ...volution_oracles_and_gci_transpiling.ipynb | 123 +++++++++++++++++- 1 file changed, 119 insertions(+), 4 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index b306551982..c0577fc300 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "765f8da6", + "id": "173074d1", "metadata": {}, "outputs": [], "source": [ @@ -25,10 +25,103 @@ " print(reduce(str.__add__, out[0]))" ] }, + { + "cell_type": "code", + "execution_count": 10, + "id": "eb3a4f7f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@pytest.mark.parametrize(\"nqubits\", [3])\n", + "def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits):\n", + " h0 = random_hermitian(2**nqubits, backend=backend)\n", + " d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))\n", + " dbi = DoubleBracketIteration(\n", + " Hamiltonian(nqubits, h0, backend=backend),\n", + " mode=DoubleBracketGeneratorType.group_commutator,\n", + " )\n", + "\n", + " for s in np.linspace(0,.01,NSTEPS):\n", + " u = dbi.eval_dbr_unitary(s,mode = DoubleBracketRotationType.single_commutator)\n", + " v = dbi.eval_dbr_unitary(s, mode = DoubleBracketRotationType.group_commutator)\n", + "\n", + " assert np.linalg.norm( u - v ) < 10 * s * np.linalg.norm(h0) * np.linalg.norm(d)\n", + "\n" + ] + } + ], + "source": [ + "print_function_source_code(test_double_bracket_iteration_eval_dbr_unitary)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ceb004ac", + "metadata": {}, + "outputs": [], + "source": [ + "import qibo\n", + "backend = qibo.backends.construct_backend(\"numpy\")\n", + "nqubits = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "50a41bdc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "numpy" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "backend" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c0e53a8d", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "ename": "UnboundLocalError", + "evalue": "local variable 'operator' referenced before assignment", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mUnboundLocalError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_9225/3866532243.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnqubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py\u001b[0m in \u001b[0;36mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0;34m(backend, nqubits)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m.01\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mNSTEPS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m \u001b[0mu\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_commutator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 64\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/models/dbi/double_bracket.py\u001b[0m in \u001b[0;36meval_dbr_unitary\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 139\u001b[0m )\n\u001b[1;32m 140\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 141\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0moperator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 143\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mstaticmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'operator' referenced before assignment" + ] + } + ], + "source": [ + "test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits)" + ] + }, { "cell_type": "code", "execution_count": 2, - "id": "cdf50e7c", + "id": "02929afc", "metadata": {}, "outputs": [ { @@ -64,7 +157,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "8688a26d", + "id": "de085a6e", "metadata": {}, "outputs": [ { @@ -80,10 +173,32 @@ "set_backend('numpy')" ] }, + { + "cell_type": "markdown", + "id": "b33d65d0", + "metadata": {}, + "source": [ + "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", + "\n", + "This is testing the following:\n", + "\n", + "`dbi` runs $V = e^{-sW}$ and rotates $H_1 = V^\\dagger H_0 V$.\n", + "\n", + "`gci` runs $Q = GC$ and rotates $J_1 = Q^\\dagger H_0 Q$.\n", + "\n", + "`dbi2` runs $R = GC$ and rotates $K_1 = R^\\dagger H_0 R$.\n", + "\n", + "We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", + "$$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", + "\n", + "We assert that gci and dbi should be within the approximation bound of the GC\n", + "$$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n" + ] + }, { "cell_type": "code", "execution_count": 8, - "id": "1add4aa2", + "id": "99b58bba", "metadata": {}, "outputs": [], "source": [ From 8a8a5fac14d39ae7251a0652aef55cb4bae8c6d2 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 5 Apr 2024 07:28:27 +0000 Subject: [PATCH 077/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/models/dbi/double_bracket.py | 26 +++--- .../group_commutator_iteration_transpiler.py | 84 ++++++++++++------- tests/test_models_dbi.py | 47 ++++++----- 3 files changed, 94 insertions(+), 63 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index d8ae367fe8..2b150e2119 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -89,7 +89,7 @@ def __init__( def __call__( self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None ): - """ We use convention that $H' = U^\dagger H U$ where $U=e^{-sW}$ with $W=[D,H]$ (or depending on `mode` an approximation, see `eval_dbr_unitary`). If $s>0$ then for $D = \Delta(H)$ the GWW DBR will give a $\sigma$-decrease, see https://arxiv.org/abs/2206.11772.""" + r"""We use convention that $H' = U^\dagger H U$ where $U=e^{-sW}$ with $W=[D,H]$ (or depending on `mode` an approximation, see `eval_dbr_unitary`). If $s>0$ then for $D = \Delta(H)$ the GWW DBR will give a $\sigma$-decrease, see https://arxiv.org/abs/2206.11772.""" operator = self.eval_dbr_unitary(step, mode, d) operator_dagger = self.backend.cast( @@ -101,22 +101,22 @@ def __call__( def eval_dbr_unitary( self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None ): - """ In call we will are working in the convention that $H' = U^\dagger H U$ where $U=e^{-sW}$ with $W=[D,H]$ or an approximation of that by a group commutator. That is handy because if we switch from the DBI in the Heisenberg picture for the Hamiltonian, we get that the transformation of the state is $|\psi'\rangle = U |\psi\rangle$ so that $\langle H\rangle_{\psi'} = \langle H' \rangle_\psi$ (i.e. when writing the unitary acting on the state dagger notation is avoided). - -The group commutator must approximate $U=e^{-s[D,H]}$. This is achieved by setting $r = \sqrt{s}$ so that -$$V = e^{-irH}e^{irD}e^{irH}e^{-irD}$$ -because -$$e^{-irH}De^{irH} = D+ir[D,H]+O(r^2)$$ -so -$$V\approx e^{irD +i^2 r^2[D,H] + O(r^2) -irD} \approx U\ .$$ -See the app in https://arxiv.org/abs/2206.11772 for a derivation. + """In call we will are working in the convention that $H' = U^\\dagger H U$ where $U=e^{-sW}$ with $W=[D,H]$ or an approximation of that by a group commutator. That is handy because if we switch from the DBI in the Heisenberg picture for the Hamiltonian, we get that the transformation of the state is $|\\psi'\rangle = U |\\psi\rangle$ so that $\\langle H\rangle_{\\psi'} = \\langle H' \rangle_\\psi$ (i.e. when writing the unitary acting on the state dagger notation is avoided). + + The group commutator must approximate $U=e^{-s[D,H]}$. This is achieved by setting $r = \\sqrt{s}$ so that + $$V = e^{-irH}e^{irD}e^{irH}e^{-irD}$$ + because + $$e^{-irH}De^{irH} = D+ir[D,H]+O(r^2)$$ + so + $$V\approx e^{irD +i^2 r^2[D,H] + O(r^2) -irD} \approx U\\ .$$ + See the app in https://arxiv.org/abs/2206.11772 for a derivation. """ if mode is None: mode = self.mode if mode is DoubleBracketGeneratorType.canonical: - operator = self.backend.calculate_matrix_exp(- - 1.0j * step, + operator = self.backend.calculate_matrix_exp( + -1.0j * step, self.commutator(self.diagonal_h_matrix, self.h.matrix), ) elif mode is DoubleBracketGeneratorType.single_commutator: @@ -129,7 +129,7 @@ def eval_dbr_unitary( elif mode is DoubleBracketGeneratorType.group_commutator: if d is None: d = self.diagonal_h_matrix - + sqrt_step = np.sqrt(step) operator = ( self.h.exp(-np.sqrt(step)) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index bbb8318c8c..035b2457ec 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -27,7 +27,7 @@ class DoubleBracketRotationType(Enum): """ ## Reserving for later development exact_GWW = auto() - """ $e^{-s [\Delta(H),H]}$""" + r""" $e^{-s [\Delta(H),H]}$""" group_commutator_imperfect = auto() """Use group commutator approximation""" @@ -86,14 +86,16 @@ def __call__( if mode_dbr is None: mode_dbr = self.mode_double_bracket_rotation - if (mode_dbr is DoubleBracketRotationType.single_commutator): + if mode_dbr is DoubleBracketRotationType.single_commutator: raise_error( ValueError, "single_commutator DBR mode doesn't make sense with EvolutionOracle", ) - + # This will run the appropriate group commutator step - double_bracket_rotation_step = self.group_commutator(step_duration, diagonal_association) + double_bracket_rotation_step = self.group_commutator( + step_duration, diagonal_association + ) before_circuit = double_bracket_rotation_step["backwards"] after_circuit = double_bracket_rotation_step["forwards"] @@ -102,20 +104,20 @@ def __call__( is EvolutionOracleType.numerical ): self.h.matrix = before_circuit @ self.h.matrix @ after_circuit - + elif ( self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation ): - self.iterated_hamiltonian_evolution_oracle = ( - FrameShiftedEvolutionOracle( - deepcopy(self.iterated_hamiltonian_evolution_oracle), - str(step_duration), - before_circuit, - after_circuit, - ) + self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( + deepcopy(self.iterated_hamiltonian_evolution_oracle), + str(step_duration), + before_circuit, + after_circuit, + ) + self.h.matrix = ( + before_circuit.unitary() @ self.h.matrix @ after_circuit.unitary() ) - self.h.matrix = before_circuit.unitary() @ self.h.matrix @ after_circuit.unitary() elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: raise_error(NotImplementedError) @@ -127,10 +129,10 @@ def group_commutator( t_step: float, eo1: EvolutionOracle, eo2: EvolutionOracle = None, - mode_dbr: DoubleBracketRotationType = None + mode_dbr: DoubleBracketRotationType = None, ): s_step = np.sqrt(t_step) - + if eo2 is None: eo2 = self.iterated_hamiltonian_evolution_oracle @@ -149,32 +151,52 @@ def group_commutator( "You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!", ) - if gc_type is DoubleBracketRotationType.group_commutator: - query_list_forward = [ eo1.circuit(-s_step), eo2.circuit(s_step), eo1.circuit(s_step), eo2.circuit(-s_step) ] - query_list_backward = [ eo2.circuit(s_step), eo1.circuit(-s_step), eo2.circuit(-s_step), eo1.circuit(s_step) ] - elif gc_type is DoubleBracketRotationType.group_commutator_reduced: - query_list_forward = [ eo2.circuit(s_step), eo1.circuit(s_step), eo2.circuit(-s_step) ] - query_list_backward = [ eo2.circuit(s_step), eo1.circuit(-s_step), eo2.circuit(-s_step) ] + if gc_type is DoubleBracketRotationType.group_commutator: + query_list_forward = [ + eo1.circuit(-s_step), + eo2.circuit(s_step), + eo1.circuit(s_step), + eo2.circuit(-s_step), + ] + query_list_backward = [ + eo2.circuit(s_step), + eo1.circuit(-s_step), + eo2.circuit(-s_step), + eo1.circuit(s_step), + ] + elif gc_type is DoubleBracketRotationType.group_commutator_reduced: + query_list_forward = [ + eo2.circuit(s_step), + eo1.circuit(s_step), + eo2.circuit(-s_step), + ] + query_list_backward = [ + eo2.circuit(s_step), + eo1.circuit(-s_step), + eo2.circuit(-s_step), + ] else: raise_error( ValueError, - "You are in the group commutator query list but your dbr mode is not recognized") - + "You are in the group commutator query list but your dbr mode is not recognized", + ) + from functools import reduce + if eo_mode is EvolutionOracleType.text_strings: return { - "forwards": reduce(str.__add__, query_list_forward), - "backwards": reduce(str.__add__, query_list_backward) - } + "forwards": reduce(str.__add__, query_list_forward), + "backwards": reduce(str.__add__, query_list_backward), + } elif eo_mode is EvolutionOracleType.hamiltonian_simulation: return { "forwards": reduce(Circuit.__add__, query_list_forward[::-1]), - "backwards": reduce(Circuit.__add__, query_list_backward[::-1]) - } + "backwards": reduce(Circuit.__add__, query_list_backward[::-1]), + } elif eo_mode is EvolutionOracleType.numerical: return { - "forwards": reduce(np.array.__matmul__, query_list_forward), - "backwards": reduce(np.array.__matmul__, query_list_backward) - } + "forwards": reduce(np.array.__matmul__, query_list_forward), + "backwards": reduce(np.array.__matmul__, query_list_backward), + } else: raise_error(ValueError, "Your EvolutionOracleType is not recognized") diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 781f528437..7e130ba9fb 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -10,9 +10,9 @@ DoubleBracketIteration, DoubleBracketScheduling, ) -from qibo.quantum_info import random_hermitian from qibo.models.dbi.double_bracket_evolution_oracles import EvolutionOracle from qibo.models.dbi.group_commutator_iteration_transpiler import * +from qibo.quantum_info import random_hermitian NSTEPS = 1 seed = 10 @@ -50,6 +50,7 @@ def test_double_bracket_iteration_group_commutator(backend, nqubits): assert initial_off_diagonal_norm > dbi.off_diagonal_norm + @pytest.mark.parametrize("nqubits", [3]) def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) @@ -59,32 +60,40 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): mode=DoubleBracketGeneratorType.group_commutator, ) - for s in np.linspace(0,.01,NSTEPS): - u = dbi.eval_dbr_unitary(s,mode = DoubleBracketRotationType.single_commutator) - v = dbi.eval_dbr_unitary(s, mode = DoubleBracketRotationType.group_commutator) + for s in np.linspace(0, 0.01, NSTEPS): + u = dbi.eval_dbr_unitary(s, mode=DoubleBracketRotationType.single_commutator) + v = dbi.eval_dbr_unitary(s, mode=DoubleBracketRotationType.group_commutator) - assert np.linalg.norm( u - v ) < 10 * s * np.linalg.norm(h0) * np.linalg.norm(d) + assert np.linalg.norm(u - v) < 10 * s * np.linalg.norm(h0) * np.linalg.norm(d) @pytest.mark.parametrize("nqubits", [3]) -def test_dbi_evolution_oracle(t_step, eps): - from qibo.hamiltonians import SymbolicHamiltonian - from qibo import symbols +def test_dbi_evolution_oracle(t_step, eps): from numpy.linalg import norm - h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) - + symbols.Y(1) * symbols.Y(2), nqubits = 3 ) - d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 ) - h_input = h_x + d_0 - - evolution_oracle = EvolutionOracle(h_input, "ZX", - mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) - + + from qibo import symbols + from qibo.hamiltonians import SymbolicHamiltonian + + h_x = SymbolicHamiltonian( + symbols.X(0) + + symbols.Z(0) * symbols.X(1) + + symbols.Y(2) + + symbols.Y(1) * symbols.Y(2), + nqubits=3, + ) + d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3) + h_input = h_x + d_0 + + evolution_oracle = EvolutionOracle( + h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation + ) + evolution_oracle.eps_trottersuzuki = eps - + U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary() V_target = h_input.exp(t_step) - - assert norm(U_hamiltonian_simulation-V_target) < eps + + assert norm(U_hamiltonian_simulation - V_target) < eps @pytest.mark.parametrize("nqubits", [1, 2]) From fe02a72532d221045cbfe5b4043405a86797a163 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 09:38:33 +0200 Subject: [PATCH 078/116] fixing typo in test file --- ...volution_oracles_and_gci_transpiling.ipynb | 76 +++++++++---------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index c0577fc300..be3f7b0bd1 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -11,9 +11,18 @@ { "cell_type": "code", "execution_count": 1, - "id": "173074d1", + "id": "b161521d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/marek/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py:68: SyntaxWarning: 'float' object is not callable; perhaps you missed a comma?\n", + " assert np.linalg.norm(u - v) < 10 * s ** (1.49)(\n" + ] + } + ], "source": [ "import inspect\n", "import sys\n", @@ -27,8 +36,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "eb3a4f7f", + "execution_count": 2, + "id": "8ecce261", "metadata": { "scrolled": true }, @@ -39,6 +48,7 @@ "text": [ "@pytest.mark.parametrize(\"nqubits\", [3])\n", "def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits):\n", + " r\"\"\"The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\"\"\"\n", " h0 = random_hermitian(2**nqubits, backend=backend)\n", " d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))\n", " dbi = DoubleBracketIteration(\n", @@ -46,11 +56,13 @@ " mode=DoubleBracketGeneratorType.group_commutator,\n", " )\n", "\n", - " for s in np.linspace(0,.01,NSTEPS):\n", - " u = dbi.eval_dbr_unitary(s,mode = DoubleBracketRotationType.single_commutator)\n", - " v = dbi.eval_dbr_unitary(s, mode = DoubleBracketRotationType.group_commutator)\n", + " for s in np.linspace(0, 0.01, NSTEPS):\n", + " u = dbi.eval_dbr_unitary(s, mode=DoubleBracketGeneratorType.single_commutator)\n", + " v = dbi.eval_dbr_unitary(s, mode=DoubleBracketGeneratorType.group_commutator)\n", "\n", - " assert np.linalg.norm( u - v ) < 10 * s * np.linalg.norm(h0) * np.linalg.norm(d)\n", + " assert np.linalg.norm(u - v) < 10 * s ** (1.49)(\n", + " np.linalg.norm(h0) + np.linalg.norm(d)\n", + " ) * np.linalg.norm(h0) * np.linalg.norm(d)\n", "\n" ] } @@ -61,8 +73,8 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "ceb004ac", + "execution_count": 3, + "id": "950eef89", "metadata": {}, "outputs": [], "source": [ @@ -73,44 +85,32 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "50a41bdc", + "execution_count": null, + "id": "b16a8c10", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "numpy" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "backend" + "pr" ] }, { "cell_type": "code", - "execution_count": 22, - "id": "c0e53a8d", + "execution_count": 5, + "id": "bcfab105", "metadata": { "scrolled": true }, "outputs": [ { - "ename": "UnboundLocalError", - "evalue": "local variable 'operator' referenced before assignment", + "ename": "TypeError", + "evalue": "'float' object is not callable", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mUnboundLocalError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_9225/3866532243.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnqubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py\u001b[0m in \u001b[0;36mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0;34m(backend, nqubits)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m.01\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mNSTEPS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m \u001b[0mu\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_commutator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 64\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/src/qibo/models/dbi/double_bracket.py\u001b[0m in \u001b[0;36meval_dbr_unitary\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 139\u001b[0m )\n\u001b[1;32m 140\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 141\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0moperator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 143\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mstaticmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'operator' referenced before assignment" + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_13478/3866532243.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnqubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py\u001b[0m in \u001b[0;36mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0;34m(backend, nqubits)\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mDoubleBracketGeneratorType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m assert np.linalg.norm(u - v) < 10 * s ** (1.49)(\n\u001b[0m\u001b[1;32m 69\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 70\u001b[0m ) * np.linalg.norm(h0) * np.linalg.norm(d)\n", + "\u001b[0;31mTypeError\u001b[0m: 'float' object is not callable" ] } ], @@ -121,7 +121,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "02929afc", + "id": "54efc9de", "metadata": {}, "outputs": [ { @@ -157,7 +157,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "de085a6e", + "id": "566ed128", "metadata": {}, "outputs": [ { @@ -175,7 +175,7 @@ }, { "cell_type": "markdown", - "id": "b33d65d0", + "id": "0fc17c2d", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", @@ -198,7 +198,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "99b58bba", + "id": "6b7217e2", "metadata": {}, "outputs": [], "source": [ From 92af754f4ae05fc56d8b46dc1eed2e9c1d36d94b Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 5 Apr 2024 13:25:48 +0200 Subject: [PATCH 079/116] almost caught what's wrong in the gci gc error --- ...volution_oracles_and_gci_transpiling.ipynb | 421 +++++++++--------- .../dbi/error in gci gc still there.ipynb | 390 ++++++++++++++++ src/qibo/models/dbi/double_bracket.py | 5 +- .../group_commutator_iteration_transpiler.py | 12 +- tests/test_models_dbi.py | 8 +- 5 files changed, 614 insertions(+), 222 deletions(-) create mode 100644 examples/dbi/error in gci gc still there.ipynb diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index be3f7b0bd1..729fac8b8a 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -13,16 +13,7 @@ "execution_count": 1, "id": "b161521d", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/marek/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py:68: SyntaxWarning: 'float' object is not callable; perhaps you missed a comma?\n", - " assert np.linalg.norm(u - v) < 10 * s ** (1.49)(\n" - ] - } - ], + "outputs": [], "source": [ "import inspect\n", "import sys\n", @@ -34,6 +25,15 @@ " print(reduce(str.__add__, out[0]))" ] }, + { + "cell_type": "markdown", + "id": "0fc17c2d", + "metadata": {}, + "source": [ + "# Check the GC bound is valid\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -56,11 +56,11 @@ " mode=DoubleBracketGeneratorType.group_commutator,\n", " )\n", "\n", - " for s in np.linspace(0, 0.01, NSTEPS):\n", - " u = dbi.eval_dbr_unitary(s, mode=DoubleBracketGeneratorType.single_commutator)\n", - " v = dbi.eval_dbr_unitary(s, mode=DoubleBracketGeneratorType.group_commutator)\n", + " for s in np.linspace(0.001, 0.01, NSTEPS):\n", + " u = dbi.eval_dbr_unitary(s,d=d, mode=DoubleBracketGeneratorType.single_commutator)\n", + " v = dbi.eval_dbr_unitary(s,d=d, mode=DoubleBracketGeneratorType.group_commutator)\n", "\n", - " assert np.linalg.norm(u - v) < 10 * s ** (1.49)(\n", + " assert np.linalg.norm(u - v) < 10 * s**1.49 * (\n", " np.linalg.norm(h0) + np.linalg.norm(d)\n", " ) * np.linalg.norm(h0) * np.linalg.norm(d)\n", "\n" @@ -73,54 +73,48 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "950eef89", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-04-05 13:00:00]: Using numpy backend on /CPU:0\n" + ] + } + ], "source": [ "import qibo\n", "backend = qibo.backends.construct_backend(\"numpy\")\n", + "qibo.set_backend(\"numpy\")\n", "nqubits = 3" ] }, { "cell_type": "code", - "execution_count": null, - "id": "b16a8c10", - "metadata": {}, - "outputs": [], - "source": [ - "pr" - ] - }, - { - "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "bcfab105", "metadata": { "scrolled": true }, - "outputs": [ - { - "ename": "TypeError", - "evalue": "'float' object is not callable", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_13478/3866532243.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnqubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py\u001b[0m in \u001b[0;36mtest_double_bracket_iteration_eval_dbr_unitary\u001b[0;34m(backend, nqubits)\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_dbr_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mDoubleBracketGeneratorType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m assert np.linalg.norm(u - v) < 10 * s ** (1.49)(\n\u001b[0m\u001b[1;32m 69\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 70\u001b[0m ) * np.linalg.norm(h0) * np.linalg.norm(d)\n", - "\u001b[0;31mTypeError\u001b[0m: 'float' object is not callable" - ] - } - ], + "outputs": [], "source": [ "test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits)" ] }, + { + "cell_type": "markdown", + "id": "fd120031", + "metadata": {}, + "source": [ + "# Check the convergence of the Trotter-Suzuki Hamiltonian simulation oracle\n" + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "id": "54efc9de", "metadata": {}, "outputs": [ @@ -129,13 +123,13 @@ "output_type": "stream", "text": [ "@pytest.mark.parametrize(\"nqubits\", [3])\n", - "def test_dbi_evolution_oracle(t_step, eps): \n", + "def test_dbi_evolution_oracle(backend,nqubits,t_step, eps): \n", " from qibo.hamiltonians import SymbolicHamiltonian\n", " from qibo import symbols\n", - " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - " h_input = h_x + d_0 \n", + " from numpy.linalg import norm\n", + " print(backend)\n", + " h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2)+ symbols.Z(0), nqubits = 3, backend = backend )\n", "\n", " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", @@ -156,30 +150,42 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "566ed128", + "execution_count": 15, + "id": "eb8bf7ff", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-05 09:12:55]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|WARNING|2024-04-05 12:26:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "numpy\n" ] } ], "source": [ - "from qibo import set_backend\n", - "set_backend('numpy')" + "test_dbi_evolution_oracle(backend,nqubits,1 ,1e-2)" ] }, { "cell_type": "markdown", - "id": "0fc17c2d", + "id": "7f4d7a01", + "metadata": {}, + "source": [ + "# Check the numerical mode of evolution oracles" + ] + }, + { + "cell_type": "markdown", + "id": "75007589", "metadata": {}, "source": [ - "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", - "\n", "This is testing the following:\n", "\n", "`dbi` runs $V = e^{-sW}$ and rotates $H_1 = V^\\dagger H_0 V$.\n", @@ -197,200 +203,197 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "6b7217e2", + "execution_count": null, + "id": "b1a50e52", "metadata": {}, "outputs": [], "source": [ - "def test_dbi_evolution_oracle(t_step, eps): \n", - " from qibo.hamiltonians import SymbolicHamiltonian\n", - " from qibo import symbols \n", - "\n", - " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - " h_input = h_x + d_0 \n", - "\n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - " \n", - " evolution_oracle.eps_trottersuzuki = eps\n", - " \n", - " U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary()\n", - " V_target = h_input.exp(t_step)\n", - " \n", - " assert norm(U_hamiltonian_simulation-V_target) < eps" + "def test_dbr_in_dbi_vs_gci_classes_numerical(t_step, eps):" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "380ed537", - "metadata": { - "scrolled": true - }, + "execution_count": 10, + "id": "1982bb12", + "metadata": {}, + "outputs": [], + "source": [ + "t_step =0.1\n", + "eps = 1e-2" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3405e782", + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-05 09:13:00]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-05 13:02:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-05 13:02:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-05 13:02:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], "source": [ - "test_dbi_evolution_oracle( 1, 1e-3) " + "from numpy.linalg import norm\n", + "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + "h_input = h_x + d_0 \n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", + "\n", + "\n", + "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", + "\n", + "V_dbi = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", + "R_dbi = dbi2.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", + "\n", + "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + "\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "\n", + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", + "Q_gci = unitary_gc_from_oracles['forwards']\n", + "\n", + "assert norm(Q_gci.conj().T - unitary_gc_from_oracles['backwards']) < 1e-12\n", + "h0_norm = np.linalg.norm(h_x.dense.matrix)\n", + "d0_norm = np.linalg.norm(d_0.dense.matrix)\n", + "assert norm(V_dbi - R_dbi) < 2 *t_step**1.49 * ( h0_norm + d0_norm ) * h0_norm * d0_norm" ] }, { "cell_type": "code", - "execution_count": null, - "id": "8a03c568", + "execution_count": 12, + "id": "7a0c43ac", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "1.0885506896087478" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from double_bracket import *\n", - "def test_group_commutator_dbi_vs_gci_numerical(t_step, eps):\n", - "\n", - " \n", - " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - " h_input = h_x + d_0 \n", - "\n", - " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - " dbi.mode = DoubleBracketGeneratorType.group_commutator\n", - "\n", - "\n", - " V_dbi = dbi.eval_dbr_unitary(t_step, d_0.dense.matrix)\n", - " \n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", - " evolution_oracle.eps_trottersuzuki = eps\n", - " \n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - " \n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", - " U_gci = unitary_gc_from_oracles['forwards']\n", - " \n", - " assert norm(U_gci.unitary() - unitary_gc_from_oracles['backwards'].unitary().conj().T) < 1e-12\n", - " \n", - " assert norm(U_gci.unitary().conj().T - V_dbi ) < 5*eps\n", - " \n", - " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", - " U_gci = unitary_gc_from_oracles['forwards']\n", - " \n", - " assert norm(U_gci - unitary_gc_from_oracles['backwards'].conj().T) < 1e-12\n", - " \n", - " assert norm(U_gci.conj().T - V_dbi ) < 5*eps\n", - " \n", - " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", - " U_gci = unitary_gc_from_oracles['forwards']\n", - " \n", - " assert isinstance(U_gci, str)\n", - "\n", - " \n", - "test_group_commutator_dbi_vs_gci(.1, 1e-5)" + "norm(Q_gci.conj().T - R_dbi )" ] }, { "cell_type": "code", - "execution_count": null, - "id": "75fa98fc", + "execution_count": 13, + "id": "2b6140e1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "1.8837381116044358" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from double_bracket import *\n", - "\n", - "def test_group_commutator_dbi_vs_gci(t_step, eps):\n", - "\n", - " \n", - " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - " h_input = h_x + d_0 \n", - "\n", - "\n", - "\n", - " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - " dbi.mode = DoubleBracketGeneratorType.group_commutator\n", - "\n", - " def wrapper_gc(self,step, d):\n", - " return (\n", - " self.h.exp(-step)\n", - " @ self.backend.calculate_matrix_exp(-step, d)\n", - " @ self.h.exp(step)\n", - " @ self.backend.calculate_matrix_exp(step, d)\n", - " )\n", - " V_dbi = wrapper_gc(dbi, np.sqrt(t_step), d_0.dense.matrix)\n", - " \n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", - " evolution_oracle.eps_trottersuzuki = eps\n", - " \n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - " \n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", - " U_gci = unitary_gc_from_oracles['forwards']\n", - " \n", - " assert norm(U_gci.unitary() - unitary_gc_from_oracles['backwards'].unitary().conj().T) < 1e-12\n", - " \n", - " assert norm(U_gci.unitary().conj().T - V_dbi ) < 5*eps\n", - " \n", - " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target ) \n", - " U_gci = unitary_gc_from_oracles['forwards']\n", - " \n", - " assert norm(U_gci - unitary_gc_from_oracles['backwards'].conj().T) < 1e-12\n", - " \n", - " assert norm(U_gci.conj().T - V_dbi ) < 5*eps\n", - " \n", - " gci.input_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", - " U_gci = unitary_gc_from_oracles['forwards']\n", - " \n", - " assert isinstance(U_gci, str)\n", - "\n", - " \n", - "test_group_commutator_dbi_vs_gci(.1, 1e-5)" + "norm(Q_gci - R_dbi )" ] }, { "cell_type": "code", - "execution_count": null, - "id": "2030892e", + "execution_count": 5, + "id": "156530d7", "metadata": {}, "outputs": [], "source": [ - "import inspect\n", + "assert norm(Q_gci.conj().T - R_dbi ) < 5*eps\n", "\n", - "from tests import *\n", - "\n" + "dbi(t_step, d = d_0.dense.matrix )\n", + "h_1 = dbi.h.matrix\n", + "dbi2(t_step, d = d_0.dense.matrix )\n", + "k_1 = dbi2.h.matirix\n", + "gci(t_step, d = d_0.dense.matrix )\n", + "j_1 = gci.iterated_hamiltonian_evolution_oracle.h\n", + "print(norm(j_1-k_1))\n", + "print(norm(V_dbi-Q_dbi))\n", + "print(norm(h_1-k_1)) \n", + "print(norm(V_dbi-R_dbi))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8a03c568", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-05 13:01:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-05 13:01:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-05 13:01:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_14250/2555506132.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_dbr_in_dbi_vs_gci_classes_numerical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_14250/3935142580.py\u001b[0m in \u001b[0;36mtest_dbr_in_dbi_vs_gci_classes_numerical\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0md0_norm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mV_dbi\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mR_dbi\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m1.49\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m \u001b[0mh0_norm\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0md0_norm\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mh0_norm\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0md0_norm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 34\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mQ_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mR_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 35\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "test_dbr_in_dbi_vs_gci_classes_numerical(.1, 1e-5)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9b926a77", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "numpy.ndarray" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(np.array([2]))" ] }, { "cell_type": "markdown", - "id": "7f4d7a01", + "id": "3b93f833", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", diff --git a/examples/dbi/error in gci gc still there.ipynb b/examples/dbi/error in gci gc still there.ipynb new file mode 100644 index 0000000000..24de9e8c29 --- /dev/null +++ b/examples/dbi/error in gci gc still there.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2dae9ffe", + "metadata": {}, + "source": [ + "## This compares to DoubleBracketIteration whenever possible" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b161521d", + "metadata": {}, + "outputs": [], + "source": [ + "import inspect\n", + "import sys\n", + "sys.path.append(\"../../tests\")\n", + "from test_models_dbi import *\n", + "def print_function_source_code( func ):\n", + " out = inspect.getsourcelines(func) \n", + " from functools import reduce\n", + " print(reduce(str.__add__, out[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1982bb12", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-04-05 13:18:37]: Using numpy backend on /CPU:0\n" + ] + } + ], + "source": [ + "t_step =0.1\n", + "eps = 1e-2\n", + "import qibo\n", + "backend = qibo.backends.construct_backend(\"numpy\")\n", + "qibo.set_backend(\"numpy\")\n", + "nqubits = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3405e782", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-05 13:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-05 13:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-05 13:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "from numpy.linalg import norm\n", + "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + "h_input = h_x + d_0 \n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", + "\n", + "\n", + "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", + "\n", + "V_dbi = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", + "R_dbi = dbi2.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", + "\n", + "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + "\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "\n", + "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", + "Q_gci = unitary_gc_from_oracles['forwards']\n", + "\n", + "assert norm(Q_gci.conj().T - unitary_gc_from_oracles['backwards']) < 1e-12\n", + "\n", + "h0_norm = np.linalg.norm(h_x.dense.matrix)\n", + "d0_norm = np.linalg.norm(d_0.dense.matrix)\n", + "assert norm(V_dbi - R_dbi) < 2 *t_step**1.49 * ( h0_norm + d0_norm ) * h0_norm * d0_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7a0c43ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.9045740584321311" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(Q_gci.conj().T - R_dbi )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b6140e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.051669878291704" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(Q_gci - R_dbi )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0a7c946f", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.linalg import expm\n", + "\n", + "s_step = np.sqrt(t_step)\n", + "Vh = expm(1j * s_step * h_input.dense.matrix )\n", + "\n", + "Vd = expm(1j * s_step * d_0.dense.matrix )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8d91ae94", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.716110830818201e-16" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - R_dbi)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8a139b0f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0516698782917042" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - Q_gci)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9ff5be12", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( Vh - evolution_oracle.circuit(-s_step))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b1821d36", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( Vd - evolution_oracle_diagonal_target.circuit(-s_step))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cd89ff33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( Vd.conj().T - evolution_oracle_diagonal_target.circuit(s_step))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "bc1d4629", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.103534121246274e-16" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( Vh.conj().T - evolution_oracle.circuit(s_step))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "eeaaef32", + "metadata": {}, + "outputs": [], + "source": [ + "from functools import reduce\n", + "S = reduce(np.ndarray.__matmul__,[ Vh,Vd,Vh.conj().T, Vd.conj().T])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "1667cc27", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.904574058432131" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(S- Q_gci)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f29d4065", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.716110830818201e-16" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(S- R_dbi)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "de639b53", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm( Vh - gci.iterated_hamiltonian_evolution_oracle.circuit(-s_step))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79086265", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 2b150e2119..d62ac36441 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -11,7 +11,7 @@ hyperopt_step, polynomial_step, ) - +from qibo.config import raise_error class DoubleBracketGeneratorType(Enum): """Define DBF evolution.""" @@ -137,7 +137,8 @@ def eval_dbr_unitary( @ self.h.exp(np.sqrt(step)) @ self.backend.calculate_matrix_exp(np.sqrt(step), d) ) - + else: + raise_error(ValueError, f"Mode { mode } not recognized.") return operator @staticmethod diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index bbb8318c8c..c9a0ea7032 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -150,11 +150,11 @@ def group_commutator( ) if gc_type is DoubleBracketRotationType.group_commutator: - query_list_forward = [ eo1.circuit(-s_step), eo2.circuit(s_step), eo1.circuit(s_step), eo2.circuit(-s_step) ] - query_list_backward = [ eo2.circuit(s_step), eo1.circuit(-s_step), eo2.circuit(-s_step), eo1.circuit(s_step) ] + query_list_forward = [ eo2.circuit(-s_step), eo1.circuit(-s_step), eo2.circuit(s_step), eo1.circuit(s_step) ] + query_list_backward = [ eo1.circuit(-s_step), eo2.circuit(-s_step), eo1.circuit(s_step), eo2.circuit(s_step) ] elif gc_type is DoubleBracketRotationType.group_commutator_reduced: - query_list_forward = [ eo2.circuit(s_step), eo1.circuit(s_step), eo2.circuit(-s_step) ] - query_list_backward = [ eo2.circuit(s_step), eo1.circuit(-s_step), eo2.circuit(-s_step) ] + query_list_forward = [ eo1.circuit(s_step), eo2.circuit(s_step), eo1.circuit(-s_step) ] + query_list_backward = [ eo1.circuit(s_step), eo2.circuit(-s_step), eo1.circuit(-s_step) ] else: raise_error( ValueError, @@ -173,8 +173,8 @@ def group_commutator( } elif eo_mode is EvolutionOracleType.numerical: return { - "forwards": reduce(np.array.__matmul__, query_list_forward), - "backwards": reduce(np.array.__matmul__, query_list_backward) + "forwards": reduce(np.ndarray.__matmul__, query_list_forward), + "backwards": reduce(np.ndarray.__matmul__, query_list_backward) } else: raise_error(ValueError, "Your EvolutionOracleType is not recognized") diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 4f2cc091bb..8c6c53276b 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -72,14 +72,12 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): @pytest.mark.parametrize("nqubits", [3]) -def test_dbi_evolution_oracle(t_step, eps): +def test_dbi_evolution_oracle(backend,nqubits,t_step, eps): from qibo.hamiltonians import SymbolicHamiltonian from qibo import symbols from numpy.linalg import norm - h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) - + symbols.Y(1) * symbols.Y(2), nqubits = 3 ) - d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 ) - h_input = h_x + d_0 + h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + + symbols.Y(1) * symbols.Y(2)+ symbols.Z(0), nqubits = 3, backend = backend ) evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) From 4c9413fd057bd5cb77d262f30d21e4224b37b558 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 5 Apr 2024 11:30:03 +0000 Subject: [PATCH 080/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/models/dbi/double_bracket.py | 3 +- .../group_commutator_iteration_transpiler.py | 36 ++++++++++++++----- tests/test_models_dbi.py | 17 +++++---- 3 files changed, 40 insertions(+), 16 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index d62ac36441..c9f92e67af 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -5,13 +5,14 @@ import hyperopt import numpy as np +from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian from qibo.models.dbi.utils_scheduling import ( grid_search_step, hyperopt_step, polynomial_step, ) -from qibo.config import raise_error + class DoubleBracketGeneratorType(Enum): """Define DBF evolution.""" diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index c240d59cc1..b5ee163ceb 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -151,12 +151,30 @@ def group_commutator( "You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!", ) - if gc_type is DoubleBracketRotationType.group_commutator: - query_list_forward = [ eo2.circuit(-s_step), eo1.circuit(-s_step), eo2.circuit(s_step), eo1.circuit(s_step) ] - query_list_backward = [ eo1.circuit(-s_step), eo2.circuit(-s_step), eo1.circuit(s_step), eo2.circuit(s_step) ] - elif gc_type is DoubleBracketRotationType.group_commutator_reduced: - query_list_forward = [ eo1.circuit(s_step), eo2.circuit(s_step), eo1.circuit(-s_step) ] - query_list_backward = [ eo1.circuit(s_step), eo2.circuit(-s_step), eo1.circuit(-s_step) ] + if gc_type is DoubleBracketRotationType.group_commutator: + query_list_forward = [ + eo2.circuit(-s_step), + eo1.circuit(-s_step), + eo2.circuit(s_step), + eo1.circuit(s_step), + ] + query_list_backward = [ + eo1.circuit(-s_step), + eo2.circuit(-s_step), + eo1.circuit(s_step), + eo2.circuit(s_step), + ] + elif gc_type is DoubleBracketRotationType.group_commutator_reduced: + query_list_forward = [ + eo1.circuit(s_step), + eo2.circuit(s_step), + eo1.circuit(-s_step), + ] + query_list_backward = [ + eo1.circuit(s_step), + eo2.circuit(-s_step), + eo1.circuit(-s_step), + ] else: raise_error( ValueError, @@ -177,8 +195,8 @@ def group_commutator( } elif eo_mode is EvolutionOracleType.numerical: return { - "forwards": reduce(np.ndarray.__matmul__, query_list_forward), - "backwards": reduce(np.ndarray.__matmul__, query_list_backward) - } + "forwards": reduce(np.ndarray.__matmul__, query_list_forward), + "backwards": reduce(np.ndarray.__matmul__, query_list_backward), + } else: raise_error(ValueError, "Your EvolutionOracleType is not recognized") diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index aec717dc4e..8d7e1c127d 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -62,20 +62,25 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): ) for s in np.linspace(0.001, 0.01, NSTEPS): - u = dbi.eval_dbr_unitary(s,d=d, mode=DoubleBracketGeneratorType.single_commutator) - v = dbi.eval_dbr_unitary(s,d=d, mode=DoubleBracketGeneratorType.group_commutator) + u = dbi.eval_dbr_unitary( + s, d=d, mode=DoubleBracketGeneratorType.single_commutator + ) + v = dbi.eval_dbr_unitary( + s, d=d, mode=DoubleBracketGeneratorType.group_commutator + ) assert np.linalg.norm(u - v) < 10 * s**1.49 * ( np.linalg.norm(h0) + np.linalg.norm(d) ) * np.linalg.norm(h0) * np.linalg.norm(d) - @pytest.mark.parametrize("nqubits", [3]) -def test_dbi_evolution_oracle(backend,nqubits,t_step, eps): - from qibo.hamiltonians import SymbolicHamiltonian - from qibo import symbols +def test_dbi_evolution_oracle(backend, nqubits, t_step, eps): from numpy.linalg import norm + + from qibo import symbols + from qibo.hamiltonians import SymbolicHamiltonian + h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) From 0ef3146c264ff9be445507e60c711576d8c25051 Mon Sep 17 00:00:00 2001 From: shangtai Date: Sat, 6 Apr 2024 04:35:50 +0800 Subject: [PATCH 081/116] introduce binary search to find the smallest step size for suzuki trotterization --- .../dbi/double_bracket_evolution_oracles.py | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index b3fb420901..8368478dde 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -115,6 +115,47 @@ def discretized_evolution_circuit(self, t_duration, eps=None): assert np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps return combined_circuit + def discretized_evolution_circuit_binary_search(self, t_duration, eps=None): + nmb_trottersuzuki_steps = 3 # this is the smallest size + nmb_trottersuzki_steps_right = 50 # this is the largest size for binary search + if eps is None: + eps = self.eps_trottersuzuki + target_unitary = self.h.exp(t_duration) + + from copy import deepcopy + + def check_accuracy(n_steps): + proposed_circuit_unitary = np.linalg.matrix_power( + deepcopy(self.h) + .circuit(t_duration / n_steps) + .unitary(), + n_steps, + ) + norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) + if self.please_be_verbose: + print(n_steps, norm_difference) + return norm_difference < eps + + while nmb_trottersuzuki_steps < nmb_trottersuzki_steps_right: + mid = (nmb_trottersuzuki_steps + nmb_trottersuzki_steps_right)//2 + if check_accuracy(mid): + nmb_trottersuzki_steps_right = mid + else: + nmb_trottersuzuki_steps = mid + 1 + + from functools import reduce + + circuit_1_step = deepcopy(self.h.circuit(t_duration / nmb_trottersuzuki_steps)) + combined_circuit = reduce( + Circuit.__add__, [circuit_1_step] * nmb_trottersuzuki_steps + ) + print("number of steps required", mid) + print("unitary: ", combined_circuit.unitary()) + print("error:", np.linalg.norm(combined_circuit.unitary() - target_unitary)) + print("eps tolerance level:< ", eps) + assert np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps + return combined_circuit + class FrameShiftedEvolutionOracle(EvolutionOracle): def __init__( From d0b8220ca85cbd44a2d828283fa01cff6ffbc36f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 5 Apr 2024 20:36:20 +0000 Subject: [PATCH 082/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../models/dbi/double_bracket_evolution_oracles.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 8368478dde..e06d1bca44 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -117,7 +117,7 @@ def discretized_evolution_circuit(self, t_duration, eps=None): def discretized_evolution_circuit_binary_search(self, t_duration, eps=None): nmb_trottersuzuki_steps = 3 # this is the smallest size - nmb_trottersuzki_steps_right = 50 # this is the largest size for binary search + nmb_trottersuzki_steps_right = 50 # this is the largest size for binary search if eps is None: eps = self.eps_trottersuzuki target_unitary = self.h.exp(t_duration) @@ -126,18 +126,16 @@ def discretized_evolution_circuit_binary_search(self, t_duration, eps=None): def check_accuracy(n_steps): proposed_circuit_unitary = np.linalg.matrix_power( - deepcopy(self.h) - .circuit(t_duration / n_steps) - .unitary(), - n_steps, - ) + deepcopy(self.h).circuit(t_duration / n_steps).unitary(), + n_steps, + ) norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) if self.please_be_verbose: print(n_steps, norm_difference) return norm_difference < eps while nmb_trottersuzuki_steps < nmb_trottersuzki_steps_right: - mid = (nmb_trottersuzuki_steps + nmb_trottersuzki_steps_right)//2 + mid = (nmb_trottersuzuki_steps + nmb_trottersuzki_steps_right) // 2 if check_accuracy(mid): nmb_trottersuzki_steps_right = mid else: From 4abbaa0a52f7584933f636f292a8535f7e0664a4 Mon Sep 17 00:00:00 2001 From: shangtai Date: Sat, 6 Apr 2024 04:47:06 +0800 Subject: [PATCH 083/116] remove print statements --- src/qibo/models/dbi/double_bracket_evolution_oracles.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 8368478dde..6828490d10 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -149,10 +149,6 @@ def check_accuracy(n_steps): combined_circuit = reduce( Circuit.__add__, [circuit_1_step] * nmb_trottersuzuki_steps ) - print("number of steps required", mid) - print("unitary: ", combined_circuit.unitary()) - print("error:", np.linalg.norm(combined_circuit.unitary() - target_unitary)) - print("eps tolerance level:< ", eps) assert np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps return combined_circuit From 6254a6877114cf9c12adcf7aa4ffec014dd3adc3 Mon Sep 17 00:00:00 2001 From: shangtai Date: Sat, 6 Apr 2024 04:58:58 +0800 Subject: [PATCH 084/116] include the binary search variant in the circuit method. --- src/qibo/models/dbi/double_bracket_evolution_oracles.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index ace6746324..ac093a7fbd 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -69,7 +69,7 @@ def circuit(self, t_duration: float = None): + " and next running discretization adjustment to reach precision eps = " + str(self.eps_trottersuzuki) ) - return self.discretized_evolution_circuit( + return self.discretized_evolution_circuit_binary_search( t_duration, eps=self.eps_trottersuzuki ) else: From 318761a97d34f821d529e6df83246a3855148112 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Sat, 6 Apr 2024 09:54:33 +0200 Subject: [PATCH 085/116] apparently still somewhere a sign error in the query lists, also in dbi currently for the sign. This can be a good start for Ashwinie to add an example notebook or utils_group_commutator.py for trouble shooting group commutators --- .../dbi/error in gci gc still there.ipynb | 386 +++++++++++++++--- .../group_commutator_iteration_transpiler.py | 21 +- 2 files changed, 357 insertions(+), 50 deletions(-) diff --git a/examples/dbi/error in gci gc still there.ipynb b/examples/dbi/error in gci gc still there.ipynb index 24de9e8c29..6facf8f6e2 100644 --- a/examples/dbi/error in gci gc still there.ipynb +++ b/examples/dbi/error in gci gc still there.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "b161521d", "metadata": {}, "outputs": [], @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "1982bb12", "metadata": {}, "outputs": [ @@ -35,7 +35,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-05 13:18:37]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-06 09:40:21]: Using numpy backend on /CPU:0\n" ] } ], @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "id": "3405e782", "metadata": {}, "outputs": [ @@ -58,9 +58,57 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-05 13:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-05 13:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-05 13:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-06 09:40:21]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-06 09:40:21]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-06 09:40:21]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.664636718428507e-16\n", + "0.0\n", + "0.0\n", + "9.664636718428507e-16\n", + "start\n", + "8.570566018546674e-16 2.069502835539648e-18\n", + "None 7.102648668054811e-16\n", + "None 2.069502835539648e-18\n", + "stop\n", + "[[ 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", + " -7.96539477e-02-0.15421646j 3.51159382e-01+0.5130534j\n", + " -6.64615932e-17-0.31397323j 3.23092247e-17+0.25955811j\n", + " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j]\n", + " [ 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", + " -3.51159382e-01-0.5130534j -7.96539477e-02-0.15421646j\n", + " 0.00000000e+00-0.25955811j -3.55618313e-17-0.31397323j\n", + " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j]\n", + " [-3.51159382e-01-0.5293799j -7.96539477e-02-0.08224007j\n", + " 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", + " -1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", + " -2.68882139e-17-0.36962312j -1.14925430e-17+0.17125522j]\n", + " [ 7.96539477e-02+0.08224007j -3.51159382e-01-0.5293799j\n", + " 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", + " 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", + " 6.93889390e-18-0.17125522j 0.00000000e+00-0.36962312j]\n", + " [-9.97465999e-18-0.36962312j 4.11996826e-18+0.17125522j\n", + " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j\n", + " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j\n", + " -3.51159382e-01+0.5293799j -7.96539477e-02+0.08224007j]\n", + " [ 3.46944695e-18-0.17125522j -3.81639165e-17-0.36962312j\n", + " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j\n", + " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j\n", + " 7.96539477e-02-0.08224007j -3.51159382e-01+0.5293799j ]\n", + " [-1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", + " 2.97071395e-17-0.31397323j -1.66967135e-17+0.25955811j\n", + " -7.96539477e-02+0.15421646j 3.51159382e-01-0.5130534j\n", + " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j]\n", + " [ 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", + " 1.38777878e-17-0.25955811j 4.16333634e-17-0.31397323j\n", + " -3.51159382e-01+0.5130534j -7.96539477e-02+0.15421646j\n", + " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j]]\n", + "9.664636718428507e-16\n" ] } ], @@ -102,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "id": "7a0c43ac", "metadata": {}, "outputs": [ @@ -112,7 +160,7 @@ "1.9045740584321311" ] }, - "execution_count": 4, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -123,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "id": "2b6140e1", "metadata": {}, "outputs": [ @@ -133,7 +181,7 @@ "1.051669878291704" ] }, - "execution_count": 5, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -144,8 +192,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "0a7c946f", + "execution_count": 9, + "id": "b2feb7af", "metadata": {}, "outputs": [], "source": [ @@ -159,8 +207,8 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "8d91ae94", + "execution_count": 10, + "id": "1a61a169", "metadata": {}, "outputs": [ { @@ -169,7 +217,7 @@ "5.716110830818201e-16" ] }, - "execution_count": 7, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -180,8 +228,8 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "8a139b0f", + "execution_count": 11, + "id": "b15db9f3", "metadata": {}, "outputs": [ { @@ -190,7 +238,7 @@ "1.0516698782917042" ] }, - "execution_count": 8, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -201,8 +249,8 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "9ff5be12", + "execution_count": 12, + "id": "7edd8473", "metadata": {}, "outputs": [ { @@ -211,7 +259,7 @@ "0.0" ] }, - "execution_count": 9, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -222,8 +270,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "b1821d36", + "execution_count": 13, + "id": "1e22de3e", "metadata": {}, "outputs": [ { @@ -232,7 +280,7 @@ "0.0" ] }, - "execution_count": 10, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -243,8 +291,8 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "cd89ff33", + "execution_count": 14, + "id": "a90fd92c", "metadata": {}, "outputs": [ { @@ -253,7 +301,7 @@ "0.0" ] }, - "execution_count": 17, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -264,8 +312,8 @@ }, { "cell_type": "code", - "execution_count": 18, - "id": "bc1d4629", + "execution_count": 15, + "id": "dc953d12", "metadata": {}, "outputs": [ { @@ -274,7 +322,7 @@ "5.103534121246274e-16" ] }, - "execution_count": 18, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -285,8 +333,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "eeaaef32", + "execution_count": 16, + "id": "1e6a99de", "metadata": {}, "outputs": [], "source": [ @@ -296,17 +344,17 @@ }, { "cell_type": "code", - "execution_count": 19, - "id": "1667cc27", + "execution_count": 17, + "id": "c81c695b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "1.904574058432131" + "1.0516698782917042" ] }, - "execution_count": 19, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -317,50 +365,294 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "f29d4065", + "execution_count": null, + "id": "bd657152", + "metadata": {}, + "outputs": [], + "source": [ + "norm(S- R_dbi)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50625680", + "metadata": {}, + "outputs": [], + "source": [ + "norm( Vh - gci.iterated_hamiltonian_evolution_oracle.circuit(-s_step))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1f3bbad", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "a2813b91", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.0\n", + "start\n", + "7.516933549631155e-16 6.149486291803641e-17\n", + "None 4.665547176382431e-16\n", + "None 6.149486291803641e-17\n", + "stop\n", + "7.516933549631155e-16\n", + "6.149486291803641e-17\n", + "4.665547176382431e-16\n", + "6.149486291803641e-17\n" + ] + }, { "data": { "text/plain": [ "5.716110830818201e-16" ] }, - "execution_count": 15, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "norm(S- R_dbi)" + "self =gci\n", + "eo1 = evolution_oracle_diagonal_target\n", + "eo2 = evolution_oracle\n", + "s_step = np.sqrt(t_step)\n", + "\n", + "if eo2 is None:\n", + " eo2 = self.iterated_hamiltonian_evolution_oracle\n", + "##\n", + "from scipy.linalg import expm, norm\n", + "\n", + "Vh = expm(1j * s_step * eo2.h.dense.matrix )\n", + "Vd = expm(1j * s_step * eo1.h.dense.matrix )\n", + "# print(norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix)))\n", + "print(norm( Vh - eo2.circuit(-s_step)))\n", + "print(norm( Vd - eo1.circuit(-s_step)))\n", + "from functools import reduce\n", + "by_hand_list = [ Vh,Vd,Vh.conj().T, Vd.conj().T]\n", + "S = reduce(np.ndarray.__matmul__,by_hand_list)\n", + "# print(norm( S - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix)))\n", + "assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value\n", + "\n", + "eo_mode = eo1.mode_evolution_oracle\n", + "\n", + "\n", + "gc_type = self.mode_double_bracket_rotation\n", + "\n", + "\n", + "if gc_type is DoubleBracketRotationType.single_commutator:\n", + " raise_error(\n", + " ValueError,\n", + " \"You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!\",\n", + " )\n", + "\n", + "if gc_type is DoubleBracketRotationType.group_commutator: \n", + " query_list_forward = [ eo2.circuit(-s_step), eo1.circuit(-s_step), eo2.circuit(s_step), eo1.circuit(s_step) ]\n", + " query_list_backward = [ eo1.circuit(-s_step), eo2.circuit(-s_step), eo1.circuit(s_step), eo2.circuit(s_step) ]\n", + "elif gc_type is DoubleBracketRotationType.group_commutator_reduced: \n", + " query_list_forward = [ eo1.circuit(s_step), eo2.circuit(s_step), eo1.circuit(-s_step) ]\n", + " query_list_backward = [ eo1.circuit(s_step), eo2.circuit(-s_step), eo1.circuit(-s_step) ] \n", + "else:\n", + " raise_error(\n", + " ValueError,\n", + " \"You are in the group commutator query list but your dbr mode is not recognized\",\n", + " )\n", + "print(\"start\")\n", + "reduce( print, [norm(x @ y.conj().T -np.eye(x.shape[0])) for x,y in zip( query_list_forward,by_hand_list)]) \n", + "from functools import reduce\n", + "print(\"stop\")\n", + "for x,y in zip( query_list_forward,by_hand_list):\n", + " print(norm(x @ y.conj().T -np.eye(x.shape[0])))\n", + "\n", + "A = reduce(np.ndarray.__matmul__, query_list_forward)\n", + "B = reduce(np.ndarray.__matmul__, by_hand_list)\n", + "norm(A-B)" ] }, { "cell_type": "code", - "execution_count": 16, - "id": "de639b53", + "execution_count": 24, + "id": "4f0cb09f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.0" + "1.0136811088581048" ] }, - "execution_count": 16, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "norm( Vh - gci.iterated_hamiltonian_evolution_oracle.circuit(-s_step))" + "norm(R_dbi- V_dbi)" ] }, + { + "cell_type": "code", + "execution_count": 18, + "id": "824ac371", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.0\n", + "start\n", + "7.516933549631155e-16 6.149486291803641e-17\n", + "None 4.665547176382431e-16\n", + "None 6.149486291803641e-17\n", + "stop\n", + "7.516933549631155e-16\n", + "6.149486291803641e-17\n", + "4.665547176382431e-16\n", + "6.149486291803641e-17\n" + ] + }, + { + "ename": "SyntaxError", + "evalue": "'return' outside function (1962676161.py, line 57)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_23193/1962676161.py\"\u001b[0;36m, line \u001b[0;32m57\u001b[0m\n\u001b[0;31m return {\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m 'return' outside function\n" + ] + } + ], + "source": [ + "if eo_mode is EvolutionOracleType.text_strings:\n", + " return {\n", + " \"forwards\": reduce(str.__add__, query_list_forward),\n", + " \"backwards\": reduce(str.__add__, query_list_backward),\n", + " }\n", + "elif eo_mode is EvolutionOracleType.hamiltonian_simulation:\n", + " return {\n", + " \"forwards\": reduce(Circuit.__add__, query_list_forward[::-1]),\n", + " \"backwards\": reduce(Circuit.__add__, query_list_backward[::-1]),\n", + " }\n", + "elif eo_mode is EvolutionOracleType.numerical:\n", + " return {\n", + " \"forwards\": reduce(np.ndarray.__matmul__, query_list_forward),\n", + " \"backwards\": reduce(np.ndarray.__matmul__, query_list_backward)\n", + " }\n", + "else:\n", + " raise_error(ValueError, \"Your EvolutionOracleType is not recognized\")\n", + "\n", + "group_commutator(gci, t_step, eo1 = evolution_oracle_diagonal_target)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "a23e136c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", + "\n", + "\n", + "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", + "\n", + "\n", + "norms = []\n", + "norms2 = []\n", + "for s in np.linspace(1e-5,.1,30):\n", + " V_dbi = dbi.eval_dbr_unitary(s, d=d_0.dense.matrix)\n", + " R_dbi = dbi2.eval_dbr_unitary(s, d=d_0.dense.matrix)\n", + " norms.append(norm(V_dbi.conj().T-R_dbi))\n", + " norms2.append(norm(V_dbi-R_dbi))\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(np.linspace(1e-5,.1,30),norms)\n", + "plt.plot(np.linspace(1e-5,.1,30), [x**1.5*12 for x in np.linspace(1e-5,.1,30)])" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "a74c98b8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAAsTAAALEwEAmpwYAAAt+0lEQVR4nO3dd3RU1drH8e9Op/fQA6H3GghFFOlIE0VBxF7uq1dREZQmTVBAhAuKBVFRrwrSJEDoXVCqEJLQklASSkihpJA6+/3jjNcYJhJJMiczeT5rsZiZszPzbJL81uGcXZTWGiGEEI7PxewChBBC5A8JdCGEcBIS6EII4SQk0IUQwklIoAshhJNwM+uDK1asqGvXrm3WxwshhEM6fPhwrNa6kq1jpgV67dq1OXTokFkfL4QQDkkpdT6nY3LJRQghnIQEuhBCOAkJdCGEcBIS6EII4SQk0IUQwklIoAshhJOQQBdCCCchgS6EEHaSkJLOzA0niYxPLpD3v2OgK6W+UkpdVUoF53BcKaUWKKXClFJBSqk2+V+mEEI4LotFs/xQJN0+3MVnu8LZeTqmQD4nNzNFlwAfA9/mcLwvUN/6xx/41Pq3EEIUeYfPX2Pq2hCCom7Q2qcsi0e0pGUtmzP38+yOZ+ha691A/N80GQR8qw2/AWWVUlXzq0AhhHBEV26k8Mayozz86T6ib6Ywb2hLVvax0HJNbzizpUA+Mz/WcqkORGZ5HmV97XL2hkqpF4EXAXx8fPLho4UQonBJSc/ky1/OsnBHGBkWzb/vr8vLHSpRYtdUWPMNlK0F7sUK5LPtujiX1noRsAjAz89PNjMVQjgNrTWbQqKZERhKZPwt+jStwvgHGuMTvRW+GARJV6HTSOg6DjyKF0gN+RHoF4GaWZ7XsL4mhBBFwqkrCUxdG8K+8DgaVi7F98/709k7HQJfgJProEpzGL4UqrUu0DryI9ADgFeUUksxbobe0FrfdrlFCCGczfXkNOZtOc1/91+gpKcb0wY1ZXi7Grgd/Q6WT4bMVOgxBTq+Aq7uBV7PHQNdKfUj0BWoqJSKAiYD7gBa68+AQOABIAxIBp4pqGKFEKIwyLRofjxwgQ83n+LGrXQe96/FqJ4NKHfrAnw3CM7/ArW7wID5UKGu3eq6Y6BrrR+7w3EN/DvfKhJCiELswNl4pgSEEHr5Jv6+5ZkysCmNvYvB3vmwaza4e8HAj6H1CFDKrrWZtmOREEI4kkvXb/H+hpOsPXaJamW8+Hh4a/o1r4q6dAQWjYToYGjyIPSdDaUqm1KjBLoQQvyNlPRMFu+JYOGOcCxaM7J7fV66ry7FSIHNE+G3T6BkZRj2AzTqZ2qtEuhCCGGD1prNodFMX28MQ+zbzBiGWLN8cQjbButeh+sXwO856DEZvMqYXbIEuhBCZBd2NZGpa0PYcyaWBpVL8sPz/nSqVxGS42H1KDj2I1SoD89sgFqdzC73fyTQhRDCKiElnQXbzvD13nMU83Bl8oAmjOhQC3cXBcdXwIa3IeU63DsGuow2boAWIhLoQogiz2LRrP79IjM3niQ2MZVH29ZkTJ+GVCzpCdcjYf0oOLMZqvvBwAVQuanZJdskgS6EKNKOR91gckAwRy5cp2XNsix+0o+WNcuCJRP2fw5bpxoN+8yE9i+Ci6up9f4dCXQhRJEUl5jKnM2nWHowkgolPJg9pAVD2tTAxUXB1RMQ8CpEHYS63aH/PChXy+yS70gCXQhRpGRkWvh+vzHLMyktk2c7+/Jaj/qU9nKHjFTY9SHsmQuepeChL6D5I3afIHS3JNCFEEXG/og4JgeEcPJKAp3rVWDKgKbUr1zKOHjhN+OsPPY0tBgKvd+DEhXNLfgfkkAXQji96JspvB94gp+PGrM8P3m8DX2bVUEpBSk3YdtUOLgYyvjAiJVQr4fZJd8VCXQhhNNKy7CwZN9Z5m89Q7pF82q3erzctR7FPKw3Nk8Gwvo3IeEydHgZ7p8AniXNLToPJNCFEE5pz5kYpgSEEB6TRI/G3rzTvwm1KpQwDiZehQ1vQchq8G4KQ7+DGn7mFpwPJNCFEE4l6loyM9afYEPwFWpVKM5XT/vRrZF1sSyt4ej3sGkCpN+Cbu9A59fssla5PUigCyGcQkp6Jl/sjmDhzjAAxvRuyHP3+OLlbr28Eh8Ba1+Ds7vBp5MxQahifRMrzn8S6EIIh7ftRDRT14ZyIT6Zfs2rMr5fY6qXtW7EnJkBvy2EHe+Bq4cxprzN0+DiYmrNBUECXQjhsC7EJTNtXQhbT1ylnndJYy/PelmGGl46agxFvBIEDftBvzlQuppp9RY0CXQhhMNJSc/k053hfLorHDcXxbi+jXimsy8ebtaz7rRk2Pk+/LrQGEv+6LfQeKDDTBC6WxLoQgiHsjU0mqnrQoiMv8WAltWY8EBjqpTJsuphxE7jWvm1c9DmSeg5DYqVM6tcu5JAF0I4hAtxyUxdG8K2k8bllR9e8KdT3SyXV5LjYfM7cPS/UL4OPLUWfO81r2ATSKALIQq1lPRMPtkZzme7wnF3UUx4oDFPd66Nu6v18orWxnjyDW9Dchx0fh26jgX3YqbWbQYJdCFEobU1NJopa0OIunaLgS2rMaFfYyqXznJ55cZFY6bn6Q1QtSWMWGH8XURJoAshCp3I+GSmBBiXV+p7l+THFzrQsW6FPxtYLHD4K9gyBSwZ0PNdY+q+a9GOtKLdeyFEoZKSnsnnuyL4ZGcYbrYurwDEnIKAkRD5G/jeBwP+Y1wzFxLoQojCYcepq0wJCOF8XDL9W1RlYr8mfx29kpEGe/8Duz8A9+Iw6BNoNdzphyL+ExLoQghTXbx+i2lrQ9gUEk2dSiX473P+3FM/2zrkkQeNCUIxJ6DZw8Z2cCW9zSm4EJNAF0KYIi3Dwhd7Ivho+xnAWHvl+S6+eLpl2bMzNRG2T4f9nxkzPB9bBg37mFRx4SeBLoSwu71hsbyzJpiImCR6N63MpAFN/1x75Q9ntsC6N+BGFLR/wVgZ0au0OQU7CAl0IYTdRN9M4d11oawLukytCsX5+pl23N8w26WTpFjYOA6O/wQVG8KzG8GngzkFOxgJdCFEgcvItLBk3zn+s/UMaZkW3ujRgH/dV+fPpW3BmCAUtMwI89QEuG8sdBkFbp7mFe5gchXoSqk+wHzAFVistZ6Z7bgP8A1Q1tpmrNY6MH9LFUI4okPn4pn4czAnryTQtWElpg5s+ufOQX+4dh7WvQ7h26FGOxj4EXg3NqVeR3bHQFdKuQILgZ5AFHBQKRWgtQ7N0mwi8JPW+lOlVBMgEKhdAPUKIRxEXGIqMzecZPnhKKqW8eKzEW3p3bSysTHzHyyZxg3P7dNBuUDfD6Ddc+DimvMbixzl5gy9PRCmtY4AUEotBQYBWQNdA3/crSgDXMrPIoUQjsNi0Sw9GMmsjSdJSs3gX/fVYWS3+pTwzBY3V4KNoYiXjkD9XtBvLpStaU7RTiI3gV4diMzyPArwz9ZmCrBZKfUqUALoYeuNlFIvAi8C+Pj4/NNahRCFXPDFG0z8OZijkdfx9y3Puw82o0HlUn9tlJ4Cu2fD3vngVRYe/tIYWy4ThPIsv26KPgYs0Vp/qJTqCHynlGqmtbZkbaS1XgQsAvDz89P59NlCCJPdTEln7ubTfPvrOcqX8GDe0JY82Kr6Xy+vAJz7xVirPC4MWj4Gvd+D4uXNKdoJ5SbQLwJZ/x9Uw/paVs8BfQC01r8qpbyAisDV/ChSCFE4aa1ZG3SZd9eFEpuYygj/Wozu3ZAyxdz/2jDlBmyZBIeXQNla8MRqqNvNlJqdWW4C/SBQXynlixHkw4Dh2dpcALoDS5RSjQEvICY/CxVCFC4RMYlMWhPCL2GxNK9ehsVP+tGyZtnbG55YC+tHQ9JV6PgK3D8ePErc3k7k2R0DXWudoZR6BdiEMSTxK611iFJqGnBIax0AvAl8oZR6A+MG6dNaa7mkIoQT+t+GEzvD8XRzYdqgpjzuXwtXl2yXVxKuQOBoI9ArN4fHfoTqbcwpuojI1TV065jywGyvTcryOBTonL+lCSEKm12nY5i0JpjzcckMbFmNif0a4511wwkwJggd+dbYDi4jBbpPhk6vgqu77TcV+UZmigoh7ujKDWPK/vrjl6lTMYcVEQHiwo2bnuf2QO0uMGA+VKhr/4KLKAl0IUSOMjItfPvreeZuOU1apoVRPY0p+39ZEREgMx32fQQ7Z4KbFwxYAG2elKGIdiaBLoSw6WjkdSasPk7IpZvc16AS0wbZmLIPcPGIsYNQ9HFoPAAemAOlqti/YCGBLoT4q5sp6czZdIrvfjuPdylPPnm8DX2bVbl9THlaEux4D377BEpWhqHfQ+P+5hQtAAl0IYRV1jHlcYmpPNWxNm/2akApLxs3M8O3w9rX4fp5aPsM9JwKXmXsXrP4Kwl0IQTnYpN4Z00we87E0qJGGb56qh3Na9gI6OR42DQBjv0AFerB04FQWwa4FRYS6EIUYakZmXy+K4KPd4Th4erC1IFNGdHBxphyrSF4JWx4G1Kuw71joMtocPey+b7CHBLoQhRR+8JjmfizsQ1cvxZVmdS/CZWzjykHuB4J69+EM5ugelsYGACVm9q/YHFHEuhCFDFxianMCDzBqiMX8SlfnCXPtKNr9m3gwFir/OCXsG0qaAv0mQntX5S1ygsxCXQhigitNcsPRfHehhMkpWbw7/vr8mq3+n/dBu4PV08YQxGjDkDd7tB/HpSrZf+ixT8igS5EERB2NYHxq4M5cDaedrXL8d7g5tTPvk45QEYq7JkLez4Ez1Lw0BfQ/BGZIOQgJNCFcGIp6Zks3BHGZ7vCKe7hxqyHm/NI25q4ZL/pCXBhv7GDUOwpaP4o9HkfStiY3i8KLQl0IZzUL2dimfjzcc7FJfNQ6+qM79eYiiU9b2+YchO2TYODi6FMDXh8BdTvaf+CRZ5JoAvhZGISUpm+PpQ1Ry/hW7EE3z/vT+d6OZxpn9oI60fBzUvg/3/QbSJ4lrRvwSLfSKAL4SQsFs2yQ5G8H3iClHQLI7vX5+WudW3f9Ey8aowpD1kF3k3g0W+hhp/9ixb5SgJdCCdwJjqB8auPc/DcNfx9yzNjcHPqeds409Yajv4Am8ZDejLcPxE6vwZuHvYvWuQ7CXQhHFjWm54lPN34YEgLhrStcftCWgDxZ421ys/ugpodYOACqNTQ/kWLAiOBLoSD2hcWy4Sfgzkbm8RDraszoV9jKti66ZmZYayIuOM9cHGDfh9C22fBxcX+RYsCJYEuhIOJT0pjxvoTrDwSRa0KxXPePQjgchAEvAKXj0HDB4y1ystUt2/Bwm4k0IVwEFprVh25yPT1oSSk3GGmZ/otY/egfR9B8QrwyDfQZJBMEHJyEuhCOICzsUlMWH2cfeFxtPEpy/sPtaBhFRszPQHO7jaulcdHQOsnoNe7UKycfQsWppBAF6IQS8uwsGh3OAu2h+Hp6sL0B5sxvL2P7Zmet67Blklw5Fso5wtPBkCd++xftDCNBLoQhdTh89cYv+o4p6ITeKB5FSYPaGp7eVutIXQNBI6B5DhjGGLXceBezP5FC1NJoAtRyCSkpPOBdU/PKqW9WPykHz2aVLbd+OYlWD8aTq2Hqi1hxArjb1EkSaALUYhsCrnC5DUhRCek8HSn2rzZqyElPW38mloscPhr2DoFMtOh57vQ4WVwlV/poky++0IUAldupDA5IJhNIdE0qlKKz55oS6uaZW03jjkNa0fChV/B9z4Y8B8oX8ee5YpCSgJdCBNZLJrv959n1sZTpGdaeLtPI57v4ou7q41JPxlpsHc+7J4N7sVh0EJo9bgMRRT/I4EuhElORycwdmUQRy5c5556FZkxuBm1KpSw3TjqkLFW+dVQaDoY+syCUjlcVxdFlgS6EHaWkp7JJzvC+HRXOCU93Zj7aEsGt65ue/2V1ETYPh32fwalqsKwH6HRA/YvWjgECXQh7OjA2XjGrgoiIiaJwa2rMzGn9VcAzmyFda/DjUjwew56TAGv0vYsVziYXAW6UqoPMB9wBRZrrWfaaPMoMAXQwDGt9fB8rFMIh3YzJZ2ZG07yw/4L1ChXjG+ebc99DSrZbpwUCxvHwfGfoGIDeHYT+HSwb8HCId0x0JVSrsBCoCcQBRxUSgVorUOztKkPjAM6a62vKaW8C6pgIRzNxuArTFoTTGxiKi908eWNng0o7mHjV09rCPoJNo6F1AS4723o8ia45XAGL0Q2uTlDbw+Eaa0jAJRSS4FBQGiWNi8AC7XW1wC01lfzu1AhHE30zRQmrTGGIjapWprFT/nRokZZ242vnYd1b0D4NqjRDgYsgMpN7FqvcHy5CfTqQGSW51GAf7Y2DQCUUnsxLstM0VpvzP5GSqkXgRcBfHx87qZeIQo9i0Xz48ELzAw8SdqdhiJaMmH/57D9XUBB39nQ7nlwsbGCohB3kF83Rd2A+kBXoAawWynVXGt9PWsjrfUiYBGAn5+fzqfPFqLQCI9JZNzK4xw4F0+nuhV4b3BzalfMYShidIgxFPHiYajfC/rNhbI17VuwcCq5CfSLQNafshrW17KKAvZrrdOBs0qp0xgBfzBfqhSikEvPtPD5rnAWbAujmIcrs4e04JGctoJLT4E9c+CXeeBVFh7+Epo9LBOERJ7lJtAPAvWVUr4YQT4MyD6C5WfgMeBrpVRFjEswEflYpxCFVlDUdd5aEcTJKwn0a16VKQObUqlUDjcyz++DgJEQdwZaPga9ZkCJCvYtWDitOwa61jpDKfUKsAnj+vhXWusQpdQ04JDWOsB6rJdSKhTIBMZoreMKsnAhzJaclsG8Laf58pezVCrlyaIn2tKraRXbjVNuwJbJxoJaZX1gxCqo192+BQunp7Q251K2n5+fPnTokCmfLURe7Q2LZeyqICLjbzHc34exfRtR2svdduMT6yBwNCRGGysi3j8ePHK4ri7EHSilDmut/Wwdk5miQvwDN5LTmb4+lOWHo6hTsQTLXuyAf50cLpkkXIENbxmbT1RuBsO+h+pt7VuwKFIk0IXIBa01G4KvMGlNCNeS03i5a11Gds9hg2atjW3gNr8DGSnQfRJ0GgmuOZzBC5FPJNCFuIPomym883Mwm0OjaVa9NN88246m1crYbhwXbmzQfG4P1LoHBsyHivXsW7AosiTQhciB1pqfDkUyff0J0jIsjOvbiOfu8cXN1gShzHTY9xHsmgWunkaQt34SXGy0FaKASKALYcOFuGTGrgpiX3gc/r7lmfVwi5wnCF363ZggdOU4NB4AfT+A0lXtW7AQSKAL8ReZFs3Xe88yZ/Mp3F1ceG9wc4a1q4mLi41JP2nJsPM9+HUhlPCGR7+DJgPtX7QQVhLoQlidupLAWyuDOBZ5ne6NvJk+uBlVyxSz3Th8h3Gt/Pp5aPs09JgKxcras1whbiOBLoq8tAwLC3eE8cnOMEp5ubPgsdYMaFHV9rT95HjYPBGOfg/l68LT66H2PfYvWggbJNBFkXY08jpvrTjG6ehEBrWqxuQBTSlfwuP2hlpDyCrY8DbcumasU37vGHDP4QxeCBNIoIsi6VZaJh9uPsVXe8/iXcqLL5/yo3vjHDZdvhEF69+E0xuhWmt4YjVUaW7fgoXIBQl0UeT8Gh7H2FVBnI9LZri/D+P6NqKUrWn7Fgsc+hK2TgFtgV7Twf8lcJVfG1E4yU+mKDISrPt6fr//Aj7li/PjCx3oWDeHaftXT8LakRC5H+p2g/7zoFxtu9YrxD8lgS6KhB2nrjJh1XEu30zhuXt8ebNXDvt6ZqQa65TvngOeJWHw59BiqKxVLhyCBLpwateT05i2LpRVRy5Sz7skK1/qRBufcrYbRx4wJgjFnITmj0Dv96FkJfsWLEQeSKALp7Ux+DITfzYW03q1Wz1e6VYPTzcbi2mlJsC2aXDgCyhdHYYvhwa97F+wEHkkgS6cTkxCKpMDggk8foWm1e6wmNbpTbBuFNy8CP7/gm4TwbOUfQsWIp9IoAunobVmzdFLTFkbQnJqJmN6N+TFe+vgbmsxrcQY2Pg2BK+ESo3huS1Qs539ixYiH0mgC6cQfTOFCauPs/XEVVr7lOWDIS2o523jTFtrOPYjbBoPaUnQdTzc8wa42ZhMJISDkUAXDk1rzfLDUby7LpS0DAsT+zXmmc6+uNpaTCv+LKx7HSJ2Qs0OMHABVGpo75KFKDAS6MJhXbx+i3GrjrP7dAzta5dn1pAW+Npa4jYzA/Z/CttngIsb9PsQ2j4ra5ULpyOBLhyO1pofDlzg/cCTWLRm6sCmPNGhlu0lbi8HGUMRLx+FBn2NMC9T3e41C2EPEujCoWTdeKJT3QrMergFNcsXv71h+i1j96C9C6B4eXhkCTR5UCYICacmgS4cgsWi+fbXc8zaeApXF8V7g5vzWPuatpe4PbvHmLYfHwGtR0DPd41QF8LJSaCLQu9cbBJvrQjiwLl47m1Qifcfak71sjaWrb11DbZMgiPfGuuuPLkG6nS1d7lCmEYCXRRaFovm633n+GDTSdxdXZg9pAWPtK1h+6w8dA0EjoGkGOg0ErqOAw8bl2KEcGIS6KJQiohJ5K0VQRw6f41ujbx5b3BzqpTxur3hzUtGkJ9cB1VawPCfoForu9crRGEggS4KlT82af5g0yk83Vz48JGWPNSm+u1n5RYLHFkCWyZDZpqxp2fHV2StclGkyU+/KDTCYxIZs/wYRy5cp0djb2YMbk7l0jbOymPPGBs0n98LtbvAgPlQoa79CxaikJFAF6bLtGi+/CWCDzefxsvdlf8MbcWgVtVuPyvPTIe9/4FdH4C7Fwz82BjFIkMRhQAk0IXJwq4mMmbFMX6/cJ2eTSoz48FmeNs6K794GNa8CldDoOlg6DMLSuWwB6gQRVSuAl0p1QeYD7gCi7XWM3No9zCwAmintT6Ub1UKp5Np0SzeE8GHW05T3MOV+cNaMbCljbPy1ETYMQP2fwYlq8CwH6HRA+YULUQhd8dAV0q5AguBnkAUcFApFaC1Ds3WrhTwGrC/IAoVziM8JpHRy42z8t5NKzP9weZUKuV5e8OwrbD2DbhxAdo9D90ng1dp+xcshIPIzRl6eyBMax0BoJRaCgwCQrO1exeYBYzJ1wqF08i0aL765SxzNp+i2N+dlSfFGcvbBi2Fig3gmY1Qq6M5RQvhQHIT6NWByCzPowD/rA2UUm2Amlrr9UqpHANdKfUi8CKAj4/PP69WOKyImETGrAji8PlrxrXywc3wLpXtWrnWcHw5bBwLKTfh3regy5vGDVAhxB3l+aaoUsoFmAs8fae2WutFwCIAPz8/ndfPFoVf1nHlXu6uzBvakgdb2RhXfv0CrHvDuMxS3Q8GfgSVm5hTtBAOKjeBfhGomeV5DetrfygFNAN2Wn9JqwABSqmBcmO0aDsbm8SY5cc4dP4aPRobsz1vG8FiyYQDi2Dbu8bzPrOg/QvgYmMzZyHE38pNoB8E6iulfDGCfBgw/I+DWusbQMU/niuldgKjJcyLLotFs2TfOWZvOomH69/M9owOgYCRcPEQ1OsJ/edCWbkUJ8TdumOga60zlFKvAJswhi1+pbUOUUpNAw5prQMKukjhOM7HJTFmRRAHzsbnvAZLegrsmQO/zAOvMvDQF9D8EZkgJEQe5eoautY6EAjM9tqkHNp2zXtZwtFYLJrv95/nvcCTuLmonFdGPP+rsVZ57GloMQx6vwclKphTtBBORmaKijyLupbM2yuD2BsWR5f6FZn1cAuqZV+vPOUGbJ0Kh76EMj4wYiXU62FOwUI4KQl0cde01iw7GMn09SfQWvP+Q80Z1s7GLkInA2H9m5B4BTr8G+4fD54lzSlaCCcmgS7uyuUbtxi78ji7TsfQsU4FZg+xsbdnQjRseAtCfwbvpjD0v1CjrSn1ClEUSKCLf0RrzaojF5myNoSMTM3UgU15okMtXFxU1kbw+39h8wTjBmi3d6Dza+Dqbl7hQhQBEugi164mpDB+1XG2nrhKu9rl+GBIS2pXLPHXRnHhsO51OLsbanU21iqvWN+UeoUoaiTQRa6sPXaJd9YEcystk4n9GvNMZ19cs56VZ2bArx/DzvfB1QP6z4M2T4OLi2k1C1HUSKCLvxWflMY7a4JZH3SZVjXLMueRltTzznZD89JRCHgVrgRBo/7wwAdQupop9QpRlEmgixxtCY1m3Krj3LiVxpjeDfnXvXVwc81yxp2WbJyR/7oQSlSER7+DJgPNK1iIIk4CXdzmZko609aGsuJwFI2rlua759rTuGq2dcgjdhr7el47B22egp7ToFhZE6oVQvxBAl38xS9nYnlrxTGiE1J5tVs9Xu1WHw+3LGflyfGw+R04+l8oXxeeWge+XcwrWAjxPxLoAoCk1AxmbjjJd7+dp26lEqx8qROtapb9s4HWELLaGFeeHA/3jIL73gL3Yjm+pxDCviTQBQfPxTN6+TEuxCfz3D2+jOndEC/3LMvX3rhozPQ8vQGqtYYnVkOV5uYVLISwSQK9CEtJz2TultN8sSeCGuWKsfSFDvjXybJQlsVirL2ydSpYMqDXDPD/P3CVHxshCiP5zSyigi/eYNRPRzkdnchwfx8mPNCYEp5ZfhxiThlrlUf+BnXuN8aVl/c1r2AhxB1JoBcxGZkWPtkZzoJtZyhfwoOvn2nH/Q29szRIM9Yp3zMHPErAg59By2GyVrkQDkACvQgJu5rImz8d5VjUDQa2rMa0QU0pW9zjzwaRB40JQjEnoNkQ6DMTSlYyr2AhxD8igV4E/LEl3KyNJynm4crHw1vTv0WWmZypCbB9Ouz/HEpXh+E/QYPe5hUshLgrEuhOLupaMmOWB/FrRBzdGnkz86FsGzWf2QLr3oAbUcbmzN0ngWcp8woWQtw1CXQnpbVm+eEopq0NRWvNrIeb86hfls0nkmJh41g4vhwqNYJnN4GPv7lFCyHyRALdCcUkpDJu1XG2nojG37c8cx5p+efmE1pD0DLYOM641NJ1PNzzOrh5mlqzECLvJNCdzMbgK4xffZzE1Awm9mvMs519/9x84to5WPs6ROyAmv4wYAF4NzKzXCFEPpJAdxI3U9KZGhDKyiNRNKtemnmPtqJ+Zeu1cEsm/PYp7JgBygUemAN+z8la5UI4GQl0J7AvPJYxy4O4cjOFkd3q8UrWBbWuHDcmCF06Ag36QL8PoUwNcwsWQhQICXQHlpKeyQebTvHlL2fxrViCFf/XkdY+5YyD6bdg12zYtwCKlYMhX0PTwTJBSAgnJoHuoIIv3uCNZUc5czWRJzvWYmzfRhT3sH47z/1inJXHh0OrEdDrXShe3tyChRAFTgLdwWRkWvh0Zzjzt52hQkkPvn22Pfc2sM7mvHUdtkyCI99AudrwxM9Q934TqxVC2JMEugM5G5vEG8uOcjTyOgNbVuPdQc0oU9zdOBgaAIFjIOkqdBoJXceBR3FzCxZC2JUEugPQWvP9/gvMWH8CDzcXPnqsNQNaWqfu37wMgaPh5DpjjfLhS401y4UQRY4EeiF39WYKb60MYuepGLrUr8gHQ1pSpYyXsVb5kW9gy2TITIUeU6Hjv8HV3eyShRAmkUAvxDYGX2bcquMkp2UybVBTnuhQy5i6H3vG2KD5/F6o3QUGzIcKdc0uVwhhslwFulKqDzAfcAUWa61nZjs+CngeyABigGe11ufzudYiI+skoRY1yjD30VbU8y4Jmemwd74xHNHdCwZ+BK2fkKGIQgggF4GulHIFFgI9gSjgoFIqQGsdmqXZ74Cf1jpZKfUSMBsYWhAFO7v9EXGM+ukYl2/cYmS3erzavT7uri5w8bAxFDE6GJoMgr6zoVQVs8sVQhQiuTlDbw+Eaa0jAJRSS4FBwP8CXWu9I0v734AR+VlkUZCakcnczadZtCeCWuWLs+KlTrTxKQdpSbBlBuz/FEpWhqHfQ+P+ZpcrhCiEchPo1YHILM+jgL9bZ/U5YIOtA0qpF4EXAXx8fHJZovM7eeUmry89yskrCX/d3zNsq7FW+fUL4Pcs9JgCXmXMLlcIUUjl601RpdQIwA+4z9ZxrfUiYBGAn5+fzs/PdkQWi+arvWeZvfEUpYu589XTfnRrVBmS42HVOAhaChXqwzMboFYns8sVQhRyuQn0i0DNLM9rWF/7C6VUD2ACcJ/WOjV/ynNel67fYvTyY+wLj6NXk8q8/1BzKpTwgKDlxsYTKdfh3jHQZbRxA1QIIe4gN4F+EKivlPLFCPJhwPCsDZRSrYHPgT5a66v5XqWTCTh2iYmrj5NhybKT0I0o+GEUnNkM1dvCwACo3NTsUoUQDuSOga61zlBKvQJswhi2+JXWOkQpNQ04pLUOAD4ASgLLrVucXdBaDyzAuh3SjVvpTFoTzJqjl2jjU5Z5Q1tRq5wXHFgEW6cajfrMhPYvgourucUKIRxOrq6ha60DgcBsr03K8rhHPtfldH4Nj+PNn44SnZDKqJ4NeLlrXdziTsFXr0LUQajbHfrPg3K1zC5VCOGgZKZoAUvNyOTDzaf5Yk8EtSuUYOVLnWhVtRjsngl75oJnKXjoC2j+iEwQEkLkiQR6ATp1JYHXlv7OySsJPO7vw4R+jSl+5RB89irEnoYWQ6H3e1CiotmlCiGcgAR6AbBYNF/vO8esjScp7eXGl0/50d23GGx5Gw4uhjI+8PhKqC9XqoQQ+UcCPZ9F30xh9PJj7DkTS4/G3sx8uAUVL26HhaMg4TJ0eBnunwCeJc0uVQjhZCTQ89HG4MuMXXWclPRMZgxuxvAmXqgN/4KQ1eDdBIZ+BzX8zC5TCOGkJNDzQWJqBtPWhvDTIWN1xHmPtqTuxTWwcAKkJ8P9E6Hza+DmYXapQggnJoGeR0cuXOONZUeJjE/mlfvr8VobN9wDH4ezu8CnIwxYAJUamF2mEKIIkEC/SxmZFj7aHsbHO8KoUtqLpc+3o/2VH+Hz98HFDfrNhbbPgIuL2aUKIYoICfS7cD4uideXHeX3C9cZ3Lo67/pnUnLTELh8DBr2g35zoHQ1s8sUQhQxEuj/gNaa5YejmBoQgquL4uNHG9M/bgl887ExlvzRb6HxQJkgJIQwhQR6Ll1PTmP86uMEHr9Chzrl+bhjIhW3PwTXzhrbwPV6F4qVM7tMIUQRJoGeC/vCYxm17BhxSalM6lGNpxMX47Lyv1C+Djy1FnzvNbtEIYSQQP87aRkWPtxyikW7I/CtUJxlXa5T67fXIDkO7nkD7nsb3IuZXaYQQgAS6DkKj0nktaW/E3zxJv/X2ovRGZ/htm0jVG0JI1YYfwshRCEigZ6N1pofD0QybV0Ixd0UgZ1O0SR4LlgyoNd08H8JXOWfTQhR+EgyZRGflMbbK4PYEhrNo7WTme76BR5H9kOdrtD/P1De1+wShRAiRxLoVnvOxDDqp2MkJ99iRZO9tD3/Jcq9ODz4KbR8TIYiCiEKvSIf6KkZmXyw8RSLfznLwPJRzPZejFfEaWj2sLEdXElvs0sUQohcKdKBHnY1gZE/HuXc5av8WHMDHWJWoNyqwWPLoGEfs8sTQoh/pEgGutaaHw5c4N11ofRwD2Jl+SUUi7kM7V+A7pOMbeGEEMLBFLlAv2a98Xko9Axflv+JzsnboXhDGLYEfPzNLk8IIe5akQr0vWGxjFr2O/fc2s6+Uj/gmZIEXccZk4TcPM0uTwgh8qRIBPofMz7X797PR8WX0N7td6jcHgYuAO/GZpcnhBD5wukDPSImkTd+PEzb6OVsL7Ycd1c36D0H/J6TtcqFEE7FaQNda83yQ1F8HxDIDNfPaeYeDnV7Q/+5UKaG2eUJIUS+c8pAv3ErnUkrD1Pv5KesdFuLKlYWHvjSGFsuE4SEEE7K6QL90Ll4vvrhe0anLqSO22UsLYbh0ud9KF7e7NKEEKJAOU2gZ2RaWLTlKGX3TucT122klq4JD67GpW43s0sTQgi7cIpAv3j9Ft8vWciT1z7G2/UGae1fxrPHRPAoYXZpQghhNw4f6NsOHMMSOIa32M+NMg1xGboKj+ptzC5LCCHsLlfj9pRSfZRSp5RSYUqpsTaOeyqlllmP71dK1c73SrNJTk1nxaIZtFvfh/s4wrWO4yjz2l6QMBdCFFF3PENXSrkCC4GeQBRwUCkVoLUOzdLsOeCa1rqeUmoYMAsYWhAFA5wOPUrSyn8zJDOYC6XbUPWJRZTzrl9QHyeEEA4hN2fo7YEwrXWE1joNWAoMytZmEPCN9fEKoLtSBTM+8ODqBfgs60G9zAjC/N/D541tuEuYCyFErgK9OhCZ5XmU9TWbbbTWGcANoEL2N1JKvaiUOqSUOhQTE3NXBZeq3pDQkh3JfGk/9fr+W2Z7CiGElV1vimqtFwGLAPz8/PTdvEej9r2hfe98rUsIIZxBbk5vLwI1szyvYX3NZhullBtQBojLjwKFEELkTm4C/SBQXynlq5TyAIYBAdnaBABPWR8PAbZrre/qDFwIIcTdueMlF611hlLqFWAT4Ap8pbUOUUpNAw5prQOAL4HvlFJhQDxG6AshhLCjXF1D11oHAoHZXpuU5XEK8Ej+liaEEOKfkCEiQgjhJCTQhRDCSUigCyGEk5BAF0IIJ6HMGl2olIoBzt/ll1cEYvOxHEcgfS4apM9FQ176XEtrXcnWAdMCPS+UUoe01n5m12FP0ueiQfpcNBRUn+WSixBCOAkJdCGEcBKOGuiLzC7ABNLnokH6XDQUSJ8d8hq6EEKI2znqGboQQohsJNCFEMJJFLpAz8uG1EqpcdbXTymlHGYXjLvts1Kqp1LqsFLquPXvbnYv/i7ldeNxpZSPUipRKTXabkXnQR5/rlsopX5VSoVYv9dedi3+LuXh59pdKfWNta8nlFLj7F78XcpFn+9VSh1RSmUopYZkO/aUUuqM9c9T2b82V7TWheYPxvK84UAdwAM4BjTJ1uZl4DPr42HAMuvjJtb2noCv9X1cze5TAfe5NVDN+rgZcNHs/hR0n7McXwEsB0ab3Z8C/h67AUFAS+vzCkXg53o4sNT6uDhwDqhtdp/yqc+1gRbAt8CQLK+XByKsf5ezPi73T2sobGfoedmQehDGD0Gq1vosEGZ9v8Lurvustf5da33J+noIUEwp5WmXqvMmTxuPK6UeBM5i9NkR5KW/vYAgrfUxAK11nNY6005150Ve+qyBEtbdz4oBacBN+5SdJ3fss9b6nNY6CLBk+9rewBatdbzW+hqwBejzTwsobIGelw2pc/O1hVF+bcL9MHBEa51aQHXmp7vus1KqJPA2MNUOdeaXvHyPGwBaKbXJ+l/1t+xQb37IS59XAEnAZeACMEdrHV/QBeeDvGRQvuSXXTeJFgVDKdUUmIVxNufspgDztNaJ1hN2Z+cG3AO0A5KBbUqpw1rrbeaWVaDaA5lANYzLD3uUUlu11hHmllX4FbYz9LxsSJ2bry2M8rQJt1KqBrAaeFJrHV7g1eaPvPTZH5itlDoHvA6Mt26RWJjlpb9RwG6tdazWOhlj57A2BV5x3uWlz8OBjVrrdK31VWAv4AhrveQlg/Inv8y+kZDthoEbxs0AX/68qdA0W5t/89cbKT9ZHzflrzdFI3CMm0d56XNZa/uHzO6Hvfqcrc0UHOOmaF6+x+WAIxg3B92ArUA/s/tUwH1+G/ja+rgEEAq0MLtP+dHnLG2XcPtN0bPW73c56+Py/7gGs/8RbHT0AeA0xt3iCdbXpgEDrY+9MEY3hAEHgDpZvnaC9etOAX3N7ktB9xmYiHGt8WiWP95m96egv89Z3sMhAj2v/QVGYNwADgZmm92Xgu4zUNL6eog1zMeY3Zd87HM7jP91JWH8byQky9c+a/23CAOeuZvPl6n/QgjhJArbNXQhhBB3SQJdCCGchAS6EEI4CQl0IYRwEhLoQgjhJCTQhRDCSUigCyGEk/h/6xK0nTgHzoMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.linspace(1e-5,.1,30),norms2)\n", + "plt.plot(np.linspace(1e-5,.1,30), [x*10 for x in np.linspace(1e-5,.1,30)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae8fa09f", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, - "id": "79086265", + "id": "b747ac2e", "metadata": {}, "outputs": [], "source": [] diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index c240d59cc1..b612ac62dd 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -135,7 +135,18 @@ def group_commutator( if eo2 is None: eo2 = self.iterated_hamiltonian_evolution_oracle - +## + from scipy.linalg import expm, norm + + Vh = expm(1j * s_step * eo2.h.dense.matrix ) + Vd = expm(1j * s_step * eo1.h.dense.matrix ) + print(norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix))) + print(norm( Vh - eo2.circuit(-s_step))) + print(norm( Vd - eo1.circuit(-s_step))) + from functools import reduce + by_hand_list = [ Vh,Vd,Vh.conj().T, Vd.conj().T] + S = reduce(np.ndarray.__matmul__,by_hand_list) + print(norm( S - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix))) assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value eo_mode = eo1.mode_evolution_oracle @@ -162,9 +173,13 @@ def group_commutator( ValueError, "You are in the group commutator query list but your dbr mode is not recognized", ) - + print("start") + reduce( print, [norm(x @ y.conj().T -np.eye(x.shape[0])) for x,y in zip( query_list_forward,by_hand_list)]) from functools import reduce - + print("stop") + print( query_list_forward[2]) + W = reduce(np.ndarray.__matmul__, query_list_forward) + print(norm(W-S)) if eo_mode is EvolutionOracleType.text_strings: return { "forwards": reduce(str.__add__, query_list_forward), From c599f2c41e11dfa67e2332495c5a2f9bd0092bdb Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 6 Apr 2024 07:55:17 +0000 Subject: [PATCH 086/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../group_commutator_iteration_transpiler.py | 37 +++++++++++++------ 1 file changed, 25 insertions(+), 12 deletions(-) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 540dadbbec..bf40daa073 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -135,18 +135,24 @@ def group_commutator( if eo2 is None: eo2 = self.iterated_hamiltonian_evolution_oracle -## + ## from scipy.linalg import expm, norm - Vh = expm(1j * s_step * eo2.h.dense.matrix ) - Vd = expm(1j * s_step * eo1.h.dense.matrix ) - print(norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix))) - print(norm( Vh - eo2.circuit(-s_step))) - print(norm( Vd - eo1.circuit(-s_step))) + Vh = expm(1j * s_step * eo2.h.dense.matrix) + Vd = expm(1j * s_step * eo1.h.dense.matrix) + print( + norm( + Vh @ Vd @ Vh.conj().T @ Vd.conj().T + - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix) + ) + ) + print(norm(Vh - eo2.circuit(-s_step))) + print(norm(Vd - eo1.circuit(-s_step))) from functools import reduce - by_hand_list = [ Vh,Vd,Vh.conj().T, Vd.conj().T] - S = reduce(np.ndarray.__matmul__,by_hand_list) - print(norm( S - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix))) + + by_hand_list = [Vh, Vd, Vh.conj().T, Vd.conj().T] + S = reduce(np.ndarray.__matmul__, by_hand_list) + print(norm(S - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix))) assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value eo_mode = eo1.mode_evolution_oracle @@ -192,12 +198,19 @@ def group_commutator( "You are in the group commutator query list but your dbr mode is not recognized", ) print("start") - reduce( print, [norm(x @ y.conj().T -np.eye(x.shape[0])) for x,y in zip( query_list_forward,by_hand_list)]) + reduce( + print, + [ + norm(x @ y.conj().T - np.eye(x.shape[0])) + for x, y in zip(query_list_forward, by_hand_list) + ], + ) from functools import reduce + print("stop") - print( query_list_forward[2]) + print(query_list_forward[2]) W = reduce(np.ndarray.__matmul__, query_list_forward) - print(norm(W-S)) + print(norm(W - S)) if eo_mode is EvolutionOracleType.text_strings: return { "forwards": reduce(str.__add__, query_list_forward), From 1401409fc0ed31247845d8dba2ddaa633a61035c Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Sat, 6 Apr 2024 16:32:31 +0200 Subject: [PATCH 087/116] fixed sign issue, now double_bracket.py has a scaling that works; next double check that the gci class matches that behavior & finish writing thests --- ...volution_oracles_and_gci_transpiling.ipynb | 272 +++++++++++++++++- src/qibo/models/dbi/double_bracket.py | 4 +- 2 files changed, 263 insertions(+), 13 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 729fac8b8a..00c2023f3d 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -106,7 +106,7 @@ }, { "cell_type": "markdown", - "id": "fd120031", + "id": "61466e18", "metadata": {}, "source": [ "# Check the convergence of the Trotter-Suzuki Hamiltonian simulation oracle\n" @@ -151,7 +151,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "eb8bf7ff", + "id": "403bf8d0", "metadata": {}, "outputs": [ { @@ -183,7 +183,7 @@ }, { "cell_type": "markdown", - "id": "75007589", + "id": "61782388", "metadata": {}, "source": [ "This is testing the following:\n", @@ -204,7 +204,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b1a50e52", + "id": "c91600c1", "metadata": {}, "outputs": [], "source": [ @@ -214,7 +214,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "1982bb12", + "id": "0a808f33", "metadata": {}, "outputs": [], "source": [ @@ -225,7 +225,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "3405e782", + "id": "ecd578d5", "metadata": {}, "outputs": [ { @@ -255,6 +255,7 @@ "V_dbi = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", "R_dbi = dbi2.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", "\n", + "\n", "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", " mode_evolution_oracle = EvolutionOracleType.numerical) \n", "\n", @@ -273,10 +274,116 @@ "assert norm(V_dbi - R_dbi) < 2 *t_step**1.49 * ( h0_norm + d0_norm ) * h0_norm * d0_norm" ] }, + { + "cell_type": "code", + "execution_count": 19, + "id": "6c6337d8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAAsTAAALEwEAmpwYAAAy4ElEQVR4nO3dd3xUVfrH8c+TQOi9SiDUhCY9NFFQlLIWEERBREFwURR11wqrrojurr2sawGVojQBUaMoCDZsQBJ6QguhJAGkhJJQ0ub5/XFHfwEyYSCTNnnerxcvMnPPnTyH8uVy7rnniKpijDHGfwUUdgHGGGPylwW9Mcb4OQt6Y4zxcxb0xhjj5yzojTHGz5Uq7ALOVrNmTW3UqFFhl2GMMcVKdHT0IVWtldOxIhf0jRo1IioqqrDLMMaYYkVEdns6ZkM3xhjj5yzojTHGz1nQG2OMn7OgN8YYP2dBb4wxfs6roBeR/iKyVUTiRGRCLu1uEhEVkfBs7010n7dVRPr5omhjjDHeO+/0ShEJBN4C+gCJQKSIRKhq7FntKgEPAquyvdcKGAa0BuoBy0UkTFWzfNcFY4wxufHmir4LEKeq8aqaDswDBubQ7lngBeB0tvcGAvNUNU1VdwJx7s8zxhiT3ZavYN3cfPlob4I+GEjI9jrR/d6fRKQj0EBVF1/oue7zx4pIlIhEHTx40KvCjTHGb0TPhI9vg+jp4PL9gEeeb8aKSADwKvDwxX6Gqk5V1XBVDa9VK8cneI0xxv+owoqX4YsHoMlVMGIRBAT6/Nt4swRCEtAg2+v67vf+UAm4FPhBRADqAhEiMsCLc40xpmRyuWDJBFg9BdrcAgPfglJB+fKtvLmijwRCRaSxiATh3FyN+OOgqh5T1Zqq2khVGwErgQGqGuVuN0xEyohIYyAUWO3zXhhjTHGSmQafjHFCvtt9MGhKvoU8eHFFr6qZIjIeWAoEAtNUNUZEJgNRqhqRy7kxIjIfiAUygftsxo0xpkRLS4GPR0D8D3DNM9DjQXBGQ/KNFLXNwcPDw9VWrzTG+KXUgzB7COzfCAPehA63+eyjRSRaVcNzOlbklik2xhi/dGQXfDQIju+DYXOgef8C+9YW9MYYk9/2b4RZNzlj83d8DiFdC/Tb21o3xhiTn3b9DNOvhYBSMHppgYc8WNAbY0z+if0cPhoMlS6BMd9A7RYem66MP8yy2N/zpQwbujHGmPyw+j346lGo3xmGfwzlq3tsujRmP/fPXUtYnYr0blGbwADfzsKxoDfGGF9She+ehZ9egbC/wJBpEFTeY/P5kQlMWLSBtvWrMn1UZ5+HPFjQG2OM72RlwBcPwrrZ0HEkXPcqBOYcs6rKlBXxPP/1FnqG1eLdER0pH5Q/kWxBb4wxvpB+AuaPhLhl0GsCXDnB44NQLpfyn683895POxnQrh4v39yOoFL5d8vUgt4YY/LqxCGYcwvsXQvXvw7hd3psmpHlYsInG/lkTSIjuzfk6RtaE5APwzXZWdAbY0xeJO905sgfT4Khs6DFdR6bnkrPYvycNXy75QAP9Qnj/t7NkHxe/gAs6I0x5uLtWw+zhoArA+6IyHWO/LFTGdw1M5Ko3Ud49sZLub1bwwIr04LeGGMuxo7vncXJylWDEV9CreYemx44fpo7pq1mx8FU3ry1A9e3rVeAhVrQG2PMhduwAD4bBzXDYMRCqOw5uHcdOsHt01ZxODWd6aO6cHlozQIs1GFBb4wx3lKFX96A5U9Dw8th2GwoV9Vj801Jxxg1PRKXKnP/2o12DTy3zU8W9MYY4w1XlntHqKnQejAMehdKlfHY/Ofth7j7oyiqlg9i5uguNKtdsQCLPZMFvTHGnE/GKfjkLtjyJXQfD32ehQDP894/X5fEIwvW07RWRWaO7kKdymULsNhzeTVDX0T6i8hWEYkTkQk5HL9HRDaKyDoR+VlEWrnfbyQip9zvrxORd33dAWOMyVcnk2HmANiyGPo/D/3+lWvIv/9TPA/OW0eHkGp8fHf3Qg958OKKXkQCgbeAPkAiECkiEaoam63ZHFV9191+APAq8Meq+jtUtb1PqzbGmIJwZJczR/5oAtw8A1rf6LGpy6W8sGQLU1bE85dL6/La0PaULR1YUJXmypuhmy5AnKrGA4jIPGAgzj6wAKjq8WztKwBFa39CY4y5UHvXwuybnfVr7vgcGnb32DQjy8XjCzewaG0St3dryKQBrfNlcbKL5U3QBwMJ2V4nAuc8FSAi9wEPAUFA72yHGovIWuA48KSq/pTDuWOBsQAhISFeF2+MMfli+zJn3ZryNWDU4lznyJ9Iy2Tc7DWs2HaQR/qGcd9VBfO064Xw2So6qvqWqjYFHgeedL+9DwhR1Q44/wjMEZHKOZw7VVXDVTW8Vq1avirJGGMu3JqPYM5QqNEE7lqWa8gfSk3j1vdW8kvcIV68qS3je4cWuZAH767ok4AG2V7Xd7/nyTzgHQBVTQPS3F9Hi8gOIAyIuqhqjTEmv6jCjy/AD/+BJlfBLR9C2XOuS/+05/BJ7pi2iv3HTzP19k5c3bJOARZ7YbwJ+kggVEQa4wT8MGB49gYiEqqq290vrwO2u9+vBSSrapaINAFCgXhfFW+MMT6RlQFf/A3WzYJ2t8KANyGwtMfmfzwIlelyMfuubnRqWK3gar0I5w16Vc0UkfHAUiAQmKaqMSIyGYhS1QhgvIhcA2QAR4CR7tN7ApNFJANwAfeoanJ+dMQYYy7K6eMw/w6I/x56PgZX/cPjOvIAK7YdZNysaKqWD2Le6K40q12pAIu9OKJatCbIhIeHa1SUjewYYwrAsSRnHfmDW5x15DvenmvzBVEJTFy0kdA6lZhxZ+ciMUf+DyISrarhOR2zJ2ONMSXT/o0w+xZIS4Hh86HZ1R6bqipvfhfHq8u2cXmzmrwzoiOVynoe2ilqLOiNMSVP3LfO9MkylWD011C3jcemmVkunvp8E3NXJzC4YzDPD26br9v+5QcLemNMybJ2lrOBd83mcNsCqBLssemJtEzGz1nD91sPMv6qZjzcN6xITp88Hwt6Y0zJoArf/xtWvAhNrnRPn6zisfnBlDTGzIxkU9Ix/jXoUm7rWnA7QvmaBb0xxv9lpkPE/bBhHrS/DW54I9fpk/EHUxk5fTWHUtJ5747wIj1H3hsW9MYY/3bqKMy/HXaugKuegJ6P5jp9Mnr3Ee6aGUmACHPHdqN9IW0W4ksW9MYY/3V0jzOz5vB2uPEdaD881+ZLY/bzwNy1XFKlLDPu7EKjmhUKqND8ZUFvjPFPSdEwZxhkpsGIT5xx+VxM/2Unk7+MpV39qnwwMpwaFT3vHlXcWNAbY/zP5i/gk79CxVow8guo3cJj0yyX8tziWKb/sou+rerwxrAOlAsqGuvI+4oFvTHGf6jCb2/BN09CcEe4dR5UrO2x+an0LB6ct5ZvYn9ndI/GPHFdyyK1jryvWNAbY/xDViYseRwi34eWA2DQFAgq77H5wZQ07poZycakY0y6oRWjejQuwGILlgW9Mab4S0uBBXdC3DK47AG45plc93WNO5DCqOmRHE5NZ8rt4fRpVbynT56PBb0xpng7luRsFHIgFq5/DcJH59r81x2HuOejaIJKBfLx3d1oW79qwdRZiCzojTHF1771TsinpcJt86HZNbk2X7Qmkcc/2UCjGhWYNqozDap7HtrxJxb0xpjiadtSZ7imXFUYvQTqXuqxqary32/jeG35Ni5rWoN3RnSiSrnis/pkXnm1BJuI9BeRrSISJyITcjh+j4hsFJF1IvKziLTKdmyi+7ytItLPl8UbY0qoVVNg7jCo2Qzu+jbXkE/PdPHIgg28tnwbN3Wsz4w7u5SokAcvruhFJBB4C+gDJAKRIhKhqrHZms1R1Xfd7QcArwL93YE/DGgN1AOWi0iYqmb5uB/GmJIgKxOWTIDI96D5tTD4PShT0WPzYyczGDc7ml93HObv14TxwNXNiuXqk3nlzdBNFyBOVeMBRGQeMBD4M+hV9Xi29hWAP7atGgjMc28SvlNE4tyf95sPajfGlCSnj8HC0RC3HC673z2zxvODTbsOnWD0zEgSk0/x6i3tGNyxfgEWW7R4E/TBQEK214lA17Mbich9wENAENA727krzzrX8+LPxhiTkyO7nZuuh7fDDf+FTiNzbb56ZzJ3f+RsSTrrrq50aVy9IKossny2TYqqvqWqTYHHgScv5FwRGSsiUSISdfDgQV+VZIzxBwmR8P7VkLLXWbPmPCG/aE0iI95fRbXyQXx6b48SH/LgXdAnAQ2yva7vfs+TecCNF3Kuqk5V1XBVDa9Vq5YXJRljSoSNC2HGdRBUEcYsz3VhMpdLeeWbrTw0fz2dGlbj03t7+M3qk3nlTdBHAqEi0lhEgnBurkZkbyAiodleXgdsd38dAQwTkTIi0hgIBVbnvWxjjF9ThR9egE/GQHAnZ2ZNrTCPzU9nZPHAvLW8+V0cQ8MbMHN0F6qUL1kza3Jz3jF6Vc0UkfHAUiAQmKaqMSIyGYhS1QhgvIhcA2QAR4CR7nNjRGQ+zo3bTOA+m3FjjMlVxmlnN6iN86Hdrc5uUKU8Lxl8MCWNsR9FsS7hKBP+0oK7ezYpkTNrciOqev5WBSg8PFyjoqIKuwxjTGE4cQjm3QYJK6H3U3DFw7nuBrV1fwqjZ0Ry+EQarw/tQP9L6xZgsUWLiESranhOx+zJWGNM0fB7LMwdCqkH4OYZ0HpQrs1/3HaQ+2avoXxQIPPv7l4i1qy5WBb0xpjCt20pLBwDQRVg1FdQv5PHpqrKh7/tZvKXsYTVqcQHI8OpV7VcARZb/FjQG2MKT/aNQi5pC8PmQhXPj9pkZLmYFBHD7FV7uKZlbV4f1oGKZSzGzsd+hYwxhSMzHRb/HdbOglYDnc27gzxPhzx6Mp17Z6/h1x2HuadXUx7t19wvd4PKDxb0xpiCd+IwzL8ddv8CPR+DKyeeZ6OQVO6aGcneo6d55eZ23NSp5C5ncDEs6I0xBevAZmc5g5T9cNMH0GZIrs1/3HaQ8XPWUKZUAHPHdqVTQ3vS9UJZ0BtjCs6fN13Lw51fn/em6/RfdvHcYuem6/sjw6lfrWRsFOJrFvTGmPyX/aZr3TZw67xcb7qmZ7p4OmITc1cn0LdVHV4b2p4KdtP1otmvnDEmf2Wmw+KHYO1H0HIADHo315uuR06kc8+saFbtTObeK5vySN/mBNhN1zyxoDfG5J/Ug85N1z2/wRWPwFVP5HrTdfvvKYyZGcX+46d5bWg7BnWwm66+YEFvjMkf+zbAvOHOsgZe3HRdHvs7f/t4HWVLBzJvbDc6hlQroEL9nwW9Mcb3Yj6Fz+6FctVg9NdQr4PHpqrK2z/s4OVvttK6XmWm3m5PuvqaBb0xxndcLvjxefjxBajfBYbOgkp1PDY/mZ7Jows3sHjDPga2r8fzg9tSLsjz9oDm4ljQG2N8Iy0VPr0btnwJ7W+D61/LdXnhpKOn+OvMKDbvP27LC+czC3pjTN4d2Q1zb4WDm6Hff6DbuFyXF14Vf5h7Z68hPdPFtJGduapF7QIstuSxoDfG5M2un2H+HeDKhNsWQrOrc20+a+VuJkXEEFK9PO+NDKdprYoFVGjJ5dXm4CLSX0S2ikiciEzI4fhDIhIrIhtE5FsRaZjtWJaIrHP/iDj7XGNMMRY1DT4cCOVrwF+/zzXk0zNdPPHpRp78bBOXh9bk0/t6WMgXkPNe0YtIIPAW0AdIBCJFJEJVY7M1WwuEq+pJERkHvAgMdR87partfVu2MaZQZabDkgkQ9QGE9oWb3oeyVTw2P5Saxr2z17B6ZzJ392rCY/1a2MqTBciboZsuQJyqxgOIyDxgIM4+sACo6vfZ2q8ERviySGNMEZJ6wBmq2fMb9HgQrn4aAjzPlNmUdIy7P4rmUGoabwxrz8D2npc+MPnDm6APBhKyvU4EuubSfgzwdbbXZUUkCmdz8OdV9bOzTxCRscBYgJCQEC9KMsYUiqRomDcCTh3x6iGoRWsSmbhoI9UrBLHgHtvur7D49GasiIwAwoFe2d5uqKpJItIE+E5ENqrqjuznqepUYCo4m4P7siZjjI+smwtfPAgV68CYb5wdoTzIyHLxr8WbmfHrLro2rs5bt3WkZkXPUy1N/vIm6JOABtle13e/dwYRuQZ4Auilqml/vK+qSe6f40XkB6ADsOPs840xRVRWBnzzFKx6BxpdATfPhAo1PDbPPh4/ukdjJl7bgtKBXs37MPnEm6CPBEJFpDFOwA8DhmdvICIdgClAf1U9kO39asBJVU0TkZpAD5wbtcaY4uDEYVgwEnb9BF3HQd9nIbC0x+brE45yz6xojpxM5/Wh7bmxg43HFwXnDXpVzRSR8cBSIBCYpqoxIjIZiFLVCOAloCKwwP1k2x5VHQC0BKaIiAtnKufzZ83WMcYUVfs2wLzbIPV3Zz/X9sNzbT4/MoEnP99ErYplWHjPZVwa7HkWjilYolq0hsTDw8M1KiqqsMswpmTbuBA+H+8sSjZsFgR73gkqPdPF5C9jmLVyD5c3q8l/b+1A9QpBBVisARCRaFUNz+mYPRlrjPl/riz49hn45Q0I6Q63fAgVPS9PcOD4ae6dvYao3Ue4u1cTHu3bnFI2Hl/kWNAbYxwnDsMnoyH+BwgfDf1fgFKer8yjdx9h3KxoUk5n8r/hHbi+bb2Cq9VcEAt6YwzsXQcf3+6Mxw94Ezre4bGpqvLhb7t5bnEsl1Qpx4djutCibuWCq9VcMAt6Y0q6dXPgi79BhVrOJiG5jMefTM9k4qKNfL5uL1e3qM2rt7SnSnnPs3BM0WBBb0xJlZkOSydC5PvQuCcMmQ4VanpsHn8wlXtmRbP9QCqP9A3j3iub2abdxYQFvTEl0fF9zno1iavhsgec9WoCPcfBkk37eWTBekoHCh+O7sIVobUKsFiTVxb0xpQ0u3+FBaOcHaFungGtB3lsmpnl4qVvtjLlx3ja1a/C2yM6EWz7uRY7FvTGlBSqsHoqLP0HVG0Id3wOtVt6bH4wJY37565hZXwyI7qF8NT1rShTyvZzLY4s6I0pCdJPwpd/hw3zoPm1MOjdXNePj96dzL2z13DsVAav3tKOwR3rF2Cxxtcs6I3xd4d3wPyR8PsmuOpJuOJhCMj5oSZVZeavu3hu8WaCq5Vj+qgutKpnUyeLOwt6Y/zZlsXw6Tgn2G9bAKF9PDZNOZ3BhEUbWbxhH9e0rMMrt7SjSjmbOukPLOiN8UdZmfD9c/Dza3BJe2cpg2oNPTaP3Xuc++asYU/ySR7v34K7ezaxqZN+xILeGH+TegAWjnaWFu50J/R/HkqXzbGpqjI/KoF/fh5D1fKlmfvXbnRpXL2ACzb5zYLeGH+yZ6UzdfLUkfMuLXwyPZMnP9vEojVJXN6sJq8Pa2+7QPkpC3pj/IEqrHoXvnkSqjSAu5ZD3TYem8cdSGHcrDXEHUzlb9eEcn/vUAJtqMZvWdAbU9ylpUDE/RDzKTS/Dm58G8pV9dj8s7VJTFy0kfJBgXw0uiuXh3pe9sD4B68WjhaR/iKyVUTiRGRCDscfEpFYEdkgIt+KSMNsx0aKyHb3j5G+LN6YEu/AFnivN8R+Dtc8A8Nmewz50xlZTFy0kb99vI42wVX46sErLORLiPNe0YtIIPAW0AdIBCJFJOKsLQHXAuGqelJExuHsCztURKoDTwPhgALR7nOP+LojxpQ4G+Y7q04GlYc7IqDxFR6b7jp0gntnryF233HGXdmUh/uE2QYhJYg3QzddgDhVjQcQkXnAQODPoFfV77O1XwmMcH/dD1imqsnuc5cB/YG5eS/dmBIq4zQseRyiZ0DIZTDkA6jsedOPz9cl8cSnmwgMEKaNCqd3izoFV6spErwJ+mAgIdvrRKBrLu3HAF/ncu4528KLyFhgLEBISIgXJRlTQh3eAQtGwv6NcPnfnSddPaw6eSo9i0kRMXwclUCnhtX4760dbEGyEsqnN2NFZATOME2vCzlPVacCU8HZHNyXNRnjN2I+hc/vd4J9+HwI6+ex6db9KYyf48yque+qpvztmjBK21BNieVN0CcBDbK9ru9+7wwicg3wBNBLVdOynXvlWef+cDGFGlNiZaY50yZXT4X6nZ0NQqo2yLGpqjIvMoFJETFUKlvK1o43gHdBHwmEikhjnOAeBpzxFIaIdACmAP1V9UC2Q0uBf4tINffrvsDEPFdtTElxZJfzANTetdB9vLNBiIcNu1NOZzBx0Ua+3LCPy5vV5NWh7ahdKecnYk3Jct6gV9VMERmPE9qBwDRVjRGRyUCUqkYALwEVgQUiArBHVQeoarKIPIvzjwXA5D9uzBpjzmPLYvhsnDNfbehsaHm9x6YbEo8yfs5ako6e4tF+zRnXq6mtVWP+JKpFa0g8PDxco6KiCrsMYwpPVgYsnwS//c9ZkOzmGVC9cY5NVZUPft7JC0u2UKtiGf57awfCG9laNSWRiESranhOx+zJWGOKkiO74ZMxkBgJXcZC3+egVM7rzySfSOfRBev5dssB+rSqw0tD2lK1fM7DOqZks6A3pqiIjYCI8c66NefZy/Xn7Yd4aP46jp7M4OkbWjHqska4h02NOYcFvTGFLeM0fPMERL4P9TrCkGkeh2rSM1288s1WpqyIp1ntiky/szOt63neEtAYsKA3pnAd2g4L7oTfN553Vk38wVQemLeWTUnHua1rCE9e14pyQbZZtzk/C3pjCsu6ubD4YWcMPpcHoP7YHGRSRCxlSgcw5fZO9Gtdt4CLNcWZBb0xBS0tFb56BNbPhYaXw03veVyr5tjJDCZ+uoGvNu6ne5MavDa0PXWr2Nx4c2Es6I0pSPs3OkM1yTug1wTo9RgE5Dz8sir+MH//eB0HUtJ4vH8LxvZsYpuDmItiQW9MQVB1brYufQLKVct1WeGMLBf//XY7b30fR0j18nwy7jLaNahasPUav2JBb0x+O3HY2QFq62Jo1gcGvQsVct7wY+ehE/z943WsSzjKzZ3qM2lAayqUsb+mJm/sT5Ax+Sn+R/j0bjh5GPr9G7qOg4BzV5FUVeas3sNzX26mdKDw5q0duKGd5zXmjbkQFvTG5IfMdPj+X/DLG1AzFIZ/DJe0y7HpgZTTTPhkI99tOcDlzWry8s3t7Iar8SkLemN87fAOZxmDvWuh0yjnSj6oQo5Nl8bsZ+KijZxIy+TpG1oxsnsjW4zM+JwFvTG+oupMmVz8CASWhls+hFYDc2yampbJ5C9imB+VSOt6lXl9aHtC61Qq4IJNSWFBb4wvnDoKix+CTZ84c+MHT4Eq9XNsGrkrmYfmryPpyCnuu6opD14dRlAp2/3J5B8LemPyas8q+OQuOJ4EvZ9y9nLNYW58eqaL15dv490fdxBcrRzz7+5uSwqbAmFBb8zFysqAFS/DihehagiM+Qbq57gcOFv3p/DQ/HXE7D3OLeH1+ecNralo0yZNAfHqT5qI9AfewNlh6n1Vff6s4z2B14G2wDBVXZjtWBaw0f1yj6oO8EHdxhSuwztg0V8hKRraDoNrX4Kylc9plpnlYupP8by+bDuVypaydWpMoThv0ItIIPAW0AdIBCJFJEJVY7M12wOMAh7J4SNOqWr7vJdqTBGgCtHTnSdcA4NyXTd+x8FUHp6/nnUJR/nLpXV57sZLqVEx501EjMlP3lzRdwHiVDUeQETmAQOBP4NeVXe5j7nyoUZjiobUA84TrtuWQJOr4Ma3c1yMzOVSpv+6ixeXbKFs6UDeGNaeAe3q2cYgptB4E/TBQEK214lA1wv4HmVFJArIBJ5X1c/ObiAiY4GxACEhIRfw0cYUkC1fOSGflgL9X3C2+cvhCdfdh0/w6IINrN6VzNUtavOfwW2oXdkefjKFqyDuBjVU1SQRaQJ8JyIbVXVH9gaqOhWYCs7m4AVQkzHeSUuFpRNhzYdQtw0M/hJqtzynmculzF61m/98vYVAEV4a0pYhnerbVbwpErwJ+iSgQbbX9d3veUVVk9w/x4vID0AHYEeuJxlTFCSshkVj4cgu6PE3uOqJHHd/Sjp6iscWrueXuMNcEVqTF25qS72q5Qq8XGM88SboI4FQEWmME/DDgOHefLiIVANOqmqaiNQEegAvXmyxxhSIrAxY8ZLzo3J9GLUYGvU4p9kfOz89++VmXKr8a9ClDO8SYlfxpsg5b9CraqaIjAeW4kyvnKaqMSIyGYhS1QgR6Qx8ClQDbhCRZ1S1NdASmOK+SRuAM0Yf6+FbGVP4fo+Fz+6Bfeuh3a3wlxeg7Lmbbyckn2Tioo38HHeIbk2q89KQdjSoXr4QCjbm/ES1aA2Jh4eHa1RUVGGXYUoaVxb8+qaz4mSZynD9a9Dq3Ec+XC7lw9928cKSrQQGCBP+0oLhXUJsITJT6EQkWlVzfGLPHs0z5lAcfDYOEldDyxvgutegYq1zmu04mMrjCzcQtfsIvcJq8e/BbQi2sXhTDFjQm5LL5YLI92DZ085N1sHvQ5shcNYYe2aWi/d+2slry7dRrnQgr9zcjsEdg20s3hQbFvSmZDqyGz6/D3b95GzvN+BNqHzJOc027zvOYws3sDHpGP1b12Xyja2pXcnmxZvixYLelCyqzpz4pf9wXg94Ezrcfs5VfFpmFm99F8fbP+ygavnSvH1bR65tc+4/BMYUBxb0puQ4vhciHoC4ZdDoChj4FlRreE6z6N1HmLhoA9t+T2VQh2D+eX0rqlU4d/68McWFBb3xf6qwdpazEFlWOvzlRej813OWMDh+OoMXl2xh9qo91K1clmmjwundok4hFW2M71jQG/92dI9zFR//PTTs4QzV1Gh6RhNVZWnMfv75eQwHU9MYdVkjHu7b3NaLN37D/iQb/+RyQdQHsHySc0V/7csQPuacq/i9R0/xz89jWL75d1peUpn37ginXYOqhVKyMfnFgt74n8M7nKv43T87ywnf8MY5Y/FZ7gefXl66lSxV/nFtC0b3aEypQNu71fgfC3rjP1xZsOpd+PZZZ1OQAf+DDiPOmVETu/c4ExdtYH3iMXqF1eK5Gy+15QuMX7OgN/7h4FZnXnxiJIT1d5YwOGtTkFPpWbz+7Tbe/2knVcuVtg1BTIlhQW+Kt6wM+PW/8MPzEFTB49Oty2J/Z1JEDElHTzE0vAETr21B1fI2ZdKUDBb0pvhKjIYvHoDfN0Grgc4N14q1z2iSkHySSRExfLvlAKG1KzJvbDe6NalRSAUbUzgs6E3xk5YC3z0Hq6ZApUtg6Gxoef2ZTTKzmPpjPP/7Po7AAOEf17bgzh6NKW03W00JZEFvipetX8Pih52nXDvfBVf/E8pWPqPJim0HeToihp2HTnBtm7o8dX0rLqliq0yaksuryxsR6S8iW0UkTkQm5HC8p4isEZFMERly1rGRIrLd/WOkrwo3JUzKfph/B8wd5mwEMmYZXPfyGSG//9hp7pu9hjumrUZVmTm6C2/f1slC3pR4572iF5FA4C2gD5AIRIpIxFk7Re0BRgGPnHVudeBpIBxQINp97hHflG/8nssFa2bAskmQeRp6PwWXPXDG3q0ZWS5m/LKL15dvI9OlPNQnjLE9m1C2dGChlW1MUeLN0E0XIE5V4wFEZB4wEPgz6FV1l/uY66xz+wHLVDXZfXwZ0B+Ym+fKjf87sAW+eBASVjqLkN3wxjnLF/y64xDPRMSy9fcUereozaQbWhNSw+bEG5OdN0EfDCRke50IdPXy83M6N/jsRiIyFhgLEBIS4uVHG7+VcQp+ehV+fg3KVISBb0P74WdMmUxIPsm/v9rM15v2E1y1HFNv70SfVnVsTrwxOSgSN2NVdSowFZw9Ywu5HFOYti2Frx6Fo7uhzS3Q799nbOt3Kj2Ld36IY8qKeAJEeLhPGH+1YRpjcuVN0CcBDbK9ru9+zxtJwJVnnfuDl+eakuToHlgyEbZ8CTWbw8gvoHHPPw+rKl9s2Md/vtrMvmOnuaFdPSb+pQX1bM9WY87Lm6CPBEJFpDFOcA8Dhnv5+UuBf4tINffrvsDEC67S+K/MdPjtf/Dji87QzDWToNt9Z9xs3ZR0jMlfxLJ6VzKtLqnMG8M60KVx9cKr2Zhi5rxBr6qZIjIeJ7QDgWmqGiMik4EoVY0Qkc7Ap0A14AYReUZVW6tqsog8i/OPBcDkP27MGsPOFc6c+EPboMX10P95qPr//3k8nJrGy99sY17kHqqVD+Lfg9owtHMDAgNsHN6YCyGqRWtIPDw8XKOiogq7DJOfUvbDN0/CxgVQtSFc+xKE9fvzcHqmi49W7uaN5ds4kZ7FHd0b8rerw6hSvnQhFm1M0SYi0aoantOxInEz1pQQWZkQ+T58/y9nTnyvx+Hyv0NpZ5xdVVmyaT/PL9nC7sMnuSK0Jv+8vhWhdSoVcuHGFG8W9KZgxP8ISybAgVhoerVzFZ9tTvzaPUf41+LNRO0+Qlidisy4szO9wmrZdEljfMCC3uSvI7ucTbm3fOkM0wyd5YzHuwM8IfkkLyzZwpcb9lGzYhn+M7gNN3eqbzs9GeNDFvQmf6SfcB56+vVNCAiE3k9C9/uhdFkAjp3M4K0f4pjxyy4CAuCB3s0Y26upbchtTD6wv1XGt1Rh40JY9k9I2QttboZrnoEqzgPR6ZkuZq/azRvfbufYqQyGdKzPw32bU7dK2UIu3Bj/ZUFvfGfvOvj6cWdtmkvawc3TIaQbAC6XsnjjPl75Ziu7Dp+kR7Ma/OPalrSuV6VwazamBLCgN3mXehC+mwxrPoLyNWDAm9D+NggIRFX5cdtBXlq6lZi9x2lepxLTR3XmyuZ2o9WYgmJBby5e+klY+Tb8/DpknoLu90Gvx5z14oHo3cm8sGQrq3cmU79aOV4b2o4B7YLtgSdjCpgFvblwrizY8DF8+6wzDt/8OujzDNQMBWDL/uO8vHQryzcfoGbFMkwe2JphnUMIKmUzaYwpDBb05sLs+B6+eQp+3wj1OsJN70OjHgDsOXyS15Zv47N1SVQsU4pH+zXnzh6NKB9kf8yMKUz2N9B45/dYWPYUxC2HqiFw0wfQejAEBHAg5TT/+y6Ouav3ECDC2J5NGNerKVXLB53/c40x+c6C3uTu+D5nyYJ1s6FMJej7HHQZC6XKcCDlNFN+jGfWyt1kupShnRvwQO9QmyppTBFjQW9ydvq4s3zwr29CVgZ0HQc9H4Hy1d0BH/tnwN/YPpj7ezejUc0KhV21MSYHFvTmTBmnnIXHfnoVTiVD60Fw9dNQvbET8F9awBtT3FjQG0dmOqz9CFa8BCn7nIXHej8JwR05kHKaqV/GMmvVbjKyLOCNKW4s6Es6V5azLvwP/3EWIAvp7txobdTDAt4YP+FV0ItIf+ANnB2m3lfV5886Xgb4EOgEHAaGquouEWkEbAa2upuuVNV7fFS7yQtVZ0XJ756Dg1ugblu4bSE0u4aEI6d4//NNfByVYAFvjB84b9CLSCDwFtAHSAQiRSRCVWOzNRsDHFHVZiIyDHgBGOo+tkNV2/u2bHPRVGHHd/Dds7B3LdQMg5tnQssBbD1wgnfnrydi/V4CBAZ1CObeKy3gjSnuvLmi7wLEqWo8gIjMAwYC2YN+IDDJ/fVC4H9iC5kULX8E/IqXYM9vUCUEbnwH2txCdGIK73wUzfLNBygfFMidlzVizBWNuaRKucKu2hjjA94EfTCQkO11ItDVUxv3ZuLHgBruY41FZC1wHHhSVX86+xuIyFhgLEBISMgFdcCchypsW+oEfFIUVA6Ga19GO9zOD/HHeef9SFbvTKZa+dL8/Zow7ujekGoV7EEnY/xJft+M3QeEqOphEekEfCYirVX1ePZGqjoVmArO5uD5XFPJ4HI5Y/ArXoL9G5ynWa9/ncw2w/hqyxHeeTuSzfuOc0mVsvzz+lYM69LAliowxk958zc7CWiQ7XV993s5tUkUkVJAFeCwqiqQBqCq0SKyAwgDovJauPHAlQUxn8JPrzj7s1ZvCgPf5njYIOav2c+M138j8cgpmtaqwEtD2jKwfbAtNmaMn/Mm6COBUBFpjBPow4DhZ7WJAEYCvwFDgO9UVUWkFpCsqlki0gQIBeJ9Vr35f1mZzjTJn16Bw9uhZnMY/D476/Zl5spEFny6ghPpWXRpXJ0nr2tF31Z1CLDlgo0pEc4b9O4x9/HAUpzpldNUNUZEJgNRqhoBfAB8JCJxQDLOPwYAPYHJIpIBuIB7VDU5PzpSYqWfgHVznOUKjuyCOpeiQ2bwW5keTPt1N99u+ZlSAcIN7eoxukdjLg22HZ2MKWnEGV0pOsLDwzUqykZ2zivld1g9FaI+gFNHILgT6d3/zmcn2zLt191s2Z9CjQpB3NatISO6hlC7si00Zow/E5FoVQ3P6ZjdfStuDmxxrt43fOwsNtbiOg61HcvMhDrM+TSBwyc20aJuJV68qS0D2tejbOnAwq7YGFPILOiLA1XYucIJ+O3fQKmyuDrczsraQ/kgNoDvPzqAksrVLWozukdjujetYfuxGmP+ZEFflGVlQMxn8Ot/nSmS5WuS0v1x5rj6MHPdcfYeO0StSmUYd2VThnUOoUH18oVdsTGmCLKgL4qOJUH0DFjzIaTuR2uGsbXLv3jjQEe++fEoWa4DXBFak6eub8U1repQOtCmRxpjPLOgLypcLoj/HqKmwdavQV2kNerNskYTeH57AxJXpFGjwgn+ekUTbu3SgIY1bP0ZY4x3LOgL28lkWDsLoqdDcjxargbbmo5iyomefLa1NC6Fy5pWZMJ1rejbqq493GSMuWAW9IVBFRKjnKmRmxZBVhrHaoXzRb3hvJTYgmObAmhQvRzjrwpmUMf6NLbVI40xeWBBX5BSD8DGhbB+DuzfSFbpCqyrcR2vJF/Orwl1qVS2FNe3v4TBHesT3rCazZwxxviEBX1+Sz8JW7+C9fOcZYI1i4OVWjKv/L28m9yJtBPlubJ5bd7uGEzvFrVt3rsxxucs6PODywW7f4b1H0Ps55CeQkqZOiwpM4gpx7oQd7o+7RpU5bHLg7m+7SXUqFimsCs2xvgxC3pfOrAFNsxDNyxAjieSFliB76QbH6Z3Y+XplnQIqc4tl9WlX+u6NmvGGFNgLOjzQtXZjm/rV+iWxciBWFwEsiqgHXPSb+Q7wmnf5BKubV2X11vXpY6tN2OMKQQW9BcqMx12rYAtX5G5+StKndiHiwDW0JzFGbezhB60Cm1Gv0vr8kzLOlS33ZqMMYXMgt4bp45C3HIyYr9Ati+jVOYJTlGGH7PasixrIJsqdKNNWBN6hdXioea1qFS2dGFXbIwxf7Kgz0nGKUiKJiP+Z05t/5EK+1cRqFkc08osy+rCioDOuBr1omtYMPeE1qRZ7Yo2FdIYU2RZ0AOcPkbWrt84smUF7P6Fqkc3UUozCVQhSevzo+tadtboSa2WPbg8rC43hVSzJ1SNMcWGV0EvIv2BN3B2mHpfVZ8/63gZ4EOgE3AYGKqqu9zHJgJjgCzgAVVd6rPqL0ZmOnp0D4d3rOH4thWU37uS2qfiCESpooFs1MZEBFxLco1wgpp0p3mjEIY2qk41G2s3xhRT5w16EQkE3gL6AIlApIhEqGpstmZjgCOq2kxEhgEvAENFpBXOtoKtgXrAchEJU9UsX3fkT6qcOLKfwwlbSd0fR8ahnQQc20251ASqpO2letYhAnFRE6igQazTUH6oeCtpwd2oFtadSxvVY1SNCrafqjHGb3hzRd8FiFPVeAARmQcMBLIH/UBgkvvrhcD/xBm0HgjMU9U0YKd7T9kuOJuI+9Sh/XtImXoDdVz7qEAa2Wep/65V2R9Ql8Qyl3KySgMyqzakdO0wQlp1o1O9GnS3YRhjjB/zJuiDgYRsrxOBrp7auDcTPwbUcL+/8qxzg8/+BiIyFhgLEBIS4m3tZ6hYtRYJZeuxv0IXsqo2pHSNxlSo24zqwc2oXb0adWzNdmNMCVUkbsaq6lRgKjibg1/MZ5QtW44Oj33t07qMMcYfeHOZmwQ0yPa6vvu9HNuISCmgCs5NWW/ONcYYk4+8CfpIIFREGotIEM7N1Yiz2kQAI91fDwG+U1V1vz9MRMqISGMgFFjtm9KNMcZ447xDN+4x9/HAUpzpldNUNUZEJgNRqhoBfAB85L7ZmozzjwHudvNxbtxmAvfl64wbY4wx5xDnwrvoCA8P16ioqMIuwxhjihURiVbV8JyO2VQUY4zxcxb0xhjj5yzojTHGz1nQG2OMnytyN2NF5CCwOw8fURM45KNyiouS1ueS1l+wPpcUeelzQ1WtldOBIhf0eSUiUZ7uPPurktbnktZfsD6XFPnVZxu6McYYP2dBb4wxfs4fg35qYRdQCEpan0taf8H6XFLkS5/9bozeGGPMmfzxit4YY0w2FvTGGOPnik3Qi0h/EdkqInEiMiGH42VE5GP38VUi0ijbsYnu97eKSL8CLTwPLrbPItJHRKJFZKP7594FXvxFysvvs/t4iIikisgjBVZ0HuXxz3ZbEflNRGLcv99lC7T4i5SHP9ulRWSmu6+bRWRigRd/kbzoc08RWSMimSIy5KxjI0Vku/vHyLPPPS9VLfI/cJZH3gE0AYKA9UCrs9rcC7zr/noY8LH761bu9mWAxu7PCSzsPuVznzsA9dxfXwokFXZ/8rvP2Y4vBBYAjxR2fwrg97kUsAFo535dowT82R6Osw81QHlgF9CosPvkoz43AtoCHwJDsr1fHYh3/1zN/XW1C/n+xeWK/s8NylU1Hfhjg/LsBgIz3V8vBK4+e4NyVd0J/LFBeVF30X1W1bWqutf9fgxQTkTKFEjVeZOX32dE5EZgJ06fi4u89LkvsEFV1wOo6mEtHvs95KXPClRw72RXDkgHjhdM2Xly3j6r6i5V3QC4zjq3H7BMVZNV9QiwDOh/Id+8uAR9ThuUn73J+BkblAPZNyg/37lFUV76nN1NwBpVTcunOn3povssIhWBx4FnCqBOX8rL73MYoCKy1P1f/scKoF5fyEufFwIngH3AHuBlVU3O74J9IC85lOcMKxKbg5v8ISKtgRdwrvz83STgNVVNdV/glwSlgMuBzsBJ4Fv35hPfFm5Z+aoLkAXUwxnG+ElElqtqfOGWVbQVlyv6krhBeV76jIjUBz4F7lDVHflerW/kpc9dgRdFZBfwN+Af7i0wi7q89DkRWKGqh1T1JPAV0DHfK867vPR5OLBEVTNU9QDwC1Ac1sPJSw7lPcMK+yaFlzcySuHcgGjM/9/IaH1Wm/s48+bNfPfXrTnzZmw8xeOGVV76XNXdfnBh96Og+nxWm0kUn5uxefl9rgaswbkpWQpYDlxX2H3K5z4/Dkx3f10BZz/qtoXdJ1/0OVvbGZx7M3an+/e7mvvr6hf0/Qv7F+ACfqGuBbbh3Ll+wv3eZGCA++uyOLMt4oDVQJNs5z7hPm8r8JfC7kt+9xl4Emccc122H7ULuz/5/fuc7TOKTdDntc/ACJybz5uAFwu7L/ndZ6Ci+/0Yd8g/Wth98WGfO+P8L+0Ezv9eYrKdO9r9axEH3Hmh39uWQDDGGD9XXMbojTHGXCQLemOM8XMW9MYY4+cs6I0xxs9Z0BtjjJ+zoDfGGD9nQW+MMX7u/wCIrO9StyxVTAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "norms = []\n", + "for r in np.linspace(1e-5,0.1,30):\n", + " V_dbi = dbi.eval_dbr_unitary(r, d=d_0.dense.matrix)\n", + " R_dbi = dbi2.eval_dbr_unitary(r, d=d_0.dense.matrix)\n", + " norms.append(norm(V_dbi.conj().T - R_dbi))\n", + " \n", + "plt.plot(np.linspace(1e-5,.1,30), [x**1.5*12 for x in np.linspace(1e-5,.1,30)])\n", + "plt.plot(np.linspace(1e-5,.1,30),norms)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "abee7a77", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", + "\n", + "\n", + "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", + "\n", + "import matplotlib.pyplot as plt\n", + "norms = []\n", + "for r in np.linspace(1e-5,0.1,30):\n", + " dbi(r, d=d_0.dense.matrix)\n", + " dbi2(r, d=d_0.dense.matrix)\n", + " norms.append(norm(dbi.h.matrix- dbi2.h.matrix))\n", + " \n", + "plt.plot(np.linspace(1e-5,.1,30), [x**1.5*1000 for x in np.linspace(1e-5,.1,30)])\n", + "plt.plot(np.linspace(1e-5,.1,30),norms)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "146a12c5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eceff544", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 12, - "id": "7a0c43ac", + "id": "687075d6", "metadata": {}, "outputs": [ { @@ -297,7 +404,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "2b6140e1", + "id": "72b0fefe", "metadata": {}, "outputs": [ { @@ -318,7 +425,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "156530d7", + "id": "eac25174", "metadata": {}, "outputs": [], "source": [ @@ -373,7 +480,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "9b926a77", + "id": "be332dde", "metadata": {}, "outputs": [ { @@ -393,7 +500,7 @@ }, { "cell_type": "markdown", - "id": "3b93f833", + "id": "75b5146e", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", @@ -413,6 +520,149 @@ "$$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n" ] }, + { + "cell_type": "code", + "execution_count": 52, + "id": "60e228b9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-06 16:29:36]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-06 16:29:36]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "t_step = 0.1\n", + "\n", + "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", + " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", + "h_input = h_x + d_0 \n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.group_commutator\n", + "dbi(t_step, d = -d_0.dense.matrix )\n", + "\n", + "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi2.mode = DoubleBracketGeneratorType.single_commutator\n", + "dbi2(t_step, d = d_0.dense.matrix )\n", + "\n", + "norms = []\n", + "\n", + "sigma_decrease_dbi = []\n", + "sigma_decrease_gci = []\n", + "for r in range(30):\n", + " dbi(t_step, d=-d_0.dense.matrix)\n", + " dbi2(t_step, d=d_0.dense.matrix)\n", + " sigma_decrease_dbi.append(dbi.off_diagonal_norm)\n", + " \n", + " sigma_decrease_gci.append(dbi2.off_diagonal_norm)\n", + " norms.append(norm(dbi.h.matrix- dbi2.h.matrix))\n", + " \n", + " \n", + "plt.plot(norms)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "161bc408", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(sigma_decrease_dbi)\n", + "plt.plot(sigma_decrease_gci)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "c25a251c", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "group_commutator_other_sorting", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_14250/4112881237.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mgci\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGroupCommutatorIterationWithEvolutionOracles\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevolution_oracle\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator_other_sorting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.10/enum.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(cls, name)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_member_map_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 436\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 437\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 438\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: group_commutator_other_sorting" + ] + } + ], + "source": [ + "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", + "evolution_oracle.eps_trottersuzuki = eps\n", + "\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", + "\n", + "assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", + "assert norm(gci.h.matrix - dbi2.h.matrix) < 20 * norm(h_input) * t_step\n", + "\n", + "dbi(t_step, d = d_0.dense.matrix ) \n", + "dbi2(t_step, d = d_0.dense.matrix ) \n", + "gci(t_step, diagonal_association=evolution_oracle_diagonal_target) \n", + "assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", + "assert norm(gci.h.matrix - dbi2.h.matrix) < (20 * norm(h_input) * t_step)**2" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index c9f92e67af..90761dda0d 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -134,9 +134,9 @@ def eval_dbr_unitary( sqrt_step = np.sqrt(step) operator = ( self.h.exp(-np.sqrt(step)) - @ self.backend.calculate_matrix_exp(-np.sqrt(step), d) - @ self.h.exp(np.sqrt(step)) @ self.backend.calculate_matrix_exp(np.sqrt(step), d) + @ self.h.exp(np.sqrt(step)) + @ self.backend.calculate_matrix_exp(-np.sqrt(step), d) ) else: raise_error(ValueError, f"Mode { mode } not recognized.") From 6de60038c03f624a69ab4e1a67a430af975c0f97 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 8 Apr 2024 14:18:17 +0800 Subject: [PATCH 088/116] Update notebooks to function --- examples/dbi/dbi_scheduling.ipynb | 25 +- examples/dbi/dbi_strategies_compare.ipynb | 55 +- examples/dbi/dbi_strategy_Ising_model.ipynb | 880 +----------------- .../dbi/dbi_strategy_magnetic_field.ipynb | 872 ----------------- 4 files changed, 82 insertions(+), 1750 deletions(-) delete mode 100644 examples/dbi/dbi_strategy_magnetic_field.ipynb diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index a7a813fcba..fdb087871b 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -105,7 +105,9 @@ "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, max_evals=100, step_max=0.6)\n", "print('hyperopt_search step:', step_hyperopt)\n", "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, n=5)\n", - "print('polynomial_approximation step:', step_poly)" + "print('polynomial_approximation step:', step_poly)\n", + "step_sa = dbi.choose_step(scheduling=DoubleBracketScheduling.simulated_annealing)\n", + "print('simulated_annealing step:', step_sa)" ] }, { @@ -119,6 +121,7 @@ "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.axvline(x=step_sa, color='b', linestyle=':',label='simulated annealing')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", "plt.title('First DBI step')\n", @@ -184,7 +187,11 @@ "# polynomial expansion\n", "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=5)\n", "poly_min = dbi.loss(step=step_poly, d=d)-dbi.off_diagonal_norm\n", - "print('polynomial_approximation step:', step_poly, 'loss', poly_min)" + "print('polynomial_approximation step:', step_poly, 'loss', poly_min)\n", + "# simulated annealing\n", + "step_sa = dbi.choose_step(scheduling=DoubleBracketScheduling.simulated_annealing, d=d)\n", + "sa_min = dbi.loss(step=step_sa, d=d)-dbi.off_diagonal_norm\n", + "print('simulated_annealing step:', step_sa, 'loss', sa_min)" ] }, { @@ -197,9 +204,11 @@ "plt.plot(s_space, off_diagonal_norm_diff)\n", "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", "plt.text(x=step_grid, y=grid_min, s=f'grid min \\n{round(grid_min,3)}')\n", - "plt.text(x=step_poly, y=poly_min, s=f'grid min \\n{round(poly_min,3)}')\n", + "plt.text(x=step_poly, y=poly_min, s=f'poly min \\n{round(poly_min,3)}')\n", + "plt.text(x=step_sa, y=sa_min, s=f'sa min \\n{round(sa_min,3)}')\n", "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.axvline(x=step_sa, color='b', linestyle=':',label='simulated annealing')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", "plt.title(f'First DBI step with D={d_str}')\n", @@ -320,10 +329,12 @@ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", " DoubleBracketScheduling.hyperopt,\n", - " DoubleBracketScheduling.polynomial_approximation,]\n", + " DoubleBracketScheduling.polynomial_approximation,\n", + " DoubleBracketScheduling.simulated_annealing,]\n", "scheduling_labels = ['grid search',\n", " 'hyperopt',\n", - " 'polynomial',]\n", + " 'polynomial',\n", + " 'simulated_annealing']\n", "Z_optimal_scheduling = []\n", "s_scheduling = []\n", "off_norm_scheduling =[]\n", @@ -380,7 +391,7 @@ "outputs": [], "source": [ "# Hamiltonian\n", - "set_backend(\"qibojit\", \"numba\")\n", + "set_backend(\"qibojit\", platform=\"numba\")\n", "\n", "# hamiltonian parameters\n", "nqubits = 5\n", @@ -431,7 +442,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.11.7" }, "vscode": { "interpreter": { diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb index 1160babed3..7b422cf05d 100644 --- a/examples/dbi/dbi_strategies_compare.ipynb +++ b/examples/dbi/dbi_strategies_compare.ipynb @@ -23,7 +23,7 @@ "from qibo import hamiltonians, set_backend\n", "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", "from qibo.quantum_info import random_hermitian\n", - "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", "from qibo.models.dbi.utils import *\n", "from qibo.models.dbi.utils_scheduling import *" ] @@ -64,7 +64,8 @@ "nqubits = 5\n", "h0 = random_hermitian(2**nqubits, seed=2)\n", "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))\n", - "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", + "cost = DoubleBracketCostFunction.off_diagonal_norm\n", + "print(\"Initial loss\", dbi.least_squares(D=dbi.diagonal_h_matrix))\n", "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" ] }, @@ -94,7 +95,7 @@ "outputs": [], "source": [ "# initialize DBI class for the canonical case\n", - "dbi_canonical = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.canonical, scheduling=scheduling)" + "dbi_canonical = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.canonical, scheduling=scheduling, cost=cost)" ] }, { @@ -104,14 +105,15 @@ "outputs": [], "source": [ "# Canonical\n", - "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n", + "loss_history_canonical = [dbi_canonical.off_diagonal_norm]\n", "steps_canonical_plot = [0]\n", "for s in range(NSTEPS):\n", " # same settings as iteration from list\n", - " step = dbi_canonical.choose_step(d=dbi.diagonal_h_matrix)\n", + " d = dbi.diagonal_h_matrix\n", + " step = dbi_canonical.choose_step(d=d)\n", " dbi_canonical(step=step)\n", " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", - " off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n", + " loss_history_canonical.append(dbi_canonical.off_diagonal_norm)\n", " steps_canonical_plot.append(steps_canonical_plot[-1]+step)" ] }, @@ -129,7 +131,7 @@ "outputs": [], "source": [ "# initialize DBI class for the Pauli-Z strategy\n", - "dbi_pauli = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)" + "dbi_pauli = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling, cost=cost)" ] }, { @@ -143,12 +145,13 @@ "Z_names = list(generate_local_Z.keys())\n", "Z_optimal = []\n", "# add in initial values for plotting\n", - "off_diagonal_norm_history_pauli = [dbi_pauli.off_diagonal_norm]\n", + "loss_history_pauli = [dbi_pauli.off_diagonal_norm]\n", "steps_pauli_plot = [0]\n", "scheduling = DoubleBracketScheduling.simulated_annealing\n", "for _ in range(NSTEPS):\n", " dbi_pauli, idx, step, flip_sign = select_best_dbr_generator(dbi_pauli, Z_ops, scheduling=scheduling, compare_canonical=False)\n", - " off_diagonal_norm_history_pauli.append(dbi_pauli.off_diagonal_norm)\n", + " d = Z_ops[idx]\n", + " loss_history_pauli.append(dbi_pauli.off_diagonal_norm)\n", " steps_pauli_plot.append(steps_pauli_plot[-1]+step)\n", " if flip_sign < 0:\n", " Z_optimal.append('-' + Z_names[idx])\n", @@ -171,7 +174,7 @@ "outputs": [], "source": [ "# initialize DBI class for the canonical case\n", - "dbi_gradient = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)" + "dbi_gradient = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling, cost=cost)" ] }, { @@ -180,9 +183,9 @@ "metadata": {}, "outputs": [], "source": [ - "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", - "d_coef = onsite_Z_decomposition(dbi_gradient.h.matrix, onsite_Z_ops)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" + "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n", + "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n", + "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])" ] }, { @@ -191,12 +194,12 @@ "metadata": {}, "outputs": [], "source": [ - "off_diagonal_norm_history_gradient = [dbi_gradient.off_diagonal_norm]\n", + "loss_history_gradient = [dbi_gradient.off_diagonal_norm]\n", "steps_gradient_plot= [0]\n", "for _ in range(NSTEPS):\n", - " step, d_coef, d = gradient_descent_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops)\n", + " step, d_coef, d = gradient_descent_pauli(dbi_gradient, d_coef, d, pauli_operator_dict=pauli_operator_dict)\n", " dbi_gradient(d=d,step=step)\n", - " off_diagonal_norm_history_gradient.append(dbi_gradient.off_diagonal_norm)\n", + " loss_history_gradient.append(dbi_gradient.off_diagonal_norm)\n", " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n", " steps_gradient_plot.append(steps_gradient_plot[-1]+step)" ] @@ -208,9 +211,9 @@ "outputs": [], "source": [ "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n", - "plt.plot(off_diagonal_norm_history_canonical, label='canonical')\n", - "plt.plot(off_diagonal_norm_history_pauli, label='Pauli-Z')\n", - "plt.plot(off_diagonal_norm_history_gradient, label='gradient')\n", + "plt.plot(loss_history_canonical, label='canonical')\n", + "plt.plot(loss_history_pauli, label='Pauli-Z')\n", + "plt.plot(loss_history_gradient, label='gradient')\n", "plt.legend()\n", "plt.xlabel('Iteration')\n", "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" @@ -223,9 +226,9 @@ "outputs": [], "source": [ "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n", - "plt.plot(steps_canonical_plot, off_diagonal_norm_history_canonical, marker='o', label='canonical')\n", - "plt.plot(steps_pauli_plot, off_diagonal_norm_history_pauli, marker='o', label='Pauli-Z')\n", - "plt.plot(steps_gradient_plot,off_diagonal_norm_history_gradient, marker='o', label='gradient')\n", + "plt.plot(steps_canonical_plot, loss_history_canonical, marker='o', label='canonical')\n", + "plt.plot(steps_pauli_plot, loss_history_pauli, marker='o', label='Pauli-Z')\n", + "plt.plot(steps_gradient_plot,loss_history_gradient, marker='o', label='gradient')\n", "plt.legend()\n", "plt.xlabel('Iteration')\n", "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" @@ -375,9 +378,9 @@ "metadata": {}, "outputs": [], "source": [ - "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", - "d_coef = onsite_Z_decomposition(dbi_gradient.h.matrix, onsite_Z_ops)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" + "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n", + "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n", + "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])" ] }, { @@ -399,7 +402,7 @@ "off_diagonal_norm_history_gradient = [dbi_gradient.off_diagonal_norm]\n", "steps_gradient_plot= [0]\n", "for _ in range(NSTEPS):\n", - " step, d_coef, d = gradient_descent_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops)\n", + " step, d_coef, d = gradient_descent_pauli(dbi_gradient, d_coef, d, pauli_operator_dict=pauli_operator_dict)\n", " dbi_gradient(d=d,step=step)\n", " off_diagonal_norm_history_gradient.append(dbi_gradient.off_diagonal_norm)\n", " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n", diff --git a/examples/dbi/dbi_strategy_Ising_model.ipynb b/examples/dbi/dbi_strategy_Ising_model.ipynb index 159560f792..a6c84b0747 100644 --- a/examples/dbi/dbi_strategy_Ising_model.ipynb +++ b/examples/dbi/dbi_strategy_Ising_model.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -57,34 +57,9 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-04-03 08:21:24]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 31.576176740060667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# backend\n", "set_backend(\"qibojit\", platform=\"numba\")\n", @@ -108,39 +83,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:21:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 572.27trial/s, best loss: 27.607173414553387]\n", - "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j)]\n", - "Gradient: [-0.20481773 0.41841615 -0.03164361 0.18666951 -0.86436728]\n", - "s: 0.11659660342715238\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/Documents/GitHub/qibo/src/qibo/models/dbi/utils.py:268: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = (\n" - ] - } - ], + "outputs": [], "source": [ "# generate pauli_operator_dict\n", "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=1)\n", @@ -154,46 +99,9 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 656.84trial/s, best loss: 27.607178280638898]\n", - "100%|██████████| 500/500 [00:00<00:00, 639.38trial/s, best loss: 24.351929237913915]\n", - "100%|██████████| 500/500 [00:00<00:00, 655.61trial/s, best loss: 22.089739447397726]\n", - "100%|██████████| 500/500 [00:00<00:00, 663.89trial/s, best loss: 20.346440770606122]\n", - "100%|██████████| 500/500 [00:00<00:00, 639.24trial/s, best loss: 18.946903760228178]\n", - "100%|██████████| 500/500 [00:00<00:00, 650.95trial/s, best loss: 17.7755177782418] \n", - "100%|██████████| 500/500 [00:00<00:00, 674.60trial/s, best loss: 16.785446486734276]\n", - "100%|██████████| 500/500 [00:00<00:00, 664.40trial/s, best loss: 15.933524819099162] \n", - "100%|██████████| 500/500 [00:00<00:00, 655.76trial/s, best loss: 15.195995775240494]\n", - "100%|██████████| 500/500 [00:00<00:00, 633.46trial/s, best loss: 14.474767679378404]\n", - "100%|██████████| 500/500 [00:00<00:00, 638.92trial/s, best loss: 14.025120975809307]\n", - "100%|██████████| 500/500 [00:00<00:00, 603.17trial/s, best loss: 13.622403395436098]\n", - "100%|██████████| 500/500 [00:00<00:00, 670.03trial/s, best loss: 13.244304046805466]\n", - "100%|██████████| 500/500 [00:00<00:00, 666.31trial/s, best loss: 12.938522658932913] \n", - "100%|██████████| 500/500 [00:00<00:00, 656.53trial/s, best loss: 12.622483913681776]\n", - "100%|██████████| 500/500 [00:00<00:00, 585.38trial/s, best loss: 12.260523262483813]\n", - "100%|██████████| 500/500 [00:00<00:00, 645.94trial/s, best loss: 11.863294969541887]\n", - "100%|██████████| 500/500 [00:00<00:00, 697.70trial/s, best loss: 11.477785002400976] \n", - "100%|██████████| 500/500 [00:00<00:00, 684.35trial/s, best loss: 11.090736331075858] \n", - "100%|██████████| 500/500 [00:00<00:00, 739.76trial/s, best loss: 10.686003198269908] \n", - "100%|██████████| 500/500 [00:00<00:00, 717.78trial/s, best loss: 10.057480301384102] \n", - "100%|██████████| 500/500 [00:00<00:00, 712.94trial/s, best loss: 10.058298967085108] \n", - "100%|██████████| 500/500 [00:00<00:00, 724.09trial/s, best loss: 10.059015434243745] \n", - "100%|██████████| 500/500 [00:00<00:00, 709.43trial/s, best loss: 10.060281060360927] \n", - "100%|██████████| 500/500 [00:00<00:00, 740.79trial/s, best loss: 10.060583338964047]\n", - "100%|██████████| 500/500 [00:00<00:00, 733.24trial/s, best loss: 10.061781462286367] \n", - "100%|██████████| 500/500 [00:00<00:00, 725.24trial/s, best loss: 10.06205592136255]\n", - "100%|██████████| 500/500 [00:00<00:00, 732.59trial/s, best loss: 10.06257005000825] \n", - "100%|██████████| 500/500 [00:00<00:00, 750.26trial/s, best loss: 10.063192908922257] \n", - "100%|██████████| 500/500 [00:00<00:00, 710.47trial/s, best loss: 10.063501140769239] \n" - ] - } - ], + "outputs": [], "source": [ "iters = 30\n", "off_diagonal_norm_1 = [dbi.off_diagonal_norm]\n", @@ -207,30 +115,9 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins random hamiltonian')\n", "plt.plot(off_diagonal_norm_1)\n", @@ -247,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -256,51 +143,9 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:22:43]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 692.10trial/s, best loss: 27.60718707087908]\n", - "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j), (0.15766557989586075+0j), (0.1267267343988193+0j), (0.10801310050393904+0j), (0.37981790024704787+0j), (0.25748679935414437+0j), (-0.2531727610451514+0j), (0.13345922163435078+0j), (-0.02961684041039575+0j), (0.36206828748686004+0j), (0.12254924877248492+0j)]\n", - "Gradient: [-0.07705712 0.15660998 -0.01151922 0.06967692 -0.32391798 -0.15885245\n", - " 0.16488954 0.11742344 0.44237635 0.39554303 -0.59878233 -0.03326744\n", - " 0.2060505 0.08567309 0.17837982]\n", - "s: 0.11627601978827411\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/Documents/GitHub/qibo/src/qibo/models/dbi/utils.py:268: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = (\n" - ] - } - ], + "outputs": [], "source": [ "# generate pauli_operator_dict\n", "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n", @@ -314,46 +159,9 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 693.59trial/s, best loss: 27.60716505293791] \n", - "100%|██████████| 500/500 [00:00<00:00, 739.77trial/s, best loss: 24.351930977389397] \n", - "100%|██████████| 500/500 [00:00<00:00, 685.07trial/s, best loss: 22.089870557907307] \n", - "100%|██████████| 500/500 [00:00<00:00, 674.17trial/s, best loss: 20.346996185055133]\n", - "100%|██████████| 500/500 [00:00<00:00, 717.27trial/s, best loss: 18.942039981805472]\n", - "100%|██████████| 500/500 [00:00<00:00, 747.61trial/s, best loss: 17.152907499929672] \n", - "100%|██████████| 500/500 [00:00<00:00, 738.25trial/s, best loss: 16.019645236154144]\n", - "100%|██████████| 500/500 [00:00<00:00, 744.74trial/s, best loss: 15.2613302219324] \n", - "100%|██████████| 500/500 [00:00<00:00, 742.43trial/s, best loss: 14.603236439507265] \n", - "100%|██████████| 500/500 [00:00<00:00, 747.77trial/s, best loss: 14.050749361766682] \n", - "100%|██████████| 500/500 [00:00<00:00, 665.47trial/s, best loss: 13.555811973998546] \n", - "100%|██████████| 500/500 [00:00<00:00, 741.86trial/s, best loss: 13.11437793825614] \n", - "100%|██████████| 500/500 [00:00<00:00, 730.33trial/s, best loss: 12.708028521672343] \n", - "100%|██████████| 500/500 [00:00<00:00, 696.14trial/s, best loss: 12.338996561474936] \n", - "100%|██████████| 500/500 [00:00<00:00, 745.68trial/s, best loss: 11.96195414708825] \n", - "100%|██████████| 500/500 [00:00<00:00, 729.21trial/s, best loss: 11.962452492607511] \n", - "100%|██████████| 500/500 [00:00<00:00, 730.13trial/s, best loss: 11.963468727156927] \n", - "100%|██████████| 500/500 [00:00<00:00, 735.49trial/s, best loss: 11.965058898358617] \n", - "100%|██████████| 500/500 [00:00<00:00, 735.24trial/s, best loss: 11.965394318636747] \n", - "100%|██████████| 500/500 [00:00<00:00, 729.17trial/s, best loss: 11.966117166464612] \n", - "100%|██████████| 500/500 [00:00<00:00, 728.15trial/s, best loss: 11.966425772210973] \n", - "100%|██████████| 500/500 [00:00<00:00, 723.59trial/s, best loss: 11.966970026858228] \n", - "100%|██████████| 500/500 [00:00<00:00, 732.31trial/s, best loss: 11.967330716148668] \n", - "100%|██████████| 500/500 [00:00<00:00, 734.26trial/s, best loss: 11.96780433370658] \n", - "100%|██████████| 500/500 [00:00<00:00, 733.15trial/s, best loss: 11.969207838189973] \n", - "100%|██████████| 500/500 [00:00<00:00, 732.58trial/s, best loss: 11.969502660368933] \n", - "100%|██████████| 500/500 [00:00<00:00, 696.01trial/s, best loss: 11.969798703907593] \n", - "100%|██████████| 500/500 [00:00<00:00, 734.39trial/s, best loss: 11.970102117939215] \n", - "100%|██████████| 500/500 [00:00<00:00, 733.83trial/s, best loss: 11.971312239622172] \n", - "100%|██████████| 500/500 [00:00<00:00, 737.13trial/s, best loss: 11.97187547672911] \n" - ] - } - ], + "outputs": [], "source": [ "iters = 30\n", "off_diagonal_norm_2 = [dbi.off_diagonal_norm]\n", @@ -367,30 +175,9 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins random hamiltonian')\n", "plt.plot(off_diagonal_norm_1, label='order 1')\n", @@ -412,27 +199,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-03 08:14:05]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# generate the Hamiltonian\n", "nqubits = 5\n", @@ -447,17 +216,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-04-03 08:14:05]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], + "outputs": [], "source": [ "# backend\n", "set_backend(\"qibojit\", platform=\"numba\")\n", @@ -474,39 +235,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 621.13trial/s, best loss: 8.145448855938055]\n", - "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n", - "Gradient: [-0.22522735 -0.52101222 -0.59635378 -0.52101222 -0.22522735]\n", - "s: 0.053751929537431395\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/Documents/GitHub/qibo/src/qibo/models/dbi/utils.py:268: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = (\n" - ] - } - ], + "outputs": [], "source": [ "dbi_TFIM_1 = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)\n", "# generate pauli_operator_dict\n", @@ -521,31 +252,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 707.38trial/s, best loss: 8.144345846120405] \n", - "100%|██████████| 500/500 [00:00<00:00, 735.41trial/s, best loss: 7.604689171773317] \n", - "100%|██████████| 500/500 [00:00<00:00, 735.65trial/s, best loss: 7.4176027901243495]\n", - "100%|██████████| 500/500 [00:00<00:00, 755.09trial/s, best loss: 7.008137714268] \n", - "100%|██████████| 500/500 [00:00<00:00, 745.89trial/s, best loss: 5.961852278701001] \n", - "100%|██████████| 500/500 [00:00<00:00, 703.36trial/s, best loss: 5.293878968775635] \n", - "100%|██████████| 500/500 [00:00<00:00, 749.97trial/s, best loss: 4.82113561785614] \n", - "100%|██████████| 500/500 [00:00<00:00, 749.13trial/s, best loss: 4.326041032299924] \n", - "100%|██████████| 500/500 [00:00<00:00, 749.48trial/s, best loss: 3.608232108710637] \n", - "100%|██████████| 500/500 [00:00<00:00, 750.07trial/s, best loss: 2.9342878051864014] \n", - "100%|██████████| 500/500 [00:00<00:00, 749.53trial/s, best loss: 2.619767373811081] \n", - "100%|██████████| 500/500 [00:00<00:00, 757.24trial/s, best loss: 2.553595125371688] \n", - "100%|██████████| 500/500 [00:00<00:00, 757.78trial/s, best loss: 2.5450651469655488] \n", - "100%|██████████| 500/500 [00:00<00:00, 758.64trial/s, best loss: 2.5411137289688988] \n", - "100%|██████████| 500/500 [00:00<00:00, 758.68trial/s, best loss: 2.5071534830104416] \n" - ] - } - ], + "outputs": [], "source": [ "NSTEPS = 15\n", "off_diagonal_norm_1 = [dbi_TFIM_1.off_diagonal_norm]\n", @@ -559,30 +268,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(f'n={nqubits} h={h} TFIM, order=1')\n", "plt.plot(off_diagonal_norm_1)\n", @@ -592,20 +280,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# the final matrix\n", "visualize_matrix(dbi_TFIM.h.matrix)" @@ -620,43 +297,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:37]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-03 08:18:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 722.72trial/s, best loss: 8.144335598357657]\n", - "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j]\n", - "Gradient: [-0.22563381 -0.52082675 -0.5963705 -0.52082675 -0.22563381 0.\n", - " 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. ]\n", - "s: 0.052813741396418624\n" - ] - } - ], + "outputs": [], "source": [ "dbi_TFIM_2 = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)\n", "# generate pauli_operator_dict\n", @@ -671,31 +314,9 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 744.95trial/s, best loss: 8.144331648273518] \n", - "100%|██████████| 500/500 [00:00<00:00, 744.80trial/s, best loss: 7.604748514246744] \n", - "100%|██████████| 500/500 [00:00<00:00, 756.14trial/s, best loss: 7.420954791755261] \n", - "100%|██████████| 500/500 [00:00<00:00, 759.14trial/s, best loss: 7.016113259744297] \n", - "100%|██████████| 500/500 [00:00<00:00, 744.68trial/s, best loss: 5.989940711739217]\n", - "100%|██████████| 500/500 [00:00<00:00, 750.40trial/s, best loss: 5.307608116085456]\n", - "100%|██████████| 500/500 [00:00<00:00, 749.79trial/s, best loss: 4.822327887100122] \n", - "100%|██████████| 500/500 [00:00<00:00, 661.39trial/s, best loss: 4.30794767213952] \n", - "100%|██████████| 500/500 [00:00<00:00, 744.71trial/s, best loss: 3.5737486865622783]\n", - "100%|██████████| 500/500 [00:00<00:00, 742.92trial/s, best loss: 2.899168952313776] \n", - "100%|██████████| 500/500 [00:00<00:00, 749.93trial/s, best loss: 2.6126410200674473] \n", - "100%|██████████| 500/500 [00:00<00:00, 754.15trial/s, best loss: 2.5428845456217983] \n", - "100%|██████████| 500/500 [00:00<00:00, 761.81trial/s, best loss: 2.520820402680462] \n", - "100%|██████████| 500/500 [00:00<00:00, 700.04trial/s, best loss: 2.4881828281706038] \n", - "100%|██████████| 500/500 [00:00<00:00, 736.96trial/s, best loss: 2.4545260560650717] \n" - ] - } - ], + "outputs": [], "source": [ "NSTEPS = 15\n", "off_diagonal_norm_2 = [dbi_TFIM_2.off_diagonal_norm]\n", @@ -709,30 +330,9 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(f'n={nqubits} h={h} TFIM')\n", "plt.plot(off_diagonal_norm_1, label='order 1')\n", @@ -741,416 +341,6 @@ "plt.xlabel('Iteration')\n", "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Different initial `d`\n", - "Next, we show the effect of different choices of the initial direction of the gradient descent method." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(-2.580645161290323+0j), (-1.2903225806451613+0j), (-0.6451612903225807+0j), (-0.32258064516129037+0j), (-0.16129032258064518+0j)]\n" - ] - } - ], - "source": [ - "H = H_TFIM.matrix\n", - "L = int(np.log2(H.shape[0]))\n", - "N = np.diag(np.linspace(np.min(np.diag(H)),np.max(np.diag(H)),2**L))\n", - "d_coef = onsite_Z_decomposition(N, onsite_Z_ops)\n", - "print(d_coef)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ4AAAGiCAYAAADXxKDZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0AUlEQVR4nO3df1hUZd4/8PeAMoLCJCrMkEikUilqG7SKZUIlV2SUmU+k/UDdfpA/imXLUp9nxS4V1zbT1sR0zR9Pkbbrj9zFTHoUrMtskUeL3OqhRKVk5CvqDKIOwdzfP4ipkV9nOIcz3PB+dd3X5Zw55z6fmfHq4/0597mPQQghQEREpBMfbwdARERdCxMPERHpiomHiIh0xcRDRES6YuIhIiJdMfEQEZGumHiIiEhXTDxERKQrJh4iItIVEw8REemKiYeIiBTLzMyEwWBwa2az2aM+urVTbERE1EkNHToUH3/8seu1r6+vR8cz8RARkUe6devm8SjH7XgNYyEiIp1cuXIFNTU1mvQlhIDBYHDbZjQaYTQam9y/pKQEYWFhMBqNGDlyJJYsWYLrr79e8fkMfCwCEZFcrly5gshIM6xWmyb99erVCxcvXnTbtmDBAmRmZjba98MPP8SlS5cQFRWFM2fOYNGiRfjmm29w7Ngx9OnTR9H5mHiIiCRjt9thMplw/OTrCAryV9nXZVwf8XuUlZUhKCjItb2lEc+vVVdXY+DAgZgzZw4yMjIUnZOlNiIiSQUF+atOPL/0FeSWeJTq2bMnhg0bhpKSEsXHcDo1EZGkhKjVpKnhcDjw9ddfw2KxKD6GIx4iIkkJUQch6lT34YkXXngBycnJGDBgACoqKrBo0SLY7XakpqYq7oOJh4iIFPvhhx8wefJknD17Fv369cOoUaNw6NAhREREKO6DiYeISFJOUQunylKZp8dv2bJF1fkAJh4iImlpcY1G7fFtwckFRESkK454iIgkVT+5QO2IR93khLZg4iEikpRw1kI4VSYelce3BUttRESkK454iIhkJWrrm9o+dMbEQ0QkKc5qIyIiUoAjHiIiWTlrAedP6vvQGRMPEZGk6kttnj12uqk+9MZSGxER6YqJRwcbN26EwWCAwWBAfn5+o/eFEBg0aBAMBgPi4+Pd3jMYDE0+BbCrOnHiBAwGAzZu3OjalpmZ2eixvZ1JU5/Z23JycrBixQqPjumIn0N6zlptms5YatNRYGAg1q9f3yi5FBQU4Pvvv0dgYGCjYz777DP0799fpwjl9OSTT+Kee+7xdhhdSk5ODr766iukp6crPsZiseCzzz7DwIED2y+wrsZZCzjVldq8kXg44tFRSkoKtm3bBrvd7rZ9/fr1iIuLw4ABAxodM2rUKCaeVvTv3x+jRo3ydhjUjLq6OjgcDhiNRowaNQr9+vXzdkjkZUw8Opo8eTIA4L333nNts9ls2LZtG6ZPn97kMVeX2hrKdvv378ezzz6Lvn37ok+fPpg4cSJOnz6tKI74+HhER0fjs88+w+jRo+Hv74/rrrsOGzZsAADk5ubilltuQUBAAIYNG4Y9e/a4Hf/dd99h2rRpGDx4MAICAnDttdciOTkZxcXFbvulpaWhR48eKCoqcm1zOp246667EBoaivLy8hbjPH36NB5++GEEBgbCZDIhJSUFVqu10X5Nldq2bt2KxMREWCwW+Pv746abbsLLL7+M6urqRsevW7cOUVFRMBqNGDJkCHJycjB16lRcd911bvudO3cOM2bMwLXXXgs/Pz9cf/31mD9/PhwOh9t+BoMBs2bNwn//93/jpptuQkBAAEaMGIF//vOfbfoelcrPz4fBYEBOTg5eeuklWCwW9OrVC8nJyThz5gyqqqrw9NNPo2/fvujbty+mTZuGixcvuvXx5ptv4o477kBISIjrkcbLli3DTz/9MnMqPj4eubm5OHnypKuE3PD9N5TTli1bhkWLFiEyMhJGoxH79+9vVGq7cuUKfvOb32DQoEGw2Wyu/q1WK8xmM+Lj41FXp/86YnKp++Um0rY2cK22Ti0oKAiTJk3C22+/jWeeeQZAfRLy8fFBSkqKRzXzJ598EuPHj0dOTg7Kysrw4osv4rHHHsO+ffsUHW+1WjFt2jTMmTMH/fv3x1/+8hdMnz4dZWVl+Pvf/4558+bBZDLhlVdewYQJE3D8+HGEhYUBqE8Iffr0wdKlS9GvXz+cO3cOmzZtwsiRI3HkyBHccMMNAIAVK1bg888/x8MPP4yioiJcc801WLhwIfLz87Fnz54WH5V7+fJl3H333Th9+jSysrIQFRWF3NxcpKSkKPp8JSUluPfee5Geno6ePXvim2++wZ/+9Cf861//cvuO1q5di2eeeQYPPfQQXn/9ddhsNixcuLBRMrly5QoSEhLw/fffY+HChRg+fDg++eQTZGVl4ejRo8jNzXXbPzc3F4WFhXjllVfQq1cvLFu2DA8++CC+/fZbXH/99R59j56aN28eEhISsHHjRpw4cQIvvPACJk+ejG7dumHEiBF47733cOTIEcybNw+BgYF44403XMd+//33mDJlCiIjI+Hn54cvvvgCixcvxjfffIO3334bALB69Wo8/fTT+P7777Fjx44mY3jjjTcQFRWFP//5zwgKCsLgwYMb7dOjRw+8//77iImJwfTp07Ft2zY4nU48+uijEELgvffeg6+vyjJSJ2dw1sLgVDd+MHih1AZB7W7Dhg0CgCgsLBT79+8XAMRXX30lhBDi1ltvFVOnThVCCDF06FAxduxYt2MBiAULFjTqa8aMGW77LVu2TAAQ5eXlrcYzduxYAUAcPnzYta2yslL4+voKf39/8eOPP7q2Hz16VAAQb7zxRrP91dbWipqaGjF48GDx+9//3u29kpISERQUJCZMmCA+/vhj4ePjI/7zP/+z1Rizs7MFAPHBBx+4bX/qqacEALFhwwbXtgULFoiW/io7nU7x008/iYKCAgFAfPHFF0IIIerq6oTZbBYjR4502//kyZOie/fuIiIiwrVtzZo1AoB4//333fb905/+JACIvXv3urYBEKGhocJut7u2Wa1W4ePjI7KyspqNs7nvsbS0tNFnbkrD363k5GS37enp6QKAeO6559y2T5gwQQQHBzfbX11dnfjpp5/E5s2bha+vrzh37pzrvfHjx7t9P1fHOnDgQFFTU9Pke1d/jq1btwoAYsWKFeKPf/yj8PHxcfs+qTGbzSYAiB++/52wVzyrqv3w/e8EAGGz2XSLn6U2nY0dOxYDBw7E22+/jeLiYhQWFjZbZmvJ/fff7/Z6+PDhAICTJ08CqC9p1dbWutrVJQuLxYKYmBjX6+DgYISEhODmm292jWwA4KabbnLrFwBqa2uxZMkSDBkyBH5+fujWrRv8/PxQUlKCr7/+2u08gwYNwrp167Bz507cd999GDNmjKJZevv370dgYGCjzzllypRWjwWA48ePY8qUKTCbzfD19UX37t0xduxYAHDF+O2338JqteLhhx92O3bAgAG47bbb3Lbt27cPPXv2xKRJk9y2T506FQDwP//zP27bExIS3CaLhIaGIiQkpM3foyfuu+8+t9cNv+H48eMbbT937pxbue3IkSO4//770adPH9f39sQTT6Curg7/93//pziG+++/H927d1e078MPP4xnn30WL774IhYtWoR58+Zh3Lhxis/VpUk6q42JR2cGgwHTpk3DO++8gzVr1iAqKgpjxozxuJ8+ffq4vTYajQDqS1QA8Morr6B79+6udvVMouDg4EZ9+vn5Ndru5+cHoL7U1CAjIwP/9V//hQkTJuAf//gHPv/8cxQWFmLEiBGu8//a+PHjERoaiitXriAjI0NR+aSyshKhoaGNtpvN5laPvXjxIsaMGYPPP/8cixYtQn5+PgoLC7F9+3YAv3xHlZWVANDkea7eVllZCbPZ3OhaUkhICLp16+bqq8HVvw9Q/xv9+vvx9HtUqrnfsLXf9tSpUxgzZgx+/PFHrFy5Ep988gkKCwvx5ptvAoBHMbVURm3K9OnT8dNPP6Fbt2547rnnPDq2S5M08fAajxdMnToVf/zjH7FmzRosXry4Xc7x9NNPu/3LtyExaeGdd97BE088gSVLlrhtP3v2LK655ppG+6elpaGqqgpDhw7Fc889hzFjxqB3794tnqNPnz7417/+1Wh7U5MLrrZv3z6cPn0a+fn5rlEOAFy4cKHROQDgzJkzrZ6nT58++PzzzyGEcEs+FRUVqK2tRd++fVuN62qefo/tbefOnaiursb27dsRERHh2n706FGP+/Lkvqrq6mo8/vjjiIqKwpkzZ/Dkk0/igw8+8PicJA+OeLzg2muvxYsvvojk5GSkpqa2yznCwsIQGxvrasOGDdOsb4PB0CiR5ebm4scff2y071//+le88847WLVqFXbt2oULFy5g2rRprZ4jISEBVVVV2LVrl9v2nJwcRfEBjZPtW2+95fb6hhtugNlsxvvvv++2/dSpUzh48KDbtrvuugsXL17Ezp073bZv3rzZ9b6nPPke9dDU9yaEwLp16xrte/XoTY20tDScOnUK27dvx/r167Fr1y68/vrrmvTd2RlErSZNbxzxeMnSpUu9HUKb3Xfffdi4cSNuvPFGDB8+HEVFRXj11Vcb3W9UXFyM5557Dqmpqa5ks379ekyaNAkrVqxo8ebDJ554Aq+//jqeeOIJLF68GIMHD8bu3bvx0UcftRrf6NGj0bt3b6SlpWHBggXo3r073n33XXzxxRdu+/n4+GDhwoV45plnMGnSJEyfPh0XLlzAwoULYbFY4OPzy7/LnnjiCbz55ptITU3FiRMnMGzYMHz66adYsmQJ7r33Xtx9990efIP1lH6Pehk3bhz8/PwwefJkzJkzB1euXEF2djbOnz/faN9hw4Zh+/btyM7ORkxMDHx8fBAbG+vxORv+YbJhwwYMHToUQ4cOxaxZs/DSSy/htttuw29/+1stPlrn5XQCTpXToZ1ObWLxAEc85LGVK1fiscceQ1ZWFpKTk7Fr1y5s377d7TpSdXU1Hn74YURGRmL16tWu7Q899BBmzpyJOXPmNFlKaxAQEIB9+/bh7rvvxssvv4xJkybhhx9+wJYtW1qNr0+fPsjNzUVAQAAee+wxTJ8+Hb169cLWrVsb7fv0009j7dq1+OKLL/Dggw9i4cKFePnll/Gb3/zGrdzVo0cP7N+/H48++iheffVVJCUlYePGjXjhhRdc1448peR71NONN96Ibdu24fz585g4cSJmz56Nm2++2W26dYPnn38ekyZNwrx58zBq1CjceuutHp/v1/8waZikAQB//vOfMXz4cKSkpDQqj1LnYBBCCG8HQdSRXLhwAVFRUZgwYQLWrl3r7XCIGrHb7TCZTDj91YMIClQ2e7DZvqp+Qlj0DthsNgQFBWkUYctYaqMuzWq1YvHixUhISECfPn1w8uRJvP7666iqqsLzzz/v7fCIWuasA1TeQKq6VNcGTDzUpRmNRpw4cQIzZszAuXPnEBAQgFGjRmHNmjUYOnSot8Mj6pSYeKhL6927N/7xj394OwyitnHWAk6VjwThfTxERKSUwVmnwVpt+pfaOKuNiIh01eFGPE6nE6dPn0ZgYGCnfqokEXUdQghUVVUhLCzM7f4w9R1rMLlAcHIBTp8+jfDwcG+HQUSkubKyMk1vEDY4napLZQYv3EDaboln9erVePXVV1FeXo6hQ4dixYoVihbDbFjR98SplQgK8m9x3+Br0jSJlYiofQkAosnH23dF7ZJ4tm7divT0dKxevRq33XYb3nrrLSQlJeHf//53k493/rWG8lpQkD+CggJaORNLcUQkC6H95QNnnQaz2jrJ5ILly5fjd7/7HZ588kncdNNNWLFiBcLDw5Gdnd0epyMi6pLqZ7Wpb3rTPPHU1NSgqKgIiYmJbtsTExMbrfgLAA6HA3a73a0REVHnpXniOXv2LOrq6ho9SCs0NLTJZ6lkZWXBZDK5GicWEBEp5KzTpums3e7jubqWefUDtBrMnTsXNpvN1crKytorJCKiTkXWUpvmkwv69u0LX1/fRqObioqKJh8xbDQaNX06JhERdWyaj3j8/PwQExODvLw8t+15eXkYPXq01qcjIuq6JC21tct06oyMDDz++OOIjY1FXFwc1q5di1OnTiEtjffdEBFpxeAUqm8ANTj1fyRbuySelJQUVFZW4pVXXkF5eTmio6Oxe/duREREKO6j/ubQluen26zTWu3HZN6g+JxERNT+2m3lghkzZmDGjBnt1T0RETnrALUr3nSWUhsREelAaJB4vLBIKB+LQEREuuKIh4hIUgbhhEGoW6vNIDrR6tRERNTOJL3Gw1IbERHpiiMeIiJZOZ0aPBaBpTYiIlKKiUd/Sm4OdXwWragvY9xXasMhIiIFpE48RERdmcHphEHlgEXtkjttwcRDRCQrp1ODWW36Jx7OaiMiIl1xxENEJCtJRzxMPEREspI08bDURkREuuKIh4hIVqIOUPsgN67VRkRESsk6nZqlNiIi0lWnH/EoXZHgpy0Bivbr/sglNeEQEWlH0skFnT7xEBF1WpImHpbaiIhIVxzxEBHJyinUj1jUzoprAyYeIiJZOYUGpTb9Ew9LbUREpCuOeIiIZKXJg+A44iEiIqWcTm2aCllZWTAYDEhPT1d8DBMPERG1SWFhIdauXYvhw4d7dBwTDxGRrJxCm9YGFy9exKOPPop169ahd+/eHh3Lazw/U7oiwZWl/or26/HyZTXhEBG1TjgBofIaj6hPPHa73W2z0WiE0Whs9rCZM2di/PjxuPvuu7Fo0SKPTskRDxERITw8HCaTydWysrKa3XfLli343//93xb3aQlHPEREshIa3Mfz84inrKwMQUFBrs3NjXbKysrw/PPPY+/evejRo0ebTsnEQ0QkKw1vIA0KCnJLPM0pKipCRUUFYmJiXNvq6upw4MABrFq1Cg6HA76+vi32wcRDRESK3XXXXSguLnbbNm3aNNx444146aWXWk06ABMPEZG8vLBkTmBgIKKjo9229ezZE3369Gm0vTlMPEREkhJO9U+u9sKTr5l4iIhInfz8fI/2Z+IhIpKVpKtTM/F4SOmNoednD2h1n95/OaU2HCLqypzQIPFoEYhneAMpERHpSvPEk5mZCYPB4NbMZrPWpyEiIqdGTWftUmobOnQoPv74Y9drJfO6iYjIQ+LnprYPnbVL4unWrZviUY7D4YDD4XC9vnqhOiIi6lza5RpPSUkJwsLCEBkZiUceeQTHjx9vdt+srCy3henCw8PbIyQiok5HOA2aNL1pnnhGjhyJzZs346OPPsK6detgtVoxevRoVFZWNrn/3LlzYbPZXK2srEzrkIiIOide46mXlJTk+vOwYcMQFxeHgQMHYtOmTcjIyGi0f2vPfCAios6l3e/j6dmzJ4YNG4aSkpL2PhURUdciDIDaUpkXJhe0+308DocDX3/9NSwWS3ufioioS5H1Go/mI54XXngBycnJGDBgACoqKrBo0SLY7XakpqZqfaoOTcmqBKWTYlrdBwAi/16kNhwiog5D88Tzww8/YPLkyTh79iz69euHUaNG4dChQ4iIiND6VEREXZtTg1JbZ5hcsGXLFq27JCKipghDfVPVhzaheIJrtRERka64OjURkaS0mBzAB8EREZFyTh8NrvHoX2tjqY2IiHTFEQ8Rkaw4q42IiPQkhAFC5aw2wVltRETU2XHE40VKVyQ4nDBO0X6x+/PUhENEspF0cgETDxGRpIQTGkyn5qw2IiLq5DjiISKSlSaPRegEq1MTEZE+tJnV1gkefU1ERNQSjniIiGTl9KlvqvrQJhRPMPEQEUlKm0VCWWojIqJOjiMeCSi9MfSfMf/R6j73Ff1NbThE1EHIOrmAiYeISFaSXuNhqY2IiHTFEQ8RkaRknVzAxENEJClZr/Gw1EZERLriiIeISFaSTi5g4iEikpSs13hYaiMiIl1xxENEJClZJxcw8XQiSlYlWHfjNEV9PfXNBrXhEFF7Expc49H/AaQstRERkb444iEikpSskwuYeIiIJCWE+ms0gqU2IiLq7DjiISKSlQalNrDURkRESgnhAyHUFa6EF2ptLLUREZGuOOIhIpKV06C+VMZSGxERKcWVC0gKSlckyIxIU7bfyTVqwiGiLsjjazwHDhxAcnIywsLCYDAYsHPnTrf3hRDIzMxEWFgY/P39ER8fj2PHjmkVLxER/azhBlK1TW8eJ57q6mqMGDECq1atavL9ZcuWYfny5Vi1ahUKCwthNpsxbtw4VFVVqQ6WiIh+0TCrTW3Tm8eltqSkJCQlJTX5nhACK1aswPz58zFx4kQAwKZNmxAaGoqcnBw888wz6qIlIiLpaZrqSktLYbVakZiY6NpmNBoxduxYHDx4sMljHA4H7Ha7WyMiotZ1mVJbS6xWKwAgNDTUbXtoaKjrvatlZWXBZDK5Wnh4uJYhERF1Wg2z2tQ2vbVLcc9gcP8gQohG2xrMnTsXNpvN1crKytojJCIi6iA0nU5tNpsB1I98LBaLa3tFRUWjUVADo9EIo9GoZRhERF2CrPfxaDriiYyMhNlsRl5enmtbTU0NCgoKMHr0aC1PRUTU5QmhwTUeGW4gvXjxIr777jvX69LSUhw9ehTBwcEYMGAA0tPTsWTJEgwePBiDBw/GkiVLEBAQgClTpmgaOBERycnjxHP48GEkJCS4XmdkZAAAUlNTsXHjRsyZMweXL1/GjBkzcP78eYwcORJ79+5FYGCgdlFTu1O6IsHT/WYq2m/t/3tTTThE1ARZV6f2OPHEx8e3GKjBYEBmZiYyMzPVxEVERK2Q9dHXfCwCERHpiouEEhFJStZZbUw8RESSkjXxsNRGRES6YuIhIpKUcGqxXptn58zOzsbw4cMRFBSEoKAgxMXF4cMPP/SoD5baiIgk5Y1SW//+/bF06VIMGjQIQP0TCB544AEcOXIEQ4cOVdQHEw8RESmWnJzs9nrx4sXIzs7GoUOHmHhIH0pvDB3fq/VHaede5GO0iTyhzQ2k9cdf/UgaJeto1tXV4W9/+xuqq6sRFxen+Jy8xkNEJCmnMGjSACA8PNztETVZWVnNnre4uBi9evWC0WhEWloaduzYgSFDhiiOmyMeIiJCWVkZgoKCXK9bGu3ccMMNOHr0KC5cuIBt27YhNTUVBQUFipMPEw8Rkay0eILoz8c3zFJTws/PzzW5IDY2FoWFhVi5ciXeeustRccz8RARSaqj3EAqhIDD4VC8PxMPEREpNm/ePCQlJSE8PBxVVVXYsmUL8vPzsWfPHsV9MPEQEUnKGyOeM2fO4PHHH0d5eTlMJhOGDx+OPXv2YNy4cYr7YOIhIpKUNxLP+vXrVZ0P4HRqIiLSGUc8RESScgofOFXeQKr2+LZg4iFdKFmV4OaAyYr6OnrpPbXhEHUKQmjwBFI+FoGIiDo7jniIiCTVUe7j8RQTDxGRpGRNPCy1ERGRrjjiISKS1K9Xl1bTh96YeIiIJMVSGxERkQIc8RARSUrWEQ8TDxGRpHiNh0glpSsS9O0Zo2i/s9VFasIhonbCxENEJCkh1JfKhNAoGA8w8RARSUrWazyc1UZERLriiIeISFJCg8kFnNVGRESKsdRGRESkAEc8RESSknXEw8RDRCQp3kBKpBOlN4b6+pha3afOaVMbDhF5iImHiEhSspbaPJ5ccODAASQnJyMsLAwGgwE7d+50e3/q1KkwGAxubdSoUVrFS0REP2sotaltevM48VRXV2PEiBFYtWpVs/vcc889KC8vd7Xdu3erCpKIiDoPj0ttSUlJSEpKanEfo9EIs9msqD+HwwGHw+F6bbfbPQ2JiKhLEjBAQGWpTeXxbdEu9/Hk5+cjJCQEUVFReOqpp1BRUdHsvllZWTCZTK4WHh7eHiEREXU6Ddd41Da9aZ54kpKS8O6772Lfvn147bXXUFhYiDvvvNNtVPNrc+fOhc1mc7WysjKtQyIiog5E81ltKSkprj9HR0cjNjYWERERyM3NxcSJExvtbzQaYTQatQ6DiKjT4308zbBYLIiIiEBJSUl7n4qIqEvpMtOpPVVZWYmysjJYLJb2PhUREUnA4xHPxYsX8d1337lel5aW4ujRowgODkZwcDAyMzPx0EMPwWKx4MSJE5g3bx769u2LBx98UNPAiVqjZFUCJasbKO2LSG9OaFBq88KsNo8Tz+HDh5GQkOB6nZGRAQBITU1FdnY2iouLsXnzZly4cAEWiwUJCQnYunUrAgMDtYuaiIik5XHiiY+Ph2jhId0fffSRqoCIiEgZWa/xcK02IiJJOWFQXSrzRqmND4IjIiJdccRDRCQrLVYeYKmNiIiUkvUGUpbaiIhIVxzxEBFJirPaiIhIV86fm9o+9MbEQ12a0hUJ+vaMUbTf2eoiNeEQdQlMPEREkmKpjYiIdOUU6melOZtfiKbdcFYbERHpiiMeIiJJCRggVC55o/b4tmDiISKSFG8gJSIiUoAjHiIiSdVPLlDfh96YeIiIJMVrPESdmNIbQ28OmKxov6OX3lMTDpHUmHiIiCQl6+QCJh4iIkkJUd/U9qE3zmojIiJdccRDRCQpAQOcnFxARER6kXWRUJbaiIhIVxzxEBFJirPaiIhIV+LnprYPvbHURkREuuKIh0hDSlckGN8rrdV9ci+uURsOdXIstRERka6cPze1feiNpTYiItIVRzxERJKS9T4eJh4iIknJeo2HpTYiItIVEw8RkaSERs0TWVlZuPXWWxEYGIiQkBBMmDAB3377rUd9MPEQEUmqodSmtnmioKAAM2fOxKFDh5CXl4fa2lokJiaiurpacR+8xkNERIrt2bPH7fWGDRsQEhKCoqIi3HHHHYr6YOIhIpKUlvfx2O12t+1GoxFGo7HV4202GwAgODhY8TmZeIi8QMmqBE/3m6mor7X/70214ZCktJxOHR4e7rZ9wYIFyMzMbOVYgYyMDNx+++2Ijo5WfE6PrvEouagkhEBmZibCwsLg7++P+Ph4HDt2zJPTEBGRzsrKymCz2Vxt7ty5rR4za9YsfPnll3jvPWVLRTXwKPEouai0bNkyLF++HKtWrUJhYSHMZjPGjRuHqqoqjwIjIqKWCfxSbmtra5jVFhQU5NZaK7PNnj0bu3btwv79+9G/f3+P4vao1NbaRSUhBFasWIH58+dj4sSJAIBNmzYhNDQUOTk5eOaZZzwKjoiImiegQanNw0dfCyEwe/Zs7NixA/n5+YiMjPT4nKqmU199Uam0tBRWqxWJiYmufYxGI8aOHYuDBw822YfD4YDdbndrRETUMc2cORPvvPMOcnJyEBgYCKvVCqvVisuXLyvuo82Jp6mLSlarFQAQGhrqtm9oaKjrvatlZWXBZDK52tUXuIiIqGlOoU3zRHZ2Nmw2G+Lj42GxWFxt69ativto86y2hotKn376aaP3DAb3oZsQotG2BnPnzkVGRobrtd1uZ/IhIlLAG08gFUL9M0vblHgaLiodOHDA7aKS2WwGUD/ysVgsru0VFRWNRkENlM4VJyKizsGjUpsQArNmzcL27duxb9++RheVIiMjYTabkZeX59pWU1ODgoICjB49WpuIiYgIgHeWzNGCRyOemTNnIicnBx988IHrohIAmEwm+Pv7w2AwID09HUuWLMHgwYMxePBgLFmyBAEBAZgyZUq7fACizkrpjaGZEa0/RhsAMk/yUdqdjaxPIPUo8WRnZwMA4uPj3bZv2LABU6dOBQDMmTMHly9fxowZM3D+/HmMHDkSe/fuRWBgoCYBExGR3DxKPEouKhkMBmRmZra61AIREanDJ5ASEZGuZC218Xk8RESkK454iIgkJUR9U9uH3ph4iIgk5YQBTg/XWmuqD72x1EZERLriiIeISFJtWWutqT70xsRDRCQrDa7xqF7srQ2YeIgkp3RFgnU3TlO031PfbFATDlGrmHiIiCQl6+QCJh4iIknJOp2as9qIiEhXHPEQEUlK1iVzmHiIiCQl63RqltqIiEhXHPEQEUlKQP1tOF4Y8DDxEBHJqr7UpnI6NUttRETU2XHEQ9RFKF2R4J8x/9HqPvcV/U1tOKQBWe/jYeIhIpKUrNOpWWojIiJdccRDRCQpltqIiEhXLLUREREpwBEPEZGkhAZL5rDURkREism6cgFLbUREpCuOeIjIjZKbQw8njFPUV+z+PLXhUAtkXZ2aiYeISFKyTqdmqY2IiHTFEQ8RkaRkvY+HiYeISFKyXuNhqY2IiHTFEQ8RkaRkvY+HiYeISFIstRERESnAEQ8RkaRkvY+HiYeIPKZ0RYLSSTGK9ov8e5GacLosWadTs9RGRES68ijxZGVl4dZbb0VgYCBCQkIwYcIEfPvtt277TJ06FQaDwa2NGjVK06CJiOjnEY9Q2bwQt0eJp6CgADNnzsShQ4eQl5eH2tpaJCYmorq62m2/e+65B+Xl5a62e/duTYMmIqJfplOrbXrz6BrPnj173F5v2LABISEhKCoqwh133OHabjQaYTabFfXpcDjgcDhcr+12uychERGRZFRd47HZbACA4OBgt+35+fkICQlBVFQUnnrqKVRUVDTbR1ZWFkwmk6uFh4erCYmIqMsQbS2v/apJtTq1EAIZGRm4/fbbER0d7dqelJSEd999F/v27cNrr72GwsJC3HnnnW6jml+bO3cubDabq5WVlbU1JCKiLqVhOrXaprc2T6eeNWsWvvzyS3z66adu21NSUlx/jo6ORmxsLCIiIpCbm4uJEyc26sdoNMJoNLY1DCIikkybEs/s2bOxa9cuHDhwAP37929xX4vFgoiICJSUlLQpQCIiapqs9/F4lHiEEJg9ezZ27NiB/Px8REZGtnpMZWUlysrKYLFY2hwkERE1Vj8dWl2trMM/+nrmzJnIycnBBx98gMDAQFitVgCAyWSCv78/Ll68iMzMTDz00EOwWCw4ceIE5s2bh759++LBBx9slw9ARB2X0hUJzs8e0Oo+vf9ySm041EF4lHiys7MBAPHx8W7bN2zYgKlTp8LX1xfFxcXYvHkzLly4AIvFgoSEBGzduhWBgYGaBU1ERF3ksQiilekP/v7++Oijj1QFREREymix8gAfi0BERJ0eV6cmIpKU+Pk/tX3ojYmHiEhSLLUREREpwBEPEZGkusQNpERE1HEIocE1Hi8s1sZSGxER6YojHiLyOiWrElxZ6q+orx4vX1YbjjRYaiMiIl2x1EZERKQARzxERJISUF8q6/BrtRERUcfhFEKDxyKw1EZERB3YgQMHkJycjLCwMBgMBuzcudPjPph4iIgkJTT6zxPV1dUYMWIEVq1a1ea4WWojIpKUN6ZTJyUlISkpSdU5mXiIiAh2u93ttdFohNFobJdzMfEQkRSU3hj605YARft1f+SSmnA6BCc0mFzw8/Hh4eFu2xcsWIDMzExVfTeHiYeISFJazmorKytDUFCQa3t7jXYAJh4iIgIQFBTklnjaExMPEZGk+ARSIiLSlZbXeJS6ePEivvvuO9fr0tJSHD16FMHBwRgwYICiPph4iIhIscOHDyMhIcH1OiMjAwCQmpqKjRs3KuqDiYeISFLeGPHEx8erXtGaiYeISFKyXuPhkjlERKQrjniIiCQlNCi1cVYbEZFKSlckcHwWrWg/Y9xXasJpV06DEwaDutXanF54+DVLbUREpCuOeIiIJOWEgEHnWW1aYOIhIpKU+HlCtdo+9MZSGxER6YojHiIiSTkBDUpt+mPiISKSFGe1ERERKcARDxGRpJxwwqByxOKNEQ8TDxGRpJh4iIgkonRFApt1Wqv7mMwb1IbTpXh0jSc7OxvDhw93PSI1Li4OH374oet9IQQyMzMRFhYGf39/xMfH49ixY5oHTUREv9zHo7bpzaPE079/fyxduhSHDx/G4cOHceedd+KBBx5wJZdly5Zh+fLlWLVqFQoLC2E2mzFu3DhUVVW1S/BERF2Z0+DUpOnNo8STnJyMe++9F1FRUYiKisLixYvRq1cvHDp0CEIIrFixAvPnz8fEiRMRHR2NTZs24dKlS8jJyWm2T4fDAbvd7taIiKjzavN06rq6OmzZsgXV1dWIi4tDaWkprFYrEhMTXfsYjUaMHTsWBw8ebLafrKwsmEwmVwsPD29rSEREXYqAU/V/Hb7UBgDFxcXo1asXjEYj0tLSsGPHDgwZMgRWqxUAEBoa6rZ/aGio672mzJ07FzabzdXKyso8DYmIqEsSqNOk6c3jWW033HADjh49igsXLmDbtm1ITU1FQUGB632DweC2vxCi0bZfMxqNMBqNnoZBRESS8jjx+Pn5YdCgQQCA2NhYFBYWYuXKlXjppZcAAFarFRaLxbV/RUVFo1EQERGpV38Pjnz38aheMkcIAYfDgcjISJjNZuTl5bneq6mpQUFBAUaPHq32NEREdBWnRld59ObRiGfevHlISkpCeHg4qqqqsGXLFuTn52PPnj0wGAxIT0/HkiVLMHjwYAwePBhLlixBQEAApkyZ0l7xExG1KyU3h9Y6N7X4vt1+CcHXPK1VSNLzKPGcOXMGjz/+OMrLy2EymTB8+HDs2bMH48aNAwDMmTMHly9fxowZM3D+/HmMHDkSe/fuRWBgYLsET0TUldVPDmj+GrrSPvRmEELoP85qgd1uh8lkQn0VUN0XSkSkB6UjHpvNhqCgINXna/j/ZFjPsfAxqFv5zClqcbq6QLPYlOBjEYiISFdcJJSISFJarLXmjRtImXiIiCTlRB3UXpJweuEaD0ttRESkK454iIgkxVIbERHpyik0KLUJCdZqa2+/zO7uULO8iYiaZbdfauX9ywB+/f+3rq3DJZ5fHhonwORDRDJQuipBVVXVz/cpaoOlNo2EhYWhrKwMgYGBrlWt7XY7wsPDUVZWptsNTlqT/TPIHj8g/2eQPX5A/s/Q1viFEKiqqkJYWJim8dQnHnWlMiYeAD4+Pujfv3+T7wUFBUn5l/XXZP8MsscPyP8ZZI8fkP8ztCV+LUc6sutwiYeIiJQRwgmn2rXaBEc8RESkUH2ZTO0ioRI+j0cPRqMRCxYskPpJpbJ/BtnjB+T/DLLHD8j/GWSPv6PocKtTExFRyxpWpzb1GAKDwVdVX0LUwXbl37quTs1SGxGRpOqv8LDURkRE1CKOeIiIJFU/I42z2oiISCdaPLbaG4++ZqmNiIh0JUXiWb16NSIjI9GjRw/ExMTgk08+8XZIimRmZsJgMLg1s9ns7bBadODAASQnJyMsLAwGgwE7d+50e18IgczMTISFhcHf3x/x8fE4duyYd4JtQmvxT506tdFvMmrUKO8E24SsrCzceuutCAwMREhICCZMmIBvv/3WbZ+O/hso+Qwd+XfIzs7G8OHDXasTxMXF4cMPP3S935G+fyEEhHCqbPpPbO7wiWfr1q1IT0/H/PnzceTIEYwZMwZJSUk4deqUt0NTZOjQoSgvL3e14uJib4fUourqaowYMQKrVq1q8v1ly5Zh+fLlWLVqFQoLC2E2mzFu3LhfLe7qXa3FDwD33HOP22+ye/duHSNsWUFBAWbOnIlDhw4hLy8PtbW1SExMRHV1tWufjv4bKPkMQMf9Hfr374+lS5fi8OHDOHz4MO6880488MADruTSkb7/hkVC1Tb9A+/gfvvb34q0tDS3bTfeeKN4+eWXvRSRcgsWLBAjRozwdhhtBkDs2LHD9drpdAqz2SyWLl3q2nblyhVhMpnEmjVrvBBhy66OXwghUlNTxQMPPOCVeNqioqJCABAFBQVCCPl+AyEafwYh5PsdevfuLf761792mO/fZrMJAMLf7zoRYLxeVfP3u04AEDabTbf4O/SIp6amBkVFRUhMTHTbnpiYiIMHD3opKs+UlJQgLCwMkZGReOSRR3D8+HFvh9RmpaWlsFqtbr+H0WjE2LFjpfk9ACA/Px8hISGIiorCU089hYqKCm+H1CybzQYACA4OBiDnb3D1Z2ggw+9QV1eHLVu2oLq6GnFxcR3u+xeiTpOmtw6deM6ePYu6ujqEhoa6bQ8NDYXVavVSVMqNHDkSmzdvxkcffYR169bBarVi9OjRqKys9HZobdLwncv6ewBAUlIS3n33Xezbtw+vvfYaCgsLceedd8LhcHg7tEaEEMjIyMDtt9+O6OhoAPL9Bk19BqDj/w7FxcXo1asXjEYj0tLSsGPHDgwZMqTDff/qr+84OZ26OQ3P5WkghGi0rSNKSkpy/XnYsGGIi4vDwIEDsWnTJmRkZHgxMnVk/T0AICUlxfXn6OhoxMbGIiIiArm5uZg4caIXI2ts1qxZ+PLLL/Hpp582ek+W36C5z9DRf4cbbrgBR48exYULF7Bt2zakpqaioKDA9b4s339H1aFHPH379oWvr2+jf0lUVFQ0+heHDHr27Ilhw4ahpKTE26G0ScOMvM7yewCAxWJBREREh/tNZs+ejV27dmH//v1uz6eS6Tdo7jM0paP9Dn5+fhg0aBBiY2ORlZWFESNGYOXKlR3u+5d1ckGHTjx+fn6IiYlBXl6e2/a8vDyMHj3aS1G1ncPhwNdffw2LxeLtUNokMjISZrPZ7feoqalBQUGBlL8HAFRWVqKsrKzD/CZCCMyaNQvbt2/Hvn37EBkZ6fa+DL9Ba5+hKR3td7iaEAIOh6PDff+ylto6/Ky2LVu2iO7du4v169eLf//73yI9PV307NlTnDhxwtuhteoPf/iDyM/PF8ePHxeHDh0S9913nwgMDOzQsVdVVYkjR46II0eOCABi+fLl4siRI+LkyZNCCCGWLl0qTCaT2L59uyguLhaTJ08WFotF2O12L0der6X4q6qqxB/+8Adx8OBBUVpaKvbv3y/i4uLEtdde22Hif/bZZ4XJZBL5+fmivLzc1S5duuTap6P/Bq19ho7+O8ydO1ccOHBAlJaWii+//FLMmzdP+Pj4iL179wohOsb33zCrrbtvqPDrZlHVuvuG6j6rrcMnHiGEePPNN0VERITw8/MTt9xyi9u0zI4sJSVFWCwW0b17dxEWFiYmTpwojh075u2wWrR//34BoFFLTU0VQtRP512wYIEwm83CaDSKO+64QxQXF3s36F9pKf5Lly6JxMRE0a9fP9G9e3cxYMAAkZqaKk6dOuXtsF2aih2A2LBhg2ufjv4btPYZOvrvMH36dNf/b/r16yfuuusuV9IRomN8/w2Jp5tvP9G9W6iq1s23n+6Jh8/jISKSTMPzeHx9gmEwqLtiIoQTdc5zuj6Pp0Nf4yEios5HiunURETUFAGonpWmf9GLiYeISFLaPI+Hi4QSEVEnxxEPEZGk6m/+VDniYamNiIiUU594vHGNh6U2IiLSFUc8RESy0mByAbwwuYCJh4hIUrJe42GpjYiIdMURDxGRtDi5gIiIdCXqr9GoaW1MPKtXr0ZkZCR69OiBmJgYfPLJJ4qPZeIhIiKPbN26Fenp6Zg/fz6OHDmCMWPGICkpCadOnVJ0PFenJiKSTMPq1IAvtCm11Xm0OvXIkSNxyy23IDs727XtpptuwoQJE5CVldXq8RzxEBFJrdlHICls9ex2u1tzOBxNnq2mpgZFRUVITEx0256YmIiDBw8qipiJh4hIMn5+fjCbzQDqNGm9evVCeHg4TCaTqzU3cjl79izq6uoQGhrqtj00NBRWq1VR/JzVRkQkmR49eqC0tBQ1NTWa9CeEgMHgXrIzGo0tHnP1/k310RwmHiIiCfXo0QM9evTQ/bx9+/aFr69vo9FNRUVFo1FQc1hqIyIixfz8/BATE4O8vDy37Xl5eRg9erSiPjjiISIij2RkZODxxx9HbGws4uLisHbtWpw6dQppaWmKjmfiISIij6SkpKCyshKvvPIKysvLER0djd27dyMiIkLR8byPh4iIdMVrPEREpCsmHiIi0hUTDxER6YqJh4iIdMXEQ0REumLiISIiXTHxEBGRrph4iIhIV0w8RESkKyYeIiLSFRMPERHp6v8D/thKNBd0ouMAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "visualize_matrix(H, 'Initial hamiltonian')\n", - "visualize_matrix(N, 'Min-max diagonal matrix')\n", - "visualize_matrix(d, 'Min-max projection onsite-Z')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we see that the min-max diagonal operator can be correctly decomposed into onsite-Z operators. Then we generate the diagonalization curve and compare with other initializations." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-03-26 16:08:28]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], - "source": [ - "# backend\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "# initialize dbi object\n", - "dbi_TFIM_MMH = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 688.27trial/s, best loss: 9.336239342915379]\n", - "New optimized step at iteration 1/15: 0.039240166337035656 with d_coef [(-2.3180340693309422+0j), (-0.9042157574954297+0j), (-0.6267094129284807+0j), (-0.37510402952816974+0j), (-0.16137910360026844+0j)], loss 9.263805656974093\n", - "100%|██████████| 500/500 [00:00<00:00, 654.86trial/s, best loss: 8.253271106315344] \n", - "New optimized step at iteration 2/15: 0.0636971166898561 with d_coef [(-2.8893154826347565+0j), (-1.3328071932958503+0j), (-0.5996311871447069+0j), (-0.38812640871658144+0j), (-0.16592899239661785+0j)], loss 8.248988639626276\n", - "100%|██████████| 500/500 [00:00<00:00, 705.90trial/s, best loss: 7.820911729728226] \n", - "New optimized step at iteration 3/15: 0.026774099108320803 with d_coef [(-3.9047191557345737+0j), (-1.3620955366051533+0j), (-1.094932722170599+0j), (-0.5744178736473565+0j), (-0.04727696085745736+0j)], loss 7.79237041903216\n", - "100%|██████████| 500/500 [00:00<00:00, 522.76trial/s, best loss: 7.506187222292692]\n", - "New optimized step at iteration 4/15: 0.029295596624437686 with d_coef [(-3.894655859483571+0j), (-1.866243073713661+0j), (-0.7092145648013096+0j), (-0.7039608847825699+0j), (-0.023283739763302808+0j)], loss 7.4962199726801755\n", - "100%|██████████| 500/500 [00:00<00:00, 576.24trial/s, best loss: 7.262455656549131]\n", - "New optimized step at iteration 5/15: 0.02836170693029348 with d_coef [(-3.9671435812064013+0j), (-1.748374386604198+0j), (-0.9350901630745362+0j), (-0.6281543245247632+0j), (-0.021512156595171472+0j)], loss 7.242940534826334\n", - "100%|██████████| 500/500 [00:00<00:00, 671.15trial/s, best loss: 7.044926289914773]\n", - "New optimized step at iteration 6/15: 0.027897015043668715 with d_coef [(-3.948390041694754+0j), (-1.8847156433519916+0j), (-0.8262997874928508+0j), (-0.6276868981090158+0j), (-0.03885078124692265+0j)], loss 7.026681601151195\n", - "100%|██████████| 500/500 [00:00<00:00, 690.94trial/s, best loss: 6.855318614477858] \n", - "New optimized step at iteration 7/15: 0.027095778110113995 with d_coef [(-3.9519653973013913+0j), (-1.911636257457286+0j), (-0.8907292589911223+0j), (-0.6344354980656255+0j), (-0.0239873577390306+0j)], loss 6.826359605831807\n", - "100%|██████████| 500/500 [00:00<00:00, 520.20trial/s, best loss: 6.6782408641935875]\n", - "New optimized step at iteration 8/15: 0.027670995126608866 with d_coef [(-3.9302491674477538+0j), (-1.9666365073691627+0j), (-0.8561543524586357+0j), (-0.6383800207112388+0j), (-0.004655769048021813+0j)], loss 6.636290444352086\n", - "100%|██████████| 500/500 [00:00<00:00, 576.02trial/s, best loss: 6.500633770102917]\n", - "New optimized step at iteration 9/15: 0.027675484066740867 with d_coef [(-3.910374644169554+0j), (-1.9831418560231258+0j), (-0.9056736621483122+0j), (-0.6540987589359828+0j), (0.02406147464053876+0j)], loss 6.447464047229631\n", - "100%|██████████| 500/500 [00:00<00:00, 686.99trial/s, best loss: 6.319748615035787]\n", - "New optimized step at iteration 10/15: 0.026930095210157 with d_coef [(-3.886824281463916+0j), (-1.99625546879924+0j), (-0.9414450075378732+0j), (-0.6563760409606512+0j), (0.03970055245590362+0j)], loss 6.2592485638502575\n", - "100%|██████████| 500/500 [00:00<00:00, 678.32trial/s, best loss: 6.1400705423264075]\n", - "New optimized step at iteration 11/15: 0.027416250931757133 with d_coef [(-3.8475665420145373+0j), (-2.037392997099672+0j), (-0.9264643353804642+0j), (-0.6830139042784837+0j), (0.08321313069136971+0j)], loss 6.056764516965165\n", - "100%|██████████| 500/500 [00:00<00:00, 729.97trial/s, best loss: 5.940597947808348] \n", - "New optimized step at iteration 12/15: 0.028200202317592835 with d_coef [(-3.82460449840812+0j), (-2.035906559623582+0j), (-0.9702033338205296+0j), (-0.6848609304443387+0j), (0.11118456157172787+0j)], loss 5.848596463276441\n", - "100%|██████████| 500/500 [00:00<00:00, 743.16trial/s, best loss: 5.72938416138] \n", - "New optimized step at iteration 13/15: 0.025525484486623708 with d_coef [(-3.8277137978993436+0j), (-2.0402358325723036+0j), (-0.9967614632890175+0j), (-0.6822006377994072+0j), (0.09661303923602668+0j)], loss 5.643243093952352\n", - "100%|██████████| 500/500 [00:00<00:00, 722.17trial/s, best loss: 5.532276668994669] \n", - "New optimized step at iteration 14/15: 0.028418788139760974 with d_coef [(-3.7489089984244486+0j), (-2.114017010442895+0j), (-0.9183197191620466+0j), (-0.7036125621442609+0j), (0.16285610695072883+0j)], loss 5.4057916657046725\n", - "100%|██████████| 500/500 [00:00<00:00, 739.76trial/s, best loss: 5.288910417094644] \n", - "New optimized step at iteration 15/15: 0.02625000676004677 with d_coef [(-3.789232226109539+0j), (-2.092494639505251+0j), (-1.0022140546781002+0j), (-0.6714823814533052+0j), (0.13551681944910254+0j)], loss 5.191808803025761\n" - ] - } - ], - "source": [ - "NSTEPS = 15\n", - "off_diagonal_norm_MMH = [dbi_TFIM_MMH.off_diagonal_norm]\n", - "s_step_MMH = [0]\n", - "# d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", - "# d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", - "for _ in range(NSTEPS):\n", - " d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", - " d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", - " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM_MMH, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " dbi_TFIM_MMH(d=d, step=s)\n", - " off_diagonal_norm_MMH.append(dbi_TFIM_MMH.off_diagonal_norm)\n", - " s_step_MMH.append(s)\n", - " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM_MMH.off_diagonal_norm}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", - "plt.plot(off_diagonal_norm_MMH, label='MMH')\n", - "plt.plot(off_diagonal_norm_delta, label='delta')\n", - "plt.xlabel('Iteration')\n", - "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Effect of `n`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-03-26 16:08:41]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 31.576176740060667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# backend\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "# initialize dbi object\n", - "nqubits = 5\n", - "h0 = random_hermitian(2**nqubits, seed=2)\n", - "scheduling = DoubleBracketScheduling.hyperopt\n", - "mode = DoubleBracketGeneratorType.single_commutator\n", - "n_1 = 5\n", - "n_2 = 3\n", - "dbi_1 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", - "dbi_2 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", - "print(\"Initial off diagonal norm\", dbi_1.off_diagonal_norm)\n", - "visualize_matrix(dbi_1.h.matrix, title=f'Random hamiltonian with L={nqubits}')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 697.70trial/s, best loss: 9.558186537868679] \n", - "The initial D coefficients: [(-3.321354431855655-1.7961649980378765e-16j), (-0.7143725995296772+3.608986798092513e-17j), (0.472710854506152+9.347215093087467e-17j), (-0.5707798509274735-1.3813111045761499e-17j), (0.34536980200226214-1.1499770144849896e-16j)]\n", - "Gradient: [ 0.65534217 0.16603388 -0.31270245 0.27247095 0.60904527]\n", - "s: 0.024282460160549718\n" - ] - } - ], - "source": [ - "# generate the onsite Z operators\n", - "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", - "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi,d,n=5, onsite_Z_ops=onsite_Z_ops)\n", - "print('The initial D coefficients:', d_coef)\n", - "print('Gradient:', grad)\n", - "print('s:', s)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 596.09trial/s, best loss: 27.467491165569765]\n", - "100%|██████████| 500/500 [00:00<00:00, 689.73trial/s, best loss: 27.469650148347917] \n", - "100%|██████████| 500/500 [00:00<00:00, 684.87trial/s, best loss: 23.138955844687388] \n", - "100%|██████████| 500/500 [00:00<00:00, 680.99trial/s, best loss: 23.147351603039073]\n", - "100%|██████████| 500/500 [00:00<00:00, 709.00trial/s, best loss: 20.03558303567074] \n", - "100%|██████████| 500/500 [00:00<00:00, 638.55trial/s, best loss: 20.01446017712839] \n", - "100%|██████████| 500/500 [00:00<00:00, 659.72trial/s, best loss: 18.534762036988734]\n", - "100%|██████████| 500/500 [00:00<00:00, 702.62trial/s, best loss: 18.511235299525854]\n", - "100%|██████████| 500/500 [00:00<00:00, 716.91trial/s, best loss: 17.667631299146947] \n", - "100%|██████████| 500/500 [00:00<00:00, 717.85trial/s, best loss: 17.623675374778802] \n", - "100%|██████████| 500/500 [00:00<00:00, 626.07trial/s, best loss: 17.043867777621116]\n", - "100%|██████████| 500/500 [00:00<00:00, 662.03trial/s, best loss: 16.99411319096819] \n", - "100%|██████████| 500/500 [00:00<00:00, 694.96trial/s, best loss: 16.644107561332255]\n", - "100%|██████████| 500/500 [00:00<00:00, 712.76trial/s, best loss: 16.467189206952877] \n", - "100%|██████████| 500/500 [00:00<00:00, 713.76trial/s, best loss: 16.046314213095602]\n", - "100%|██████████| 500/500 [00:00<00:00, 699.95trial/s, best loss: 15.878928292681035] \n", - "100%|██████████| 500/500 [00:00<00:00, 691.24trial/s, best loss: 15.62141427589626] \n", - "100%|██████████| 500/500 [00:00<00:00, 667.73trial/s, best loss: 15.306325490043811] \n", - "100%|██████████| 500/500 [00:00<00:00, 694.90trial/s, best loss: 15.001484687547642] \n", - "100%|██████████| 500/500 [00:00<00:00, 709.52trial/s, best loss: 14.685062151226393] \n", - "100%|██████████| 500/500 [00:00<00:00, 710.15trial/s, best loss: 14.382216679135025] \n", - "100%|██████████| 500/500 [00:00<00:00, 710.67trial/s, best loss: 14.119940441735679] \n", - "100%|██████████| 500/500 [00:00<00:00, 708.88trial/s, best loss: 13.78053626699668] \n", - "100%|██████████| 500/500 [00:00<00:00, 626.04trial/s, best loss: 13.454854914663409] \n", - "100%|██████████| 500/500 [00:00<00:00, 703.66trial/s, best loss: 13.234269890734126] \n", - "100%|██████████| 500/500 [00:00<00:00, 718.00trial/s, best loss: 12.91970011325924] \n", - "100%|██████████| 500/500 [00:00<00:00, 720.73trial/s, best loss: 12.720794188076404] \n", - "100%|██████████| 500/500 [00:00<00:00, 707.81trial/s, best loss: 12.318517501084749] \n", - "100%|██████████| 500/500 [00:00<00:00, 681.10trial/s, best loss: 12.239079499566277]\n", - "100%|██████████| 500/500 [00:00<00:00, 725.63trial/s, best loss: 11.84799809909737] \n", - "100%|██████████| 500/500 [00:00<00:00, 718.62trial/s, best loss: 11.791868030395284] \n", - "100%|██████████| 500/500 [00:00<00:00, 720.66trial/s, best loss: 11.327252333996837]\n", - "100%|██████████| 500/500 [00:00<00:00, 714.03trial/s, best loss: 11.399156998591792] \n", - "100%|██████████| 500/500 [00:00<00:00, 716.52trial/s, best loss: 10.930539957425072] \n", - "100%|██████████| 500/500 [00:00<00:00, 677.71trial/s, best loss: 11.030749112814767]\n", - "100%|██████████| 500/500 [00:00<00:00, 722.09trial/s, best loss: 10.541671026174445] \n", - "100%|██████████| 500/500 [00:00<00:00, 651.08trial/s, best loss: 10.710765125494259] \n", - "100%|██████████| 500/500 [00:00<00:00, 721.96trial/s, best loss: 10.218781456526894] \n", - "100%|██████████| 500/500 [00:00<00:00, 714.29trial/s, best loss: 10.415667907517046] \n", - "100%|██████████| 500/500 [00:00<00:00, 710.97trial/s, best loss: 9.86363032877] \n", - "100%|██████████| 500/500 [00:00<00:00, 719.97trial/s, best loss: 10.15401395656047] \n", - "100%|██████████| 500/500 [00:00<00:00, 723.84trial/s, best loss: 9.562300454021948] \n", - "100%|██████████| 500/500 [00:00<00:00, 718.29trial/s, best loss: 9.907794571609012] \n", - "100%|██████████| 500/500 [00:00<00:00, 674.37trial/s, best loss: 9.224080650038678]\n", - "100%|██████████| 500/500 [00:00<00:00, 697.77trial/s, best loss: 9.68514825302649] \n", - "100%|██████████| 500/500 [00:00<00:00, 725.93trial/s, best loss: 8.950894937315692] \n", - "100%|██████████| 500/500 [00:00<00:00, 722.83trial/s, best loss: 9.467012864418232]\n", - "100%|██████████| 500/500 [00:00<00:00, 720.74trial/s, best loss: 8.647047841471467] \n", - "100%|██████████| 500/500 [00:00<00:00, 722.07trial/s, best loss: 9.264932438521221] \n", - "100%|██████████| 500/500 [00:00<00:00, 724.61trial/s, best loss: 8.403247837651655] \n", - "100%|██████████| 500/500 [00:00<00:00, 686.26trial/s, best loss: 9.063835314892646]\n", - "100%|██████████| 500/500 [00:00<00:00, 717.35trial/s, best loss: 8.149990124972552] \n", - "100%|██████████| 500/500 [00:00<00:00, 715.79trial/s, best loss: 8.87960896954228] \n", - "100%|██████████| 500/500 [00:00<00:00, 726.35trial/s, best loss: 7.913881055204248]\n", - "100%|██████████| 500/500 [00:00<00:00, 724.78trial/s, best loss: 8.697803369655396] \n", - "100%|██████████| 500/500 [00:00<00:00, 687.97trial/s, best loss: 7.678966990725647] \n", - "100%|██████████| 500/500 [00:00<00:00, 720.81trial/s, best loss: 8.529279658079181] \n", - "100%|██████████| 500/500 [00:00<00:00, 728.49trial/s, best loss: 7.4907779318523815]\n", - "100%|██████████| 500/500 [00:00<00:00, 721.37trial/s, best loss: 8.367946297589626] \n", - "100%|██████████| 500/500 [00:00<00:00, 723.56trial/s, best loss: 7.305839659415738] \n" - ] - } - ], - "source": [ - "iters = 30\n", - "d_coef_1, d_1 = d_coef, d\n", - "d_coef_2, d_2 = d_coef, d\n", - "\n", - "off_diagonal_norm_1 = [dbi_1.off_diagonal_norm]\n", - "off_diagonal_norm_2 = [dbi_2.off_diagonal_norm]\n", - "s_step_1 = [0]\n", - "s_step_2 = [0]\n", - "for i in range(iters):\n", - " s_1, d_coef_1, d_1 = gradient_descent_onsite_Z(dbi_1, d_coef_1, d_1, onsite_Z_ops=onsite_Z_ops, n=n_1, max_evals=100)\n", - " s_2, d_coef_2, d_2 = gradient_descent_onsite_Z(dbi_2, d_coef_2, d_2, onsite_Z_ops=onsite_Z_ops, n=n_2, max_evals=100)\n", - " dbi_1(step=s_1, d=d_1)\n", - " dbi_2(step=s_2, d=d_2)\n", - " off_diagonal_norm_1.append(dbi_1.off_diagonal_norm)\n", - " off_diagonal_norm_2.append(dbi_2.off_diagonal_norm)\n", - " s_step_1.append(s_1)\n", - " s_step_2.append(s_2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", - "plt.plot(off_diagonal_norm_1, label=f'n_taylor={n_1}')\n", - "plt.plot(off_diagonal_norm_2, label=f'n_taylor={n_2}')\n", - "plt.legend()\n", - "plt.xlabel('Iteration')\n", - "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" - ] } ], "metadata": { diff --git a/examples/dbi/dbi_strategy_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb deleted file mode 100644 index fc1c51bd40..0000000000 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ /dev/null @@ -1,872 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Double-Bracket Iteration Strategy: magnetic field (onsite Z)\n", - "This notebook shows the diagonalization process of DBI using the magnetic field strategy, which varies the diagonal operator $D$ by gradient descent. To find the gradient with respect to $D$, parameterization of $D$ is required. For the purpose of this notebook, we represent it by onsite Pauli-Z operators, i.e.\n", - "\n", - "$$ D = \\sum \\alpha_i Z_i $$\n", - "\n", - "Note that it is also possible to have higher-order terms, such as $ D = \\sum \\alpha_i Z_i + \\sum \\beta_{i,j}Z_iZ_j+...$\n", - "\n", - "The gradients are calculated under the premise that the diagonalization gain curve can be fitted by a polynomial, and that the iteration step duration is taken at the first dip of the curve." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "from copy import deepcopy\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from qibo import hamiltonians, set_backend\n", - "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", - "from qibo.quantum_info import random_hermitian\n", - "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "def visualize_matrix(matrix, title=\"\"):\n", - " \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n", - " fig, ax = plt.subplots(figsize=(5,5))\n", - " ax.set_title(title)\n", - " try:\n", - " im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n", - " except TypeError:\n", - " im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n", - " fig.colorbar(im, ax=ax)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Test on random Hamiltonian" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-03-26 16:07:47]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 31.576176740060667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# backend\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "# initialize dbi object\n", - "nqubits = 5\n", - "h0 = random_hermitian(2**nqubits, seed=2)\n", - "scheduling = DoubleBracketScheduling.hyperopt\n", - "mode = DoubleBracketGeneratorType.single_commutator\n", - "n_taylor = 5\n", - "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", - "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", - "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:07:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 691.96trial/s, best loss: 27.607175404720753]\n", - "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j)]\n", - "Gradient: [-0.20478337 0.418433 -0.03167988 0.18669773 -0.86435984]\n", - "s: 0.11660954506915275\n" - ] - } - ], - "source": [ - "# generate the onsite Z operators\n", - "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", - "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi, d=d, onsite_Z_ops=onsite_Z_ops)\n", - "print('The initial D coefficients:', d_coef)\n", - "print('Gradient:', grad)\n", - "print('s:', s)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 703.22trial/s, best loss: 27.607182422340095] \n", - "100%|██████████| 500/500 [00:00<00:00, 729.43trial/s, best loss: 24.35179754917795] \n", - "100%|██████████| 500/500 [00:00<00:00, 729.08trial/s, best loss: 22.089444283591433] \n", - "100%|██████████| 500/500 [00:00<00:00, 698.65trial/s, best loss: 20.347120765676763]\n", - "100%|██████████| 500/500 [00:00<00:00, 623.16trial/s, best loss: 18.94635121785982]\n", - "100%|██████████| 500/500 [00:00<00:00, 605.13trial/s, best loss: 17.773702241529776] \n", - "100%|██████████| 500/500 [00:00<00:00, 687.10trial/s, best loss: 16.784805711373227] \n", - "100%|██████████| 500/500 [00:00<00:00, 695.51trial/s, best loss: 15.934402363491223] \n", - "100%|██████████| 500/500 [00:00<00:00, 652.85trial/s, best loss: 15.197822552085507] \n", - "100%|██████████| 500/500 [00:00<00:00, 685.77trial/s, best loss: 14.481250187299748] \n", - "100%|██████████| 500/500 [00:00<00:00, 692.66trial/s, best loss: 14.044172334074341] \n", - "100%|██████████| 500/500 [00:00<00:00, 692.91trial/s, best loss: 13.670766358199891] \n", - "100%|██████████| 500/500 [00:00<00:00, 684.26trial/s, best loss: 13.325331286760488] \n", - "100%|██████████| 500/500 [00:00<00:00, 636.50trial/s, best loss: 13.01668686825596] \n", - "100%|██████████| 500/500 [00:00<00:00, 612.11trial/s, best loss: 12.711623339299685] \n", - "100%|██████████| 500/500 [00:00<00:00, 697.36trial/s, best loss: 12.409020875491057] \n", - "100%|██████████| 500/500 [00:00<00:00, 683.72trial/s, best loss: 12.08748982503799] \n", - "100%|██████████| 500/500 [00:00<00:00, 738.27trial/s, best loss: 11.75348065601818]\n", - "100%|██████████| 500/500 [00:00<00:00, 724.55trial/s, best loss: 11.410208539441799] \n", - "100%|██████████| 500/500 [00:00<00:00, 729.97trial/s, best loss: 11.06582875641592] \n", - "100%|██████████| 500/500 [00:00<00:00, 723.17trial/s, best loss: 10.734278849532725] \n", - "100%|██████████| 500/500 [00:00<00:00, 736.09trial/s, best loss: 10.391106227243483] \n", - "100%|██████████| 500/500 [00:00<00:00, 695.73trial/s, best loss: 9.835687097799866] \n", - "100%|██████████| 500/500 [00:00<00:00, 645.00trial/s, best loss: 9.836151362023536]\n", - "100%|██████████| 500/500 [00:00<00:00, 662.94trial/s, best loss: 9.83679254247866] \n", - "100%|██████████| 500/500 [00:00<00:00, 692.56trial/s, best loss: 9.83815541734947] \n", - "100%|██████████| 500/500 [00:00<00:00, 683.98trial/s, best loss: 9.838623865790995] \n", - "100%|██████████| 500/500 [00:00<00:00, 691.24trial/s, best loss: 9.83915601848446] \n", - "100%|██████████| 500/500 [00:00<00:00, 697.64trial/s, best loss: 9.843010172903082] \n", - "100%|██████████| 500/500 [00:00<00:00, 669.37trial/s, best loss: 9.844996826247685] \n" - ] - } - ], - "source": [ - "iters = 30\n", - "off_diagonal_norm = [dbi.off_diagonal_norm]\n", - "s_step = [0]\n", - "for i in range(iters):\n", - " s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef=d_coef, d=d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " dbi(step=s, d=d)\n", - " off_diagonal_norm.append(dbi.off_diagonal_norm)\n", - " s_step.append(s)" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(str(nqubits) + ' spins random hamiltonian')\n", - "plt.plot(off_diagonal_norm)\n", - "plt.xlabel('Iteration')\n", - "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Test on TFIM\n", - "Here we choose to customize our TFIM in the X axis using `SymbolicHamiltonian`. It is also possible to use Hadamard gate to rotate the TFIM inbuilt in `qibo`.\n", - "\n", - "$$ H = -(\\sum X_i X_{i+1} + \\sum hZ_i)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:13]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# generate the Hamiltonian\n", - "nqubits = 5\n", - "h = 1\n", - "H_TFIM = SymbolicHamiltonian( - h*symbols.Z(nqubits-1), nqubits=nqubits)\n", - "# add linear interaction terms\n", - "for i in range(nqubits-1):\n", - " H_TFIM -= SymbolicHamiltonian(symbols.X(i)*symbols.X(i+1) + h*symbols.Z(i), nqubits=nqubits)\n", - "H_TFIM = H_TFIM.dense\n", - "visualize_matrix(H_TFIM.matrix, title=f'TFIM with L={nqubits} h={h}')" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-03-26 16:08:14]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], - "source": [ - "# backend\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "# initialize dbi object\n", - "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:14]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:01<00:00, 383.66trial/s, best loss: 8.1443761719701] \n", - "Initial off-diagonal norm: 9.844996868109437\n", - "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n", - "Gradient: [-0.22567346 -0.52080864 -0.59637211 -0.52080864 -0.22567346]\n", - "s: 0.05271207518843116\n" - ] - } - ], - "source": [ - "# generate the onsite Z operators\n", - "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", - "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix, onsite_Z_ops)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi_TFIM, d, n=5, onsite_Z_ops=onsite_Z_ops)\n", - "print('Initial off-diagonal norm:', dbi.off_diagonal_norm)\n", - "print('The initial D coefficients:', d_coef)\n", - "print('Gradient:', grad)\n", - "print('s:', s)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 591.53trial/s, best loss: 8.145383187499851]\n", - "New optimized step at iteration 1/15: 0.05372645731587117 with d_coef [(-0.9894224152921011+0j), (-0.9787695132043422+0j), (-0.9750406784474285+0j), (-0.9787695132043422+0j), (-0.9894224152921011+0j)], loss 8.143621474679835\n", - "100%|██████████| 500/500 [00:00<00:00, 645.70trial/s, best loss: 7.605789256028495]\n", - "New optimized step at iteration 2/15: 0.05650469375482817 with d_coef [(-0.967659680502992+0j), (-1.1697984701193866+0j), (-1.1812229848159992+0j), (-1.169798470119386+0j), (-0.9676596805029926+0j)], loss 7.597613753384701\n", - "100%|██████████| 500/500 [00:00<00:00, 655.89trial/s, best loss: 7.428351470243482] \n", - "New optimized step at iteration 3/15: 0.0398775478554277 with d_coef [(-0.9211510601202757+0j), (-1.8583923563596692+0j), (-1.3920649030243233+0j), (-1.8583923563596683+0j), (-0.9211510601202774+0j)], loss 7.340829616091421\n", - "100%|██████████| 500/500 [00:00<00:00, 662.71trial/s, best loss: 7.044497387511533] \n", - "New optimized step at iteration 4/15: 0.04899248221924902 with d_coef [(-0.6972643143931548+0j), (-2.4626900070115862+0j), (-0.9844514837970455+0j), (-2.462690007011585+0j), (-0.6972643143931571+0j)], loss 6.642213913279594\n", - "100%|██████████| 500/500 [00:00<00:00, 657.76trial/s, best loss: 5.999678025090855] \n", - "New optimized step at iteration 5/15: 0.022874588399740523 with d_coef [(-0.5466790556822081+0j), (-2.999350700331548+0j), (-0.3794556667684317+0j), (-2.9993507003315476+0j), (-0.5466790556822098+0j)], loss 5.886447625252318\n", - "100%|██████████| 500/500 [00:00<00:00, 574.02trial/s, best loss: 5.3112300777947405]\n", - "New optimized step at iteration 6/15: 0.019141369630992236 with d_coef [(-0.7333858133569751+0j), (-3.0535952858417934+0j), (0.5756460221651358+0j), (-3.053595285841793+0j), (-0.7333858133569763+0j)], loss 5.250048883689106\n", - "100%|██████████| 500/500 [00:00<00:00, 675.11trial/s, best loss: 4.816608426854996] \n", - "New optimized step at iteration 7/15: 0.023987091082236008 with d_coef [(-1.0481221272508368+0j), (-3.1124649418400363+0j), (1.4655494332027308+0j), (-3.1124649418400367+0j), (-1.048122127250837+0j)], loss 4.718211391122002\n", - "100%|██████████| 500/500 [00:00<00:00, 679.58trial/s, best loss: 4.284286113986318] \n", - "New optimized step at iteration 8/15: 0.02139251957239659 with d_coef [(-1.4568864129920867+0j), (-3.060562777832911+0j), (2.2749298849030803+0j), (-3.0605627778329114+0j), (-1.4568864129920873+0j)], loss 4.141138157155743\n", - "100%|██████████| 500/500 [00:00<00:00, 707.05trial/s, best loss: 3.539292516453598] \n", - "New optimized step at iteration 9/15: 0.02678154139520766 with d_coef [(-1.8702833982016478+0j), (-2.970343142930349+0j), (3.048114960756174+0j), (-2.9703431429303495+0j), (-1.8702833982016478+0j)], loss 3.3574911798518396\n", - "100%|██████████| 500/500 [00:00<00:00, 712.38trial/s, best loss: 2.874231151326864] \n", - "New optimized step at iteration 10/15: 0.01690916984115942 with d_coef [(-2.3030995103215814+0j), (-2.7605226880132614+0j), (3.777805532801257+0j), (-2.7605226880132614+0j), (-2.3030995103215792+0j)], loss 2.8230284010126816\n", - "100%|██████████| 500/500 [00:00<00:00, 666.99trial/s, best loss: 2.6088111056187437]\n", - "New optimized step at iteration 11/15: 0.026384092579150507 with d_coef [(-2.303103545745607+0j), (-2.76052331639202+0j), (3.7778137111811922+0j), (-2.76052331639202+0j), (-2.303103545745605+0j)], loss 2.6088111361606745\n", - "100%|██████████| 500/500 [00:00<00:00, 698.11trial/s, best loss: 2.546900361123962] \n", - "New optimized step at iteration 12/15: 0.015856203984303208 with d_coef [(-2.4537053596179947+0j), (-2.9677391380139637+0j), (4.069082377286002+0j), (-2.9677391380139513+0j), (-2.453705359617996+0j)], loss 2.546553818422246\n", - "100%|██████████| 500/500 [00:00<00:00, 742.58trial/s, best loss: 2.5253329418331236] \n", - "New optimized step at iteration 13/15: 0.022393088088665674 with d_coef [(-2.3237315151526348+0j), (-3.577847645999822+0j), (4.518564738562181+0j), (-3.577847645999736+0j), (-2.323731515152562+0j)], loss 2.500500419765173\n", - "100%|██████████| 500/500 [00:00<00:00, 746.30trial/s, best loss: 2.477865397687387] \n", - "New optimized step at iteration 14/15: 0.015967541185165194 with d_coef [(-1.9364597181792154+0j), (-4.149207093868703+0j), (4.441437397182407+0j), (-4.149207093868369+0j), (-1.936459718178632+0j)], loss 2.4579020061866172\n", - "100%|██████████| 500/500 [00:00<00:00, 742.62trial/s, best loss: 2.435713071167654] \n", - "New optimized step at iteration 15/15: 0.01431296703708781 with d_coef [(-1.5093021425133906+0j), (-4.700001486852238+0j), (4.295827265099874+0j), (-4.700001486851165+0j), (-1.5093021425092228+0j)], loss 2.422561227610107\n" - ] - } - ], - "source": [ - "NSTEPS = 15\n", - "off_diagonal_norm_delta = [dbi_TFIM.off_diagonal_norm]\n", - "s_step_delta = [0]\n", - "for _ in range(NSTEPS):\n", - " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100, n=5, use_ds=True)\n", - " dbi_TFIM(step=s, d=d)\n", - " off_diagonal_norm_delta.append(dbi_TFIM.off_diagonal_norm)\n", - " s_step_delta.append(s)\n", - " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM.off_diagonal_norm}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", - "plt.plot(off_diagonal_norm_delta)\n", - "plt.xlabel('Iteration')\n", - "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# the final matrix\n", - "visualize_matrix(dbi_TFIM.h.matrix)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Different initial `d`\n", - "Next, we show the effect of different choices of the initial direction of the gradient descent method." - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(-2.580645161290323+0j), (-1.2903225806451613+0j), (-0.6451612903225807+0j), (-0.32258064516129037+0j), (-0.16129032258064518+0j)]\n" - ] - } - ], - "source": [ - "H = H_TFIM.matrix\n", - "L = int(np.log2(H.shape[0]))\n", - "N = np.diag(np.linspace(np.min(np.diag(H)),np.max(np.diag(H)),2**L))\n", - "d_coef = onsite_Z_decomposition(N, onsite_Z_ops)\n", - "print(d_coef)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "visualize_matrix(H, 'Initial hamiltonian')\n", - "visualize_matrix(N, 'Min-max diagonal matrix')\n", - "visualize_matrix(d, 'Min-max projection onsite-Z')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we see that the min-max diagonal operator can be correctly decomposed into onsite-Z operators. Then we generate the diagonalization curve and compare with other initializations." - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-03-26 16:08:28]: Using qibojit (numba) backend on /CPU:0\n" - ] - } - ], - "source": [ - "# backend\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "# initialize dbi object\n", - "dbi_TFIM_MMH = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 688.27trial/s, best loss: 9.336239342915379]\n", - "New optimized step at iteration 1/15: 0.039240166337035656 with d_coef [(-2.3180340693309422+0j), (-0.9042157574954297+0j), (-0.6267094129284807+0j), (-0.37510402952816974+0j), (-0.16137910360026844+0j)], loss 9.263805656974093\n", - "100%|██████████| 500/500 [00:00<00:00, 654.86trial/s, best loss: 8.253271106315344] \n", - "New optimized step at iteration 2/15: 0.0636971166898561 with d_coef [(-2.8893154826347565+0j), (-1.3328071932958503+0j), (-0.5996311871447069+0j), (-0.38812640871658144+0j), (-0.16592899239661785+0j)], loss 8.248988639626276\n", - "100%|██████████| 500/500 [00:00<00:00, 705.90trial/s, best loss: 7.820911729728226] \n", - "New optimized step at iteration 3/15: 0.026774099108320803 with d_coef [(-3.9047191557345737+0j), (-1.3620955366051533+0j), (-1.094932722170599+0j), (-0.5744178736473565+0j), (-0.04727696085745736+0j)], loss 7.79237041903216\n", - "100%|██████████| 500/500 [00:00<00:00, 522.76trial/s, best loss: 7.506187222292692]\n", - "New optimized step at iteration 4/15: 0.029295596624437686 with d_coef [(-3.894655859483571+0j), (-1.866243073713661+0j), (-0.7092145648013096+0j), (-0.7039608847825699+0j), (-0.023283739763302808+0j)], loss 7.4962199726801755\n", - "100%|██████████| 500/500 [00:00<00:00, 576.24trial/s, best loss: 7.262455656549131]\n", - "New optimized step at iteration 5/15: 0.02836170693029348 with d_coef [(-3.9671435812064013+0j), (-1.748374386604198+0j), (-0.9350901630745362+0j), (-0.6281543245247632+0j), (-0.021512156595171472+0j)], loss 7.242940534826334\n", - "100%|██████████| 500/500 [00:00<00:00, 671.15trial/s, best loss: 7.044926289914773]\n", - "New optimized step at iteration 6/15: 0.027897015043668715 with d_coef [(-3.948390041694754+0j), (-1.8847156433519916+0j), (-0.8262997874928508+0j), (-0.6276868981090158+0j), (-0.03885078124692265+0j)], loss 7.026681601151195\n", - "100%|██████████| 500/500 [00:00<00:00, 690.94trial/s, best loss: 6.855318614477858] \n", - "New optimized step at iteration 7/15: 0.027095778110113995 with d_coef [(-3.9519653973013913+0j), (-1.911636257457286+0j), (-0.8907292589911223+0j), (-0.6344354980656255+0j), (-0.0239873577390306+0j)], loss 6.826359605831807\n", - "100%|██████████| 500/500 [00:00<00:00, 520.20trial/s, best loss: 6.6782408641935875]\n", - "New optimized step at iteration 8/15: 0.027670995126608866 with d_coef [(-3.9302491674477538+0j), (-1.9666365073691627+0j), (-0.8561543524586357+0j), (-0.6383800207112388+0j), (-0.004655769048021813+0j)], loss 6.636290444352086\n", - "100%|██████████| 500/500 [00:00<00:00, 576.02trial/s, best loss: 6.500633770102917]\n", - "New optimized step at iteration 9/15: 0.027675484066740867 with d_coef [(-3.910374644169554+0j), (-1.9831418560231258+0j), (-0.9056736621483122+0j), (-0.6540987589359828+0j), (0.02406147464053876+0j)], loss 6.447464047229631\n", - "100%|██████████| 500/500 [00:00<00:00, 686.99trial/s, best loss: 6.319748615035787]\n", - "New optimized step at iteration 10/15: 0.026930095210157 with d_coef [(-3.886824281463916+0j), (-1.99625546879924+0j), (-0.9414450075378732+0j), (-0.6563760409606512+0j), (0.03970055245590362+0j)], loss 6.2592485638502575\n", - "100%|██████████| 500/500 [00:00<00:00, 678.32trial/s, best loss: 6.1400705423264075]\n", - "New optimized step at iteration 11/15: 0.027416250931757133 with d_coef [(-3.8475665420145373+0j), (-2.037392997099672+0j), (-0.9264643353804642+0j), (-0.6830139042784837+0j), (0.08321313069136971+0j)], loss 6.056764516965165\n", - "100%|██████████| 500/500 [00:00<00:00, 729.97trial/s, best loss: 5.940597947808348] \n", - "New optimized step at iteration 12/15: 0.028200202317592835 with d_coef [(-3.82460449840812+0j), (-2.035906559623582+0j), (-0.9702033338205296+0j), (-0.6848609304443387+0j), (0.11118456157172787+0j)], loss 5.848596463276441\n", - "100%|██████████| 500/500 [00:00<00:00, 743.16trial/s, best loss: 5.72938416138] \n", - "New optimized step at iteration 13/15: 0.025525484486623708 with d_coef [(-3.8277137978993436+0j), (-2.0402358325723036+0j), (-0.9967614632890175+0j), (-0.6822006377994072+0j), (0.09661303923602668+0j)], loss 5.643243093952352\n", - "100%|██████████| 500/500 [00:00<00:00, 722.17trial/s, best loss: 5.532276668994669] \n", - "New optimized step at iteration 14/15: 0.028418788139760974 with d_coef [(-3.7489089984244486+0j), (-2.114017010442895+0j), (-0.9183197191620466+0j), (-0.7036125621442609+0j), (0.16285610695072883+0j)], loss 5.4057916657046725\n", - "100%|██████████| 500/500 [00:00<00:00, 739.76trial/s, best loss: 5.288910417094644] \n", - "New optimized step at iteration 15/15: 0.02625000676004677 with d_coef [(-3.789232226109539+0j), (-2.092494639505251+0j), (-1.0022140546781002+0j), (-0.6714823814533052+0j), (0.13551681944910254+0j)], loss 5.191808803025761\n" - ] - } - ], - "source": [ - "NSTEPS = 15\n", - "off_diagonal_norm_MMH = [dbi_TFIM_MMH.off_diagonal_norm]\n", - "s_step_MMH = [0]\n", - "# d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", - "# d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", - "for _ in range(NSTEPS):\n", - " d = np.diag(np.linspace(np.min(np.diag(dbi_TFIM_MMH.h.matrix)),np.max(np.diag(dbi_TFIM_MMH.h.matrix)),2**nqubits))\n", - " d_coef = onsite_Z_decomposition(d, onsite_Z_ops)\n", - " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM_MMH, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " dbi_TFIM_MMH(d=d, step=s)\n", - " off_diagonal_norm_MMH.append(dbi_TFIM_MMH.off_diagonal_norm)\n", - " s_step_MMH.append(s)\n", - " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM_MMH.off_diagonal_norm}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", - "plt.plot(off_diagonal_norm_MMH, label='MMH')\n", - "plt.plot(off_diagonal_norm_delta, label='delta')\n", - "plt.xlabel('Iteration')\n", - "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Effect of `n`" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-03-26 16:08:41]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 31.576176740060667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# backend\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "# initialize dbi object\n", - "nqubits = 5\n", - "h0 = random_hermitian(2**nqubits, seed=2)\n", - "scheduling = DoubleBracketScheduling.hyperopt\n", - "mode = DoubleBracketGeneratorType.single_commutator\n", - "n_1 = 5\n", - "n_2 = 3\n", - "dbi_1 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", - "dbi_2 = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n", - "print(\"Initial off diagonal norm\", dbi_1.off_diagonal_norm)\n", - "visualize_matrix(dbi_1.h.matrix, title=f'Random hamiltonian with L={nqubits}')" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-03-26 16:08:41]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 697.70trial/s, best loss: 9.558186537868679] \n", - "The initial D coefficients: [(-3.321354431855655-1.7961649980378765e-16j), (-0.7143725995296772+3.608986798092513e-17j), (0.472710854506152+9.347215093087467e-17j), (-0.5707798509274735-1.3813111045761499e-17j), (0.34536980200226214-1.1499770144849896e-16j)]\n", - "Gradient: [ 0.65534217 0.16603388 -0.31270245 0.27247095 0.60904527]\n", - "s: 0.024282460160549718\n" - ] - } - ], - "source": [ - "# generate the onsite Z operators\n", - "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", - "d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)\n", - "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", - "grad, s = gradient_onsite_Z(dbi,d,n=5, onsite_Z_ops=onsite_Z_ops)\n", - "print('The initial D coefficients:', d_coef)\n", - "print('Gradient:', grad)\n", - "print('s:', s)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 596.09trial/s, best loss: 27.467491165569765]\n", - "100%|██████████| 500/500 [00:00<00:00, 689.73trial/s, best loss: 27.469650148347917] \n", - "100%|██████████| 500/500 [00:00<00:00, 684.87trial/s, best loss: 23.138955844687388] \n", - "100%|██████████| 500/500 [00:00<00:00, 680.99trial/s, best loss: 23.147351603039073]\n", - "100%|██████████| 500/500 [00:00<00:00, 709.00trial/s, best loss: 20.03558303567074] \n", - "100%|██████████| 500/500 [00:00<00:00, 638.55trial/s, best loss: 20.01446017712839] \n", - "100%|██████████| 500/500 [00:00<00:00, 659.72trial/s, best loss: 18.534762036988734]\n", - "100%|██████████| 500/500 [00:00<00:00, 702.62trial/s, best loss: 18.511235299525854]\n", - "100%|██████████| 500/500 [00:00<00:00, 716.91trial/s, best loss: 17.667631299146947] \n", - "100%|██████████| 500/500 [00:00<00:00, 717.85trial/s, best loss: 17.623675374778802] \n", - "100%|██████████| 500/500 [00:00<00:00, 626.07trial/s, best loss: 17.043867777621116]\n", - "100%|██████████| 500/500 [00:00<00:00, 662.03trial/s, best loss: 16.99411319096819] \n", - "100%|██████████| 500/500 [00:00<00:00, 694.96trial/s, best loss: 16.644107561332255]\n", - "100%|██████████| 500/500 [00:00<00:00, 712.76trial/s, best loss: 16.467189206952877] \n", - "100%|██████████| 500/500 [00:00<00:00, 713.76trial/s, best loss: 16.046314213095602]\n", - "100%|██████████| 500/500 [00:00<00:00, 699.95trial/s, best loss: 15.878928292681035] \n", - "100%|██████████| 500/500 [00:00<00:00, 691.24trial/s, best loss: 15.62141427589626] \n", - "100%|██████████| 500/500 [00:00<00:00, 667.73trial/s, best loss: 15.306325490043811] \n", - "100%|██████████| 500/500 [00:00<00:00, 694.90trial/s, best loss: 15.001484687547642] \n", - "100%|██████████| 500/500 [00:00<00:00, 709.52trial/s, best loss: 14.685062151226393] \n", - "100%|██████████| 500/500 [00:00<00:00, 710.15trial/s, best loss: 14.382216679135025] \n", - "100%|██████████| 500/500 [00:00<00:00, 710.67trial/s, best loss: 14.119940441735679] \n", - "100%|██████████| 500/500 [00:00<00:00, 708.88trial/s, best loss: 13.78053626699668] \n", - "100%|██████████| 500/500 [00:00<00:00, 626.04trial/s, best loss: 13.454854914663409] \n", - "100%|██████████| 500/500 [00:00<00:00, 703.66trial/s, best loss: 13.234269890734126] \n", - "100%|██████████| 500/500 [00:00<00:00, 718.00trial/s, best loss: 12.91970011325924] \n", - "100%|██████████| 500/500 [00:00<00:00, 720.73trial/s, best loss: 12.720794188076404] \n", - "100%|██████████| 500/500 [00:00<00:00, 707.81trial/s, best loss: 12.318517501084749] \n", - "100%|██████████| 500/500 [00:00<00:00, 681.10trial/s, best loss: 12.239079499566277]\n", - "100%|██████████| 500/500 [00:00<00:00, 725.63trial/s, best loss: 11.84799809909737] \n", - "100%|██████████| 500/500 [00:00<00:00, 718.62trial/s, best loss: 11.791868030395284] \n", - "100%|██████████| 500/500 [00:00<00:00, 720.66trial/s, best loss: 11.327252333996837]\n", - "100%|██████████| 500/500 [00:00<00:00, 714.03trial/s, best loss: 11.399156998591792] \n", - "100%|██████████| 500/500 [00:00<00:00, 716.52trial/s, best loss: 10.930539957425072] \n", - "100%|██████████| 500/500 [00:00<00:00, 677.71trial/s, best loss: 11.030749112814767]\n", - "100%|██████████| 500/500 [00:00<00:00, 722.09trial/s, best loss: 10.541671026174445] \n", - "100%|██████████| 500/500 [00:00<00:00, 651.08trial/s, best loss: 10.710765125494259] \n", - "100%|██████████| 500/500 [00:00<00:00, 721.96trial/s, best loss: 10.218781456526894] \n", - "100%|██████████| 500/500 [00:00<00:00, 714.29trial/s, best loss: 10.415667907517046] \n", - "100%|██████████| 500/500 [00:00<00:00, 710.97trial/s, best loss: 9.86363032877] \n", - "100%|██████████| 500/500 [00:00<00:00, 719.97trial/s, best loss: 10.15401395656047] \n", - "100%|██████████| 500/500 [00:00<00:00, 723.84trial/s, best loss: 9.562300454021948] \n", - "100%|██████████| 500/500 [00:00<00:00, 718.29trial/s, best loss: 9.907794571609012] \n", - "100%|██████████| 500/500 [00:00<00:00, 674.37trial/s, best loss: 9.224080650038678]\n", - "100%|██████████| 500/500 [00:00<00:00, 697.77trial/s, best loss: 9.68514825302649] \n", - "100%|██████████| 500/500 [00:00<00:00, 725.93trial/s, best loss: 8.950894937315692] \n", - "100%|██████████| 500/500 [00:00<00:00, 722.83trial/s, best loss: 9.467012864418232]\n", - "100%|██████████| 500/500 [00:00<00:00, 720.74trial/s, best loss: 8.647047841471467] \n", - "100%|██████████| 500/500 [00:00<00:00, 722.07trial/s, best loss: 9.264932438521221] \n", - "100%|██████████| 500/500 [00:00<00:00, 724.61trial/s, best loss: 8.403247837651655] \n", - "100%|██████████| 500/500 [00:00<00:00, 686.26trial/s, best loss: 9.063835314892646]\n", - "100%|██████████| 500/500 [00:00<00:00, 717.35trial/s, best loss: 8.149990124972552] \n", - "100%|██████████| 500/500 [00:00<00:00, 715.79trial/s, best loss: 8.87960896954228] \n", - "100%|██████████| 500/500 [00:00<00:00, 726.35trial/s, best loss: 7.913881055204248]\n", - "100%|██████████| 500/500 [00:00<00:00, 724.78trial/s, best loss: 8.697803369655396] \n", - "100%|██████████| 500/500 [00:00<00:00, 687.97trial/s, best loss: 7.678966990725647] \n", - "100%|██████████| 500/500 [00:00<00:00, 720.81trial/s, best loss: 8.529279658079181] \n", - "100%|██████████| 500/500 [00:00<00:00, 728.49trial/s, best loss: 7.4907779318523815]\n", - "100%|██████████| 500/500 [00:00<00:00, 721.37trial/s, best loss: 8.367946297589626] \n", - "100%|██████████| 500/500 [00:00<00:00, 723.56trial/s, best loss: 7.305839659415738] \n" - ] - } - ], - "source": [ - "iters = 30\n", - "d_coef_1, d_1 = d_coef, d\n", - "d_coef_2, d_2 = d_coef, d\n", - "\n", - "off_diagonal_norm_1 = [dbi_1.off_diagonal_norm]\n", - "off_diagonal_norm_2 = [dbi_2.off_diagonal_norm]\n", - "s_step_1 = [0]\n", - "s_step_2 = [0]\n", - "for i in range(iters):\n", - " s_1, d_coef_1, d_1 = gradient_descent_onsite_Z(dbi_1, d_coef_1, d_1, onsite_Z_ops=onsite_Z_ops, n=n_1, max_evals=100)\n", - " s_2, d_coef_2, d_2 = gradient_descent_onsite_Z(dbi_2, d_coef_2, d_2, onsite_Z_ops=onsite_Z_ops, n=n_2, max_evals=100)\n", - " dbi_1(step=s_1, d=d_1)\n", - " dbi_2(step=s_2, d=d_2)\n", - " off_diagonal_norm_1.append(dbi_1.off_diagonal_norm)\n", - " off_diagonal_norm_2.append(dbi_2.off_diagonal_norm)\n", - " s_step_1.append(s_1)\n", - " s_step_2.append(s_2)" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", - "plt.plot(off_diagonal_norm_1, label=f'n_taylor={n_1}')\n", - "plt.plot(off_diagonal_norm_2, label=f'n_taylor={n_2}')\n", - "plt.legend()\n", - "plt.xlabel('Iteration')\n", - "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "DBF_qibo", - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 5c391b2b123e072d174e4592e2cf0d38f83e0564 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 8 Apr 2024 15:32:28 +0800 Subject: [PATCH 089/116] Update code strucutre and dependencies --- examples/dbi/dbi_scheduling.ipynb | 3 +- examples/dbi/dbi_strategies_compare.ipynb | 4 +- examples/dbi/dbi_strategy_Ising_model.ipynb | 7 +- examples/dbi/dbi_strategy_Pauli-Z.ipynb | 4 +- src/qibo/models/dbi/double_bracket.py | 1 - src/qibo/models/dbi/utils.py | 321 ++------------------ src/qibo/models/dbi/utils_analytical.py | 210 +++++++++++++ src/qibo/models/dbi/utils_scheduling.py | 179 +++-------- src/qibo/models/dbi/utils_strategies.py | 181 +++++++++++ 9 files changed, 465 insertions(+), 445 deletions(-) create mode 100644 src/qibo/models/dbi/utils_analytical.py create mode 100644 src/qibo/models/dbi/utils_strategies.py diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index fdb087871b..a0ac88e6a6 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -30,7 +30,8 @@ "from qibo import hamiltonians, set_backend\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", "from qibo.models.dbi.utils import *\n", - "from qibo.models.dbi.utils_scheduling import *" + "from qibo.models.dbi.utils_scheduling import *\n", + "from qibo.models.dbi.utils_strategies import *" ] }, { diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb index 7b422cf05d..7dfe2c5c60 100644 --- a/examples/dbi/dbi_strategies_compare.ipynb +++ b/examples/dbi/dbi_strategies_compare.ipynb @@ -15,6 +15,7 @@ "metadata": {}, "outputs": [], "source": [ + "\n", "from copy import deepcopy\n", "\n", "import numpy as np\n", @@ -25,7 +26,8 @@ "from qibo.quantum_info import random_hermitian\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", "from qibo.models.dbi.utils import *\n", - "from qibo.models.dbi.utils_scheduling import *" + "from qibo.models.dbi.utils_scheduling import *\n", + "from qibo.models.dbi.utils_strategies import *" ] }, { diff --git a/examples/dbi/dbi_strategy_Ising_model.ipynb b/examples/dbi/dbi_strategy_Ising_model.ipynb index a6c84b0747..ad3b1b5d73 100644 --- a/examples/dbi/dbi_strategy_Ising_model.ipynb +++ b/examples/dbi/dbi_strategy_Ising_model.ipynb @@ -28,7 +28,8 @@ "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", "from qibo.quantum_info import random_hermitian\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *" + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_strategies import *" ] }, { @@ -103,7 +104,7 @@ "metadata": {}, "outputs": [], "source": [ - "iters = 30\n", + "iters = 15\n", "off_diagonal_norm_1 = [dbi.off_diagonal_norm]\n", "s_step = [0]\n", "for i in range(iters):\n", @@ -163,7 +164,7 @@ "metadata": {}, "outputs": [], "source": [ - "iters = 30\n", + "iters = 15\n", "off_diagonal_norm_2 = [dbi.off_diagonal_norm]\n", "s_step = [0]\n", "for i in range(iters):\n", diff --git a/examples/dbi/dbi_strategy_Pauli-Z.ipynb b/examples/dbi/dbi_strategy_Pauli-Z.ipynb index d89fdd5e74..2b60e12896 100644 --- a/examples/dbi/dbi_strategy_Pauli-Z.ipynb +++ b/examples/dbi/dbi_strategy_Pauli-Z.ipynb @@ -40,7 +40,9 @@ "\n", "from qibo import hamiltonians, set_backend\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *" + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *\n", + "from qibo.models.dbi.utils_strategies import *" ] }, { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 124977d51f..c7f1d9eb38 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -2,7 +2,6 @@ from enum import Enum, auto from typing import Optional -import hyperopt import numpy as np from qibo.hamiltonians import Hamiltonian diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 0aeb738cf0..9f3767debb 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -1,19 +1,28 @@ import math -from copy import deepcopy from itertools import combinations, product -from typing import Optional -import hyperopt import numpy as np from qibo import symbols from qibo.backends import _check_backend from qibo.hamiltonians import SymbolicHamiltonian -from qibo.models.dbi.double_bracket import ( - DoubleBracketGeneratorType, - DoubleBracketIteration, - DoubleBracketScheduling, -) + + +def commutator(A, B): + """Compute commutator between two arrays.""" + return A @ B - B @ A + + +def variance(A, state): + """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\\langle\\mu|A^2|\\mu\rangle-\\langle\\mu|A|\\mu\rangle^2$""" + B = A @ A + return B[state, state] - A[state, state] ** 2 + + +def covariance(A, B, state): + """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\\langle\\mu|AB|\\mu\rangle-\\langle\\mu|A|\\mu\rangle\\langle\\mu|B|\\mu\rangle$""" + C = A @ B + B @ A + return C[state, state] - 2 * A[state, state] * B[state, state] def generate_Z_operators(nqubits: int, backend=None): @@ -73,72 +82,6 @@ def str_to_symbolic(name: str): return tensor_op -def select_best_dbr_generator( - dbi_object: DoubleBracketIteration, - d_list: list, - step: Optional[float] = None, - compare_canonical: bool = True, - scheduling: DoubleBracketScheduling = None, - **kwargs, -): - """Selects the best double bracket rotation generator from a list and execute the rotation. - - Args: - dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. - d_list (list): list of diagonal operators (np.array) to run from. - step (float): fixed iteration duration. - Defaults to ``None``, optimize with `scheduling` method and `choose_step` function. - compare_canonical (boolean): if `True`, the diagonalization effect with operators from `d_list` is compared with the canonical bracket. - scheduling (`DoubleBracketScheduling`): scheduling method for finding the optimal step. - - Returns: - The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. - """ - if scheduling is None: - scheduling = dbi_object.scheduling - norms_off_diagonal_restriction = [dbi_object.off_diagonal_norm] * (len(d_list) + 1) - optimal_steps = np.zeros(len(d_list) + 1) - flip_list = np.ones(len(d_list) + 1) - for i, d in enumerate(d_list): - # prescribed step durations - dbi_eval = deepcopy(dbi_object) - flip_list[i] = cs_angle_sgn(dbi_eval, d) - if flip_list[i] != 0: - if step is None: - step_best = dbi_eval.choose_step( - d=flip_list[i] * d, scheduling=scheduling, **kwargs - ) - else: - step_best = step - dbi_eval(step=step_best, d=flip_list[i] * d) - optimal_steps[i] = step_best - norms_off_diagonal_restriction[i] = dbi_eval.off_diagonal_norm - # canonical - if compare_canonical is True: - dbi_eval = deepcopy(dbi_object) - dbi_eval.mode = DoubleBracketGeneratorType.canonical - if step is None: - step_best = dbi_eval.choose_step(scheduling=scheduling, **kwargs) - else: - step_best = step - dbi_eval(step=step_best) - optimal_steps[-1] = step_best - norms_off_diagonal_restriction[-1] = dbi_eval.off_diagonal_norm - # find best d - idx_max_loss = np.argmin(norms_off_diagonal_restriction) - flip = flip_list[idx_max_loss] - step_optimal = optimal_steps[idx_max_loss] - dbi_eval = deepcopy(dbi_object) - if idx_max_loss == len(d_list) and compare_canonical is True: - # canonical - dbi_eval(step=step_optimal, mode=DoubleBracketGeneratorType.canonical) - - else: - d_optimal = flip * d_list[idx_max_loss] - dbi_eval(step=step_optimal, d=d_optimal) - return dbi_eval, idx_max_loss, step_optimal, flip - - def cs_angle_sgn(dbi_object, d): """Calculates the sign of Cauchy-Schwarz Angle :math:`\\langle W(Z), W({\\rm canonical}) \\rangle_{\\rm HS}`.""" norm = np.trace( @@ -152,132 +95,6 @@ def cs_angle_sgn(dbi_object, d): return np.sign(norm) -def dGamma_di_Pauli( - dbi_object: DoubleBracketIteration, n: int, Z_i: np.array, d: np.array -): - """Computes the derivatives $\frac{\\partial \\Gamma_n}{\\partial \alpha_i}$ where the diagonal operator $D=\\sum \alpha_i Z_i$. - - Args: - dbi_object (DoubleBracketIteration): the target dbi object - n (int): the number of nested commutators in `Gamma` - i (int/tupple): the index of onsite-Z coefficient - d (np.array): the diagonal operator - - Returns: - (list): [dGamma_0_di, dGamma_1_di, ..., dGamma_n_di] - """ - nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) - dGamma_di = [np.zeros((2**nqubits, 2**nqubits))] * (n + 1) - Gamma_list = dbi_object.generate_Gamma_list(n=n + 2, d=d) - W = dbi_object.commutator(d, dbi_object.h.matrix) - dW_di = dbi_object.commutator(Z_i, dbi_object.h.matrix) - for k in range(n + 1): - if k == 0: - continue - elif k == 1: - dGamma_di[k] = dW_di - else: - dGamma_di[k] = dbi_object.commutator( - dW_di, Gamma_list[k - 1] - ) + dbi_object.commutator(W, dGamma_di[k - 1]) - return dGamma_di - - -def ds_di_Pauli( - dbi_object: DoubleBracketIteration, - d: np.array, - Z_i: np.array, - taylor_coef: Optional[list] = None, -): - r"""Return the derivatives of the first 3 polynomial coefficients with respect to onsite Pauli-Z coefficients\ - Args: - dbi_object (DoubleBracketIteration): the target dbi object - d (np.array): the diagonal operator - i (int): the index of onsite-Z coefficient - taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}`, from the highest order to the lowest. - onsite_Z_ops (list): onsite Z operators of `dbi_object.h` - Returns: - floats da, db, dc, ds - """ - # generate the list of derivatives w.r.t ith Z operator coefficient - dGamma_di = dGamma_di_Pauli(dbi_object, n=4, Z_i=Z_i, d=d) - Gamma_list = dbi_object.generate_Gamma_list(n=4, d=d) - - def derivative_product(k1, k2): - r"""Calculate the derivative of a product $\sigma(\Gamma(n1,i))@\sigma(\Gamma(n2,i))""" - return dbi_object.sigma(dGamma_di[k1]) @ dbi_object.sigma( - Gamma_list[k2] - ) + dbi_object.sigma(dbi_object.sigma(Gamma_list[k1])) @ dbi_object.sigma( - dGamma_di[k2] - ) - - # calculate the derivatives of s polynomial coefficients - da = np.trace(3 * derivative_product(1, 2) + 3 * derivative_product(3, 0)) - db = np.trace(2 * derivative_product(1, 1) + 2 * derivative_product(0, 2)) - dc = np.trace(2 * derivative_product(1, 0)) - - ds = 0 - if taylor_coef != None: - a, b, c = taylor_coef[len(taylor_coef) - 3 :] - delta = b**2 - 4 * a * c - ddelta = 2 * (b * db - 2 * (a * dc + da * c)) - - ds = (-db + 0.5 * ddelta / np.sqrt(delta)) * a - (-b + np.sqrt(delta)) * da - ds /= 2 * a**2 - - return da, db, dc, ds - - -def gradient_Pauli( - dbi_object: DoubleBracketIteration, - d: np.array, - pauli_operator_dict: dict, - use_ds=False, - n=3, - **kwargs, -): - r"""Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients - Args: - dbi_object (DoubleBracketIteration): the target dbi object - d (np.array): the diagonal operator - n_taylor (int): the highest order of the taylore expansion of w.r.t `s` - onsite_Z_ops (list): list of Pauli-Z operators - taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}` - use_ds (boolean): if False, ds is set to 0 - """ - # n is the highest order for calculating s - - # pauli_index is the list of positions \mu - pauli_operators = list(pauli_operator_dict.values()) - num_paul = len(pauli_operators) - grad = np.zeros(num_paul) - coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n=n) - s = dbi_object.choose_step( - d=d, - **kwargs, - ) - - a, b, c = coef[len(coef) - 3 :] - - for i, operator in enumerate(pauli_operators): - da, db, dc, ds = ds_di_Pauli( - dbi_object, d=d, Z_i=operator, taylor_coef=[a, b, c] - ) - if use_ds is True: - ds = 0 - grad[i] = ( - s**3 / 3 * da - + s**2 / 2 * db - + 2 * s * dc - + s**2 * ds * a - + s * ds * b - + 2 * ds * c - ) - grad = np.array(grad) - grad = grad / np.linalg.norm(grad) - return grad, s - - def decompose_into_Pauli_basis(h_matrix: np.array, pauli_operators: list): """finds the decomposition of hamiltonian `h_matrix` into Pauli-Z operators""" nqubits = int(np.log2(h_matrix.shape[0])) @@ -301,89 +118,16 @@ def generate_pauli_index(nqubits, order): raise ValueError("Order must be a positive integer") -def generate_pauli_operator_dict(nqubits: int, parameterization_order: int): +def generate_pauli_operator_dict( + nqubits: int, parameterization_order: int = 1, symbols_pauli=symbols.Z +): pauli_index = generate_pauli_index(nqubits, order=parameterization_order) pauli_operators = [ - generate_Pauli_operators(nqubits, symbols.Z, index) for index in pauli_index + generate_Pauli_operators(nqubits, symbols_pauli, index) for index in pauli_index ] return {index: operator for index, operator in zip(pauli_index, pauli_operators)} -def gradient_descent_pauli( - dbi_object: DoubleBracketIteration, - d_coef: list, - d: Optional[np.array] = None, - pauli_operator_dict: dict = None, - parameterization_order: int = 1, - n: int = 3, - onsite_Z_ops: Optional[list] = None, - lr_min: float = 1e-5, - lr_max: float = 1, - max_evals: int = 100, - space: callable = None, - optimizer: callable = None, - verbose: bool = False, - use_ds: bool = True, -): - """calculate the elements of one gradient descent step on `dbi_object`. - - Args: - dbi_object (DoubleBracketIteration): the target dbi object - d_coef (list): the initial decomposition of `d` into Pauli-Z operators - d (np.array, optional): the initial diagonal operator. Defaults to None. - n_taylor (int, optional): the highest order to expand the loss function derivative. Defaults to 2. - onsite_Z_ops (list, optional): list of onsite-Z operators. Defaults to None. - lr_min (float, optional): the minimal gradient step. Defaults to 1e-5. - lr_max (float, optional): the maximal gradient step. Defaults to 1. - max_evals (int, optional): the max number of evaluations for `hyperopt` to find the optimal gradient step `lr`. Defaults to 100. - space (callable, optional): the search space for `hyperopt`. Defaults to None. - optimizer (callable, optional): optimizer for `hyperopt`. Defaults to None. - verbose (bool, optional): option to print out the 'hyperopt' progress. Defaults to False. - use_ds (bool, optional): if False, ds is set to 0. Defaults to True. - - Returns: - the optimal step found, coeffcients of `d` in Pauli-Z basis, matrix of `d` - - """ - nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) - if pauli_operator_dict is None: - pauli_operator_dict = generate_pauli_operator_dict( - nqubits, parameterization_order - ) - - grad, s = gradient_Pauli( - dbi_object, d, n=n, pauli_operator_dict=pauli_operator_dict, use_ds=use_ds - ) - # optimize gradient descent step with hyperopt - if space is None: - space = hyperopt.hp.loguniform("lr", np.log(lr_min), np.log(lr_max)) - if optimizer is None: - optimizer = hyperopt.tpe - - def func_loss_to_lr(lr): - d_coef_eval = [d_coef[j] - grad[j] * lr for j in range(nqubits)] - d_eval = sum( - [ - d_coef_eval[i] * list(pauli_operator_dict.values())[i] - for i in range(nqubits) - ] - ) - return dbi_object.loss(step=s, d=d_eval) - - best = hyperopt.fmin( - fn=func_loss_to_lr, - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, - ) - lr = best["lr"] - - d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)] - d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)]) - return s, d_coef, d - - def diagonal_min_max(matrix: np.array): L = int(np.log2(matrix.shape[0])) D = np.linspace(np.min(np.diag(matrix)), np.max(np.diag(matrix)), 2**L) @@ -391,29 +135,6 @@ def diagonal_min_max(matrix: np.array): return D -def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): - if d is None: - d = dbi_object.diagonal_h_matrix - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) - Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) - sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) - exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) - # coefficients for rotation with [W,H] and H - c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:] - c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1] - # product coefficient - trace_coefficients = [0] * (2 * n + 1) - for k in range(n + 1): - for j in range(n + 1): - power = k + j - product_matrix = c1[k] @ c2[j] - trace_coefficients[power] += 2 * np.trace(product_matrix) - # coefficients from high to low (n:0) - coef = list(reversed(trace_coefficients[: n + 1])) - return coef - - def generate_Pauli_operators(nqubits, symbols_pauli, positions): # generate matrix of an nqubit-pauli operator with `symbols_pauli` at `positions` if isinstance(positions, int): diff --git a/src/qibo/models/dbi/utils_analytical.py b/src/qibo/models/dbi/utils_analytical.py new file mode 100644 index 0000000000..35295fe6de --- /dev/null +++ b/src/qibo/models/dbi/utils_analytical.py @@ -0,0 +1,210 @@ +from qibo.models.dbi.utils import * + + +def dGamma_di_Pauli(dbi_object, n: int, Z_i: np.array, d: np.array): + """Computes the derivatives $\frac{\\partial \\Gamma_n}{\\partial \alpha_i}$ where the diagonal operator $D=\\sum \alpha_i Z_i$. + + Args: + dbi_object (DoubleBracketIteration): the target dbi object + n (int): the number of nested commutators in `Gamma` + i (int/tupple): the index of onsite-Z coefficient + d (np.array): the diagonal operator + + Returns: + (list): [dGamma_0_di, dGamma_1_di, ..., dGamma_n_di] + """ + nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) + dGamma_di = [np.zeros((2**nqubits, 2**nqubits))] * (n + 1) + Gamma_list = dbi_object.generate_Gamma_list(n=n + 2, d=d) + W = dbi_object.commutator(d, dbi_object.h.matrix) + dW_di = dbi_object.commutator(Z_i, dbi_object.h.matrix) + for k in range(n + 1): + if k == 0: + continue + elif k == 1: + dGamma_di[k] = dW_di + else: + dGamma_di[k] = dbi_object.commutator( + dW_di, Gamma_list[k - 1] + ) + dbi_object.commutator(W, dGamma_di[k - 1]) + return dGamma_di + + +def ds_di_Pauli( + dbi_object, + d: np.array, + Z_i: np.array, + taylor_coef: Optional[list] = None, +): + r"""Return the derivatives of the first 3 polynomial coefficients with respect to onsite Pauli-Z coefficients\ + Args: + dbi_object (DoubleBracketIteration): the target dbi object + d (np.array): the diagonal operator + i (int): the index of onsite-Z coefficient + taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}`, from the highest order to the lowest. + onsite_Z_ops (list): onsite Z operators of `dbi_object.h` + Returns: + floats da, db, dc, ds + """ + # generate the list of derivatives w.r.t ith Z operator coefficient + dGamma_di = dGamma_di_Pauli(dbi_object, n=4, Z_i=Z_i, d=d) + Gamma_list = dbi_object.generate_Gamma_list(n=4, d=d) + + def derivative_product(k1, k2): + r"""Calculate the derivative of a product $\sigma(\Gamma(n1,i))@\sigma(\Gamma(n2,i))""" + return dbi_object.sigma(dGamma_di[k1]) @ dbi_object.sigma( + Gamma_list[k2] + ) + dbi_object.sigma(dbi_object.sigma(Gamma_list[k1])) @ dbi_object.sigma( + dGamma_di[k2] + ) + + # calculate the derivatives of s polynomial coefficients + da = np.trace(3 * derivative_product(1, 2) + 3 * derivative_product(3, 0)) + db = np.trace(2 * derivative_product(1, 1) + 2 * derivative_product(0, 2)) + dc = np.trace(2 * derivative_product(1, 0)) + + ds = 0 + if taylor_coef != None: + a, b, c = taylor_coef[len(taylor_coef) - 3 :] + delta = b**2 - 4 * a * c + ddelta = 2 * (b * db - 2 * (a * dc + da * c)) + + ds = (-db + 0.5 * ddelta / np.sqrt(delta)) * a - (-b + np.sqrt(delta)) * da + ds /= 2 * a**2 + + return da, db, dc, ds + + +def gradient_Pauli( + dbi_object, + d: np.array, + pauli_operator_dict: dict, + use_ds=False, + n=3, + **kwargs, +): + r"""Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients + Args: + dbi_object (DoubleBracketIteration): the target dbi object + d (np.array): the diagonal operator + n_taylor (int): the highest order of the taylore expansion of w.r.t `s` + onsite_Z_ops (list): list of Pauli-Z operators + taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}` + use_ds (boolean): if False, ds is set to 0 + """ + # n is the highest order for calculating s + + # pauli_index is the list of positions \mu + pauli_operators = list(pauli_operator_dict.values()) + num_paul = len(pauli_operators) + grad = np.zeros(num_paul) + coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n=n) + s = dbi_object.choose_step( + d=d, + **kwargs, + ) + + a, b, c = coef[len(coef) - 3 :] + + for i, operator in enumerate(pauli_operators): + da, db, dc, ds = ds_di_Pauli( + dbi_object, d=d, Z_i=operator, taylor_coef=[a, b, c] + ) + if use_ds is True: + ds = 0 + grad[i] = ( + s**3 / 3 * da + + s**2 / 2 * db + + 2 * s * dc + + s**2 * ds * a + + s * ds * b + + 2 * ds * c + ) + grad = np.array(grad) + grad = grad / np.linalg.norm(grad) + return grad, s + + +def dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list): + # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) + A = np.zeros(d.shape) + A[i, i] = 1 + B = commutator(commutator(A, H), Gamma_list[n - 1]) + W = commutator(d, H) + return B + commutator(W, dGamma[-1]) + + +def dpolynomial_diDiagonal(dbi_object, s, d, H, i): + # Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz) + # Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation + derivative = 0 + A = np.zeros(d.shape) + Gamma_list = dbi_object.generate_Gamma_list(4, d) + A[i, i] = 1 + dGamma = [commutator(A, H)] + derivative += np.real( + np.trace(Gamma_list[0] @ A) + np.trace(dGamma[0] @ d + Gamma_list[1] @ A) * s + ) + for n in range(2, 4): + dGamma.append(dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list)) + derivative += np.real( + np.trace(dGamma[-1] @ d + Gamma_list[n] @ A) * s**n / math.factorial(n) + ) + + return derivative + + +def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) + sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients for rotation with [W,H] and H + c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:] + c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1] + # product coefficient + trace_coefficients = [0] * (2 * n + 1) + for k in range(n + 1): + for j in range(n + 1): + power = k + j + product_matrix = c1[k] @ c2[j] + trace_coefficients[power] += 2 * np.trace(product_matrix) + # coefficients from high to low (n:0) + coef = list(reversed(trace_coefficients[: n + 1])) + return coef + + +def least_squares_polynomial_expansion_coef(dbi_object, d: np.array = None, n: int = 3): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + Gamma_list = dbi_object.generate_Gamma_list(n + 1, d) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients + coef = np.empty(n) + for i in range(n): + coef[i] = np.real(exp_list[i] * np.trace(d @ Gamma_list[i + 1])) + coef = list(reversed(coef)) + return coef + + +def energy_fluctuation_polynomial_expansion_coef( + dbi_object, d: np.array = None, n: int = 3, state=0 +): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + Gamma_list = dbi_object.generate_Gamma_list(n + 1, d) + # coefficients + coef = np.empty(3) + coef[0] = np.real(2 * covariance(Gamma_list[0], Gamma_list[1], state)) + coef[1] = np.real(2 * variance(Gamma_list[1], state)) + coef[2] = np.real( + covariance(Gamma_list[0], Gamma_list[3], state) + + 3 * covariance(Gamma_list[1], Gamma_list[2], state) + ) + coef = list(reversed(coef)) + return coef diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 488d52ca40..4284c6caef 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -1,29 +1,17 @@ import math -from copy import deepcopy from functools import partial from typing import Optional import hyperopt import numpy as np -error = 1e-3 - - -def commutator(A, B): - """Compute commutator between two arrays.""" - return A @ B - B @ A - - -def variance(A, state): - """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\\langle\\mu|A^2|\\mu\rangle-\\langle\\mu|A|\\mu\rangle^2$""" - B = A @ A - return B[state, state] - A[state, state] ** 2 +from qibo.models.dbi.utils_analytical import ( + energy_fluctuation_polynomial_expansion_coef, + least_squares_polynomial_expansion_coef, + off_diagonal_norm_polynomial_expansion_coef, +) - -def covariance(A, B, state): - """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\\langle\\mu|AB|\\mu\rangle-\\langle\\mu|A|\\mu\rangle\\langle\\mu|B|\\mu\rangle$""" - C = A @ B + B @ A - return C[state, state] - 2 * A[state, state] * B[state, state] +error = 1e-3 def grid_search_step( @@ -156,126 +144,6 @@ def polynomial_step( return None -def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): - if d is None: - d = dbi_object.diagonal_h_matrix - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) - Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) - sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) - exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) - # coefficients for rotation with [W,H] and H - c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:] - c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1] - # product coefficient - trace_coefficients = [0] * (2 * n + 1) - for k in range(n + 1): - for j in range(n + 1): - power = k + j - product_matrix = c1[k] @ c2[j] - trace_coefficients[power] += 2 * np.trace(product_matrix) - # coefficients from high to low (n:0) - coef = list(reversed(trace_coefficients[: n + 1])) - return coef - - -def least_squares_polynomial_expansion_coef(dbi_object, d: np.array = None, n: int = 3): - if d is None: - d = dbi_object.diagonal_h_matrix - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - Gamma_list = dbi_object.generate_Gamma_list(n + 1, d) - exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) - # coefficients - coef = np.empty(n) - for i in range(n): - coef[i] = np.real(exp_list[i] * np.trace(d @ Gamma_list[i + 1])) - coef = list(reversed(coef)) - return coef - - -# TODO: add a general expansion formula not stopping at 3rd order -def energy_fluctuation_polynomial_expansion_coef( - dbi_object, d: np.array = None, n: int = 3, state=0 -): - if d is None: - d = dbi_object.diagonal_h_matrix - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - Gamma_list = dbi_object.generate_Gamma_list(n + 1, d) - # coefficients - coef = np.empty(3) - coef[0] = np.real(2 * covariance(Gamma_list[0], Gamma_list[1], state)) - coef[1] = np.real(2 * variance(Gamma_list[1], state)) - coef[2] = np.real( - covariance(Gamma_list[0], Gamma_list[3], state) - + 3 * covariance(Gamma_list[1], Gamma_list[2], state) - ) - coef = list(reversed(coef)) - return coef - - -def dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list): - # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) - A = np.zeros(d.shape) - A[i, i] = 1 - B = commutator(commutator(A, H), Gamma_list[n - 1]) - W = commutator(d, H) - return B + commutator(W, dGamma[-1]) - - -def dpolynomial_diDiagonal(dbi_object, d, H, i): - # Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz) - # Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation - derivative = 0 - s = polynomial_step(dbi_object, n=3, d=d) - A = np.zeros(d.shape) - Gamma_list = dbi_object.generate_Gamma_list(4, d) - A[i, i] = 1 - dGamma = [commutator(A, H)] - derivative += np.real( - np.trace(Gamma_list[0] @ A) + np.trace(dGamma[0] @ d + Gamma_list[1] @ A) * s - ) - for n in range(2, 4): - dGamma.append(dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list)) - derivative += np.real( - np.trace(dGamma[-1] @ d + Gamma_list[n] @ A) * s**n / math.factorial(n) - ) - - return derivative - - -def gradientDiagonal(dbi_object, d, H): - # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz) - grad = np.zeros(len(d)) - for i in range(len(d)): - derivative = dpolynomial_diDiagonal(dbi_object, d, H, i) - grad[i] = d[i, i] - derivative - return grad - - -def gradient_ascent(dbi_object, d, step, iterations): - H = dbi_object.h.matrix - loss = np.zeros(iterations + 1) - grad = np.zeros((iterations, len(d))) - dbi_eval = deepcopy(dbi_object) - s = polynomial_step(dbi_object, n=3, d=d) - dbi_eval(s, d=d) - loss[0] = dbi_eval(d) - diagonals = np.empty((len(d), iterations + 1)) - diagonals[:, 0] = np.diag(d) - - for i in range(iterations): - dbi_eval = deepcopy(dbi_object) - grad[i, :] = gradientDiagonal(dbi_object, d, H) - for j in range(len(d)): - d[j, j] = d[j, j] - step * grad[i, j] - s = polynomial_step(dbi_object, n=3, d=d) - dbi_eval(s, d=d) - loss[i + 1] = dbi_eval.least_squares(d) - diagonals[:, i + 1] = np.diag(d) - - return d, loss, grad, diagonals - - def simulated_annealing_step( dbi_object, d: Optional[np.array] = None, @@ -289,6 +157,41 @@ def simulated_annealing_step( min_temp=1e-5, max_iter=200, ): + """ + Perform a single step of simulated annealing optimization. + + Parameters: + dbi_object: DBI object + The object representing the problem to be optimized. + d: Optional[np.array], optional + The diagonal matrix 'd' used in optimization. If None, it uses the diagonal + matrix 'diagonal_h_matrix' from dbi_object. + initial_s: float or None, optional + Initial value for 's', the step size. If None, it is initialized using + polynomial_step function with 'n=4'. If 'polynomial_step' returns None, + 'initial_s' is set to 'step_min'. + step_min: float, optional + Minimum value for the step size 's'. + step_max: float, optional + Maximum value for the step size 's'. + s_jump_range: float or None, optional + Range for the random jump in step size. If None, it's calculated based on + 'step_min', 'step_max', and 's_jump_range_divident'. + s_jump_range_divident: int, optional + Dividend to determine the range for random jump in step size. + initial_temp: float, optional + Initial temperature for simulated annealing. + cooling_rate: float, optional + Rate at which temperature decreases in simulated annealing. + min_temp: float, optional + Minimum temperature threshold for termination of simulated annealing. + max_iter: int, optional + Maximum number of iterations for simulated annealing. + + Returns: + float: + The optimized step size 's'. + """ if d is None: d = dbi_object.diagonal_h_matrix diff --git a/src/qibo/models/dbi/utils_strategies.py b/src/qibo/models/dbi/utils_strategies.py new file mode 100644 index 0000000000..dfc5a00ae1 --- /dev/null +++ b/src/qibo/models/dbi/utils_strategies.py @@ -0,0 +1,181 @@ +import hyperopt + +from qibo.models.dbi.double_bracket import * +from qibo.models.dbi.utils import cs_angle_sgn +from qibo.models.dbi.utils_analytical import * +from qibo.models.dbi.utils_scheduling import polynomial_step + + +def select_best_dbr_generator( + dbi_object: DoubleBracketIteration, + d_list: list, + step: Optional[float] = None, + compare_canonical: bool = True, + scheduling: DoubleBracketScheduling = None, + **kwargs, +): + """Selects the best double bracket rotation generator from a list and execute the rotation. + + Args: + dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. + d_list (list): list of diagonal operators (np.array) to run from. + step (float): fixed iteration duration. + Defaults to ``None``, optimize with `scheduling` method and `choose_step` function. + compare_canonical (boolean): if `True`, the diagonalization effect with operators from `d_list` is compared with the canonical bracket. + scheduling (`DoubleBracketScheduling`): scheduling method for finding the optimal step. + + Returns: + The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. + """ + if scheduling is None: + scheduling = dbi_object.scheduling + norms_off_diagonal_restriction = [dbi_object.off_diagonal_norm] * (len(d_list) + 1) + optimal_steps = np.zeros(len(d_list) + 1) + flip_list = np.ones(len(d_list) + 1) + for i, d in enumerate(d_list): + # prescribed step durations + dbi_eval = deepcopy(dbi_object) + flip_list[i] = cs_angle_sgn(dbi_eval, d) + if flip_list[i] != 0: + if step is None: + step_best = dbi_eval.choose_step( + d=flip_list[i] * d, scheduling=scheduling, **kwargs + ) + else: + step_best = step + dbi_eval(step=step_best, d=flip_list[i] * d) + optimal_steps[i] = step_best + norms_off_diagonal_restriction[i] = dbi_eval.off_diagonal_norm + # canonical + if compare_canonical is True: + dbi_eval = deepcopy(dbi_object) + dbi_eval.mode = DoubleBracketGeneratorType.canonical + if step is None: + step_best = dbi_eval.choose_step(scheduling=scheduling, **kwargs) + else: + step_best = step + dbi_eval(step=step_best) + optimal_steps[-1] = step_best + norms_off_diagonal_restriction[-1] = dbi_eval.off_diagonal_norm + # find best d + idx_max_loss = np.argmin(norms_off_diagonal_restriction) + flip = flip_list[idx_max_loss] + step_optimal = optimal_steps[idx_max_loss] + dbi_eval = deepcopy(dbi_object) + if idx_max_loss == len(d_list) and compare_canonical is True: + # canonical + dbi_eval(step=step_optimal, mode=DoubleBracketGeneratorType.canonical) + + else: + d_optimal = flip * d_list[idx_max_loss] + dbi_eval(step=step_optimal, d=d_optimal) + return dbi_eval, idx_max_loss, step_optimal, flip + + +def gradient_descent_pauli( + dbi_object: DoubleBracketIteration, + d_coef: list, + d: Optional[np.array] = None, + pauli_operator_dict: dict = None, + parameterization_order: int = 1, + n: int = 3, + onsite_Z_ops: Optional[list] = None, + lr_min: float = 1e-5, + lr_max: float = 1, + max_evals: int = 100, + space: callable = None, + optimizer: callable = None, + verbose: bool = False, + use_ds: bool = True, +): + """calculate the elements of one gradient descent step on `dbi_object`. + + Args: + dbi_object (DoubleBracketIteration): the target dbi object + d_coef (list): the initial decomposition of `d` into Pauli-Z operators + d (np.array, optional): the initial diagonal operator. Defaults to None. + n_taylor (int, optional): the highest order to expand the loss function derivative. Defaults to 2. + onsite_Z_ops (list, optional): list of onsite-Z operators. Defaults to None. + lr_min (float, optional): the minimal gradient step. Defaults to 1e-5. + lr_max (float, optional): the maximal gradient step. Defaults to 1. + max_evals (int, optional): the max number of evaluations for `hyperopt` to find the optimal gradient step `lr`. Defaults to 100. + space (callable, optional): the search space for `hyperopt`. Defaults to None. + optimizer (callable, optional): optimizer for `hyperopt`. Defaults to None. + verbose (bool, optional): option to print out the 'hyperopt' progress. Defaults to False. + use_ds (bool, optional): if False, ds is set to 0. Defaults to True. + + Returns: + the optimal step found, coeffcients of `d` in Pauli-Z basis, matrix of `d` + + """ + nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) + if pauli_operator_dict is None: + pauli_operator_dict = generate_pauli_operator_dict( + nqubits, parameterization_order + ) + + grad, s = gradient_Pauli( + dbi_object, d, n=n, pauli_operator_dict=pauli_operator_dict, use_ds=use_ds + ) + # optimize gradient descent step with hyperopt + if space is None: + space = hyperopt.hp.loguniform("lr", np.log(lr_min), np.log(lr_max)) + if optimizer is None: + optimizer = hyperopt.tpe + + def func_loss_to_lr(lr): + d_coef_eval = [d_coef[j] - grad[j] * lr for j in range(nqubits)] + d_eval = sum( + [ + d_coef_eval[i] * list(pauli_operator_dict.values())[i] + for i in range(nqubits) + ] + ) + return dbi_object.loss(step=s, d=d_eval) + + best = hyperopt.fmin( + fn=func_loss_to_lr, + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + lr = best["lr"] + + d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)] + d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)]) + return s, d_coef, d + + +def gradientDiagonal(dbi_object, d, H, n=3): + # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz) + grad = np.zeros(len(d)) + for i in range(len(d)): + s = polynomial_step(dbi_object, n=3, d=d) + derivative = dpolynomial_diDiagonal(dbi_object, s, d, H, i) + grad[i] = d[i, i] - derivative + return grad + + +def gradient_ascent(dbi_object, d, step, iterations): + H = dbi_object.h.matrix + loss = np.zeros(iterations + 1) + grad = np.zeros((iterations, len(d))) + dbi_eval = deepcopy(dbi_object) + s = polynomial_step(dbi_object, n=3, d=d) + dbi_eval(s, d=d) + loss[0] = dbi_eval(d) + diagonals = np.empty((len(d), iterations + 1)) + diagonals[:, 0] = np.diag(d) + + for i in range(iterations): + dbi_eval = deepcopy(dbi_object) + grad[i, :] = gradientDiagonal(dbi_object, d, H) + for j in range(len(d)): + d[j, j] = d[j, j] - step * grad[i, j] + s = polynomial_step(dbi_object, n=3, d=d) + dbi_eval(s, d=d) + loss[i + 1] = dbi_eval.least_squares(d) + diagonals[:, i + 1] = np.diag(d) + + return d, loss, grad, diagonals From 8b96110ddee56ff68c8f14121c98d1cca2dab5bc Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 8 Apr 2024 17:30:42 +0800 Subject: [PATCH 090/116] Import dependency (optional) --- src/qibo/models/dbi/utils_analytical.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/qibo/models/dbi/utils_analytical.py b/src/qibo/models/dbi/utils_analytical.py index 35295fe6de..b23fd0a33e 100644 --- a/src/qibo/models/dbi/utils_analytical.py +++ b/src/qibo/models/dbi/utils_analytical.py @@ -1,3 +1,5 @@ +from typing import Optional + from qibo.models.dbi.utils import * From 417bbfc8845b5ebd019d386db27f73bf43260727 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 9 Apr 2024 03:04:16 +0200 Subject: [PATCH 091/116] small changes in the testing notebook --- ...volution_oracles_and_gci_transpiling.ipynb | 266 +++++++++++------- 1 file changed, 170 insertions(+), 96 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 00c2023f3d..735324d5c6 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -30,8 +30,9 @@ "id": "0fc17c2d", "metadata": {}, "source": [ - "# Check the GC bound is valid\n", - "\n" + "## Check the GC bound is valid\n", + "\n", + "The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\n" ] }, { @@ -57,8 +58,12 @@ " )\n", "\n", " for s in np.linspace(0.001, 0.01, NSTEPS):\n", - " u = dbi.eval_dbr_unitary(s,d=d, mode=DoubleBracketGeneratorType.single_commutator)\n", - " v = dbi.eval_dbr_unitary(s,d=d, mode=DoubleBracketGeneratorType.group_commutator)\n", + " u = dbi.eval_dbr_unitary(\n", + " s, d=d, mode=DoubleBracketGeneratorType.single_commutator\n", + " )\n", + " v = dbi.eval_dbr_unitary(\n", + " s, d=d, mode=DoubleBracketGeneratorType.group_commutator\n", + " )\n", "\n", " assert np.linalg.norm(u - v) < 10 * s**1.49 * (\n", " np.linalg.norm(h0) + np.linalg.norm(d)\n", @@ -73,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "950eef89", "metadata": {}, "outputs": [ @@ -81,7 +86,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-05 13:00:00]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-06 16:30:47]: Using numpy backend on /CPU:0\n" ] } ], @@ -94,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "id": "bcfab105", "metadata": { "scrolled": true @@ -106,7 +111,7 @@ }, { "cell_type": "markdown", - "id": "61466e18", + "id": "70ac58a2", "metadata": {}, "source": [ "# Check the convergence of the Trotter-Suzuki Hamiltonian simulation oracle\n" @@ -114,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "id": "54efc9de", "metadata": {}, "outputs": [ @@ -123,23 +128,32 @@ "output_type": "stream", "text": [ "@pytest.mark.parametrize(\"nqubits\", [3])\n", - "def test_dbi_evolution_oracle(backend,nqubits,t_step, eps): \n", - " from qibo.hamiltonians import SymbolicHamiltonian\n", - " from qibo import symbols\n", + "def test_dbi_evolution_oracle(backend, nqubits, t_step, eps):\n", " from numpy.linalg import norm\n", - " print(backend)\n", - " h_input = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2)+ symbols.Z(0), nqubits = 3, backend = backend )\n", "\n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - " \n", + " from qibo import symbols\n", + " from qibo.hamiltonians import SymbolicHamiltonian\n", + "\n", + " h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + " )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " h_input = h_x + d_0\n", + "\n", + " evolution_oracle = EvolutionOracle(\n", + " h_input, \"ZX\", mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation\n", + " )\n", + "\n", " evolution_oracle.eps_trottersuzuki = eps\n", - " \n", + "\n", " U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary()\n", " V_target = h_input.exp(t_step)\n", - " \n", - " assert norm(U_hamiltonian_simulation-V_target) < eps\n", + "\n", + " assert norm(U_hamiltonian_simulation - V_target) < eps\n", "\n" ] } @@ -150,22 +164,15 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "403bf8d0", + "execution_count": 6, + "id": "69456994", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-05 12:26:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "numpy\n" + "[Qibo 0.2.7|WARNING|2024-04-06 16:30:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -183,7 +190,7 @@ }, { "cell_type": "markdown", - "id": "61782388", + "id": "e81631c7", "metadata": {}, "source": [ "This is testing the following:\n", @@ -203,18 +210,27 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "c91600c1", + "execution_count": 7, + "id": "7e99a090", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "incomplete input (396783170.py, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_26457/396783170.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m def test_dbr_in_dbi_vs_gci_classes_numerical(t_step, eps):\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m incomplete input\n" + ] + } + ], "source": [ "def test_dbr_in_dbi_vs_gci_classes_numerical(t_step, eps):" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "0a808f33", + "execution_count": 8, + "id": "aa8e61b9", "metadata": {}, "outputs": [], "source": [ @@ -224,17 +240,65 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "ecd578d5", + "execution_count": 9, + "id": "df4e4b89", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-05 13:02:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-05 13:02:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-05 13:02:38]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-06 16:31:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-06 16:31:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-06 16:31:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4659812578464106\n", + "0.0\n", + "0.0\n", + "2.4659812578464106\n", + "start\n", + "8.570566018546674e-16 2.069502835539648e-18\n", + "None 7.102648668054811e-16\n", + "None 2.069502835539648e-18\n", + "stop\n", + "[[ 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", + " -7.96539477e-02-0.15421646j 3.51159382e-01+0.5130534j\n", + " -6.64615932e-17-0.31397323j 3.23092247e-17+0.25955811j\n", + " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j]\n", + " [ 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", + " -3.51159382e-01-0.5130534j -7.96539477e-02-0.15421646j\n", + " 0.00000000e+00-0.25955811j -3.55618313e-17-0.31397323j\n", + " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j]\n", + " [-3.51159382e-01-0.5293799j -7.96539477e-02-0.08224007j\n", + " 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", + " -1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", + " -2.68882139e-17-0.36962312j -1.14925430e-17+0.17125522j]\n", + " [ 7.96539477e-02+0.08224007j -3.51159382e-01-0.5293799j\n", + " 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", + " 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", + " 6.93889390e-18-0.17125522j 0.00000000e+00-0.36962312j]\n", + " [-9.97465999e-18-0.36962312j 4.11996826e-18+0.17125522j\n", + " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j\n", + " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j\n", + " -3.51159382e-01+0.5293799j -7.96539477e-02+0.08224007j]\n", + " [ 3.46944695e-18-0.17125522j -3.81639165e-17-0.36962312j\n", + " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j\n", + " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j\n", + " 7.96539477e-02-0.08224007j -3.51159382e-01+0.5293799j ]\n", + " [-1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", + " 2.97071395e-17-0.31397323j -1.66967135e-17+0.25955811j\n", + " -7.96539477e-02+0.15421646j 3.51159382e-01-0.5130534j\n", + " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j]\n", + " [ 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", + " 1.38777878e-17-0.25955811j 4.16333634e-17-0.31397323j\n", + " -3.51159382e-01+0.5130534j -7.96539477e-02+0.15421646j\n", + " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j]]\n", + "9.664636718428507e-16\n" ] } ], @@ -276,23 +340,31 @@ }, { "cell_type": "code", - "execution_count": 19, - "id": "6c6337d8", + "execution_count": 10, + "id": "2b895267", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/marek/.local/lib/python3.10/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", + " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n" + ] + }, { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 19, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -317,23 +389,23 @@ }, { "cell_type": "code", - "execution_count": 27, - "id": "abee7a77", + "execution_count": 11, + "id": "ec6361ca", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 27, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -367,7 +439,7 @@ { "cell_type": "code", "execution_count": null, - "id": "146a12c5", + "id": "b37cbc0e", "metadata": {}, "outputs": [], "source": [] @@ -375,7 +447,7 @@ { "cell_type": "code", "execution_count": null, - "id": "eceff544", + "id": "51f190d6", "metadata": {}, "outputs": [], "source": [] @@ -383,13 +455,13 @@ { "cell_type": "code", "execution_count": 12, - "id": "687075d6", + "id": "508d1f97", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "1.0885506896087478" + "1.2900424090942901" ] }, "execution_count": 12, @@ -404,13 +476,13 @@ { "cell_type": "code", "execution_count": 13, - "id": "72b0fefe", + "id": "b2c1f105", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "1.8837381116044358" + "1.7519139418638479" ] }, "execution_count": 13, @@ -424,10 +496,22 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "eac25174", + "execution_count": 14, + "id": "583ca695", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_26457/3167801605.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mQ_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mR_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mh_1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mdbi2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], "source": [ "assert norm(Q_gci.conj().T - R_dbi ) < 5*eps\n", "\n", @@ -445,31 +529,21 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "id": "8a03c568", "metadata": { "scrolled": true }, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-05 13:01:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-05 13:01:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-05 13:01:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", + "ename": "NameError", + "evalue": "name 'test_dbr_in_dbi_vs_gci_classes_numerical' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_14250/2555506132.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_dbr_in_dbi_vs_gci_classes_numerical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/tmp/ipykernel_14250/3935142580.py\u001b[0m in \u001b[0;36mtest_dbr_in_dbi_vs_gci_classes_numerical\u001b[0;34m(t_step, eps)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0md0_norm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mV_dbi\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mR_dbi\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m1.49\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m \u001b[0mh0_norm\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0md0_norm\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mh0_norm\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0md0_norm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 34\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mQ_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mR_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 35\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_26457/2555506132.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_dbr_in_dbi_vs_gci_classes_numerical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'test_dbr_in_dbi_vs_gci_classes_numerical' is not defined" ] } ], @@ -479,8 +553,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "be332dde", + "execution_count": 16, + "id": "4d9fa85d", "metadata": {}, "outputs": [ { @@ -489,7 +563,7 @@ "numpy.ndarray" ] }, - "execution_count": 12, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -500,7 +574,7 @@ }, { "cell_type": "markdown", - "id": "75b5146e", + "id": "72d81f56", "metadata": {}, "source": [ "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", @@ -522,31 +596,31 @@ }, { "cell_type": "code", - "execution_count": 52, - "id": "60e228b9", + "execution_count": 17, + "id": "e1afea06", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-06 16:29:36]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-06 16:29:36]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-06 16:31:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-06 16:31:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] }, { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 52, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -591,23 +665,23 @@ }, { "cell_type": "code", - "execution_count": 53, - "id": "161bc408", + "execution_count": 18, + "id": "02789b1e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 53, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -625,8 +699,8 @@ }, { "cell_type": "code", - "execution_count": 54, - "id": "c25a251c", + "execution_count": 19, + "id": "4efc5549", "metadata": {}, "outputs": [ { @@ -636,7 +710,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_14250/4112881237.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mgci\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGroupCommutatorIterationWithEvolutionOracles\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevolution_oracle\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator_other_sorting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/tmp/ipykernel_26457/4112881237.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mgci\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGroupCommutatorIterationWithEvolutionOracles\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevolution_oracle\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator_other_sorting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/lib/python3.10/enum.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(cls, name)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_member_map_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 436\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 437\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 438\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mAttributeError\u001b[0m: group_commutator_other_sorting" ] From 20ceda2fb41335393af37ca5c04f4a458c12b6b7 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Thu, 25 Apr 2024 09:29:13 +0200 Subject: [PATCH 092/116] tests started working for gci vs dbi --- ...volution_oracles_and_gci_transpiling.ipynb | 893 +++++++++--------- .../group_commutator_iteration_transpiler.py | 44 +- tests/test_models_dbi.py | 41 +- 3 files changed, 484 insertions(+), 494 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 735324d5c6..54f6c2dc32 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -25,60 +25,9 @@ " print(reduce(str.__add__, out[0]))" ] }, - { - "cell_type": "markdown", - "id": "0fc17c2d", - "metadata": {}, - "source": [ - "## Check the GC bound is valid\n", - "\n", - "The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\n" - ] - }, { "cell_type": "code", "execution_count": 2, - "id": "8ecce261", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "@pytest.mark.parametrize(\"nqubits\", [3])\n", - "def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits):\n", - " r\"\"\"The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\"\"\"\n", - " h0 = random_hermitian(2**nqubits, backend=backend)\n", - " d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))\n", - " dbi = DoubleBracketIteration(\n", - " Hamiltonian(nqubits, h0, backend=backend),\n", - " mode=DoubleBracketGeneratorType.group_commutator,\n", - " )\n", - "\n", - " for s in np.linspace(0.001, 0.01, NSTEPS):\n", - " u = dbi.eval_dbr_unitary(\n", - " s, d=d, mode=DoubleBracketGeneratorType.single_commutator\n", - " )\n", - " v = dbi.eval_dbr_unitary(\n", - " s, d=d, mode=DoubleBracketGeneratorType.group_commutator\n", - " )\n", - "\n", - " assert np.linalg.norm(u - v) < 10 * s**1.49 * (\n", - " np.linalg.norm(h0) + np.linalg.norm(d)\n", - " ) * np.linalg.norm(h0) * np.linalg.norm(d)\n", - "\n" - ] - } - ], - "source": [ - "print_function_source_code(test_double_bracket_iteration_eval_dbr_unitary)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "id": "950eef89", "metadata": {}, "outputs": [ @@ -86,7 +35,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-06 16:30:47]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-25 09:05:33]: Using numpy backend on /CPU:0\n" ] } ], @@ -98,324 +47,243 @@ ] }, { - "cell_type": "code", - "execution_count": 4, - "id": "bcfab105", - "metadata": { - "scrolled": true - }, - "outputs": [], + "cell_type": "markdown", + "id": "7f4d7a01", + "metadata": {}, "source": [ - "test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits)" + "# Check the numerical mode of evolution oracles" ] }, { "cell_type": "markdown", - "id": "70ac58a2", + "id": "e81631c7", "metadata": {}, "source": [ - "# Check the convergence of the Trotter-Suzuki Hamiltonian simulation oracle\n" + "This is testing the following:\n", + "\n", + "`dbi_exact` runs $V_{exact} = e^{-sW}$ and rotates $H_1 = V_{exact}^\\dagger H_0 V_{exact}$.\n", + "\n", + "`dbi_GC` runs $V_{GC} = GC$ and rotates $K_1 = V_{GC}^\\dagger H_0 V_{GC}$.\n", + "\n", + "We assert that dbi_exact and dbi_GC should be within the approximation bound of the GC\n", + "$$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n", + "\n", + "`gci` runs $V_{EO,GC} = GC$ and rotates $J_1 = V_{EO,GC}^\\dagger H_0 V_{EO,GC}$.\n", + "\n", + "We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", + "$$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", + "\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "54efc9de", + "execution_count": 3, + "id": "aa8e61b9", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "@pytest.mark.parametrize(\"nqubits\", [3])\n", - "def test_dbi_evolution_oracle(backend, nqubits, t_step, eps):\n", - " from numpy.linalg import norm\n", - "\n", - " from qibo import symbols\n", - " from qibo.hamiltonians import SymbolicHamiltonian\n", - "\n", - " h_x = SymbolicHamiltonian(\n", - " symbols.X(0)\n", - " + symbols.Z(0) * symbols.X(1)\n", - " + symbols.Y(2)\n", - " + symbols.Y(1) * symbols.Y(2),\n", - " nqubits=3,\n", - " )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - " h_input = h_x + d_0\n", - "\n", - " evolution_oracle = EvolutionOracle(\n", - " h_input, \"ZX\", mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation\n", - " )\n", - "\n", - " evolution_oracle.eps_trottersuzuki = eps\n", - "\n", - " U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary()\n", - " V_target = h_input.exp(t_step)\n", - "\n", - " assert norm(U_hamiltonian_simulation - V_target) < eps\n", - "\n" - ] - } - ], + "outputs": [], "source": [ - "print_function_source_code(test_dbi_evolution_oracle)" + "t_step =0.01\n", + "eps = 1e-2" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "69456994", - "metadata": {}, + "execution_count": 12, + "id": "fe0539ad", + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-06 16:30:47]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-25 09:09:11]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-25 09:09:11]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], "source": [ - "test_dbi_evolution_oracle(backend,nqubits,1 ,1e-2)" - ] - }, - { - "cell_type": "markdown", - "id": "7f4d7a01", - "metadata": {}, - "source": [ - "# Check the numerical mode of evolution oracles" - ] - }, - { - "cell_type": "markdown", - "id": "e81631c7", - "metadata": {}, - "source": [ - "This is testing the following:\n", + "from numpy.linalg import norm\n", "\n", - "`dbi` runs $V = e^{-sW}$ and rotates $H_1 = V^\\dagger H_0 V$.\n", + "h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + ")\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + "h_input = h_x + d_0\n", "\n", - "`gci` runs $Q = GC$ and rotates $J_1 = Q^\\dagger H_0 Q$.\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", "\n", - "`dbi2` runs $R = GC$ and rotates $K_1 = R^\\dagger H_0 R$.\n", + "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + "v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", "\n", - "We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", - "$$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", + "dbi(t_step, d = d_0.dense.matrix )\n", + "h_1 = dbi.h.matrix\n", "\n", - "We assert that gci and dbi should be within the approximation bound of the GC\n", - "$$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n" + "dbi.h = deepcopy(h_input.dense)\n", + "dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + "k_1 = dbi.h.matrix\n", + "\n", + "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + "norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + ")\n", + "assert norm(v_exact - v_gc) < norms_bound\n", + "assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound " ] }, { "cell_type": "code", - "execution_count": 7, - "id": "7e99a090", + "execution_count": 13, + "id": "4e3a5afa", "metadata": {}, "outputs": [ { - "ename": "SyntaxError", - "evalue": "incomplete input (396783170.py, line 1)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_26457/396783170.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m def test_dbr_in_dbi_vs_gci_classes_numerical(t_step, eps):\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m incomplete input\n" - ] + "data": { + "text/plain": [ + "0.007946732303441253" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "def test_dbr_in_dbi_vs_gci_classes_numerical(t_step, eps):" + "norm(v_exact - v_gc)\n" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "aa8e61b9", - "metadata": {}, - "outputs": [], - "source": [ - "t_step =0.1\n", - "eps = 1e-2" - ] - }, - { - "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "id": "df4e4b89", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-06 16:31:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-06 16:31:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-06 16:31:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-25 09:09:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2.4659812578464106\n", - "0.0\n", - "0.0\n", - "2.4659812578464106\n", - "start\n", - "8.570566018546674e-16 2.069502835539648e-18\n", - "None 7.102648668054811e-16\n", - "None 2.069502835539648e-18\n", - "stop\n", - "[[ 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", - " -7.96539477e-02-0.15421646j 3.51159382e-01+0.5130534j\n", - " -6.64615932e-17-0.31397323j 3.23092247e-17+0.25955811j\n", - " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j]\n", - " [ 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", - " -3.51159382e-01-0.5130534j -7.96539477e-02-0.15421646j\n", - " 0.00000000e+00-0.25955811j -3.55618313e-17-0.31397323j\n", - " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j]\n", - " [-3.51159382e-01-0.5293799j -7.96539477e-02-0.08224007j\n", - " 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", - " -1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", - " -2.68882139e-17-0.36962312j -1.14925430e-17+0.17125522j]\n", - " [ 7.96539477e-02+0.08224007j -3.51159382e-01-0.5293799j\n", - " 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", - " 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", - " 6.93889390e-18-0.17125522j 0.00000000e+00-0.36962312j]\n", - " [-9.97465999e-18-0.36962312j 4.11996826e-18+0.17125522j\n", - " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j\n", - " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j\n", - " -3.51159382e-01+0.5293799j -7.96539477e-02+0.08224007j]\n", - " [ 3.46944695e-18-0.17125522j -3.81639165e-17-0.36962312j\n", - " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j\n", - " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j\n", - " 7.96539477e-02-0.08224007j -3.51159382e-01+0.5293799j ]\n", - " [-1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", - " 2.97071395e-17-0.31397323j -1.66967135e-17+0.25955811j\n", - " -7.96539477e-02+0.15421646j 3.51159382e-01-0.5130534j\n", - " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j]\n", - " [ 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", - " 1.38777878e-17-0.25955811j 4.16333634e-17-0.31397323j\n", - " -3.51159382e-01+0.5130534j -7.96539477e-02+0.15421646j\n", - " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j]]\n", - "9.664636718428507e-16\n" + "1.3625360448211346e-15\n", + "0.027414371976916107\n" ] } ], "source": [ - "from numpy.linalg import norm\n", - "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - "h_input = h_x + d_0 \n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", - "\n", - "\n", - "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", - "\n", - "V_dbi = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", - "R_dbi = dbi2.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", - "\n", - "\n", "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", " mode_evolution_oracle = EvolutionOracleType.numerical) \n", - "\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + "d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_02, \"D0\",\n", " mode_evolution_oracle = EvolutionOracleType.numerical)\n", "\n", "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", "\n", - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", - "Q_gci = unitary_gc_from_oracles['forwards']\n", + "u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", + "u_gci = u_gc_from_oracles['forwards']\n", + "\n", + "assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", + "\n", "\n", - "assert norm(Q_gci.conj().T - unitary_gc_from_oracles['backwards']) < 1e-12\n", - "h0_norm = np.linalg.norm(h_x.dense.matrix)\n", - "d0_norm = np.linalg.norm(d_0.dense.matrix)\n", - "assert norm(V_dbi - R_dbi) < 2 *t_step**1.49 * ( h0_norm + d0_norm ) * h0_norm * d0_norm" + "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + "norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + ")\n", + "assert norm(v_exact - u_gci) < norms_bound\n", + "\n", + "gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", + "j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", + "print(norm(j_1-k_1))\n", + "print(norm(j_1-h_1))" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "2b895267", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/marek/.local/lib/python3.10/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", - " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "norms = []\n", + "norms2 = []\n", "for r in np.linspace(1e-5,0.1,30):\n", - " V_dbi = dbi.eval_dbr_unitary(r, d=d_0.dense.matrix)\n", - " R_dbi = dbi2.eval_dbr_unitary(r, d=d_0.dense.matrix)\n", - " norms.append(norm(V_dbi.conj().T - R_dbi))\n", + " u_gc_from_oracles = gci.group_commutator( r, evolution_oracle_diagonal_target ) \n", + " u_gci = u_gc_from_oracles['forwards']\n", + " v_exact = dbi.eval_dbr_unitary(r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + " v_gc = dbi.eval_dbr_unitary(r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", + " norms.append(norm(u_gci - v_exact))\n", + " norms2.append(norm(u_gci - v_gc))\n", + "\n", " \n", "plt.plot(np.linspace(1e-5,.1,30), [x**1.5*12 for x in np.linspace(1e-5,.1,30)])\n", - "plt.plot(np.linspace(1e-5,.1,30),norms)" + "plt.plot(np.linspace(1e-5,.1,30),norms)\n", + "plt.plot(np.linspace(1e-5,.1,30),norms2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d55523e", + "metadata": {}, + "outputs": [], + "source": [ + "print(np.max(norms2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d843f1f", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "print_function_source_code(GroupCommutatorIterationWithEvolutionOracles.group_commutator)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d99fbc3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "583ca695", + "metadata": {}, + "outputs": [], + "source": [ + "assert norm(Q_gci.conj().T - R_dbi ) < 5*eps\n", + "\n", + "\n", + "test_dbr_in_dbi_vs_gci_classes_numerical(.1, 1e-5)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "ec6361ca", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", @@ -439,139 +307,329 @@ { "cell_type": "code", "execution_count": null, - "id": "b37cbc0e", + "id": "7e99a090", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "def test_dbr_in_dbi_vs_gci_classes_numerical(t_step, eps):" + ] + }, + { + "cell_type": "markdown", + "id": "0fc17c2d", "metadata": {}, + "source": [ + "## Check the GC bound is valid and corectly implemented in DoubleBracketIteration\n", + "\n", + "The bound is $$||e^{-t[D,H]}-GC(s=\\sqrt{t})||\\le t^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ecce261", + "metadata": { + "scrolled": true + }, "outputs": [], - "source": [] + "source": [ + "print_function_source_code(test_double_bracket_iteration_eval_dbr_unitary)" + ] }, { "cell_type": "code", "execution_count": null, - "id": "51f190d6", + "id": "bcfab105", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits)" + ] + }, + { + "cell_type": "markdown", + "id": "af472177", + "metadata": {}, + "source": [ + "### We repeat the function in order to plot the bound" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54fea9c7", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "r\"\"\"The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\"\"\"\n", + "h0 = random_hermitian(2**nqubits, backend=backend)\n", + "d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))\n", + "dbi = DoubleBracketIteration(\n", + " Hamiltonian(nqubits, h0, backend=backend),\n", + " mode=DoubleBracketGeneratorType.group_commutator,\n", + ")\n", + "\n", + "times = np.linspace(0.001, 0.01, 10)\n", + "norms = []\n", + "norms_bound = []\n", + "for s in times:\n", + " u = dbi.eval_dbr_unitary(\n", + " s, d=d, mode=DoubleBracketGeneratorType.single_commutator\n", + " )\n", + " v = dbi.eval_dbr_unitary(\n", + " s, d=d, mode=DoubleBracketGeneratorType.group_commutator\n", + " )\n", + "\n", + " norms.append(np.linalg.norm(u - v) )\n", + " w = dbi.commutator(h0,d)\n", + " norms_bound.append(0.5*s**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h0,w)) + np.linalg.norm(dbi.commutator(d,w))\n", + " ))\n", + " assert np.linalg.norm(u - v) < 10 * s**1.49 * (\n", + " np.linalg.norm(h0) + np.linalg.norm(d)\n", + " ) * np.linalg.norm(h0) * np.linalg.norm(d)" + ] + }, + { + "cell_type": "markdown", + "id": "5127adad", + "metadata": {}, + "source": [ + "Unfortunately we cannot assume that \n", + "`assert popt[0] < 1.51`\n", + "because in principle data satisfying the bound can be ragged and could have a large slope.\n", + "When the bound is saturated, however, then the following fit works:" + ] }, { "cell_type": "code", - "execution_count": 12, - "id": "508d1f97", + "execution_count": null, + "id": "f34ad940", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.2900424090942901" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "norm(Q_gci.conj().T - R_dbi )" + "from scipy.optimize import curve_fit\n", + "popt, pcov = curve_fit( (lambda x, a, b: a*x+b ), [np.log(t) for t in times], [np.log(n) for n in norms])\n", + "assert popt[0] < 1.51" + ] + }, + { + "cell_type": "markdown", + "id": "ac31a3fa", + "metadata": {}, + "source": [ + "In practice that assertion usually goes through. We check this further by these plots" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "b2c1f105", + "execution_count": null, + "id": "ef43be9c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.7519139418638479" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "norm(Q_gci - R_dbi )" + "import matplotlib.pyplot as plt\n", + "plt.plot(norms)\n", + "plt.plot(norms_bound)" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "583ca695", + "execution_count": null, + "id": "eecc6a33", "metadata": {}, - "outputs": [ - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_26457/3167801605.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mQ_gci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mR_dbi\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mh_1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mdbi2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md_0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ - "assert norm(Q_gci.conj().T - R_dbi ) < 5*eps\n", - "\n", - "dbi(t_step, d = d_0.dense.matrix )\n", - "h_1 = dbi.h.matrix\n", - "dbi2(t_step, d = d_0.dense.matrix )\n", - "k_1 = dbi2.h.matirix\n", - "gci(t_step, d = d_0.dense.matrix )\n", - "j_1 = gci.iterated_hamiltonian_evolution_oracle.h\n", - "print(norm(j_1-k_1))\n", - "print(norm(V_dbi-Q_dbi))\n", - "print(norm(h_1-k_1)) \n", - "print(norm(V_dbi-R_dbi))" + "plt.loglog(times,norms)\n", + "plt.loglog(times,norms_bound)" + ] + }, + { + "cell_type": "markdown", + "id": "c652e516", + "metadata": {}, + "source": [ + "Usually random Hamiltonian matrices give something $a\\approx 1.49$" ] }, { "cell_type": "code", - "execution_count": 15, - "id": "8a03c568", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'test_dbr_in_dbi_vs_gci_classes_numerical' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_26457/2555506132.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_dbr_in_dbi_vs_gci_classes_numerical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'test_dbr_in_dbi_vs_gci_classes_numerical' is not defined" - ] - } - ], + "execution_count": null, + "id": "3ef04b41", + "metadata": {}, + "outputs": [], "source": [ - "test_dbr_in_dbi_vs_gci_classes_numerical(.1, 1e-5)" + "popt" + ] + }, + { + "cell_type": "markdown", + "id": "70ac58a2", + "metadata": {}, + "source": [ + "# Check the convergence of the Trotter-Suzuki Hamiltonian simulation oracle\n" ] }, { "cell_type": "code", - "execution_count": 16, - "id": "4d9fa85d", + "execution_count": null, + "id": "54efc9de", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "numpy.ndarray" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], + "source": [ + "print_function_source_code(test_dbi_evolution_oracle)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69456994", + "metadata": {}, + "outputs": [], "source": [ - "type(np.array([2]))" + "test_dbi_evolution_oracle(backend,nqubits,1 ,1e-2)" ] }, + { + "cell_type": "markdown", + "id": "8c54cfa8", + "metadata": {}, + "source": [ + "This was just a check to see if using the circuit method works. Then covering the numerical and text flag." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b37cbc0e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "964c64c3", + "metadata": {}, + "outputs": [], + "source": [ + " def group_commutator(\n", + " self,\n", + " t_step: float,\n", + " eo1: EvolutionOracle,\n", + " eo2: EvolutionOracle = None,\n", + " mode_dbr: DoubleBracketRotationType = None,\n", + " ):\n", + " s_step = np.sqrt(t_step)\n", + "\n", + " if eo2 is None:\n", + " eo2 = self.iterated_hamiltonian_evolution_oracle\n", + " ##\n", + " from scipy.linalg import expm, norm\n", + "\n", + " Vh = expm(1j * s_step * eo2.h.dense.matrix)\n", + " Vd = expm(-1j * s_step * eo1.h.dense.matrix)\n", + " print(\n", + " norm(\n", + " Vh @ Vd @ Vh.conj().T @ Vd.conj().T\n", + " - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix)\n", + " )\n", + " )\n", + " print(norm(Vh - eo2.circuit(-s_step)))\n", + " print(norm(Vd - eo1.circuit(s_step)))\n", + " from functools import reduce\n", + "\n", + " by_hand_list = [Vh, Vd, Vh.conj().T, Vd.conj().T]\n", + " S = reduce(np.ndarray.__matmul__, by_hand_list)\n", + " print(\"reduce list\", norm(S - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix)))\n", + " assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value\n", + "\n", + " eo_mode = eo1.mode_evolution_oracle\n", + "\n", + " if mode_dbr is None:\n", + " gc_type = self.mode_double_bracket_rotation\n", + " else:\n", + " gc_type = mode_dbr\n", + "\n", + " if gc_type is DoubleBracketRotationType.single_commutator:\n", + " raise_error(\n", + " ValueError,\n", + " \"You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!\",\n", + " )\n", + "\n", + " if gc_type is DoubleBracketRotationType.group_commutator:\n", + " query_list_forward = [\n", + " eo2.circuit(-s_step),\n", + " eo1.circuit(s_step),\n", + " eo2.circuit(s_step),\n", + " eo1.circuit(-s_step),\n", + " ]\n", + " query_list_backward = [\n", + " eo1.circuit(s_step),\n", + " eo2.circuit(-s_step),\n", + " eo1.circuit(-s_step),\n", + " eo2.circuit(s_step),\n", + " ]\n", + " elif gc_type is DoubleBracketRotationType.group_commutator_reduced:\n", + " query_list_forward = [\n", + " eo1.circuit(s_step),\n", + " eo2.circuit(s_step),\n", + " eo1.circuit(-s_step),\n", + " ]\n", + " query_list_backward = [\n", + " eo1.circuit(s_step),\n", + " eo2.circuit(-s_step),\n", + " eo1.circuit(-s_step),\n", + " ]\n", + " else:\n", + " raise_error(\n", + " ValueError,\n", + " \"You are in the group commutator query list but your dbr mode is not recognized\",\n", + " )\n", + " print(\"start\")\n", + " reduce(\n", + " print,\n", + " [\n", + " norm(x @ y.conj().T - np.eye(x.shape[0]))\n", + " for x, y in zip(query_list_forward, by_hand_list)\n", + " ],\n", + " )\n", + " from functools import reduce\n", + "\n", + " print(\"stop\")\n", + " W = reduce(np.ndarray.__matmul__, query_list_forward)\n", + " print(norm(W - S))\n", + " if eo_mode is EvolutionOracleType.text_strings:\n", + " return {\n", + " \"forwards\": reduce(str.__add__, query_list_forward),\n", + " \"backwards\": reduce(str.__add__, query_list_backward),\n", + " }\n", + " elif eo_mode is EvolutionOracleType.hamiltonian_simulation:\n", + " return {\n", + " \"forwards\": reduce(Circuit.__add__, query_list_forward[::-1]),\n", + " \"backwards\": reduce(Circuit.__add__, query_list_backward[::-1]),\n", + " }\n", + " elif eo_mode is EvolutionOracleType.numerical:\n", + " return {\n", + " \"forwards\": reduce(np.ndarray.__matmul__, query_list_forward),\n", + " \"backwards\": reduce(np.ndarray.__matmul__, query_list_backward),\n", + " }\n", + " else:\n", + " raise_error(ValueError, \"Your EvolutionOracleType is not recognized\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51f190d6", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "72d81f56", @@ -596,41 +654,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "e1afea06", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-06 16:31:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-06 16:31:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "t_step = 0.1\n", "\n", @@ -665,33 +692,10 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "02789b1e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(sigma_decrease_dbi)\n", "plt.plot(sigma_decrease_gci)" @@ -699,23 +703,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "4efc5549", "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "group_commutator_other_sorting", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_26457/4112881237.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mgci\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGroupCommutatorIterationWithEvolutionOracles\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevolution_oracle\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode_double_bracket_rotation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDoubleBracketRotationType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator_other_sorting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/lib/python3.10/enum.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(cls, name)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_member_map_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 436\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 437\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 438\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: group_commutator_other_sorting" - ] - } - ], + "outputs": [], "source": [ "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index bf40daa073..83371c3ff7 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -61,7 +61,7 @@ def __init__( DoubleBracketGeneratorType.group_commutator ) super().__init__( - input_hamiltonian_evolution_oracle.h, mode_double_bracket_rotation_old + input_hamiltonian_evolution_oracle.h.dense, mode_double_bracket_rotation_old ) self.input_hamiltonian_evolution_oracle = input_hamiltonian_evolution_oracle @@ -135,28 +135,9 @@ def group_commutator( if eo2 is None: eo2 = self.iterated_hamiltonian_evolution_oracle - ## - from scipy.linalg import expm, norm - - Vh = expm(1j * s_step * eo2.h.dense.matrix) - Vd = expm(1j * s_step * eo1.h.dense.matrix) - print( - norm( - Vh @ Vd @ Vh.conj().T @ Vd.conj().T - - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix) - ) - ) - print(norm(Vh - eo2.circuit(-s_step))) - print(norm(Vd - eo1.circuit(-s_step))) - from functools import reduce - by_hand_list = [Vh, Vd, Vh.conj().T, Vd.conj().T] - S = reduce(np.ndarray.__matmul__, by_hand_list) - print(norm(S - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix))) assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value - eo_mode = eo1.mode_evolution_oracle - if mode_dbr is None: gc_type = self.mode_double_bracket_rotation else: @@ -171,14 +152,14 @@ def group_commutator( if gc_type is DoubleBracketRotationType.group_commutator: query_list_forward = [ eo2.circuit(-s_step), - eo1.circuit(-s_step), - eo2.circuit(s_step), eo1.circuit(s_step), + eo2.circuit(s_step), + eo1.circuit(-s_step), ] query_list_backward = [ - eo1.circuit(-s_step), - eo2.circuit(-s_step), eo1.circuit(s_step), + eo2.circuit(-s_step), + eo1.circuit(-s_step), eo2.circuit(s_step), ] elif gc_type is DoubleBracketRotationType.group_commutator_reduced: @@ -197,20 +178,9 @@ def group_commutator( ValueError, "You are in the group commutator query list but your dbr mode is not recognized", ) - print("start") - reduce( - print, - [ - norm(x @ y.conj().T - np.eye(x.shape[0])) - for x, y in zip(query_list_forward, by_hand_list) - ], - ) - from functools import reduce - print("stop") - print(query_list_forward[2]) - W = reduce(np.ndarray.__matmul__, query_list_forward) - print(norm(W - S)) + eo_mode = eo1.mode_evolution_oracle + from functools import reduce if eo_mode is EvolutionOracleType.text_strings: return { "forwards": reduce(str.__add__, query_list_forward), diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 8d7e1c127d..ab67359e39 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -53,7 +53,7 @@ def test_double_bracket_iteration_group_commutator(backend, nqubits): @pytest.mark.parametrize("nqubits", [3]) def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): - r"""The bound is $$||e^{-[D,H]}-GC||\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$""" + r"""The bound is $$||e^{-[D,H]}-GC||\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$ which we check by a loglog fit.""" h0 = random_hermitian(2**nqubits, backend=backend) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( @@ -61,7 +61,10 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): mode=DoubleBracketGeneratorType.group_commutator, ) - for s in np.linspace(0.001, 0.01, NSTEPS): + times = np.linspace(0.001, 0.01, 10) + norms = [] + norms_bound = [] + for s in times: u = dbi.eval_dbr_unitary( s, d=d, mode=DoubleBracketGeneratorType.single_commutator ) @@ -69,13 +72,24 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): s, d=d, mode=DoubleBracketGeneratorType.group_commutator ) + norms.append(np.linalg.norm(u - v) ) + w = dbi.commutator(h0,d) + norms_bound.append(0.5*s**1.48 * ( + np.linalg.norm(dbi.commutator(h0,w)) + np.linalg.norm(dbi.commutator(d,w)) + )) assert np.linalg.norm(u - v) < 10 * s**1.49 * ( - np.linalg.norm(h0) + np.linalg.norm(d) - ) * np.linalg.norm(h0) * np.linalg.norm(d) + np.linalg.norm(h0) + np.linalg.norm(d) + ) * np.linalg.norm(h0) * np.linalg.norm(d) + @pytest.mark.parametrize("nqubits", [3]) -def test_dbi_evolution_oracle(backend, nqubits, t_step, eps): +def test_dbi_evolution_oracle(backend, nqubits, t_step = 0.1, eps = 0.001 ): + """ We test the basic functionality provided by `EvolutionOracle`: + - hamiltonian_simulation: will use `SymbolicHamiltonian.circuit()` and should match with the corresponding evolution unitary up to the discretization error threshold + - numerical is just exponential $e^{-1jt_{step} H}$ + - text_strings will have strings which just have the name of the evolution oracle + """ from numpy.linalg import norm from qibo import symbols @@ -94,7 +108,6 @@ def test_dbi_evolution_oracle(backend, nqubits, t_step, eps): evolution_oracle = EvolutionOracle( h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation ) - evolution_oracle.eps_trottersuzuki = eps U_hamiltonian_simulation = evolution_oracle.circuit(t_step).unitary() @@ -102,6 +115,22 @@ def test_dbi_evolution_oracle(backend, nqubits, t_step, eps): assert norm(U_hamiltonian_simulation - V_target) < eps + evolution_oracle_np = EvolutionOracle( + h_input, "ZX numpy", mode_evolution_oracle=EvolutionOracleType.numerical + ) + U_np = evolution_oracle_np.circuit(t_step) + assert norm(U_np - V_target) < 1e-12 + + evolution_oracle_txt = EvolutionOracle( + h_input, "ZX test", mode_evolution_oracle=EvolutionOracleType.text_strings + ) + U_txt = evolution_oracle_txt.circuit(t_step) + assert isinstance(U_txt, str) + + + + + @pytest.mark.parametrize("nqubits", [1, 2]) def test_double_bracket_iteration_single_commutator(backend, nqubits): From 82adef2904755c5b84caa04d1aee0c33cc8a6727 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Fri, 26 Apr 2024 11:44:27 +0200 Subject: [PATCH 093/116] gci and dbi agree on the GC with np backend; next test (and correct) the hamiltonian simulation mode --- ...volution_oracles_and_gci_transpiling.ipynb | 778 +++++++++--------- .../dbi/double_bracket_evolution_oracles.py | 6 +- .../group_commutator_iteration_transpiler.py | 19 +- tests/test_models_dbi.py | 78 ++ 4 files changed, 478 insertions(+), 403 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 54f6c2dc32..501aca081a 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -35,7 +35,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-25 09:05:33]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-26 11:35:38]: Using numpy backend on /CPU:0\n" ] } ], @@ -46,6 +46,121 @@ "nqubits = 3" ] }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dabe5cf5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-26 11:42:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-26 11:42:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.7435671769611e-15\n", + "6.019125649086664\n", + "6.019125649086664\n", + "2.1112854320411976e-14\n", + "6.251889133927085\n", + "6.251889133927082\n", + "6.133971102219123e-14\n", + "6.153453052674688\n", + "6.153453052674681\n", + "9.354334563414852\n", + "6.17137286905534\n", + "6.0399303182680475\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_381350/3696440568.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m \u001b[0mtest_gci_implementations_normal_and_oracles\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnqubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_381350/3696440568.py\u001b[0m in \u001b[0;36mtest_gci_implementations_normal_and_oracles\u001b[0;34m(backend, nqubits)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_r\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mj_r\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_r\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mj_r\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "def test_gci_implementations_normal_and_oracles(backend,nqubits):\n", + "\n", + " h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + " )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " h_input = h_x + d_0\n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.numerical) \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + " from numpy.linalg import norm\n", + "\n", + " times = np.linspace(1e-5,1,5)\n", + " for r in times:\n", + "\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " k_r = dbi.h.matrix\n", + " dbi.h = deepcopy(h_input.dense) \n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " j_r = gci.h.matrix\n", + " gci.h = deepcopy(h_input.dense) \n", + " gci.iterated_hamiltonian_evolution_oracle = deepcopy(evolution_oracle) \n", + "\n", + " assert norm(k_r-j_r) < 1e-12\n", + "\n", + " r = 1\n", + " for _ in range(3):\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " k_r = dbi.h.matrix\n", + " j_r = gci.h.matrix\n", + " \n", + " print(norm(k_r-j_r))\n", + " print(norm(dbi.sigma(k_r)))\n", + " print(norm(dbi.sigma(j_r)))\n", + " assert norm(k_r-j_r) < 1e-12 \n", + " \n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + " r = 1\n", + " for _ in range(3):\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " k_r = dbi.h.matrix\n", + " j_r = gci.h.matrix\n", + " \n", + " print(norm(k_r-j_r))\n", + " print(norm(dbi.sigma(k_r)))\n", + " print(norm(dbi.sigma(j_r)))\n", + " assert norm(k_r-j_r) < 1e-12 \n", + " \n", + " \n", + "\n", + "test_gci_implementations_normal_and_oracles(backend,nqubits)" + ] + }, { "cell_type": "markdown", "id": "7f4d7a01", @@ -78,242 +193,326 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "aa8e61b9", - "metadata": {}, - "outputs": [], - "source": [ - "t_step =0.01\n", - "eps = 1e-2" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "fe0539ad", + "execution_count": 4, + "id": "7e99a090", "metadata": { - "scrolled": true + "scrolled": false }, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-25 09:09:11]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-25 09:09:11]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps):\n", + " \"\"\"\n", + "\n", + " This is testing the following:\n", + "\n", + " `dbi_exact` runs $V_{exact} = e^{-sW}$ and rotates $H_1 = V_{exact}^\\dagger H_0 V_{exact}$.\n", + "\n", + " `dbi_GC` runs $V_{GC} = GC$ and rotates $K_1 = V_{GC}^\\dagger H_0 V_{GC}$.\n", + "\n", + " We assert that dbi_exact and dbi_GC should be within the approximation bound of the GC\n", + " $$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n", + "\n", + " `gci` runs $V_{EO,GC} = GC$ and rotates $J_1 = V_{EO,GC}^\\dagger H_0 V_{EO,GC}$.\n", + "\n", + " We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", + " $$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", + " \"\"\"\n", + "\n", + " from numpy.linalg import norm\n", + "\n", + " h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + " )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " h_input = h_x + d_0\n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + " v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", + "\n", + " dbi(t_step, d = d_0.dense.matrix )\n", + " h_1 = dbi.h.matrix\n", + "\n", + " dbi.h = deepcopy(h_input.dense)\n", + " dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " k_1 = dbi.h.matrix\n", + "\n", + " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + " norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + " )\n", + " assert norm(v_exact - v_gc) < norms_bound\n", + " assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + " d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_02, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + " #gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "\n", + " u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", + " u_gci = u_gc_from_oracles['forwards']\n", + "\n", + " assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", + "\n", + "\n", + " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + " norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + " )\n", + " assert norm(v_exact - u_gci) < norms_bound\n", + "\n", + " gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", + " j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", + " assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", + " assert norm(j_1-k_1) < 1e-12 \n", + "\n" ] } ], "source": [ - "from numpy.linalg import norm\n", - "\n", - "h_x = SymbolicHamiltonian(\n", - " symbols.X(0)\n", - " + symbols.Z(0) * symbols.X(1)\n", - " + symbols.Y(2)\n", - " + symbols.Y(1) * symbols.Y(2),\n", - " nqubits=3,\n", - ")\n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - "h_input = h_x + d_0\n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "\n", - "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - "v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", - "\n", - "dbi(t_step, d = d_0.dense.matrix )\n", - "h_1 = dbi.h.matrix\n", - "\n", - "dbi.h = deepcopy(h_input.dense)\n", - "dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", - "k_1 = dbi.h.matrix\n", - "\n", - "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", - "norms_bound = 0.5*t_step**1.48 * (\n", - " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", - ")\n", - "assert norm(v_exact - v_gc) < norms_bound\n", - "assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound " + "print_function_source_code(test_gci_evolution_oracles_types_numerical)" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "4e3a5afa", + "execution_count": 5, + "id": "583ca695", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.007946732303441253" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(v_exact - v_gc)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "df4e4b89", - "metadata": { - "scrolled": true - }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-25 09:09:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-26 11:35:39]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-26 11:35:39]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-26 11:35:39]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.3625360448211346e-15\n", - "0.027414371976916107\n" + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_381350/1930429299.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mt_step\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;36m0.01\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0meps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1e-2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtest_gci_evolution_oracles_types_numerical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnqubits\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py\u001b[0m in \u001b[0;36mtest_gci_evolution_oracles_types_numerical\u001b[0;34m(nqubits, backend, t_step, eps)\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0mj_1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh_1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mj_1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh_input\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mnorms_bound\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 206\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mj_1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mk_1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 207\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 208\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " ] } ], "source": [ - "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical) \n", - "d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_02, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - "\n", - "u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", - "u_gci = u_gc_from_oracles['forwards']\n", - "\n", - "assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", + "t_step =0.01\n", + "eps = 1e-2\n", + "test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "82e15080", + "metadata": {}, + "source": [ + "## Check numerical GCI with evolution oracles against `DoubleBracketIteration`\n", "\n", + "Basically we have again a bound for how $H_k$ differs from $J_k$ for various duriations of the DBR.\n", "\n", - "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", - "norms_bound = 0.5*t_step**1.48 * (\n", - " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", - ")\n", - "assert norm(v_exact - u_gci) < norms_bound\n", - "\n", - "gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", - "j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", - "print(norm(j_1-k_1))\n", - "print(norm(j_1-h_1))" + "The plots below show that the GCI implementation for 1 step agrees precisely" ] }, { "cell_type": "code", "execution_count": null, - "id": "2b895267", + "id": "39bf5eeb", "metadata": {}, "outputs": [], "source": [ + "h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + ")\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + "h_input = h_x + d_0\n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", + "\n", + "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + "\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + "\n", "import matplotlib.pyplot as plt\n", + "from numpy.linalg import norm\n", "norms = []\n", "norms2 = []\n", - "for r in np.linspace(1e-5,0.1,30):\n", - " u_gc_from_oracles = gci.group_commutator( r, evolution_oracle_diagonal_target ) \n", - " u_gci = u_gc_from_oracles['forwards']\n", - " v_exact = dbi.eval_dbr_unitary(r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - " v_gc = dbi.eval_dbr_unitary(r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", - " norms.append(norm(u_gci - v_exact))\n", - " norms2.append(norm(u_gci - v_gc))\n", - "\n", + "norms_bound = []\n", + "times = np.linspace(1e-5,1,30)\n", + "for r in times:\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.single_commutator )\n", + " h_r = dbi.h.matrix\n", + " dbi.h = deepcopy(h_input.dense) \n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " k_r = dbi.h.matrix\n", + " dbi.h = deepcopy(h_input.dense) \n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " j_r = gci.h.matrix\n", + " gci.h = deepcopy(h_input.dense) \n", " \n", - "plt.plot(np.linspace(1e-5,.1,30), [x**1.5*12 for x in np.linspace(1e-5,.1,30)])\n", - "plt.plot(np.linspace(1e-5,.1,30),norms)\n", - "plt.plot(np.linspace(1e-5,.1,30),norms2)" + " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + " norms_bound.append(norm(h_input.dense.matrix)*r**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + " ))\n", + " \n", + " norms.append(norm(h_r -k_r ))\n", + " norms2.append(norm(h_r-j_r))\n", + " \n", + "plt.loglog(times, norms_bound)\n", + "plt.loglog(times,norms, \n", + " '-s')\n", + "plt.loglog(times,norms2, '-x')" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "0d55523e", + "cell_type": "markdown", + "id": "373d201e", "metadata": {}, - "outputs": [], "source": [ - "print(np.max(norms2))" + "### This is captured in the following test\n", + "(we restrict to both group commutator modes as for more steps there will be deviations)" ] }, { "cell_type": "code", "execution_count": null, - "id": "0d843f1f", - "metadata": { - "scrolled": true - }, + "id": "9212f94b", + "metadata": {}, "outputs": [], "source": [ - "print_function_source_code(GroupCommutatorIterationWithEvolutionOracles.group_commutator)" + " \n", + "\n", + " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + " v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", + "\n", + " assert norm(v_exact - v_gc) < norms_bound\n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + " d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_02, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + " #gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "\n", + " u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", + " u_gci = u_gc_from_oracles['forwards']\n", + "\n", + " assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", + "\n", + "\n", + " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + " norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + " )\n", + " assert norm(v_exact - u_gci) < norms_bound\n", + "\n", + " gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", + " j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", + " assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", + " assert norm(j_1-k_1) < 1e-12 " ] }, { - "cell_type": "code", - "execution_count": null, - "id": "6d99fbc3", + "cell_type": "markdown", + "id": "f6d8c3a3", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "### Next many steps: the `DoubleBracketIteration` implementation agrees with evolution oracles for the gc mode. In the exact commutator exponential a deviation builds up" + ] }, { "cell_type": "code", "execution_count": null, - "id": "583ca695", + "id": "2b895267", "metadata": {}, "outputs": [], "source": [ - "assert norm(Q_gci.conj().T - R_dbi ) < 5*eps\n", - "\n", + "r=0.01\n", "\n", - "test_dbr_in_dbi_vs_gci_classes_numerical(.1, 1e-5)" + "norms_it = []\n", + "norms_it2 = []\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "for _ in range(15):\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.single_commutator )\n", + " dbi2(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " h_r = dbi.h.matrix\n", + " k_r = dbi2.h.matrix\n", + " j_r = gci.h.matrix\n", + " norms_it.append(norm(k_r-j_r))\n", + " norms_it2.append(norm(h_r-j_r)) \n", + "plt.plot(norms_it)\n", + "plt.show()\n", + "plt.plot(norms_it2)" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "ec6361ca", + "cell_type": "markdown", + "id": "18335bd2", "metadata": {}, - "outputs": [], "source": [ - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", - "\n", - "\n", - "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", - "\n", - "import matplotlib.pyplot as plt\n", - "norms = []\n", - "for r in np.linspace(1e-5,0.1,30):\n", - " dbi(r, d=d_0.dense.matrix)\n", - " dbi2(r, d=d_0.dense.matrix)\n", - " norms.append(norm(dbi.h.matrix- dbi2.h.matrix))\n", - " \n", - "plt.plot(np.linspace(1e-5,.1,30), [x**1.5*1000 for x in np.linspace(1e-5,.1,30)])\n", - "plt.plot(np.linspace(1e-5,.1,30),norms)" + "## Simple test of group commutator" ] }, { "cell_type": "code", "execution_count": null, - "id": "7e99a090", - "metadata": { - "scrolled": false - }, + "id": "ec6361ca", + "metadata": {}, "outputs": [], "source": [ - "def test_dbr_in_dbi_vs_gci_classes_numerical(t_step, eps):" + "def test_exact_dbr_vs_gc_bound(nqubits,backend):\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + " dbi.mode = DoubleBracketGeneratorType.single_commutator\n", + "\n", + "\n", + " dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", + " dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", + "\n", + " import matplotlib.pyplot as plt\n", + " norms = []\n", + " for r in np.linspace(1e-5,0.1,30):\n", + " dbi(r, d=d_0.dense.matrix)\n", + " dbi2(r, d=d_0.dense.matrix)\n", + " norms.append(norm(dbi.h.matrix- dbi2.h.matrix))\n", + " \n", + " #plt.plot(np.linspace(1e-5,.1,30), [x**1.5*1000 for x in np.linspace(1e-5,.1,30)])\n", + " plt.plot(np.linspace(1e-5,.1,30),norms)\n", + "test_exact_dbr_vs_gc_bound(nqubits,backend)" ] }, { @@ -352,7 +551,7 @@ }, { "cell_type": "markdown", - "id": "af472177", + "id": "7b26748a", "metadata": {}, "source": [ "### We repeat the function in order to plot the bound" @@ -361,7 +560,7 @@ { "cell_type": "code", "execution_count": null, - "id": "54fea9c7", + "id": "66797b85", "metadata": {}, "outputs": [], "source": [ @@ -396,7 +595,7 @@ }, { "cell_type": "markdown", - "id": "5127adad", + "id": "ae8f9d27", "metadata": {}, "source": [ "Unfortunately we cannot assume that \n", @@ -408,7 +607,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f34ad940", + "id": "b5d93311", "metadata": {}, "outputs": [], "source": [ @@ -419,7 +618,7 @@ }, { "cell_type": "markdown", - "id": "ac31a3fa", + "id": "354379af", "metadata": {}, "source": [ "In practice that assertion usually goes through. We check this further by these plots" @@ -428,7 +627,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ef43be9c", + "id": "740002dd", "metadata": {}, "outputs": [], "source": [ @@ -440,7 +639,7 @@ { "cell_type": "code", "execution_count": null, - "id": "eecc6a33", + "id": "4a919cc8", "metadata": {}, "outputs": [], "source": [ @@ -450,7 +649,7 @@ }, { "cell_type": "markdown", - "id": "c652e516", + "id": "48535cc5", "metadata": {}, "source": [ "Usually random Hamiltonian matrices give something $a\\approx 1.49$" @@ -459,13 +658,21 @@ { "cell_type": "code", "execution_count": null, - "id": "3ef04b41", + "id": "63146096", "metadata": {}, "outputs": [], "source": [ "popt" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "c34fee50", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "70ac58a2", @@ -496,7 +703,7 @@ }, { "cell_type": "markdown", - "id": "8c54cfa8", + "id": "9f454286", "metadata": {}, "source": [ "This was just a check to see if using the circuit method works. Then covering the numerical and text flag." @@ -510,118 +717,6 @@ "outputs": [], "source": [] }, - { - "cell_type": "code", - "execution_count": null, - "id": "964c64c3", - "metadata": {}, - "outputs": [], - "source": [ - " def group_commutator(\n", - " self,\n", - " t_step: float,\n", - " eo1: EvolutionOracle,\n", - " eo2: EvolutionOracle = None,\n", - " mode_dbr: DoubleBracketRotationType = None,\n", - " ):\n", - " s_step = np.sqrt(t_step)\n", - "\n", - " if eo2 is None:\n", - " eo2 = self.iterated_hamiltonian_evolution_oracle\n", - " ##\n", - " from scipy.linalg import expm, norm\n", - "\n", - " Vh = expm(1j * s_step * eo2.h.dense.matrix)\n", - " Vd = expm(-1j * s_step * eo1.h.dense.matrix)\n", - " print(\n", - " norm(\n", - " Vh @ Vd @ Vh.conj().T @ Vd.conj().T\n", - " - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix)\n", - " )\n", - " )\n", - " print(norm(Vh - eo2.circuit(-s_step)))\n", - " print(norm(Vd - eo1.circuit(s_step)))\n", - " from functools import reduce\n", - "\n", - " by_hand_list = [Vh, Vd, Vh.conj().T, Vd.conj().T]\n", - " S = reduce(np.ndarray.__matmul__, by_hand_list)\n", - " print(\"reduce list\", norm(S - super().eval_dbr_unitary(t_step, d=eo1.h.dense.matrix)))\n", - " assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value\n", - "\n", - " eo_mode = eo1.mode_evolution_oracle\n", - "\n", - " if mode_dbr is None:\n", - " gc_type = self.mode_double_bracket_rotation\n", - " else:\n", - " gc_type = mode_dbr\n", - "\n", - " if gc_type is DoubleBracketRotationType.single_commutator:\n", - " raise_error(\n", - " ValueError,\n", - " \"You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!\",\n", - " )\n", - "\n", - " if gc_type is DoubleBracketRotationType.group_commutator:\n", - " query_list_forward = [\n", - " eo2.circuit(-s_step),\n", - " eo1.circuit(s_step),\n", - " eo2.circuit(s_step),\n", - " eo1.circuit(-s_step),\n", - " ]\n", - " query_list_backward = [\n", - " eo1.circuit(s_step),\n", - " eo2.circuit(-s_step),\n", - " eo1.circuit(-s_step),\n", - " eo2.circuit(s_step),\n", - " ]\n", - " elif gc_type is DoubleBracketRotationType.group_commutator_reduced:\n", - " query_list_forward = [\n", - " eo1.circuit(s_step),\n", - " eo2.circuit(s_step),\n", - " eo1.circuit(-s_step),\n", - " ]\n", - " query_list_backward = [\n", - " eo1.circuit(s_step),\n", - " eo2.circuit(-s_step),\n", - " eo1.circuit(-s_step),\n", - " ]\n", - " else:\n", - " raise_error(\n", - " ValueError,\n", - " \"You are in the group commutator query list but your dbr mode is not recognized\",\n", - " )\n", - " print(\"start\")\n", - " reduce(\n", - " print,\n", - " [\n", - " norm(x @ y.conj().T - np.eye(x.shape[0]))\n", - " for x, y in zip(query_list_forward, by_hand_list)\n", - " ],\n", - " )\n", - " from functools import reduce\n", - "\n", - " print(\"stop\")\n", - " W = reduce(np.ndarray.__matmul__, query_list_forward)\n", - " print(norm(W - S))\n", - " if eo_mode is EvolutionOracleType.text_strings:\n", - " return {\n", - " \"forwards\": reduce(str.__add__, query_list_forward),\n", - " \"backwards\": reduce(str.__add__, query_list_backward),\n", - " }\n", - " elif eo_mode is EvolutionOracleType.hamiltonian_simulation:\n", - " return {\n", - " \"forwards\": reduce(Circuit.__add__, query_list_forward[::-1]),\n", - " \"backwards\": reduce(Circuit.__add__, query_list_backward[::-1]),\n", - " }\n", - " elif eo_mode is EvolutionOracleType.numerical:\n", - " return {\n", - " \"forwards\": reduce(np.ndarray.__matmul__, query_list_forward),\n", - " \"backwards\": reduce(np.ndarray.__matmul__, query_list_backward),\n", - " }\n", - " else:\n", - " raise_error(ValueError, \"Your EvolutionOracleType is not recognized\")\n" - ] - }, { "cell_type": "code", "execution_count": null, @@ -630,104 +725,6 @@ "outputs": [], "source": [] }, - { - "cell_type": "markdown", - "id": "72d81f56", - "metadata": {}, - "source": [ - "# Show that double bracket iteration group commutator and dbi converge for small s BHMM\n", - "\n", - "This is testing the following:\n", - "\n", - "`dbi` runs $V = e^{-sW}$ and rotates $H_1 = V^\\dagger H_0 V$.\n", - "\n", - "`gci` runs $Q = GC$ and rotates $J_1 = Q^\\dagger H_0 Q$.\n", - "\n", - "`dbi2` runs $R = GC$ and rotates $K_1 = R^\\dagger H_0 R$.\n", - "\n", - "We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", - "$$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", - "\n", - "We assert that gci and dbi should be within the approximation bound of the GC\n", - "$$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e1afea06", - "metadata": {}, - "outputs": [], - "source": [ - "t_step = 0.1\n", - "\n", - "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - "h_input = h_x + d_0 \n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.group_commutator\n", - "dbi(t_step, d = -d_0.dense.matrix )\n", - "\n", - "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi2.mode = DoubleBracketGeneratorType.single_commutator\n", - "dbi2(t_step, d = d_0.dense.matrix )\n", - "\n", - "norms = []\n", - "\n", - "sigma_decrease_dbi = []\n", - "sigma_decrease_gci = []\n", - "for r in range(30):\n", - " dbi(t_step, d=-d_0.dense.matrix)\n", - " dbi2(t_step, d=d_0.dense.matrix)\n", - " sigma_decrease_dbi.append(dbi.off_diagonal_norm)\n", - " \n", - " sigma_decrease_gci.append(dbi2.off_diagonal_norm)\n", - " norms.append(norm(dbi.h.matrix- dbi2.h.matrix))\n", - " \n", - " \n", - "plt.plot(norms)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "02789b1e", - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(sigma_decrease_dbi)\n", - "plt.plot(sigma_decrease_gci)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4efc5549", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", - "evolution_oracle.eps_trottersuzuki = eps\n", - "\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", - "\n", - "assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", - "assert norm(gci.h.matrix - dbi2.h.matrix) < 20 * norm(h_input) * t_step\n", - "\n", - "dbi(t_step, d = d_0.dense.matrix ) \n", - "dbi2(t_step, d = d_0.dense.matrix ) \n", - "gci(t_step, diagonal_association=evolution_oracle_diagonal_target) \n", - "assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", - "assert norm(gci.h.matrix - dbi2.h.matrix) < (20 * norm(h_input) * t_step)**2" - ] - }, { "cell_type": "code", "execution_count": null, @@ -735,7 +732,7 @@ "metadata": {}, "outputs": [], "source": [ - "from double_bracket import *\n", + "from qibo.models.double_bracket import *\n", "\n", "def test_dbi_vs_gci(t_step, eps):\n", " if t_step > 1:\n", @@ -777,15 +774,6 @@ "test_dbi_vs_gci(.1, 1e-5)" ] }, - { - "cell_type": "markdown", - "id": "8db582f1", - "metadata": {}, - "source": [ - "# Show that double bracket iteration group commutator and gci are numerically exact\n", - "\n" - ] - }, { "cell_type": "markdown", "id": "5381e44f", @@ -977,7 +965,7 @@ " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", "\n", " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", + " diagonal_association = evolution_oracle_diagonal_target )\n", "\n", " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),d_0.dense.matrix)\n", "\n", @@ -1575,6 +1563,14 @@ "\n", "query_list['forwards']" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7654f54f", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index ac093a7fbd..751cba4947 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -177,12 +177,12 @@ def circuit(self, t_duration: float = None): if self.mode_evolution_oracle is EvolutionOracleType.text_strings: return self.name + "(" + str(t_duration) + ")" elif self.mode_evolution_oracle is EvolutionOracleType.numerical: - return self.before_circuit @ self.h.exp(t_duration) @ self.after_circuit + return self.before_circuit @ self.base_evolution_oracle(t_duration) @ self.after_circuit elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: return ( - self.before_circuit + self.after_circuit + self.base_evolution_oracle.circuit(t_duration) - + self.after_circuit + + self.before_circuit ) else: raise_error( diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 83371c3ff7..e5716ca9ab 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -71,9 +71,8 @@ def __init__( self.gci_unitary = [] self.gci_unitary_dagger = [] - self.iterated_hamiltonian_evolution_oracle = ( - self.input_hamiltonian_evolution_oracle - ) + self.iterated_hamiltonian_evolution_oracle = deepcopy( self.input_hamiltonian_evolution_oracle ) + def __call__( self, @@ -99,6 +98,13 @@ def __call__( before_circuit = double_bracket_rotation_step["backwards"] after_circuit = double_bracket_rotation_step["forwards"] + self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( + deepcopy(self.iterated_hamiltonian_evolution_oracle), + str(step_duration), + before_circuit, + after_circuit, + ) + if ( self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.numerical @@ -109,12 +115,7 @@ def __call__( self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation ): - self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - deepcopy(self.iterated_hamiltonian_evolution_oracle), - str(step_duration), - before_circuit, - after_circuit, - ) + self.h.matrix = ( before_circuit.unitary() @ self.h.matrix @ after_circuit.unitary() ) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index ab67359e39..e26fdcda84 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -129,6 +129,84 @@ def test_dbi_evolution_oracle(backend, nqubits, t_step = 0.1, eps = 0.001 ): +def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps): + """ + + This is testing the following: + + `dbi_exact` runs $V_{exact} = e^{-sW}$ and rotates $H_1 = V_{exact}^\dagger H_0 V_{exact}$. + + `dbi_GC` runs $V_{GC} = GC$ and rotates $K_1 = V_{GC}^\dagger H_0 V_{GC}$. + + We assert that dbi_exact and dbi_GC should be within the approximation bound of the GC + $$||J_1-H_1||\le2 ||H_0||\,||R-V||\le C ||H_0|| s^{3/2}$$ + + `gci` runs $V_{EO,GC} = GC$ and rotates $J_1 = V_{EO,GC}^\dagger H_0 V_{EO,GC}$. + + We assert that gci and dbi2 should be within machine precision for the correct sorting. + $$||J_1-K_1||\le2 ||H_0||\,||R-Q||\le \epsilon$$ + """ + + from numpy.linalg import norm + + h_x = SymbolicHamiltonian( + symbols.X(0) + + symbols.Z(0) * symbols.X(1) + + symbols.Y(2) + + symbols.Y(1) * symbols.Y(2), + nqubits=3, + ) + d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3) + h_input = h_x + d_0 + + dbi = DoubleBracketIteration(deepcopy(h_input.dense)) + + v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator) + v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator) + + dbi(t_step, d = d_0.dense.matrix ) + h_1 = dbi.h.matrix + + dbi.h = deepcopy(h_input.dense) + dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) + k_1 = dbi.h.matrix + + w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix) + norms_bound = 0.5*t_step**1.48 * ( + np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w)) + ) + assert norm(v_exact - v_gc) < norms_bound + assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound + + evolution_oracle = EvolutionOracle(h_input, "ZX", + mode_evolution_oracle = EvolutionOracleType.numerical) + d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3) + evolution_oracle_diagonal_target = EvolutionOracle(d_02, "D0", + mode_evolution_oracle = EvolutionOracleType.numerical) + + gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle )) + #gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator + + u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) + u_gci = u_gc_from_oracles['forwards'] + + assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12 + + + v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator) + w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix) + norms_bound = 0.5*t_step**1.48 * ( + np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w)) + ) + assert norm(v_exact - u_gci) < norms_bound + + gci(t_step, diagonal_association= evolution_oracle_diagonal_target ) + j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix + assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound + assert norm(j_1-k_1) < 1e-12 + + + From f49d553ed7a2fb891cd94462ea8f4c8124b0e41c Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 29 Apr 2024 14:48:29 +0200 Subject: [PATCH 094/116] the gci with evolution oracles agress with gci with classical memoization; next extract circuit and check that it gives a correct result --- ...volution_oracles_and_gci_transpiling.ipynb | 611 +++++++++--------- .../dbi/double_bracket_evolution_oracles.py | 31 +- .../group_commutator_iteration_transpiler.py | 18 +- 3 files changed, 347 insertions(+), 313 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index 501aca081a..ff4d9e29f4 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -35,7 +35,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-26 11:35:38]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-29 12:14:42]: Using numpy backend on /CPU:0\n" ] } ], @@ -48,49 +48,281 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "dabe5cf5", + "execution_count": null, + "id": "6095d17a", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-26 11:42:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-26 11:42:50]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-29 14:45:18]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-29 14:45:19]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "5.7435671769611e-15\n", - "6.019125649086664\n", - "6.019125649086664\n", - "2.1112854320411976e-14\n", - "6.251889133927085\n", - "6.251889133927082\n", - "6.133971102219123e-14\n", - "6.153453052674688\n", - "6.153453052674681\n", - "9.354334563414852\n", - "6.17137286905534\n", - "6.0399303182680475\n" + "eith diff 1.5712440057340736e-07\n", + "U dbr diff 1.1569097113412146e-05\n", + "h diff 3.3021307730058864e-05\n", + "sigma dbi 5.60100317946555\n", + "sigma gci 5.601003185838881\n", + "eith diff 2.881755892359207e-07\n", + "U dbr diff 1.1124982181225484e-05\n", + "h diff 6.476110230712104e-05\n", + "sigma dbi 5.546955161050127\n", + "sigma gci 5.546955233970926\n", + "eith diff 5.843412359673229e-07\n", + "U dbr diff 1.0710955536295385e-05\n", + "h diff 9.525342119986412e-05\n", + "sigma dbi 5.494680926176547\n", + "sigma gci 5.494681200037203\n", + "eith diff 8.81222405885465e-07\n", + "U dbr diff 1.0325625670392596e-05\n", + "h diff 0.00012453892531827423\n", + "sigma dbi 5.44411695218482\n", + "sigma gci 5.444117625508951\n", + "eith diff 1.169127621411016e-06\n", + "U dbr diff 9.967311672226913e-06\n", + "h diff 0.00015266248434895235\n", + "sigma dbi 5.395180752751458\n", + "sigma gci 5.395182076480832\n", + "eith diff 1.4466560682228037e-06\n", + "U dbr diff 9.634155420969876e-06\n", + "h diff 0.00017967130915922002\n", + "sigma dbi 5.3477817719619924\n", + "sigma gci 5.347784037232165\n" + ] + } + ], + "source": [ + "def test_gci_frame_shifted_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation):\n", + "\n", + " h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + " )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " h_input = h_x + d_0\n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle) \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle)\n", + "\n", + " from numpy.linalg import norm\n", + "\n", + " r = .01\n", + " for _ in range(7):\n", + " a = dbi.h.exp(r)\n", + " b = gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)\n", + " print( \"eith diff\", norm( a - b))\n", + " a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", + " b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", + " print(\"U dbr diff\",norm( a - b))\n", + "\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " \n", + " k_r = dbi.h.matrix\n", + " j_r = gci.h.matrix\n", + " print('h diff',norm(k_r-j_r))\n", + "\n", + " print(\"sigma dbi\", norm(dbi.sigma(k_r)))\n", + " print(\"sigma gci\", norm(dbi.sigma(j_r)))\n", + "\n", + " \n", + "test_gci_frame_shifted_oracles(backend,nqubits)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "21f87059", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-29 12:14:42]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-29 12:14:42]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] }, { - "ename": "AssertionError", - "evalue": "", + "name": "stdout", + "output_type": "stream", + "text": [ + "eval ab 4.460072397196506e-05\n", + "evolution eith 9.092521730556182e-05\n", + "eval dbr diff 4.460072397196506e-05\n", + "h diff 0.00014214956955464143\n", + "eval gcr 4.127345219458045e-05\n", + "evolution eith 7.632202655334346e-05\n" + ] + } + ], + "source": [ + "eo_mode = EvolutionOracleType.hamiltonian_simulation\n", + "r= 0.1\n", + "\n", + "h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + ")\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + "h_input = h_x + d_0\n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + "evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = eo_mode ) \n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = eo_mode)\n", + "from numpy.linalg import norm\n", + "\n", + "r=0.2\n", + "\n", + "a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", + "b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", + "print(\"eval ab\", norm(a-b))\n", + "\n", + "\n", + "print('evolution eith',norm(dbi.h.exp(r)\n", + " -\n", + " gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)))\n", + "a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", + "b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", + "print(\"eval dbr diff\", norm(a-b))\n", + "\n", + "dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) \n", + "\n", + "gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + "k_r = dbi.h.matrix\n", + "j_r = gci.h.matrix\n", + "\n", + "print('h diff',norm(k_r-j_r))\n", + "\n", + "a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", + "b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", + "print(\"eval gcr\", norm(a-b))\n", + "\n", + "print('evolution eith',norm(dbi.h.exp(r)\n", + " -\n", + " gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "548aafac", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 't_step' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_381350/3696440568.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m \u001b[0mtest_gci_implementations_normal_and_oracles\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnqubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/tmp/ipykernel_381350/3696440568.py\u001b[0m in \u001b[0;36mtest_gci_implementations_normal_and_oracles\u001b[0;34m(backend, nqubits)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_r\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdbi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mj_r\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_r\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mj_r\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_63614/4039678752.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;31m#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mu_gc_from_oracles\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mu_gci\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mu_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'forwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 't_step' is not defined" ] } ], + "source": [ + "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "\n", + "u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", + "u_gci = u_gc_from_oracles['forwards']\n", + "\n", + "assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", + "\n", + "\n", + "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + "norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + ")\n", + "assert norm(v_exact - u_gci) < norms_bound\n", + "u_gcr = gci.eval_gcr_unitary(t_step,evolution_oracle_diagonal_target )\n", + "assert norm(v_exact - u_gcr) < norms_bound\n", + "print(norm(v_exact-u_gcr))\n", + "print(norm(dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)-u_gci))\n", + "gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", + "\n", + "j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", + "assert norm(dbi.h.matrix-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a58b6c7b", + "metadata": {}, + "outputs": [], + "source": [ + "dbi = DoubleBracketIteration(deepcopy(h_input.dense)) \n", + "evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + "evolution_oracle.eps_trottersuzuki = 1e-9\n", + "evolution_oracle_diagonal_target.eps_trottersuzuki = 1e-9\n", + "r = .\n", + "for _ in range(3):\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " k_r = dbi.h.matrix\n", + " j_r = gci.h.matrix\n", + "\n", + " print(norm(k_r-j_r))\n", + " print(norm(dbi.sigma(k_r)))\n", + " print(norm(dbi.sigma(j_r)))\n", + " assert norm(k_r-j_r) < 1e-12 " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4004f8f", + "metadata": {}, + "outputs": [], + "source": [ + "test_gci_implementations_normal_and_oracles(backend,nqubits)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1598800e", + "metadata": {}, + "outputs": [], "source": [ "def test_gci_implementations_normal_and_oracles(backend,nqubits):\n", "\n", @@ -134,16 +366,17 @@ " k_r = dbi.h.matrix\n", " j_r = gci.h.matrix\n", " \n", - " print(norm(k_r-j_r))\n", - " print(norm(dbi.sigma(k_r)))\n", - " print(norm(dbi.sigma(j_r)))\n", " assert norm(k_r-j_r) < 1e-12 \n", " \n", + " \n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense)) \n", " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", "\n", " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", + " evolution_oracle.eps_trottersuzuki = 1e-9\n", + " evolution_oracle_diagonal_target.eps_trottersuzuki = 1e-9\n", " r = 1\n", " for _ in range(3):\n", " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", @@ -154,10 +387,8 @@ " print(norm(k_r-j_r))\n", " print(norm(dbi.sigma(k_r)))\n", " print(norm(dbi.sigma(j_r)))\n", - " assert norm(k_r-j_r) < 1e-12 \n", + " assert norm(k_r-j_r) < 1e-12 \n", " \n", - " \n", - "\n", "test_gci_implementations_normal_and_oracles(backend,nqubits)" ] }, @@ -193,127 +424,22 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "7e99a090", "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps):\n", - " \"\"\"\n", - "\n", - " This is testing the following:\n", - "\n", - " `dbi_exact` runs $V_{exact} = e^{-sW}$ and rotates $H_1 = V_{exact}^\\dagger H_0 V_{exact}$.\n", - "\n", - " `dbi_GC` runs $V_{GC} = GC$ and rotates $K_1 = V_{GC}^\\dagger H_0 V_{GC}$.\n", - "\n", - " We assert that dbi_exact and dbi_GC should be within the approximation bound of the GC\n", - " $$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n", - "\n", - " `gci` runs $V_{EO,GC} = GC$ and rotates $J_1 = V_{EO,GC}^\\dagger H_0 V_{EO,GC}$.\n", - "\n", - " We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", - " $$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", - " \"\"\"\n", - "\n", - " from numpy.linalg import norm\n", - "\n", - " h_x = SymbolicHamiltonian(\n", - " symbols.X(0)\n", - " + symbols.Z(0) * symbols.X(1)\n", - " + symbols.Y(2)\n", - " + symbols.Y(1) * symbols.Y(2),\n", - " nqubits=3,\n", - " )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - " h_input = h_x + d_0\n", - "\n", - " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "\n", - " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - " v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", - "\n", - " dbi(t_step, d = d_0.dense.matrix )\n", - " h_1 = dbi.h.matrix\n", - "\n", - " dbi.h = deepcopy(h_input.dense)\n", - " dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", - " k_1 = dbi.h.matrix\n", - "\n", - " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", - " norms_bound = 0.5*t_step**1.48 * (\n", - " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", - " )\n", - " assert norm(v_exact - v_gc) < norms_bound\n", - " assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", - "\n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical) \n", - " d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_02, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", - "\n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - " #gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - "\n", - " u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", - " u_gci = u_gc_from_oracles['forwards']\n", - "\n", - " assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", - "\n", - "\n", - " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", - " norms_bound = 0.5*t_step**1.48 * (\n", - " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", - " )\n", - " assert norm(v_exact - u_gci) < norms_bound\n", - "\n", - " gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", - " j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", - " assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", - " assert norm(j_1-k_1) < 1e-12 \n", - "\n" - ] - } - ], + "outputs": [], "source": [ "print_function_source_code(test_gci_evolution_oracles_types_numerical)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "583ca695", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-26 11:35:39]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-26 11:35:39]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-26 11:35:39]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_381350/1930429299.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mt_step\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;36m0.01\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0meps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1e-2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtest_gci_evolution_oracles_types_numerical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnqubits\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Projects_git/DBI_qibo/qibo/examples/dbi/../../tests/test_models_dbi.py\u001b[0m in \u001b[0;36mtest_gci_evolution_oracles_types_numerical\u001b[0;34m(nqubits, backend, t_step, eps)\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0mj_1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterated_hamiltonian_evolution_oracle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh_1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mj_1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh_input\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mnorms_bound\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 206\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mj_1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mk_1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 207\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 208\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "t_step =0.01\n", "eps = 1e-2\n", @@ -323,7 +449,7 @@ }, { "cell_type": "markdown", - "id": "82e15080", + "id": "0f0b06ec", "metadata": {}, "source": [ "## Check numerical GCI with evolution oracles against `DoubleBracketIteration`\n", @@ -336,7 +462,7 @@ { "cell_type": "code", "execution_count": null, - "id": "39bf5eeb", + "id": "a2c2422b", "metadata": {}, "outputs": [], "source": [ @@ -395,7 +521,7 @@ }, { "cell_type": "markdown", - "id": "373d201e", + "id": "5e89586e", "metadata": {}, "source": [ "### This is captured in the following test\n", @@ -405,48 +531,45 @@ { "cell_type": "code", "execution_count": null, - "id": "9212f94b", + "id": "40308fc2", "metadata": {}, "outputs": [], "source": [ - " \n", - "\n", - " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - " v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", - "\n", - " assert norm(v_exact - v_gc) < norms_bound\n", "\n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical) \n", - " d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_02, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", "\n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - " #gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", "\n", - " u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", - " u_gci = u_gc_from_oracles['forwards']\n", + "u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", + "u_gci = u_gc_from_oracles['forwards']\n", "\n", - " assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", + "assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", "\n", "\n", - " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", - " norms_bound = 0.5*t_step**1.48 * (\n", - " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", - " )\n", - " assert norm(v_exact - u_gci) < norms_bound\n", + "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + "norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + ")\n", + "assert norm(v_exact - u_gci) < norms_bound\n", + "u_gcr = gci.eval_gcr_unitary(t_step,evolution_oracle_diagonal_target )\n", + "assert norm(v_exact - u_gcr) < norms_bound\n", + "print(norm(v_exact-u_gcr))\n", + "print(norm(dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)-u_gci))\n", + "gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", "\n", - " gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", - " j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", - " assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", - " assert norm(j_1-k_1) < 1e-12 " + "j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", + "assert norm(dbi.h.matrix-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n" ] }, { "cell_type": "markdown", - "id": "f6d8c3a3", + "id": "fe2c0711", "metadata": {}, "source": [ "### Next many steps: the `DoubleBracketIteration` implementation agrees with evolution oracles for the gc mode. In the exact commutator exponential a deviation builds up" @@ -482,7 +605,7 @@ }, { "cell_type": "markdown", - "id": "18335bd2", + "id": "1e6319bf", "metadata": {}, "source": [ "## Simple test of group commutator" @@ -551,7 +674,7 @@ }, { "cell_type": "markdown", - "id": "7b26748a", + "id": "c708df6a", "metadata": {}, "source": [ "### We repeat the function in order to plot the bound" @@ -560,7 +683,7 @@ { "cell_type": "code", "execution_count": null, - "id": "66797b85", + "id": "d4cff4ad", "metadata": {}, "outputs": [], "source": [ @@ -595,7 +718,7 @@ }, { "cell_type": "markdown", - "id": "ae8f9d27", + "id": "914f2c09", "metadata": {}, "source": [ "Unfortunately we cannot assume that \n", @@ -607,7 +730,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5d93311", + "id": "05128816", "metadata": {}, "outputs": [], "source": [ @@ -618,7 +741,7 @@ }, { "cell_type": "markdown", - "id": "354379af", + "id": "5c757242", "metadata": {}, "source": [ "In practice that assertion usually goes through. We check this further by these plots" @@ -627,7 +750,7 @@ { "cell_type": "code", "execution_count": null, - "id": "740002dd", + "id": "62c60671", "metadata": {}, "outputs": [], "source": [ @@ -639,7 +762,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4a919cc8", + "id": "038df7d5", "metadata": {}, "outputs": [], "source": [ @@ -649,7 +772,7 @@ }, { "cell_type": "markdown", - "id": "48535cc5", + "id": "3bcc8be4", "metadata": {}, "source": [ "Usually random Hamiltonian matrices give something $a\\approx 1.49$" @@ -658,7 +781,7 @@ { "cell_type": "code", "execution_count": null, - "id": "63146096", + "id": "6cd3e03b", "metadata": {}, "outputs": [], "source": [ @@ -668,7 +791,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c34fee50", + "id": "d0f05dfe", "metadata": {}, "outputs": [], "source": [] @@ -703,136 +826,12 @@ }, { "cell_type": "markdown", - "id": "9f454286", + "id": "392a7c7c", "metadata": {}, "source": [ "This was just a check to see if using the circuit method works. Then covering the numerical and text flag." ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "b37cbc0e", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "51f190d6", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0f86c490", - "metadata": {}, - "outputs": [], - "source": [ - "from qibo.models.double_bracket import *\n", - "\n", - "def test_dbi_vs_gci(t_step, eps):\n", - " if t_step > 1:\n", - " t_step = 0.1\n", - " \n", - " h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - " h_input = h_x + d_0 \n", - "\n", - " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - " dbi.mode = DoubleBracketGeneratorType.group_commutator\n", - " dbi(t_step, d = d_0.dense.matrix )\n", - " \n", - " dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", - " dbi2.mode = DoubleBracketGeneratorType.single_commutator\n", - " dbi2(t_step, d = d_0.dense.matrix )\n", - " \n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", - " evolution_oracle.eps_trottersuzuki = eps\n", - " \n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - " \n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", - " \n", - " assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", - " assert norm(gci.h.matrix - dbi2.h.matrix) < 20 * norm(h_input) * t_step\n", - " \n", - " dbi(t_step, d = d_0.dense.matrix ) \n", - " dbi2(t_step, d = d_0.dense.matrix ) \n", - " gci(t_step, diagonal_association=evolution_oracle_diagonal_target) \n", - " assert norm(gci.h.matrix - dbi.h.matrix) < 1e-12 \n", - " assert norm(gci.h.matrix - dbi2.h.matrix) < (20 * norm(h_input) * t_step)**2\n", - " \n", - " \n", - "test_dbi_vs_gci(.1, 1e-5)" - ] - }, - { - "cell_type": "markdown", - "id": "5381e44f", - "metadata": {}, - "source": [ - "# Show that double bracket iteration and gci gc and gc_reduced converge for small s BHMM\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2e97f0c6", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "61699387", - "metadata": {}, - "outputs": [], - "source": [ - "dbi(t_step, d = d_0.dense.matrix)\n" - ] - }, - { - "cell_type": "markdown", - "id": "09ab7a86", - "metadata": {}, - "source": [ - "#### 2. Evolution oracle hamiltonian simulation\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c9a9b4ef", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3a4b6a36", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "\n" - ] - }, { "cell_type": "code", "execution_count": null, @@ -1567,7 +1566,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7654f54f", + "id": "a149d57c", "metadata": {}, "outputs": [], "source": [] diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 751cba4947..d86376e69b 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -44,7 +44,7 @@ def __init__( self.name = name self.mode_evolution_oracle = mode_evolution_oracle self.mode_find_number_of_trottersuzuki_steps = True - self.eps_trottersuzuki = 0.1 + self.eps_trottersuzuki = 0.0001 self.please_be_verbose = False def __call__(self, t_duration: float = None): @@ -54,8 +54,23 @@ def __call__(self, t_duration: float = None): else: return self.circuit(t_duration=t_duration) - def circuit(self, t_duration: float = None): + def eval_unitary(self, t_duration): + """ This wraps around `circuit` and always returns a unitary""" + if self.mode_evolution_oracle is EvolutionOracleType.numerical: + return self.circuit(t_duration) + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + return self.circuit(t_duration).unitary() + else: + raise_error( + ValueError, + f"You are using an EvolutionOracle type which does not seem to return a unitary.", + ) + + + def circuit(self, t_duration: float = None): + """This function returns depending on `EvolutionOracleType` string, ndarray or `Circuit`. + In the hamiltonian_simulation mode we evaluate an appropriate Trotter-Suzuki discretization up to `self.eps_trottersuzuki` threshold.""" if self.mode_evolution_oracle is EvolutionOracleType.text_strings: return self.name + str(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.numerical: @@ -162,8 +177,6 @@ def __init__( assert isinstance(before_circuit, type(after_circuit)) - # if base_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation : - # assert type(before_circuit) is Circuit, str(type(before_circuit)) self.h = base_evolution_oracle.h self.base_evolution_oracle = base_evolution_oracle @@ -179,6 +192,7 @@ def circuit(self, t_duration: float = None): elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.before_circuit @ self.base_evolution_oracle(t_duration) @ self.after_circuit elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + return ( self.after_circuit + self.base_evolution_oracle.circuit(t_duration) @@ -189,7 +203,14 @@ def circuit(self, t_duration: float = None): ValueError, f"You are using an EvolutionOracle type which is not yet supported.", ) - + def get_composed_circuit(self): + c = self.circuit(0) + while isinstance(base_evolution_oracle, FrameShiftedEvolutionOracle): + if self.mode_evolution_oracle is EvolutionOracleType.numerical: + c = base_evolution_oracle.get_composed_unitary() @ c + elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + c = c + base_evolution_oracle.get_composed_unitary() + class DoubleBracketDiagonalAssociationType(Enum): """Define the evolution generator of a variant of the double-bracket iterations.""" diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index e5716ca9ab..e5ded44fbd 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -93,8 +93,8 @@ def __call__( # This will run the appropriate group commutator step double_bracket_rotation_step = self.group_commutator( - step_duration, diagonal_association - ) + step_duration, diagonal_association, mode_dbr = mode_dbr) + before_circuit = double_bracket_rotation_step["backwards"] after_circuit = double_bracket_rotation_step["forwards"] @@ -124,6 +124,20 @@ def __call__( raise_error(NotImplementedError) else: super().__call__(step, d) + def eval_gcr_unitary( + self, + step_duration: float, + eo1: EvolutionOracle, + eo2: EvolutionOracle = None, + mode_dbr: DoubleBracketRotationType = None, + ): + u = self.group_commutator( step_duration, eo1, eo2, mode_dbr = mode_dbr )["forwards"] + if eo1.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + return u.unitary() + elif eo1.mode_evolution_oracle is EvolutionOracleType.numerical: + return u + else: + raise_error(NotImplementedError) def group_commutator( self, From a2a2c5d846948885ad3f8118752120460f09399a Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 29 Apr 2024 17:11:07 +0200 Subject: [PATCH 095/116] cleaned up notebook and test file; next extract circuit and check that it gives a correct result --- ...volution_oracles_and_gci_transpiling.ipynb | 1567 +++++------------ tests/test_models_dbi.py | 145 +- 2 files changed, 582 insertions(+), 1130 deletions(-) diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb index ff4d9e29f4..00c2807a93 100644 --- a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb +++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb @@ -35,7 +35,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-29 12:14:42]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-29 17:10:31]: Using numpy backend on /CPU:0\n" ] } ], @@ -47,349 +47,210 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "6095d17a", + "cell_type": "markdown", + "id": "9bb4a0a0", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-29 14:45:18]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-29 14:45:19]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "eith diff 1.5712440057340736e-07\n", - "U dbr diff 1.1569097113412146e-05\n", - "h diff 3.3021307730058864e-05\n", - "sigma dbi 5.60100317946555\n", - "sigma gci 5.601003185838881\n", - "eith diff 2.881755892359207e-07\n", - "U dbr diff 1.1124982181225484e-05\n", - "h diff 6.476110230712104e-05\n", - "sigma dbi 5.546955161050127\n", - "sigma gci 5.546955233970926\n", - "eith diff 5.843412359673229e-07\n", - "U dbr diff 1.0710955536295385e-05\n", - "h diff 9.525342119986412e-05\n", - "sigma dbi 5.494680926176547\n", - "sigma gci 5.494681200037203\n", - "eith diff 8.81222405885465e-07\n", - "U dbr diff 1.0325625670392596e-05\n", - "h diff 0.00012453892531827423\n", - "sigma dbi 5.44411695218482\n", - "sigma gci 5.444117625508951\n", - "eith diff 1.169127621411016e-06\n", - "U dbr diff 9.967311672226913e-06\n", - "h diff 0.00015266248434895235\n", - "sigma dbi 5.395180752751458\n", - "sigma gci 5.395182076480832\n", - "eith diff 1.4466560682228037e-06\n", - "U dbr diff 9.634155420969876e-06\n", - "h diff 0.00017967130915922002\n", - "sigma dbi 5.3477817719619924\n", - "sigma gci 5.347784037232165\n" - ] - } - ], "source": [ - "def test_gci_frame_shifted_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation):\n", + "# Test frame shifted oracles\n", "\n", - " h_x = SymbolicHamiltonian(\n", - " symbols.X(0)\n", - " + symbols.Z(0) * symbols.X(1)\n", - " + symbols.Y(2)\n", - " + symbols.Y(1) * symbols.Y(2),\n", - " nqubits=3,\n", - " )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - " h_input = h_x + d_0\n", - "\n", - " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "\n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle) \n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "In a group commutator iteration (GCI) we have\n", + "$$J_{k+1}= U_k^\\dagger J_k U_k$$\n", + "which is obtained by a product formula for $U_k$.\n", + "We will use two examples\n", + "$$A_k = e^{is D} e^{is J_k} e^{-isD}$$\n", + "and\n", + "$$B_k = e^{-is J_k}e^{is D} e^{is J_k} e^{-isD}$$\n", + "In both cases $D$ is fixed, which amounts to a product formula approximation of the BHMM scheme.\n", "\n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle)\n", - "\n", - " from numpy.linalg import norm\n", - "\n", - " r = .01\n", - " for _ in range(7):\n", - " a = dbi.h.exp(r)\n", - " b = gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)\n", - " print( \"eith diff\", norm( a - b))\n", - " a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", - " b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", - " print(\"U dbr diff\",norm( a - b))\n", - "\n", - " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", - " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", - " \n", - " k_r = dbi.h.matrix\n", - " j_r = gci.h.matrix\n", - " print('h diff',norm(k_r-j_r))\n", + "For $B_k$ we have the group commutator bound, see below. For $A_k$ we will have that\n", + "$$J_{k+1}= A_k^\\dagger J_k A_k= B_k^\\dagger J_k B_k$$\n", + "because of a reduction by means of a commutator vanishing (the ordering was chosen on purpose).\n", "\n", - " print(\"sigma dbi\", norm(dbi.sigma(k_r)))\n", - " print(\"sigma gci\", norm(dbi.sigma(j_r)))\n", + "This means that $A_k$ and $B_k$ schemes should give the same `GroupCommutatorIterationWithEvolutionOracles.h`. Additionally that should be also `DoubleBracketIteration.h` as long as the ordering is correct.\n", "\n", - " \n", - "test_gci_frame_shifted_oracles(backend,nqubits)" + "If we operate in the `EvolutionOracleType.hamiltonian_simulation` there will be deviations based on the `EvolutionOracle.eps_trottersuzuki` threshold.\n" ] }, { "cell_type": "code", "execution_count": 3, - "id": "21f87059", - "metadata": { - "scrolled": true - }, + "id": "d65bc873", + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-29 12:14:42]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-29 12:14:42]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:31]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:31]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "eval ab 4.460072397196506e-05\n", - "evolution eith 9.092521730556182e-05\n", - "eval dbr diff 4.460072397196506e-05\n", - "h diff 0.00014214956955464143\n", - "eval gcr 4.127345219458045e-05\n", - "evolution eith 7.632202655334346e-05\n" + "def test_gci_frame_shifted_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation):\n", + " \"\"\"In a group commutator iteration (GCI) we have\n", + "$$J_{k+1}= U_k^\\dagger J_k U_k$$\n", + "which is obtained by a product formula for $U_k$.\n", + "We will use two examples\n", + "$$A_k = e^{is D} e^{is J_k} e^{-isD}$$\n", + "\n", + "This means that $A_k$ and $B_k$ schemes should give the same `Groupand\n", + "$$B_k = e^{-is J_k}e^{is D} e^{is J_k} e^{-isD}$$\n", + "In both cases $D$ is fixed, which amounts to a product formula approximation of the BHMM scheme.\n", + "\n", + "For $B_k$ we have the group commutator bound, see below. For $A_k$ we will have that\n", + "$$J_{k+1}= A_k^\\dagger J_k A_k= B_k^\\dagger J_k B_k$$\n", + "because of a reduction by means of a commutator vanishing (the ordering was chosen on purpose).\n", + "CommutatorIterationWithEvolutionOracles.h`. Additionally that should be also `DoubleBracketIteration.h` as long as the ordering is correct.\n", + "\n", + "If we operate in the `EvolutionOracleType.hamiltonian_simulation` there will be deviations based on the `EvolutionOracle.eps_trottersuzuki` threshold.\"\"\"\n", + " \n", + " h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + " )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " h_input = h_x + d_0\n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle) \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle)\n", + "\n", + " from numpy.linalg import norm\n", + " \n", + " if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:\n", + " threshold = evolution_oracle.eps_trottersuzuki * 10\n", + " else:\n", + " threshold = 1e-12\n", + " \n", + " r = .01\n", + " for _ in range(3):\n", + " a = dbi.h.exp(r)\n", + " b = gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)\n", + "\n", + " assert norm(a-b) < threshold\n", + " a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", + " b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", + "\n", + " assert norm(a-b) < threshold\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " \n", + " k_r = dbi.h.matrix\n", + " j_r = gci.h.matrix\n", + "\n", + " assert norm(a-b) < threshold\n", + " \n", + " assert norm(norm(dbi.sigma(k_r))-norm(dbi.sigma(j_r))) < threshold\n", + "\n" ] } ], "source": [ - "eo_mode = EvolutionOracleType.hamiltonian_simulation\n", - "r= 0.1\n", - "\n", - "h_x = SymbolicHamiltonian(\n", - " symbols.X(0)\n", - " + symbols.Z(0) * symbols.X(1)\n", - " + symbols.Y(2)\n", - " + symbols.Y(1) * symbols.Y(2),\n", - " nqubits=3,\n", - ")\n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - "h_input = h_x + d_0\n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "\n", - "evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = eo_mode ) \n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = eo_mode)\n", - "from numpy.linalg import norm\n", + "print_function_source_code(test_gci_frame_shifted_oracles) \n", "\n", - "r=0.2\n", - "\n", - "a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", - "b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", - "print(\"eval ab\", norm(a-b))\n", - "\n", - "\n", - "print('evolution eith',norm(dbi.h.exp(r)\n", - " -\n", - " gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)))\n", - "a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", - "b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", - "print(\"eval dbr diff\", norm(a-b))\n", - "\n", - "dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) \n", - "\n", - "gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", - "k_r = dbi.h.matrix\n", - "j_r = gci.h.matrix\n", - "\n", - "print('h diff',norm(k_r-j_r))\n", - "\n", - "a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n", - "b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n", - "print(\"eval gcr\", norm(a-b))\n", - "\n", - "print('evolution eith',norm(dbi.h.exp(r)\n", - " -\n", - " gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)))" + "test_gci_frame_shifted_oracles(backend,nqubits)" + ] + }, + { + "cell_type": "markdown", + "id": "47301c6c", + "metadata": {}, + "source": [ + "The regular implementation in `DoubleBracketIteration` should be viewed as using classical dynamic programming: memoization of the updated Hamiltonian is used explicitly. Instead, using `FrameShiftedEvolutionOracle` we can store a sequence of recursive rotations such that eventually the iteration gives the same result.\n", + " This function tests numerical agreement using the numpy backend." ] }, { "cell_type": "code", "execution_count": 4, - "id": "548aafac", + "id": "b4004f8f", "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 't_step' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_63614/4039678752.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;31m#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mu_gc_from_oracles\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_commutator\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mt_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevolution_oracle_diagonal_target\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mu_gci\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mu_gc_from_oracles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'forwards'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 't_step' is not defined" + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "def test_gci_implementation_normal_and_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.numerical):\n", + " \"\"\"The regular implementation in `DoubleBracketIteration` should be viewed as using classical dynamic programming: memoization of the updated Hamiltonian is used explicitly. Instead, using `FrameShiftedEvolutionOracle` we can store a sequence of recursive rotations such that eventually the iteration gives the same result.\n", + " This function tests numerical agreement using the numpy backend.\n", + " \"\"\"\n", + " h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + " ) \n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " h_input = h_x + d_0\n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle) \n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle)\n", + "\n", + " from numpy.linalg import norm\n", + "\n", + " times = np.linspace(1e-5,1,5)\n", + " for r in times:\n", + "\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " k_r = dbi.h.matrix\n", + " dbi.h = deepcopy(h_input.dense) \n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " j_r = gci.h.matrix\n", + " gci.h = deepcopy(h_input.dense) \n", + " gci.iterated_hamiltonian_evolution_oracle = deepcopy(evolution_oracle) \n", + "\n", + " assert norm(k_r-j_r) < 1e-12\n", + "\n", + " r = 1\n", + " for _ in range(3):\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + " k_r = dbi.h.matrix\n", + " j_r = gci.h.matrix\n", + " \n", + " assert norm(k_r-j_r) < 1e-12 \n", + "\n" ] } ], "source": [ - "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical) \n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - "\n", - "u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) \n", - "u_gci = u_gc_from_oracles['forwards']\n", - "\n", - "assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", - "\n", - "\n", - "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", - "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", - "norms_bound = 0.5*t_step**1.48 * (\n", - " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", - ")\n", - "assert norm(v_exact - u_gci) < norms_bound\n", - "u_gcr = gci.eval_gcr_unitary(t_step,evolution_oracle_diagonal_target )\n", - "assert norm(v_exact - u_gcr) < norms_bound\n", - "print(norm(v_exact-u_gcr))\n", - "print(norm(dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)-u_gci))\n", - "gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", - "\n", - "j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n", - "assert norm(dbi.h.matrix-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", - " \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a58b6c7b", - "metadata": {}, - "outputs": [], - "source": [ - "dbi = DoubleBracketIteration(deepcopy(h_input.dense)) \n", - "evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - "evolution_oracle.eps_trottersuzuki = 1e-9\n", - "evolution_oracle_diagonal_target.eps_trottersuzuki = 1e-9\n", - "r = .\n", - "for _ in range(3):\n", - " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", - " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", - " k_r = dbi.h.matrix\n", - " j_r = gci.h.matrix\n", + "print_function_source_code(test_gci_implementation_normal_and_oracles)\n", "\n", - " print(norm(k_r-j_r))\n", - " print(norm(dbi.sigma(k_r)))\n", - " print(norm(dbi.sigma(j_r)))\n", - " assert norm(k_r-j_r) < 1e-12 " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b4004f8f", - "metadata": {}, - "outputs": [], - "source": [ - "test_gci_implementations_normal_and_oracles(backend,nqubits)" + " \n", + "test_gci_implementation_normal_and_oracles(backend,nqubits, mode_evolution_oracle = EvolutionOracleType.numerical)" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "1598800e", + "cell_type": "markdown", + "id": "d9771f86", "metadata": {}, - "outputs": [], "source": [ - "def test_gci_implementations_normal_and_oracles(backend,nqubits):\n", - "\n", - " h_x = SymbolicHamiltonian(\n", - " symbols.X(0)\n", - " + symbols.Z(0) * symbols.X(1)\n", - " + symbols.Y(2)\n", - " + symbols.Y(1) * symbols.Y(2),\n", - " nqubits=3,\n", - " )\n", - " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", - " h_input = h_x + d_0\n", - "\n", - " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "\n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.numerical) \n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "\n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", - "\n", - " from numpy.linalg import norm\n", - "\n", - " times = np.linspace(1e-5,1,5)\n", - " for r in times:\n", - "\n", - " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", - " k_r = dbi.h.matrix\n", - " dbi.h = deepcopy(h_input.dense) \n", - " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", - " j_r = gci.h.matrix\n", - " gci.h = deepcopy(h_input.dense) \n", - " gci.iterated_hamiltonian_evolution_oracle = deepcopy(evolution_oracle) \n", - "\n", - " assert norm(k_r-j_r) < 1e-12\n", - "\n", - " r = 1\n", - " for _ in range(3):\n", - " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", - " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", - " k_r = dbi.h.matrix\n", - " j_r = gci.h.matrix\n", - " \n", - " assert norm(k_r-j_r) < 1e-12 \n", - " \n", - " \n", - " dbi = DoubleBracketIteration(deepcopy(h_input.dense)) \n", - " evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation) \n", - " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "\n", - " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - " evolution_oracle.eps_trottersuzuki = 1e-9\n", - " evolution_oracle_diagonal_target.eps_trottersuzuki = 1e-9\n", - " r = 1\n", - " for _ in range(3):\n", - " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", - " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", - " k_r = dbi.h.matrix\n", - " j_r = gci.h.matrix\n", - " \n", - " print(norm(k_r-j_r))\n", - " print(norm(dbi.sigma(k_r)))\n", - " print(norm(dbi.sigma(j_r)))\n", - " assert norm(k_r-j_r) < 1e-12 \n", - " \n", - "test_gci_implementations_normal_and_oracles(backend,nqubits)" + "#### Remark:\n", + "If Hamiltonian_simulation is used as the mode then the eps_trottersuzuki might be too law to pass this assertion." ] }, { @@ -424,22 +285,108 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "7e99a090", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps):\n", + " \"\"\"\n", + "\n", + " This is testing the following:\n", + "\n", + " `dbi_exact` runs $V_{exact} = e^{-sW}$ and rotates $H_1 = V_{exact}^\\dagger H_0 V_{exact}$.\n", + "\n", + " `dbi_GC` runs $V_{GC} = GC$ and rotates $K_1 = V_{GC}^\\dagger H_0 V_{GC}$.\n", + "\n", + " We assert that dbi_exact and dbi_GC should be within the approximation bound of the GC\n", + " $$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n", + "\n", + " `gci` runs $V_{EO,GC} = GC$ and rotates $J_1 = V_{EO,GC}^\\dagger H_0 V_{EO,GC}$.\n", + "\n", + " We assert that gci and dbi2 should be within machine precision for the correct sorting.\n", + " $$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n", + " \"\"\"\n", + " from numpy.linalg import norm\n", + " h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + " nqubits=3,\n", + " )\n", + " d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + " h_input = h_x + d_0\n", + "\n", + " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + " w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n", + " norms_bound = 0.5*t_step**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n", + " )\n", + "\n", + " v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n", + " v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n", + " assert norm(v_exact - v_gc) < norms_bound\n", + "\n", + " dbi(t_step, d = d_0.dense.matrix )\n", + " h_1 = dbi.h.matrix\n", + "\n", + " dbi.h = deepcopy(h_input.dense)\n", + " dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " k_1 = dbi.h.matrix\n", + "\n", + " assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", + "\n", + " evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical) \n", + "\n", + " evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle = EvolutionOracleType.numerical)\n", + "\n", + " gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + " u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target )\n", + " assert norm(u_gc_from_oracles['forwards'].conj().T - u_gc_from_oracles['backwards']) < 1e-12\n", + "\n", + " assert norm(v_exact - gci.eval_gcr_unitary(t_step, evolution_oracle_diagonal_target)) < norms_bound\n", + "\n", + " gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n", + " j_1 = gci.h.matrix\n", + "\n", + " assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound \n", + "\n", + " assert norm(j_1-k_1) < 1e-12\n", + "\n" + ] + } + ], "source": [ "print_function_source_code(test_gci_evolution_oracles_types_numerical)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "583ca695", - "metadata": {}, - "outputs": [], + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "t_step =0.01\n", "eps = 1e-2\n", @@ -461,10 +408,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "a2c2422b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "/home/marek/.local/lib/python3.10/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", + " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n", + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:35]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "h_x = SymbolicHamiltonian(\n", " symbols.X(0)\n", @@ -530,10 +510,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "40308fc2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-29 17:10:36]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.007946732303441253\n", + "0.0\n" + ] + } + ], "source": [ "\n", "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", @@ -577,10 +573,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "2b895267", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "r=0.01\n", "\n", @@ -613,10 +644,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "ec6361ca", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "def test_exact_dbr_vs_gc_bound(nqubits,backend):\n", " dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", @@ -650,19 +694,56 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "8ecce261", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@pytest.mark.parametrize(\"nqubits\", [3])\n", + "def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits):\n", + " r\"\"\"The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$ which we check by a loglog fit.\"\"\"\n", + " h0 = random_hermitian(2**nqubits, backend=backend)\n", + " d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))\n", + " dbi = DoubleBracketIteration(\n", + " Hamiltonian(nqubits, h0, backend=backend),\n", + " mode=DoubleBracketGeneratorType.group_commutator,\n", + " )\n", + "\n", + " times = np.linspace(0.001, 0.01, 10)\n", + " norms = []\n", + " norms_bound = []\n", + " for s in times:\n", + " u = dbi.eval_dbr_unitary(\n", + " s, d=d, mode=DoubleBracketGeneratorType.single_commutator\n", + " )\n", + " v = dbi.eval_dbr_unitary(\n", + " s, d=d, mode=DoubleBracketGeneratorType.group_commutator\n", + " )\n", + "\n", + " norms.append(np.linalg.norm(u - v) )\n", + " w = dbi.commutator(h0,d)\n", + " norms_bound.append(0.5*s**1.48 * (\n", + " np.linalg.norm(dbi.commutator(h0,w)) + np.linalg.norm(dbi.commutator(d,w))\n", + " ))\n", + " assert np.linalg.norm(u - v) < 10 * s**1.49 * (\n", + " np.linalg.norm(h0) + np.linalg.norm(d)\n", + " ) * np.linalg.norm(h0) * np.linalg.norm(d)\n", + "\n" + ] + } + ], "source": [ "print_function_source_code(test_double_bracket_iteration_eval_dbr_unitary)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "bcfab105", "metadata": { "scrolled": true @@ -682,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "d4cff4ad", "metadata": {}, "outputs": [], @@ -729,7 +810,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "05128816", "metadata": {}, "outputs": [], @@ -749,10 +830,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "62c60671", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(norms)\n", @@ -761,10 +865,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "038df7d5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.loglog(times,norms)\n", "plt.loglog(times,norms_bound)" @@ -780,796 +907,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "6cd3e03b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.49083955, 3.49249848])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "popt" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d0f05dfe", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "70ac58a2", - "metadata": {}, - "source": [ - "# Check the convergence of the Trotter-Suzuki Hamiltonian simulation oracle\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "54efc9de", - "metadata": {}, - "outputs": [], - "source": [ - "print_function_source_code(test_dbi_evolution_oracle)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "69456994", - "metadata": {}, - "outputs": [], - "source": [ - "test_dbi_evolution_oracle(backend,nqubits,1 ,1e-2)" - ] - }, - { - "cell_type": "markdown", - "id": "392a7c7c", - "metadata": {}, - "source": [ - "This was just a check to see if using the circuit method works. Then covering the numerical and text flag." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e20f72df", - "metadata": {}, - "outputs": [], - "source": [ - "t_step = 1\n", - "def check_hs_eps(eps):\n", - " evolution_oracle_hamiltonian_simulation.eps_trottersuzuki = eps\n", - " U_hamiltonian_simulation = evolution_oracle_hamiltonian_simulation.circuit(t_step).unitary()\n", - " V_target = h_input.exp(t_step)\n", - " print(eps,norm(U_hamiltonian_simulation-V_target))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "32f515a0", - "metadata": {}, - "outputs": [], - "source": [ - "check_hs_eps(0.1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3640b862", - "metadata": {}, - "outputs": [], - "source": [ - "check_hs_eps(.001)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "51de5892", - "metadata": {}, - "outputs": [], - "source": [ - "check_hs_eps(1e-4)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "acb49e83", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "da441e93", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))\n", - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "26b4c66a", - "metadata": {}, - "outputs": [], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.h" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "72bdc7a7", - "metadata": {}, - "outputs": [], - "source": [ - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6635da98", - "metadata": {}, - "outputs": [], - "source": [ - "for a in DoubleBracketRotationType:\n", - " print(a.name)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d4407257", - "metadata": {}, - "outputs": [], - "source": [ - "def test_gc_numerical_vs_circuit(eps):\n", - " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", - " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", - " \n", - " gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = False\n", - " evolution_oracle_diagonal_target.please_be_verbose = False\n", - " \n", - "\n", - " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_reduced\n", - "\n", - " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", - "\n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - "\n", - " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),d_0.dense.matrix)\n", - "\n", - " bckwd = unitary_gc_from_oracles['backwards']\n", - " fwd = unitary_gc_from_oracles['forwards']\n", - "\n", - " e1 = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step))\n", - " e2 = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step))\n", - "\n", - " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - "\n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association = evolution_oracle_diagonal_target )\n", - "\n", - " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),d_0.dense.matrix)\n", - "\n", - " bckwdhs = unitary_gc_from_oracles['backwards'].unitary()\n", - " fwdhs = unitary_gc_from_oracles['forwards'].unitary()\n", - "\n", - " e1hs = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step)).unitary()\n", - " e2hs = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step)).unitary()\n", - "\n", - " print(\"e1:\", norm( e1hs-e1))\n", - " print(\"e2:\", norm(e2hs-e2))\n", - " print(\"Testing inversion forwards:\", norm(bckwd-bckwdhs))\n", - " print(\"Testing inversion backwards:\", norm(fwd - fwdhs))\n", - "\n", - "test_gc_numerical_vs_circuit(0.1)\n", - "\n", - "test_gc_numerical_vs_circuit(0.0001)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2a173296", - "metadata": {}, - "outputs": [], - "source": [ - "def test_group_commutator_against_itself(gci, evolution_diagonal,eps = 0.0001):\n", - " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", - " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", - " for s in np.linspace(0,1,5):\n", - " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - " evolution_diagonal.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - " gc_hs = gci.group_commutator(s,evolution_diagonal)\n", - " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " evolution_diagonal.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " gc_np = gci.group_commutator(s,evolution_diagonal)\n", - " print(norm(gc_np['forwards']-gc_hs['forwards'].unitary()))\n", - " print(norm(gc_np['backwards']-gc_hs['backwards'].unitary()))\n", - "\n", - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator \n", - "test_group_commutator_against_itself(gci, evolution_oracle_diagonal_target)\n", - "\n", - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting \n", - "test_group_commutator_against_itself(gci, evolution_oracle_diagonal_target)\n", - "\n", - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_reduced \n", - "test_group_commutator_against_itself(gci, evolution_oracle_diagonal_target)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "93ee9d5e", - "metadata": {}, - "outputs": [], - "source": [ - "def test_gc_numerical_vs_bracket(eps = 0.3):\n", - " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", - " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", - " \n", - " gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = False\n", - " evolution_oracle_diagonal_target.please_be_verbose = False\n", - " \n", - "\n", - " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - "\n", - " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", - "\n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - "\n", - " import scipy\n", - " unitary_gc_existing1 = scipy.linalg.expm( t_step * (d_0.dense.matrix @ h_x.dense.matrix\n", - " -h_x.dense.matrix@d_0.dense.matrix))\n", - "\n", - " bckwd = unitary_gc_from_oracles['backwards']\n", - " fwd = unitary_gc_from_oracles['forwards']\n", - "\n", - " e1 = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step))\n", - " e2 = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step))\n", - "\n", - " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - "\n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - "\n", - " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),-d_0.dense.matrix)\n", - "\n", - " bckwdhs = unitary_gc_from_oracles['backwards'].unitary()\n", - " fwdhs = unitary_gc_from_oracles['forwards'].unitary()\n", - "\n", - " e1hs = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step)).unitary()\n", - " e2hs = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step)).unitary()\n", - " print(\"Test:\", norm(unitary_gc_existing-unitary_gc_existing1))\n", - " print(\"e1:\", norm( e1hs-e1))\n", - " print(\"e2:\", norm(e2hs-e2))\n", - " print(\"Testing inversion forwards:\", norm(bckwd-bckwdhs))\n", - " print(\"Testing inversion backwards:\", norm(fwd - fwdhs))\n", - "\n", - "test_gc_numerical_vs_bracket(0.1)\n", - "\n", - "test_gc_numerical_vs_bracket(0.0001)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d2f19ef9", - "metadata": {}, - "outputs": [], - "source": [ - "def gc_hs_eps(eps):\n", - " gci.iterated_hamiltonian_evolution_oracle.eps_trottersuzuki = eps\n", - " evolution_oracle_diagonal_target.eps_trottersuzuki = eps\n", - " \n", - " gci.iterated_hamiltonian_evolution_oracle.please_be_verbose = True\n", - " evolution_oracle_diagonal_target.please_be_verbose = False\n", - " \n", - " gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - " evolution_oracle_diagonal_target.mode_evolution_oracle = EvolutionOracleType.numerical\n", - "\n", - " gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - " \n", - " unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - " \n", - " unitary_gc_existing = wrapper_gc(dbi, np.sqrt(t_step),-d_0.dense.matrix)\n", - " \n", - " bckwd = unitary_gc_from_oracles['backwards']\n", - " fwd = unitary_gc_from_oracles['forwards']\n", - " \n", - " e1 = gci.iterated_hamiltonian_evolution_oracle.circuit(np.sqrt(t_step))\n", - " e2 = evolution_oracle_diagonal_target.circuit(np.sqrt(t_step))\n", - " \n", - " print(\"Backwards:\", norm( bckwd - unitary_gc_existing))\n", - " print(\"Forwards:\", norm(fwd - unitary_gc_existing))\n", - " print(\"Testing inversion forwards:\", norm(fwd - e2.conj().T @ e1.conj().T @ e2 @e1))\n", - " print(\"Testing inversion backwards:\", norm(bckwd - e2.conj().T @ e1.conj().T @ e2 @e1))\n", - " print(\"Testing inversion forwards:\", norm(fwd - e1.conj().T @ e2.conj().T @ e1 @e2))\n", - " print(\"Testing inversion backwards:\", norm(bckwd - e1.conj().T @ e2.conj().T @ e1 @e2))\n", - " print(\"Testing inversion forwards:\", norm(fwd - e1@e2@ e1.conj().T @ e2.conj().T ))\n", - " print(\"Testing inversion backwards:\", norm(bckwd - e1@e2@e1.conj().T @ e2.conj().T ))\n", - " print(\"Testing inversion forwards:\", norm(fwd - e1.conj().T@e2@ e1 @ e2.conj().T ))\n", - " print(\"Testing inversion backwards:\", norm(bckwd - e1.conj().T@e2@e1 @ e2.conj().T ))\n", - " print(\"Testing reversal:\", norm(bckwd@fwd - unitary_gc_existing @unitary_gc_existing.T.conj() ))\n", - " print(\"Testing reversal:\", norm(bckwd@fwd - e1@e1.conj().T ))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ae8e83bf", - "metadata": {}, - "outputs": [], - "source": [ - "gc_hs_eps(0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "5dcc9f04", - "metadata": {}, - "source": [ - "We may improve the discrepancy by setting smaller eps" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b1bf92e2", - "metadata": {}, - "outputs": [], - "source": [ - "gc_hs_eps(0.0001)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f12288b0", - "metadata": {}, - "outputs": [], - "source": [ - "norm(unitary_gc_from_oracles['forwards'].unitary() - unitary_gc_existing)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "77579bc5", - "metadata": {}, - "outputs": [], - "source": [ - "norm(unitary_gc_from_oracles['backwards'].unitary() - unitary_gc_existing)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0128e99d", - "metadata": {}, - "outputs": [], - "source": [ - "stop" - ] - }, - { - "cell_type": "markdown", - "id": "a3504871", - "metadata": {}, - "source": [ - "#### Test more explicitly\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "642cbce1", - "metadata": {}, - "outputs": [], - "source": [ - "u_h = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", - "u_d = evolution_oracle_diagonal_target.circuit( np.sqrt(t_step)).unitary()\n", - "u_h_reversed = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", - "u_d_reversed = evolution_oracle_diagonal_target.circuit( -np.sqrt(t_step)).unitary()\n", - "norm( u_h_reversed @ u_d_reversed @ u_h @ u_d - unitary_gc_existing)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6edaa7bb", - "metadata": {}, - "outputs": [], - "source": [ - "u_h = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step))\n", - "u_d = evolution_oracle_diagonal_target.circuit( np.sqrt(t_step))\n", - "u_h_reversed = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step))\n", - "u_d_reversed = evolution_oracle_diagonal_target.circuit( -np.sqrt(t_step))\n", - "norm( (u_h_reversed + u_d_reversed + u_h + u_d).unitary() - unitary_gc_existing)" - ] - }, - { - "cell_type": "markdown", - "id": "b56f305f", - "metadata": {}, - "source": [ - "#### 3. Evolution oracle numpy\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1b6f6c17", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_numerical = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_numerical ))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e3bec576", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.numerical)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f14d3133", - "metadata": {}, - "outputs": [], - "source": [ - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )" - ] - }, - { - "cell_type": "markdown", - "id": "6256dc33", - "metadata": {}, - "source": [ - "Compared to the group commutator using Hamiltonian simulation there will be small deviations that arise from Trotter-Suzuki decomposition" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5ab01c82", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "norm(unitary_gc_from_oracles['backwards'] - unitary_gc_existing)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5d3354a8", - "metadata": {}, - "outputs": [], - "source": [ - "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" - ] - }, - { - "cell_type": "markdown", - "id": "26dfc6ac", - "metadata": {}, - "source": [ - "We may check by switching the group commutator flag that the difference comes from ordering and inversions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2e43555b", - "metadata": {}, - "outputs": [], - "source": [ - "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_other_sorting\n", - "\n", - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle = evolution_oracle_diagonal_target )\n", - "norm(unitary_gc_from_oracles['forwards'] - unitary_gc_existing)" - ] - }, - { - "cell_type": "markdown", - "id": "d6a735d4", - "metadata": {}, - "source": [ - "#### 4. Check gci rotation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5471e516", - "metadata": {}, - "outputs": [], - "source": [ - "evolution_oracle_hamiltonian_simulation = EvolutionOracle(deepcopy(h_input), \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation)\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle_hamiltonian_simulation ))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7a7ac8f4", - "metadata": {}, - "outputs": [], - "source": [ - "type(gci.iterated_hamiltonian_evolution_oracle)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d30c7558", - "metadata": {}, - "outputs": [], - "source": [ - "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1fe303d2", - "metadata": {}, - "outputs": [], - "source": [ - "type(gci.iterated_hamiltonian_evolution_oracle)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6ab13137", - "metadata": {}, - "outputs": [], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ca82a687", - "metadata": {}, - "outputs": [], - "source": [ - "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cd4f541d", - "metadata": {}, - "outputs": [], - "source": [ - "norm( dbi.h.exp(t_step) - u_frame_shifted)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "67257043", - "metadata": {}, - "outputs": [], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "feb5fde9", - "metadata": {}, - "outputs": [], - "source": [ - "gci(t_step, diagonal_association=evolution_oracle_diagonal_target)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "95de4c31", - "metadata": {}, - "outputs": [], - "source": [ - "dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2bcc8f07", - "metadata": {}, - "outputs": [], - "source": [ - "u_frame_shifted = gci.iterated_hamiltonian_evolution_oracle.circuit(t_step).unitary()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eafa1770", - "metadata": {}, - "outputs": [], - "source": [ - "norm( dbi.h.exp(t_step) - u_frame_shifted)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "05e94ce8", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ed2b81e1", - "metadata": {}, - "outputs": [], - "source": [ - "for k in range(3):\n", - " gci(t_step, diagonal_association=evolution_oracle_diagonal_target)\n", - " dbi(t_step, d = evolution_oracle_diagonal_target.h.dense.matrix)\n", - " print(norm( dbi.h.exp(t_step) - u_frame_shifted))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "15d96e82", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3fdf49bd", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9130482b", - "metadata": {}, - "outputs": [], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "de46b823", - "metadata": {}, - "outputs": [], - "source": [ - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.numerical\n", - "gc_numpy = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.numerical))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d4f78e3a", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e4d23962", - "metadata": {}, - "outputs": [], - "source": [ - "## Test more fancy functionalities\n", - "input_hamiltonian_evolution_oracle_hamiltonian_simulation.please_be_verbose = False\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(input_hamiltonian_evolution_oracle_hamiltonian_simulation ))\n", - "d_ev = EvolutionOracle(d_0, \"D0\",mode_evolution_oracle=EvolutionOracleType.hamiltonian_simulation)\n", - "\n", - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", - "query_list = gci.group_commutator( np.sqrt(t_step),\n", - " diagonal_association_evolution_oracle= d_ev )\n", - "\n", - "norm(query_list['forwards'].unitary() -query_list['backwards'].unitary().conj().T)\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2e69dc0b", - "metadata": {}, - "outputs": [], - "source": [ - "norm(query_list['forwards'] -query_list['backwards'].T.conj())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bfee7994", - "metadata": {}, - "outputs": [], - "source": [ - "#Test file entry\n", - "u = gci.iterated_hamiltonian_evolution_oracle.circuit( np.sqrt(t_step)).unitary()\n", - "u2 = gci.iterated_hamiltonian_evolution_oracle.circuit( -np.sqrt(t_step)).unitary()\n", - "norm(u-u2.T.conj())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "527bb789", - "metadata": {}, - "outputs": [], - "source": [ - "d_0.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - "gci.iterated_hamiltonian_evolution_oracle.mode_evolution_oracle = EvolutionOracleType.text_strings\n", - "query_list = gci.group_commutator( np.sqrt(t_step*2),\n", - " diagonal_association_evolution_oracle= EvolutionOracle(d_0, \"D0\"))\n", - "\n", - "\n", - "query_list['forwards']" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a149d57c", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index e26fdcda84..9166481407 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -146,9 +146,7 @@ def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps): We assert that gci and dbi2 should be within machine precision for the correct sorting. $$||J_1-K_1||\le2 ||H_0||\,||R-Q||\le \epsilon$$ """ - from numpy.linalg import norm - h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) @@ -161,8 +159,14 @@ def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps): dbi = DoubleBracketIteration(deepcopy(h_input.dense)) + w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix) + norms_bound = 0.5*t_step**1.48 * ( + np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w)) + ) + v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator) v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator) + assert norm(v_exact - v_gc) < norms_bound dbi(t_step, d = d_0.dense.matrix ) h_1 = dbi.h.matrix @@ -171,45 +175,138 @@ def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps): dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) k_1 = dbi.h.matrix - w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix) - norms_bound = 0.5*t_step**1.48 * ( - np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w)) - ) - assert norm(v_exact - v_gc) < norms_bound assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle = EvolutionOracleType.numerical) - d_02 = SymbolicHamiltonian(symbols.Z(0), nqubits=3) - evolution_oracle_diagonal_target = EvolutionOracle(d_02, "D0", - mode_evolution_oracle = EvolutionOracleType.numerical) + + evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", + mode_evolution_oracle = EvolutionOracleType.numerical) gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle )) - #gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator - u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) - u_gci = u_gc_from_oracles['forwards'] + u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) + assert norm(u_gc_from_oracles['forwards'].conj().T - u_gc_from_oracles['backwards']) < 1e-12 - assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12 + assert norm(v_exact - gci.eval_gcr_unitary(t_step, evolution_oracle_diagonal_target)) < norms_bound + gci(t_step, diagonal_association= evolution_oracle_diagonal_target ) + j_1 = gci.h.matrix - v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator) - w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix) - norms_bound = 0.5*t_step**1.48 * ( - np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w)) - ) - assert norm(v_exact - u_gci) < norms_bound + assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound - gci(t_step, diagonal_association= evolution_oracle_diagonal_target ) - j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix - assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound - assert norm(j_1-k_1) < 1e-12 + assert norm(j_1-k_1) < 1e-12 + + +def test_gci_frame_shifted_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation): + """In a group commutator iteration (GCI) we have +$$J_{k+1}= U_k^\dagger J_k U_k$$ +which is obtained by a product formula for $U_k$. +We will use two examples +$$A_k = e^{is D} e^{is J_k} e^{-isD}$$ + +This means that $A_k$ and $B_k$ schemes should give the same `Groupand +$$B_k = e^{-is J_k}e^{is D} e^{is J_k} e^{-isD}$$ +In both cases $D$ is fixed, which amounts to a product formula approximation of the BHMM scheme. + +For $B_k$ we have the group commutator bound, see below. For $A_k$ we will have that +$$J_{k+1}= A_k^\dagger J_k A_k= B_k^\dagger J_k B_k$$ +because of a reduction by means of a commutator vanishing (the ordering was chosen on purpose). +CommutatorIterationWithEvolutionOracles.h`. Additionally that should be also `DoubleBracketIteration.h` as long as the ordering is correct. + +If we operate in the `EvolutionOracleType.hamiltonian_simulation` there will be deviations based on the `EvolutionOracle.eps_trottersuzuki` threshold.""" + + h_x = SymbolicHamiltonian( + symbols.X(0) + + symbols.Z(0) * symbols.X(1) + + symbols.Y(2) + + symbols.Y(1) * symbols.Y(2), + nqubits=3, + ) + d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3) + h_input = h_x + d_0 + + dbi = DoubleBracketIteration(deepcopy(h_input.dense)) + + evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle) + gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle )) + + evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", + mode_evolution_oracle) + + from numpy.linalg import norm + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + threshold = evolution_oracle.eps_trottersuzuki * 10 + else: + threshold = 1e-12 + r = .01 + for _ in range(3): + a = dbi.h.exp(r) + b = gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r) + + assert norm(a-b) < threshold + a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator) + b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target) + + assert norm(a-b) < threshold + dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) + gci(r, diagonal_association= evolution_oracle_diagonal_target ) + + k_r = dbi.h.matrix + j_r = gci.h.matrix + + assert norm(a-b) < threshold + + assert norm(norm(dbi.sigma(k_r))-norm(dbi.sigma(j_r))) < threshold + +def test_gci_implementation_normal_and_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.numerical): + """The regular implementation in `DoubleBracketIteration` should be viewed as using classical dynamic programming: memoization of the updated Hamiltonian is used explicitly. Instead, using `FrameShiftedEvolutionOracle` we can store a sequence of recursive rotations such that eventually the iteration gives the same result. + This function tests numerical agreement using the numpy backend. + """ + h_x = SymbolicHamiltonian( + symbols.X(0) + + symbols.Z(0) * symbols.X(1) + + symbols.Y(2) + + symbols.Y(1) * symbols.Y(2), + nqubits=3, + ) + d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3) + h_input = h_x + d_0 + + dbi = DoubleBracketIteration(deepcopy(h_input.dense)) + evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle) + gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle )) + + evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", + mode_evolution_oracle) + from numpy.linalg import norm + times = np.linspace(1e-5,1,5) + for r in times: + + dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) + k_r = dbi.h.matrix + dbi.h = deepcopy(h_input.dense) + gci(r, diagonal_association= evolution_oracle_diagonal_target ) + j_r = gci.h.matrix + gci.h = deepcopy(h_input.dense) + gci.iterated_hamiltonian_evolution_oracle = deepcopy(evolution_oracle) + + assert norm(k_r-j_r) < 1e-12 + + r = 1 + for _ in range(3): + dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) + gci(r, diagonal_association= evolution_oracle_diagonal_target ) + k_r = dbi.h.matrix + j_r = gci.h.matrix + + assert norm(k_r-j_r) < 1e-12 @pytest.mark.parametrize("nqubits", [1, 2]) def test_double_bracket_iteration_single_commutator(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) From ea7985597684344fab417862d71181febf28b223 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 29 Apr 2024 18:13:40 +0200 Subject: [PATCH 096/116] updating some variables to check if tests will advance --- src/qibo/models/dbi/double_bracket_evolution_oracles.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index d86376e69b..9215996f38 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -207,9 +207,9 @@ def get_composed_circuit(self): c = self.circuit(0) while isinstance(base_evolution_oracle, FrameShiftedEvolutionOracle): if self.mode_evolution_oracle is EvolutionOracleType.numerical: - c = base_evolution_oracle.get_composed_unitary() @ c + c = self.base_evolution_oracle.get_composed_unitary() @ c elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - c = c + base_evolution_oracle.get_composed_unitary() + c = c + self.base_evolution_oracle.get_composed_circuit() class DoubleBracketDiagonalAssociationType(Enum): From 28db39080c9cabee5c9308bc1dd235ce3900146c Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 30 Apr 2024 01:54:21 +0200 Subject: [PATCH 097/116] moved the diagonal associations code sketch elsewhere to the analog project repo --- .../dbi/double_bracket_evolution_oracles.py | 117 ------------------ 1 file changed, 117 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 9215996f38..dd29803219 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -212,121 +212,4 @@ def get_composed_circuit(self): c = c + self.base_evolution_oracle.get_composed_circuit() -class DoubleBracketDiagonalAssociationType(Enum): - """Define the evolution generator of a variant of the double-bracket iterations.""" - dephasing = auto() - """Use dephasing for a canonical bracket.""" - - prescribed = auto() - """Use some input diagonal matrix for each step: general diagonalization DBI""" - - fixed = auto() - """Use same input diagonal matrix in each step: BHMM DBI""" - - optimization = auto() - """Perform optimization to find best diagonal operator""" - - -class DiagonalAssociationDephasingChannel(EvolutionOracle): - - def __init__( - self, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings, - ): - super().__init__( - mode_diagonal_association=DoubleBracketDiagonalAssociationType.dephasing, - mode_evolution_oracle=mode_evolution_oracle, - ) - - def __call__( - self, J_input: EvolutionOracle, k_step_number: list = None, t_duration=None - ): - if mode_evolution_oracle is EvolutionOracleType.text_strings: - if t_duration is None: - # iterate over all Z ops - return r"\Delta(" + J_input.name + ")" - else: - return "exp( i" + str(t_duration) + r"\Delta(" + J_input.name + ")" - elif mode_evolution_oracle is EvolutionOracleType.numerical: - if t_duration is None: - return J_input.h.diag() - else: - return J_input.diag().exp(t_duration) - if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - if t_duration is None: - # iterate over all Z ops - return sum(Z @ J_input @ Z) - else: - return sum(Z @ J_input.circuit(t_duration) @ Z) - - -class DiagonalAssociationFromList(EvolutionOracle): - - def __init__( - self, - d_k_list: list = None, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings, - ): - super().__init__( - mode_diagonal_association=DoubleBracketDiagonalAssociationType.prescribed, - mode_evolution_oracle=mode_evolution_oracle, - ) - self.d_k_list = d_k_list - - def __call__(self, k_step_number: list = None, t_duration=None): - - if mode_evolution_oracle is EvolutionOracleType.text_strings: - if t_duration is None: - return "D_" + str(k_step_number) - else: - return "exp( i" + str(t_duration) + "D_k" - elif mode_evolution_oracle is EvolutionOracleType.numerical: - if t_duration is None: - return d_k_list[k_step_number] - else: - return d_k_list[k_step_number].exp(t_duration) - if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - if t_duration is None: - raise_error( - ValueError, - f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.", - ) - else: - return d_k_list[k_step_number.circuit(t_duration)] - - -class DiagonalAssociationFromOptimization(EvolutionOracle): - - def __init__( - self, - loss_function: None, - mode: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, - mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings, - ): - self.loss = loss_function - - def __call__( - self, h: AbstractHamiltonian, k_step_number: list = None, t_duration=None - ): - if self.mode_evolution_oracle is EvolutionOracleType.text_strings: - if t_duration is None: - return r"Optimize $\mu$ D_" + str(k_step_number) - else: - return r"Optimize $\mu$ exp( i" + str(t_duration) + "D_k" - elif self.mode_evolution_oracle is EvolutionOracleType.numerical: - if t_duration is None: - raise_error(TypeError, "Not implemented") - return 0 - else: - raise_error(TypeError, "Not implemented") - return 0 - if self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - if t_duration is None: - raise_error( - ValueError, - f"In the hamiltonian_simulation mode you need to work with evolution operators so please specify a time.", - ) - else: - raise_error(TypeError, "Not implemented") - return None From 96403569e29c9dec7bc1135edeec21c786094c28 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 30 Apr 2024 09:45:28 +0200 Subject: [PATCH 098/116] a circuit extraction notebook in examples - you can use it to analyze gate count in boosting; next reduced group commutators and make tests to pass --- examples/dbi/extracting_dbi_circuits.ipynb | 191 ++++++++++++++++++ .../dbi/double_bracket_evolution_oracles.py | 9 +- .../group_commutator_iteration_transpiler.py | 2 - 3 files changed, 197 insertions(+), 5 deletions(-) create mode 100644 examples/dbi/extracting_dbi_circuits.ipynb diff --git a/examples/dbi/extracting_dbi_circuits.ipynb b/examples/dbi/extracting_dbi_circuits.ipynb new file mode 100644 index 0000000000..1028017fa2 --- /dev/null +++ b/examples/dbi/extracting_dbi_circuits.ipynb @@ -0,0 +1,191 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2dae9ffe", + "metadata": {}, + "source": [ + "## This compares to DoubleBracketIteration whenever possible\n", + "\n", + "Note that we are not using the reduced group commutator so just 4 steps of the iteration using circuit representations uses quite a lot of time (several seconds)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b161521d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-04-30 09:44:18]: Using numpy backend on /CPU:0\n" + ] + } + ], + "source": [ + "import inspect\n", + "import sys\n", + "sys.path.append(\"../../tests\")\n", + "from test_models_dbi import *\n", + "def print_function_source_code( func ):\n", + " out = inspect.getsourcelines(func) \n", + " from functools import reduce\n", + " print(reduce(str.__add__, out[0]))\n", + "import qibo\n", + "backend = qibo.backends.construct_backend(\"numpy\")\n", + "qibo.set_backend(\"numpy\")\n", + "nqubits = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d8eac22c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|WARNING|2024-04-30 09:44:18]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-04-30 09:44:18]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], + "source": [ + "r=0.1\n", + "mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", + "h_x = SymbolicHamiltonian(\n", + " symbols.X(0)\n", + " + symbols.Z(0) * symbols.X(1)\n", + " + symbols.Y(2)\n", + " + symbols.Y(1) * symbols.Y(2),\n", + "nqubits=3,\n", + ")\n", + "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n", + "h_input = h_x + d_0\n", + "\n", + "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", + "\n", + "evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle) \n", + "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", + "\n", + "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", + " mode_evolution_oracle)\n", + "\n", + "from numpy.linalg import norm\n", + "\n", + "for _ in range(4):\n", + " dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n", + " gci(r, diagonal_association= evolution_oracle_diagonal_target )\n", + "\n", + "k_r = dbi.h.matrix\n", + "j_r = gci.h.matrix\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cad5fe99", + "metadata": {}, + "outputs": [], + "source": [ + "u = gci.iterated_hamiltonian_evolution_oracle.get_composed_circuit()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1d8388e6", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'Circuit' object has no attribute 'conj'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_143211/1837199151.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mh0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mh_input\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mh_end\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mh0\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'Circuit' object has no attribute 'conj'" + ] + } + ], + "source": [ + "h0 = h_input.dense.matrix\n", + "h_end = u.conj().T @ h0 @ u" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc364e18", + "metadata": {}, + "outputs": [], + "source": [ + "norm(h_end - dbi.h.matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14dbec14", + "metadata": {}, + "outputs": [], + "source": [ + "gci.input_hamiltonian_evolution_oracle.eps_trottersuzuki" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfce7a1b", + "metadata": {}, + "outputs": [], + "source": [ + "norm(h_end - dbi.h.matrix)/gci.input_hamiltonian_evolution_oracle.eps_trottersuzuki" + ] + }, + { + "cell_type": "markdown", + "id": "e3459bcb", + "metadata": {}, + "source": [ + "We conclude that this is fine. Feel free to change to the numerical mode where the error will start piling up merely from the floating point operations and will build up from the double digit precision." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a9ea4c1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index dd29803219..9ae5360866 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -205,11 +205,14 @@ def circuit(self, t_duration: float = None): ) def get_composed_circuit(self): c = self.circuit(0) - while isinstance(base_evolution_oracle, FrameShiftedEvolutionOracle): + fseo = self + while isinstance( fseo, FrameShiftedEvolutionOracle): if self.mode_evolution_oracle is EvolutionOracleType.numerical: - c = self.base_evolution_oracle.get_composed_unitary() @ c + c = fseo.after_circuit @ c elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - c = c + self.base_evolution_oracle.get_composed_circuit() + c = c + fseo.after_circuit + fseo = fseo.base_evolution_oracle + return c diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index e5ded44fbd..55cfdb32a5 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -50,7 +50,6 @@ def __init__( input_hamiltonian_evolution_oracle: EvolutionOracle, mode_double_bracket_rotation: DoubleBracketRotationType = DoubleBracketRotationType.group_commutator, mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.numerical, - mode_diagonal_association: DoubleBracketDiagonalAssociationType = DoubleBracketDiagonalAssociationType.dephasing, ): if mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator: mode_double_bracket_rotation_old = ( @@ -66,7 +65,6 @@ def __init__( self.input_hamiltonian_evolution_oracle = input_hamiltonian_evolution_oracle - self.mode_diagonal_association = mode_diagonal_association self.mode_double_bracket_rotation = mode_double_bracket_rotation self.gci_unitary = [] From 75dab021a03a6a238d2a0d474e9d9c8a48a350c8 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 30 Apr 2024 10:56:59 +0200 Subject: [PATCH 099/116] removing old file --- .../dbi/error in gci gc still there.ipynb | 682 ------------------ 1 file changed, 682 deletions(-) delete mode 100644 examples/dbi/error in gci gc still there.ipynb diff --git a/examples/dbi/error in gci gc still there.ipynb b/examples/dbi/error in gci gc still there.ipynb deleted file mode 100644 index 6facf8f6e2..0000000000 --- a/examples/dbi/error in gci gc still there.ipynb +++ /dev/null @@ -1,682 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "2dae9ffe", - "metadata": {}, - "source": [ - "## This compares to DoubleBracketIteration whenever possible" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "b161521d", - "metadata": {}, - "outputs": [], - "source": [ - "import inspect\n", - "import sys\n", - "sys.path.append(\"../../tests\")\n", - "from test_models_dbi import *\n", - "def print_function_source_code( func ):\n", - " out = inspect.getsourcelines(func) \n", - " from functools import reduce\n", - " print(reduce(str.__add__, out[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1982bb12", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|INFO|2024-04-06 09:40:21]: Using numpy backend on /CPU:0\n" - ] - } - ], - "source": [ - "t_step =0.1\n", - "eps = 1e-2\n", - "import qibo\n", - "backend = qibo.backends.construct_backend(\"numpy\")\n", - "qibo.set_backend(\"numpy\")\n", - "nqubits = 3" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "3405e782", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.7|WARNING|2024-04-06 09:40:21]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-06 09:40:21]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-06 09:40:21]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "9.664636718428507e-16\n", - "0.0\n", - "0.0\n", - "9.664636718428507e-16\n", - "start\n", - "8.570566018546674e-16 2.069502835539648e-18\n", - "None 7.102648668054811e-16\n", - "None 2.069502835539648e-18\n", - "stop\n", - "[[ 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", - " -7.96539477e-02-0.15421646j 3.51159382e-01+0.5130534j\n", - " -6.64615932e-17-0.31397323j 3.23092247e-17+0.25955811j\n", - " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j]\n", - " [ 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", - " -3.51159382e-01-0.5130534j -7.96539477e-02-0.15421646j\n", - " 0.00000000e+00-0.25955811j -3.55618313e-17-0.31397323j\n", - " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j]\n", - " [-3.51159382e-01-0.5293799j -7.96539477e-02-0.08224007j\n", - " 4.02235598e-01-0.29764673j -2.53495292e-01+0.18758172j\n", - " -1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", - " -2.68882139e-17-0.36962312j -1.14925430e-17+0.17125522j]\n", - " [ 7.96539477e-02+0.08224007j -3.51159382e-01-0.5293799j\n", - " 2.53495292e-01-0.18758172j 4.02235598e-01-0.29764673j\n", - " 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", - " 6.93889390e-18-0.17125522j 0.00000000e+00-0.36962312j]\n", - " [-9.97465999e-18-0.36962312j 4.11996826e-18+0.17125522j\n", - " 1.35752717e-01+0.04415144j 2.15406665e-01-0.02782494j\n", - " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j\n", - " -3.51159382e-01+0.5293799j -7.96539477e-02+0.08224007j]\n", - " [ 3.46944695e-18-0.17125522j -3.81639165e-17-0.36962312j\n", - " -2.15406665e-01+0.02782494j 1.35752717e-01+0.04415144j\n", - " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j\n", - " 7.96539477e-02-0.08224007j -3.51159382e-01+0.5293799j ]\n", - " [-1.35752717e-01+0.04415144j -2.15406665e-01-0.02782494j\n", - " 2.97071395e-17-0.31397323j -1.66967135e-17+0.25955811j\n", - " -7.96539477e-02+0.15421646j 3.51159382e-01-0.5130534j\n", - " 4.02235598e-01+0.29764673j -2.53495292e-01-0.18758172j]\n", - " [ 2.15406665e-01+0.02782494j -1.35752717e-01+0.04415144j\n", - " 1.38777878e-17-0.25955811j 4.16333634e-17-0.31397323j\n", - " -3.51159382e-01+0.5130534j -7.96539477e-02+0.15421646j\n", - " 2.53495292e-01+0.18758172j 4.02235598e-01+0.29764673j]]\n", - "9.664636718428507e-16\n" - ] - } - ], - "source": [ - "from numpy.linalg import norm\n", - "h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) \n", - " + symbols.Y(1) * symbols.Y(2), nqubits = 3 )\n", - "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits = 3 )\n", - "h_input = h_x + d_0 \n", - "\n", - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", - "\n", - "\n", - "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", - "\n", - "V_dbi = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", - "R_dbi = dbi2.eval_dbr_unitary(t_step, d=d_0.dense.matrix)\n", - "\n", - "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical) \n", - "\n", - "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", - " mode_evolution_oracle = EvolutionOracleType.numerical)\n", - "\n", - "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n", - "\n", - "unitary_gc_from_oracles = gci.group_commutator( np.sqrt(t_step), evolution_oracle_diagonal_target ) \n", - "Q_gci = unitary_gc_from_oracles['forwards']\n", - "\n", - "assert norm(Q_gci.conj().T - unitary_gc_from_oracles['backwards']) < 1e-12\n", - "\n", - "h0_norm = np.linalg.norm(h_x.dense.matrix)\n", - "d0_norm = np.linalg.norm(d_0.dense.matrix)\n", - "assert norm(V_dbi - R_dbi) < 2 *t_step**1.49 * ( h0_norm + d0_norm ) * h0_norm * d0_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "7a0c43ac", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.9045740584321311" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(Q_gci.conj().T - R_dbi )" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "2b6140e1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.051669878291704" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(Q_gci - R_dbi )" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b2feb7af", - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.linalg import expm\n", - "\n", - "s_step = np.sqrt(t_step)\n", - "Vh = expm(1j * s_step * h_input.dense.matrix )\n", - "\n", - "Vd = expm(1j * s_step * d_0.dense.matrix )" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "1a61a169", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5.716110830818201e-16" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - R_dbi)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "b15db9f3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.0516698782917042" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - Q_gci)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "7edd8473", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( Vh - evolution_oracle.circuit(-s_step))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "1e22de3e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( Vd - evolution_oracle_diagonal_target.circuit(-s_step))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "a90fd92c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( Vd.conj().T - evolution_oracle_diagonal_target.circuit(s_step))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "dc953d12", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5.103534121246274e-16" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm( Vh.conj().T - evolution_oracle.circuit(s_step))" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1e6a99de", - "metadata": {}, - "outputs": [], - "source": [ - "from functools import reduce\n", - "S = reduce(np.ndarray.__matmul__,[ Vh,Vd,Vh.conj().T, Vd.conj().T])" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "c81c695b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.0516698782917042" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(S- Q_gci)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bd657152", - "metadata": {}, - "outputs": [], - "source": [ - "norm(S- R_dbi)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "50625680", - "metadata": {}, - "outputs": [], - "source": [ - "norm( Vh - gci.iterated_hamiltonian_evolution_oracle.circuit(-s_step))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c1f3bbad", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "a2813b91", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n", - "0.0\n", - "start\n", - "7.516933549631155e-16 6.149486291803641e-17\n", - "None 4.665547176382431e-16\n", - "None 6.149486291803641e-17\n", - "stop\n", - "7.516933549631155e-16\n", - "6.149486291803641e-17\n", - "4.665547176382431e-16\n", - "6.149486291803641e-17\n" - ] - }, - { - "data": { - "text/plain": [ - "5.716110830818201e-16" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "self =gci\n", - "eo1 = evolution_oracle_diagonal_target\n", - "eo2 = evolution_oracle\n", - "s_step = np.sqrt(t_step)\n", - "\n", - "if eo2 is None:\n", - " eo2 = self.iterated_hamiltonian_evolution_oracle\n", - "##\n", - "from scipy.linalg import expm, norm\n", - "\n", - "Vh = expm(1j * s_step * eo2.h.dense.matrix )\n", - "Vd = expm(1j * s_step * eo1.h.dense.matrix )\n", - "# print(norm( Vh @ Vd @ Vh.conj().T @ Vd.conj().T - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix)))\n", - "print(norm( Vh - eo2.circuit(-s_step)))\n", - "print(norm( Vd - eo1.circuit(-s_step)))\n", - "from functools import reduce\n", - "by_hand_list = [ Vh,Vd,Vh.conj().T, Vd.conj().T]\n", - "S = reduce(np.ndarray.__matmul__,by_hand_list)\n", - "# print(norm( S - super().eval_dbr_unitary(t_step,d = eo1.h.dense.matrix)))\n", - "assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value\n", - "\n", - "eo_mode = eo1.mode_evolution_oracle\n", - "\n", - "\n", - "gc_type = self.mode_double_bracket_rotation\n", - "\n", - "\n", - "if gc_type is DoubleBracketRotationType.single_commutator:\n", - " raise_error(\n", - " ValueError,\n", - " \"You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!\",\n", - " )\n", - "\n", - "if gc_type is DoubleBracketRotationType.group_commutator: \n", - " query_list_forward = [ eo2.circuit(-s_step), eo1.circuit(-s_step), eo2.circuit(s_step), eo1.circuit(s_step) ]\n", - " query_list_backward = [ eo1.circuit(-s_step), eo2.circuit(-s_step), eo1.circuit(s_step), eo2.circuit(s_step) ]\n", - "elif gc_type is DoubleBracketRotationType.group_commutator_reduced: \n", - " query_list_forward = [ eo1.circuit(s_step), eo2.circuit(s_step), eo1.circuit(-s_step) ]\n", - " query_list_backward = [ eo1.circuit(s_step), eo2.circuit(-s_step), eo1.circuit(-s_step) ] \n", - "else:\n", - " raise_error(\n", - " ValueError,\n", - " \"You are in the group commutator query list but your dbr mode is not recognized\",\n", - " )\n", - "print(\"start\")\n", - "reduce( print, [norm(x @ y.conj().T -np.eye(x.shape[0])) for x,y in zip( query_list_forward,by_hand_list)]) \n", - "from functools import reduce\n", - "print(\"stop\")\n", - "for x,y in zip( query_list_forward,by_hand_list):\n", - " print(norm(x @ y.conj().T -np.eye(x.shape[0])))\n", - "\n", - "A = reduce(np.ndarray.__matmul__, query_list_forward)\n", - "B = reduce(np.ndarray.__matmul__, by_hand_list)\n", - "norm(A-B)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "4f0cb09f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.0136811088581048" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(R_dbi- V_dbi)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "824ac371", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n", - "0.0\n", - "start\n", - "7.516933549631155e-16 6.149486291803641e-17\n", - "None 4.665547176382431e-16\n", - "None 6.149486291803641e-17\n", - "stop\n", - "7.516933549631155e-16\n", - "6.149486291803641e-17\n", - "4.665547176382431e-16\n", - "6.149486291803641e-17\n" - ] - }, - { - "ename": "SyntaxError", - "evalue": "'return' outside function (1962676161.py, line 57)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_23193/1962676161.py\"\u001b[0;36m, line \u001b[0;32m57\u001b[0m\n\u001b[0;31m return {\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m 'return' outside function\n" - ] - } - ], - "source": [ - "if eo_mode is EvolutionOracleType.text_strings:\n", - " return {\n", - " \"forwards\": reduce(str.__add__, query_list_forward),\n", - " \"backwards\": reduce(str.__add__, query_list_backward),\n", - " }\n", - "elif eo_mode is EvolutionOracleType.hamiltonian_simulation:\n", - " return {\n", - " \"forwards\": reduce(Circuit.__add__, query_list_forward[::-1]),\n", - " \"backwards\": reduce(Circuit.__add__, query_list_backward[::-1]),\n", - " }\n", - "elif eo_mode is EvolutionOracleType.numerical:\n", - " return {\n", - " \"forwards\": reduce(np.ndarray.__matmul__, query_list_forward),\n", - " \"backwards\": reduce(np.ndarray.__matmul__, query_list_backward)\n", - " }\n", - "else:\n", - " raise_error(ValueError, \"Your EvolutionOracleType is not recognized\")\n", - "\n", - "group_commutator(gci, t_step, eo1 = evolution_oracle_diagonal_target)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "a23e136c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi.mode = DoubleBracketGeneratorType.single_commutator\n", - "\n", - "\n", - "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n", - "dbi2.mode = DoubleBracketGeneratorType.group_commutator\n", - "\n", - "\n", - "norms = []\n", - "norms2 = []\n", - "for s in np.linspace(1e-5,.1,30):\n", - " V_dbi = dbi.eval_dbr_unitary(s, d=d_0.dense.matrix)\n", - " R_dbi = dbi2.eval_dbr_unitary(s, d=d_0.dense.matrix)\n", - " norms.append(norm(V_dbi.conj().T-R_dbi))\n", - " norms2.append(norm(V_dbi-R_dbi))\n", - "import matplotlib.pyplot as plt \n", - "plt.plot(np.linspace(1e-5,.1,30),norms)\n", - "plt.plot(np.linspace(1e-5,.1,30), [x**1.5*12 for x in np.linspace(1e-5,.1,30)])" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "a74c98b8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(np.linspace(1e-5,.1,30),norms2)\n", - "plt.plot(np.linspace(1e-5,.1,30), [x*10 for x in np.linspace(1e-5,.1,30)])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ae8fa09f", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b747ac2e", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 24bb12d47c3064b4ac9101ac9dcb7ecfdb82962a Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 2 May 2024 12:21:22 +0800 Subject: [PATCH 100/116] Resolve cost function notebook issues based on commit 6a41ccf --- ...t_functions_and_d_gradients_tutorial.ipynb | 706 ++++++++++++++++++ examples/dbi/dbi_costs.ipynb | 367 --------- src/qibo/models/dbi/double_bracket.py | 46 +- src/qibo/models/dbi/utils.py | 28 +- src/qibo/models/dbi/utils_analytical.py | 5 +- src/qibo/models/dbi/utils_gradients.py | 198 +++++ src/qibo/models/dbi/utils_scheduling.py | 16 +- 7 files changed, 961 insertions(+), 405 deletions(-) create mode 100644 examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb delete mode 100644 examples/dbi/dbi_costs.ipynb create mode 100644 src/qibo/models/dbi/utils_gradients.py diff --git a/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb b/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb new file mode 100644 index 0000000000..6607eaf6dc --- /dev/null +++ b/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb @@ -0,0 +1,706 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-bracket Iteration other cost functions and respective scheduling\n", + "\n", + "This notebook presents two additional cost functions for the double-bracket flow: least-squares and energy fluctuation with their respectice scheduling methods." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Least-squares\n", + "\n", + "The cost function is defined as: $\\frac{1}{2}||D-H_k||^2 =\\frac{1}{2}(||D||^2+||H||^2) -Tr(D H_k)$ as in (the negative of https://epubs.siam.org/doi/abs/10.1137/S0036141092229732?journalCode=sjmael) We seek to minimize this function at each DBF iteration. For numerical optimizations, we also ignore the norm of H term as for a given hamiltonian it is fixed through out the flow.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"numpy\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/2**nqubits\n", + "s_space = np.linspace(1e-5, 1.0, 500)\n", + "off_diagonal_norm_diff = []\n", + "potential = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " potential.append(dbi_eval.least_squares(d=d))\n", + "\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.figure()\n", + "plt.plot(s_space, potential)\n", + "plt.xlabel('s')\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.title('First DBI step')\n", + "plt.ylabel('Least squares cost function')\n", + "plt.legend()\n", + "plt.figure()\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('First DBI step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Comparison of the least-squares cost function with the original cost function using the polynomial scheduling method" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", + "off_diagonal_norm_diff_least_squares = [dbi.off_diagonal_norm]\n", + "iters = 100\n", + "dbi_ls = deepcopy(dbi)\n", + "cost = DoubleBracketCostFunction.off_diagonal_norm\n", + "dbi_od = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "for _ in range(iters):\n", + " step_poly = dbi_od.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_od(step_poly,d=d)\n", + " step_poly = dbi_ls.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_ls(step_poly,d=d)\n", + " off_diagonal_norm_diff.append(dbi_od.off_diagonal_norm)\n", + " off_diagonal_norm_diff_least_squares.append(dbi_ls.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff, label=r'Off-diagonal norm')\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff_least_squares, label=r'Least squares')\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Energy fluctuation\n", + "\n", + "This cost function is defined as: $\\Xi_k^2 (\\mu) = \\langle \\mu | H_k^2| \\mu \\rangle - \\langle \\mu | H_k| \\mu \\rangle^2$. We must specify the state $| \\mu \\rangle$ for which we want to minimize the fluctuation. The overall diagonalization isn't guaranteed.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"numpy\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 3\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the energy fluctuation cost function\n", + "cost = DoubleBracketCostFunction.energy_fluctuation\n", + "# define the state\n", + "state = np.zeros(2**nqubits)\n", + "state[3] = 1\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, ref_state=state)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "d = np.diag(np.linspace(2**nqubits,1,2**nqubits))/2**nqubits\n", + "s_space = np.linspace(-1, 1, 1000)\n", + "off_diagonal_norm_diff = []\n", + "fluctuation = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " fluctuation.append(dbi_eval.energy_fluctuation(state=state))\n", + "\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + "print('polynomial_approximation step:', step_poly)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.figure()\n", + "plt.plot(s_space, fluctuation)\n", + "plt.xlabel('s')\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label ='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.title('First DBI step')\n", + "plt.ylabel('Energy fluctuation')\n", + "plt.legend()\n", + "plt.figure()\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('First DBI step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", + "energy_fluc = [dbi.energy_fluctuation(state=state)]\n", + "iters = 10\n", + "dbi_ = deepcopy(dbi)\n", + "for _ in range(iters):\n", + " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_(step_poly,d=d)\n", + " off_diagonal_norm_diff.append(dbi_.off_diagonal_norm)\n", + " energy_fluc.append(dbi_.energy_fluctuation(state=state))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff)\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "\n", + "plt.figure()\n", + "plt.plot(range(iters+1), energy_fluc)\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'Energy fluctuation')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "iters = 30\n", + "states = [0,1,2,3,4,5,6,7]\n", + "energy = np.empty((len(states),iters))\n", + "\n", + "\n", + "d = (np.diag(np.linspace(1,2**nqubits,2**nqubits)))\n", + "for i in range(len(states)):\n", + " dbi_ = deepcopy(dbi)\n", + " dbi_.state = states[i]\n", + " for j in range(iters):\n", + " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " if step_poly is not None:\n", + " dbi_(step_poly, d=d)\n", + " energy[i,j] = np.real(dbi_.h.matrix[states[i],states[i]])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n", + "print('Eigenvalues:', eigvals )\n", + "plt.figure()\n", + "for i in range(len(states)):\n", + " plt.plot(range(iters), energy[i,:],'.', label='State ' + str(states[i]))\n", + "for eigvals in eigvals:\n", + " plt.axhline(y=eigvals, color='r', linestyle='--')\n", + "plt.xlabel('Iterations')\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradients for finding optimal $D$\n", + "\n", + "An advantage of the least-squares cost function is that one can use gradient descent and the learning is more stable than with the off-diagonal cost function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qibo.models.dbi.utils_gradients import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"numpy\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 3\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the energy fluctuation cost function\n", + "cost = DoubleBracketCostFunction.energy_fluctuation\n", + "# define the state\n", + "state = np.zeros(2**nqubits)\n", + "state[3] = 1\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, ref_state=state)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cost = DoubleBracketCostFunction.least_squares\n", + "nqubits = 5\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "params = np.linspace(1,2**nqubits,2**nqubits)\n", + "\n", + "step = 1e-2\n", + "iterations = 200\n", + "d, loss, grad, diags = gradient_descent_dbr_d_ansatz(dbi, params, iterations, step)\n", + "\n", + "plt.figure()\n", + "plt.plot(range(iterations+1), loss)\n", + "plt.xlabel('Learning iterations')\n", + "plt.ylabel('Loss: Least squares')\n", + "\n", + "plt.figure()\n", + "for i in range(2**nqubits):\n", + " plt.plot(diags[i,:], label='State ' + str(i))\n", + "plt.xlabel('Learning iterations')\n", + "plt.ylabel('Diagonal elements')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training for $D$ can greatly improve the decrease of the off-diagonal norm at each iteration. Nonetheless, during training the ascending values condition may be no longer satisfied creating a exponential decrease after few iterations" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cost = DoubleBracketCost.least_squares\n", + "nqubits = 5\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "params = np.linspace(1,2**nqubits,2**nqubits)\n", + "d_fixed = np.diag(params)\n", + "dbi_trained = deepcopy(dbi)\n", + "flows = 50\n", + "iterations = 200\n", + "off_diagonal_norm = np.empty((2,flows+1))\n", + "off_diagonal_norm[0,0] = dbi_trained.off_diagonal_norm\n", + "off_diagonal_norm[1,0] = dbi.off_diagonal_norm\n", + "d_trained, loss, grad, diags = gradient_descent_dbr_d_ansatz(dbi_trained, params, iterations,step)\n", + "for i in range(flows):\n", + "\n", + " s = dbi_trained.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_trained, n=3)\n", + " dbi_trained(s,d=d_trained)\n", + " off_diagonal_norm[0,i+1] = dbi_trained.off_diagonal_norm\n", + " s = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_fixed, n=3)\n", + " dbi(s,d=d_fixed)\n", + " off_diagonal_norm[1,i+1] = dbi.off_diagonal_norm\n", + "\n", + "plt.figure()\n", + "plt.plot(off_diagonal_norm[0,:], label='Trained')\n", + "plt.plot(off_diagonal_norm[1,:], label='Untrained')\n", + "plt.legend()\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A solution can be to redo the training at each step, with a $D$ having ascending values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cost = DoubleBracketCost.least_squares\n", + "nqubits = 5\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "params = np.linspace(1,2**nqubits,2**nqubits)\n", + "d_fixed = np.diag(params)\n", + "dbi_trained = deepcopy(dbi)\n", + "flows = 50\n", + "iterations = 20\n", + "off_diagonal_norm = np.empty((2,flows+1))\n", + "off_diagonal_norm[0,0] = dbi_trained.off_diagonal_norm\n", + "off_diagonal_norm[1,0] = dbi.off_diagonal_norm\n", + "\n", + "for i in range(flows):\n", + " d_trained, loss, grad, diags = gradient_descent_dbr_d_ansatz(dbi_trained, params, iterations,step)\n", + " s = dbi_trained.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_trained, n=3)\n", + " dbi_trained(s,d=d_trained)\n", + " off_diagonal_norm[0,i+1] = dbi_trained.off_diagonal_norm\n", + " s = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_fixed, n=3)\n", + " dbi(s,d=d_fixed)\n", + " off_diagonal_norm[1,i+1] = dbi.off_diagonal_norm\n", + "\n", + "plt.figure()\n", + "plt.plot(off_diagonal_norm[0,:], label='Trained')\n", + "plt.plot(off_diagonal_norm[1,:], label='Untrained')\n", + "plt.legend()\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The numerical gradients may be preferred as they decrease more the loss at each iteration and are computationally faster. They may be more precise as the previous analytic since the analytic computations use the polynomial approximation as a starting point" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nqubits = [3,4,5,6]\n", + "iterations = 30\n", + "step = 1e-2\n", + "differences = np.empty((len(nqubits),iterations+1))\n", + "loss_max = np.empty(len(nqubits))\n", + "for q in range(len(nqubits)):\n", + " # define the hamiltonian\n", + " H_TFIM = hamiltonians.TFIM(nqubits=nqubits[q], h=h)\n", + "\n", + " # define the least-squares cost function\n", + " cost = DoubleBracketCost.least_squares\n", + " # initialize class\n", + " dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + " loss_max [q] = dbi.least_squares(d=np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q])))\n", + " params = np.linspace(1,2**nqubits[q],2**nqubits[q])\n", + " d_analytic, loss_analytic, grad_analytic, diags_analytic = gradient_descent_dbr_d_ansatz(dbi, params, iterations, step)\n", + " params = np.linspace(1,2**nqubits[q],2**nqubits[q])\n", + " d_numerical, loss_numerical, grad_numerical, diags_numerical = gradient_descent_dbr_d_ansatz(dbi, params,iterations,step, analytic=False)\n", + " differences[q,:] = loss_analytic - loss_numerical\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "for q in range(len(nqubits)):\n", + " plt.plot(differences[q,:],label= 'nqubits = {}'.format(nqubits[q]))\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel('Difference in analytic and numerical loss function')\n", + "plt.legend()\n", + "\n", + "plt.figure()\n", + "plt.title('Normalized difference')\n", + "for q in range(len(nqubits)):\n", + " plt.plot(differences[q,:]/loss_max[q],label= 'nqubits = {}'.format(nqubits[q]))\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel('Difference in analytic and numerical loss function')\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1-local ansatz\n", + "\n", + "We can consider, as an alternative to the a fully parametrized diagonal, a diagonal matrix of the form: $D = \\sum \\alpha_i Z_i$. This has the advantage of having a linear number of parameters to optimize instead of an exponential as well as being easier to implement in a quantum computer " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"numpy\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCost.least_squares\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dbi_eval = deepcopy(dbi)\n", + "params = np.linspace(1,2**nqubits,2**nqubits)\n", + "d_opt, loss_opt, grad_opt, diags_opt = gradient_descent_dbr_d_ansatz(dbi, params, 100,1e-2, analytic=False, d_type = d_ansatz_type.element_wise)\n", + "flows = 50\n", + "off_diagonal_norm = np.empty((flows+1,2))\n", + "off_diagonal_norm[0,:] = dbi_eval.off_diagonal_norm\n", + "for i in range(flows):\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_opt,n=3)\n", + " dbi_eval(step_poly,d=d_opt)\n", + " off_diagonal_norm[i+1,0] = dbi_eval.off_diagonal_norm\n", + "\n", + "\n", + "\n", + "dbi_eval = deepcopy(dbi)\n", + "params = np.linspace(1,nqubits,nqubits)\n", + "d_opt, loss_opt, grad_opt, diags_opt = gradient_descent_dbr_d_ansatz(dbi, params, 30, 1e-3, analytic=False, d_type = d_ansatz_type.local_1)\n", + "best = np.argmin(loss_opt)\n", + "d_opt = d_ansatz(diags_opt[:,best], d_ansatz_type.local_1)\n", + "for i in range(flows):\n", + " step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_opt,n=3)\n", + " dbi_eval(step_poly,d=d_opt)\n", + " off_diagonal_norm[i+1,1] = dbi_eval.off_diagonal_norm\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.plot(off_diagonal_norm[:,0],label='element-wise ansatz')\n", + "plt.plot(off_diagonal_norm[:,1],label='1-local ansatz')\n", + "plt.xlabel('Flows Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"numpy\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCost.least_squares\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dbi_eval = deepcopy(dbi)\n", + "params = np.linspace(1,nqubits,nqubits)\n", + "d_opt, loss_opt, grad_opt, diags_opt = gradient_descent_dbr_d_ansatz(dbi, params, 20, 1e-3, analytic=False, d_type = d_ansatz_type.local_1)\n", + "best = np.argmin(loss_opt)\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(loss_opt)\n", + "\n", + "s = np.linspace(-0.1,0.1,100)\n", + "least_squares = np.empty(100)\n", + "off_diagonal_norm = np.empty(100)\n", + "for i in range(100):\n", + " dbi_eval(s[i],d=d_opt)\n", + " least_squares[i] = dbi_eval.least_squares(d=d_opt)\n", + " off_diagonal_norm[i] = dbi_eval.off_diagonal_norm\n", + "plt.figure()\n", + "plt.plot(s,loss)\n", + "plt.xlabel('s')\n", + "plt.ylabel('Least squares cost function')\n", + "plt.figure()\n", + "plt.plot(s,off_diagonal_norm)\n", + "plt.xlabel('s')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "\n", + "\n", + "print(np.diag(d_opt))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dbi", + "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.9.19" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "43f1f904380137ff38e17e8a93371c4872e6bababc18e270d8a0497ea5c7ea38" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/dbi/dbi_costs.ipynb b/examples/dbi/dbi_costs.ipynb deleted file mode 100644 index e772b94bce..0000000000 --- a/examples/dbi/dbi_costs.ipynb +++ /dev/null @@ -1,367 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Double-bracket Iteration other cost functions and respective scheduling\n", - "\n", - "This notebook presents two additional cost functions for the double-bracket flow: least-squares and energy fluctuation with their respectice scheduling methods." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from copy import deepcopy\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from qibo import hamiltonians, set_backend\n", - "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", - "from qibo.models.dbi.utils import *\n", - "from qibo.models.dbi.utils_scheduling import *" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Least-squares\n", - "\n", - "The cost function is defined as: $\\frac{1}{2}||D-H_k||^2 =\\frac{1}{2}(||D||^2+||H||^2) -Tr(D H_k)$ as in https://epubs.siam.org/doi/abs/10.1137/S0036141092229732?journalCode=sjmael. We seek to maximize this function at each iteration." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Hamiltonian\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "\n", - "# hamiltonian parameters\n", - "nqubits = 5\n", - "h = 3.0\n", - "\n", - "# define the hamiltonian\n", - "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", - "\n", - "# define the least-squares cost function\n", - "cost = DoubleBracketCostFunction.least_squares\n", - "# initialize class\n", - "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# generate data for plotting sigma decrease of the first step\n", - "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", - "s_space = np.linspace(1e-5, 0.6, 1000)\n", - "off_diagonal_norm_diff = []\n", - "potential = []\n", - "for s in s_space:\n", - " dbi_eval = deepcopy(dbi)\n", - " dbi_eval(s,d=d)\n", - " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", - " potential.append(dbi_eval.least_squares(D=d))\n", - "\n", - "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", - "print('grid_search step:', step_grid)\n", - "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", - "print('hyperopt_search step:', step_hyperopt)\n", - "# polynomial\n", - "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", - "print('polynomial_approximation step:', step_poly)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Plot the results\n", - "plt.figure()\n", - "plt.plot(s_space, potential)\n", - "plt.xlabel('s')\n", - "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", - "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", - "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", - "plt.title('First DBI step')\n", - "plt.ylabel('Least squares cost function')\n", - "plt.legend()\n", - "plt.figure()\n", - "plt.plot(s_space, off_diagonal_norm_diff)\n", - "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", - "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", - "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", - "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", - "plt.xlabel('s')\n", - "plt.title('First DBI step')\n", - "plt.legend()\n", - "print('The minimum for cost function in the tested range is:', step_grid)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Comparison of the least-squares cost function with the original cost function using the polynomial scheduling method" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", - "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", - "off_diagonal_norm_diff_least_squares = [dbi.off_diagonal_norm]\n", - "iters = 100\n", - "dbi_ls = deepcopy(dbi)\n", - "cost = DoubleBracketCostFunction.off_diagonal_norm\n", - "dbi_od = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", - "for _ in range(iters):\n", - " step_poly = dbi_od.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", - " dbi_od(step_poly,d=d)\n", - " step_poly = dbi_ls.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", - " dbi_ls(step_poly,d=d)\n", - " off_diagonal_norm_diff.append(dbi_od.off_diagonal_norm)\n", - " off_diagonal_norm_diff_least_squares.append(dbi_ls.off_diagonal_norm)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.figure()\n", - "plt.plot(range(iters+1), off_diagonal_norm_diff, label=r'Off-diagonal norm')\n", - "plt.plot(range(iters+1), off_diagonal_norm_diff_least_squares, label=r'Least squares')\n", - "plt.xlabel('Iterations')\n", - "plt.ylabel(r'$||\\sigma(H_k)||$')\n", - "plt.legend()\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Energy fluctuation\n", - "\n", - "This cost function is defined as: $\\Xi_k^2 (\\mu) = \\langle \\mu | H_k^2| \\mu \\rangle - \\langle \\mu | H_k| \\mu \\rangle^2$" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Hamiltonian\n", - "set_backend(\"qibojit\", platform=\"numba\")\n", - "\n", - "# hamiltonian parameters\n", - "nqubits = 3\n", - "h = 3.0\n", - "\n", - "# define the hamiltonian\n", - "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", - "\n", - "# define the energy fluctuation cost function\n", - "cost = DoubleBracketCostFunction.energy_fluctuation\n", - "# define the state\n", - "state = 0\n", - "# initialize class\n", - "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, state=state)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# generate data for plotting sigma decrease of the first step\n", - "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", - "s_space = np.linspace(1e-5, 0.9, 1000)\n", - "off_diagonal_norm_diff = []\n", - "fluctuation = []\n", - "for s in s_space:\n", - " dbi_eval = deepcopy(dbi)\n", - " dbi_eval(s,d=d)\n", - " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", - " fluctuation.append(dbi_eval.energy_fluctuation(state=state))\n", - "\n", - "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", - "print('grid_search step:', step_grid)\n", - "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", - "print('hyperopt_search step:', step_hyperopt)\n", - "# polynomial\n", - "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", - "print('polynomial_approximation step:', step_poly)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Plot the results\n", - "plt.figure()\n", - "plt.plot(s_space, fluctuation)\n", - "plt.xlabel('s')\n", - "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", - "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label ='hyperopt')\n", - "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", - "plt.title('First DBI step')\n", - "plt.ylabel('Energy fluctuation')\n", - "plt.legend()\n", - "plt.figure()\n", - "plt.plot(s_space, off_diagonal_norm_diff)\n", - "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", - "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", - "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", - "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", - "plt.xlabel('s')\n", - "plt.title('First DBI step')\n", - "plt.legend()\n", - "print('The minimum for cost function in the tested range is:', step_grid)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", - "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", - "energy_fluc = [dbi.energy_fluctuation(state=state)]\n", - "iters = 50\n", - "dbi_ = deepcopy(dbi)\n", - "for _ in range(iters):\n", - " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", - " dbi_(step_poly,d=d)\n", - " off_diagonal_norm_diff.append(dbi_.off_diagonal_norm)\n", - " energy_fluc.append(dbi_.energy_fluctuation(state=state))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.figure()\n", - "plt.plot(range(iters+1), off_diagonal_norm_diff)\n", - "plt.xlabel('Iterations')\n", - "plt.ylabel(r'$||\\sigma(H_k)||$')\n", - "\n", - "plt.figure()\n", - "plt.plot(range(iters+1), energy_fluc)\n", - "plt.xlabel('Iterations')\n", - "plt.ylabel(r'Energy fluctuation')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "iters = 10\n", - "columnNorm = np.empty((2**nqubits,iters))\n", - "d = (np.diag(np.linspace(1,2**nqubits,2**nqubits)))\n", - "for i in range(2**nqubits):\n", - " dbi_ = deepcopy(dbi)\n", - " dbi_.state = i\n", - " for j in range(iters):\n", - " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", - " dbi_(step_poly,d=d)\n", - " columnNorm[i,j] = np.linalg.norm(dbi_.h.matrix[:,i])\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n", - "plt.figure()\n", - "for i in range(2**nqubits):\n", - " plt.plot(range(iters), columnNorm[i], label='State ' + str(i))\n", - " plt.axhline(y=eigvals[i], color='r', linestyle='--')\n", - "plt.xlabel('Iterations')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cost = DoubleBracketCostFunction.least_squares\n", - "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", - "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", - "\n", - "step = 1e-2\n", - "iterations = 100\n", - "\n", - "d, loss, grad, diags = gradient_ascent(dbi, d,step, iterations)\n", - "\n", - "n = 3" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index c7f1d9eb38..27b94d2cfb 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -5,6 +5,11 @@ import numpy as np from qibo.hamiltonians import Hamiltonian +from qibo.models.dbi.utils_analytical import ( + energy_fluctuation_polynomial_expansion_coef, + least_squares_polynomial_expansion_coef, + off_diagonal_norm_polynomial_expansion_coef, +) from qibo.models.dbi.utils_scheduling import ( grid_search_step, hyperopt_step, @@ -79,14 +84,14 @@ def __init__( mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, scheduling: DoubleBracketScheduling = DoubleBracketScheduling.grid_search, cost: DoubleBracketCostFunction = DoubleBracketCostFunction.off_diagonal_norm, - state: int = 0, + ref_state: int = 0, ): self.h = hamiltonian self.h0 = deepcopy(self.h) self.mode = mode self.scheduling = scheduling self.cost = cost - self.state = state + self.ref_state = ref_state def __call__( self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None @@ -150,12 +155,11 @@ def backend(self): """Get Hamiltonian's backend.""" return self.h0.backend - def least_squares(self, D: np.array): + def least_squares(self, d: np.array): """Least squares cost function.""" - H = self.h.matrix - return -np.real( - np.trace(H @ D) - 0.5 * (np.linalg.norm(H) ** 2 + np.linalg.norm(D) ** 2) - ) + h_np = self.backend.to_numpy(self.h.matrix) + + return np.real(0.5 * np.linalg.norm(d) ** 2 - np.trace(h_np @ d)) def choose_step( self, @@ -200,14 +204,14 @@ def loss(self, step: float, d: np.array = None, look_ahead: int = 1): elif self.cost == DoubleBracketCostFunction.least_squares: loss = self.least_squares(d) elif self.cost == DoubleBracketCostFunction.energy_fluctuation: - loss = self.energy_fluctuation(self.state) + loss = self.energy_fluctuation(self.ref_state) # set back the initial configuration self.h = h_copy return loss - def energy_fluctuation(self, state=None): + def energy_fluctuation(self, state): """ Evaluate energy fluctuation @@ -219,11 +223,12 @@ def energy_fluctuation(self, state=None): Args: state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ - if state is None: - state = self.state - state_vector = np.zeros(len(self.h.matrix)) - state_vector[state] = 1.0 - return np.real(self.h.energy_fluctuation(state_vector)) + h_np = self.backend.cast(np.diag(np.diag(self.backend.to_numpy(self.h.matrix)))) + h2 = h_np @ h_np + a = state.conj() @ h2 @ state + b = state.conj() @ h_np @ state + return (np.sqrt(np.real(a - b**2))).item() + r # return np.real(self.h.energy_fluctuation(state)) def sigma(self, h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) @@ -235,3 +240,16 @@ def generate_Gamma_list(self, n: int, d: np.array): for _ in range(n - 1): Gamma_list.append(self.commutator(W, Gamma_list[-1])) return Gamma_list + + def cost_expansion(self, d, n): + if self.cost is DoubleBracketCostFunction.off_diagonal_norm: + coef = off_diagonal_norm_polynomial_expansion_coef(self, d, n) + elif self.cost is DoubleBracketCostFunction.least_squares: + coef = least_squares_polynomial_expansion_coef(self, d, n) + elif self.cost is DoubleBracketCostFunction.energy_fluctuation: + coef = energy_fluctuation_polynomial_expansion_coef( + self, d, n, self.ref_state + ) + else: + raise ValueError(f"Cost function {self.cost} not recognized.") + return coef diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 9f3767debb..85dbd9518c 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -8,21 +8,29 @@ from qibo.hamiltonians import SymbolicHamiltonian -def commutator(A, B): +def commutator(a, b): """Compute commutator between two arrays.""" - return A @ B - B @ A + return a @ b - b @ a -def variance(A, state): - """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\\langle\\mu|A^2|\\mu\rangle-\\langle\\mu|A|\\mu\rangle^2$""" - B = A @ A - return B[state, state] - A[state, state] ** 2 +def variance(a, state): + """Calculates the variance of a matrix A with respect to a state: + Var($A$) = $\\langle\\mu|A^2|\\mu\rangle-\\langle\\mu|A|\\mu\rangle^2$""" + b = a @ a + return state.conj().T @ b @ state - (state.conj().T @ a @ state) ** 2 -def covariance(A, B, state): - """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\\langle\\mu|AB|\\mu\rangle-\\langle\\mu|A|\\mu\rangle\\langle\\mu|B|\\mu\rangle$""" - C = A @ B + B @ A - return C[state, state] - 2 * A[state, state] * B[state, state] +def covariance(a, b, state): + """This is a generalization of the notion of covariance, needed for the polynomial expansion of the energy fluctuation, + applied to two operators A and B with respect to a state: + Cov($A,B$) = $\\langle\\mu|AB|\\mu\rangle-\\langle\\mu|A|\\mu\rangle\\langle\\mu|B|\\mu\rangle$ + """ + + c = a @ b + b @ a + return ( + state.conj().T @ c @ state + - 2 * state.conj().T @ a @ state * state.conj().T @ b @ state + ) def generate_Z_operators(nqubits: int, backend=None): diff --git a/src/qibo/models/dbi/utils_analytical.py b/src/qibo/models/dbi/utils_analytical.py index b23fd0a33e..6d09a76ffd 100644 --- a/src/qibo/models/dbi/utils_analytical.py +++ b/src/qibo/models/dbi/utils_analytical.py @@ -1,6 +1,9 @@ +import math from typing import Optional -from qibo.models.dbi.utils import * +import numpy as np + +from qibo.models.dbi.utils import commutator, covariance, variance def dGamma_di_Pauli(dbi_object, n: int, Z_i: np.array, d: np.array): diff --git a/src/qibo/models/dbi/utils_gradients.py b/src/qibo/models/dbi/utils_gradients.py new file mode 100644 index 0000000000..7790f3d2c5 --- /dev/null +++ b/src/qibo/models/dbi/utils_gradients.py @@ -0,0 +1,198 @@ +import math +from copy import deepcopy +from enum import Enum, auto + +import numpy as np + +from qibo import symbols +from qibo.hamiltonians import SymbolicHamiltonian +from qibo.models.dbi.utils import commutator +from qibo.models.dbi.utils_scheduling import polynomial_step + + +class d_ansatz_type(Enum): + + element_wise = auto() + local_1 = auto() + # local_2 = auto() # for future implementation + # ising = auto() # for future implementation + + +def d_ansatz(params: np.array, d_type: d_ansatz_type): + r""" + Creates the $D$ operator for the double-bracket iteration ansatz depending on the type of parameterization. + If $\alpha_i$ are our parameters and d the number of qubits then: + + element_wise: $D = \sum_{i=0}^{2^d} \alpha_i |i\rangle \langle i|$ + local_1: $D = \sum_{i=1}^{d} \alpha_i Z_i$ + Args: + params(np.array): parameters for the ansatz. + d_type(d_ansatz type): type of parameterization for the ansatz. + """ + + if d_type is d_ansatz_type.element_wise: + d = np.zeros((len(params), len(params))) + for i in range(len(params)): + d[i, i] = params[i] + + elif d_type is d_ansatz_type.local_1: + + op_list = [params[i] * symbols.Z(i) for i in range(len(params))] + symbolHam = op_list[0] + for i in range(len(params) - 1): + symbolHam += op_list[i + 1] + + d = SymbolicHamiltonian(symbolHam, nqubits=len(params)) + d = d.dense.matrix + else: + raise ValueError(f"Parameterization type {type} not recognized.") + + return d + + +def dGamma_diDiagonal(d, h, n, i, dGamma, gamma_list): + r""" + Gradient of the nth gamma operator with respect to the ith diagonal elements of D. + $Gamma_{n} = [W,[W,...,[W,H]]...]]$, + $\frac{\partial Gamma_{n}}{\partial D_{ii}} = \partial_{D_{ii}} W\Gamma_{n-1}-\partial_{D_{ii}}\Gamma_{n-1} W$. + and thus is can be computed recursively. + Args: + d(np.array): D operator. + h(np.array): Hamiltonian. + n(int): nth Gamma operator. + i(int): Index of the diagonal element of D. + dGamma(list): List of the n-1 derivatives of the gamma operators (better to keep them in memory than to calculate at each iteration). + gamma_list(list): List of the n gamma operators. + Returns: + (float): Derivative of the nth gamma operator with respect to the ith diagonal elements of D. + """ + dD_di = np.zeros(d.shape) + dD_di[i, i] = 1 + dW_di = commutator(commutator(dD_di, h), gamma_list[n - 1]) + w = commutator(d, h) + return dW_di + commutator(w, dGamma[-1]) + + +# def dpolynomial_diDiagonal(dbi_object, d, h, i): #element_wise_ansatz +def derivative_scalar_product_dbr_approx_element_wise_ansatz(dbi_object, d, h, i): + r""" + TODO: add formula and explain terms + Gradient wrt the ith diagonal elements of D. + We make Double_bracket rotation with duration given by the minimzer of the ´polynomial_step´ function. + Gradient of the Taylor expansion of the least squares loss function as a function of $s$ the duration of Double-Bracket rotation element-wise ansatz: + $\partial_{D_{ii}} \text{Tr}(H_k@D) \approx \sum_{k=0}^{n} \frac{1}{k!!} \partial_{D_ii}\text{Tr}(\Gamma_{k}D)$. + Args: + dbi_object(DoubleBracketIteration): DoubleBracketIteration object. + d(np.array): D operator. + h(np.array): Hamiltonian. + i(int): Index of the diagonal element of D. + Returns: + derivative(float): Derivative of the polynomial expansion with respect to the ith diagonal elements of D. + """ + derivative = 0 + s = polynomial_step(dbi_object, n=3, d=d) + dD_di = np.zeros(d.shape) + gamma_list = dbi_object.generate_Gamma_list(4, d) + dD_di[i, i] = 1 + dGamma = [commutator(dD_di, h)] + derivative += np.real( + np.trace(gamma_list[0] @ dD_di) + + np.trace(dGamma[0] @ d + gamma_list[1] @ dD_di) * s + ) + for n in range(2, 4): + dGamma.append(dGamma_diDiagonal(d, h, n, i, dGamma, gamma_list)) + derivative += np.real( + np.trace(dGamma[-1] @ d + gamma_list[n] @ dD_di) * s**n / math.factorial(n) + ) + + return derivative + + +def gradientDiagonalEntries( + dbi_object, params, h, analytic=True, d_type=d_ansatz_type.element_wise, delta=1e-4 +): + r""" + Gradient of the DBI with respect to the parametrization of D. If analytic is True, the analytical gradient of the polynomial expansion of the DBI is used. + As the analytical gradient is applied on the polynomial expansion of the cost function, the numerical gradients may be more accurate. + + Args: + dbi_object(DoubleBracketIteration): DoubleBracketIteration object. + params(np.array): Parameters for the ansatz (note that the dimension must be 2**nqubits for full ansazt and nqubits for Pauli ansatz). + h(np.array): Hamiltonian. + analytic(bool): If True, the gradient is calculated analytically, otherwise numerically. + d_type(d_ansatz_type): Ansatz used for the D operator. Options are 'Full' and '1-local'. + delta(float): Step size for numerical gradient. + Returns: + grad(np.array): Gradient of the D operator. + """ + + grad = np.zeros(len(params)) + d = d_ansatz(params, d_type) + if analytic == True: + for i in range(len(params)): + derivative = derivative_scalar_product_dbr_approx_element_wise_ansatz( + dbi_object, d, h, i + ) + grad[i] = d[i, i] - derivative + else: + for i in range(len(params)): + params_new = deepcopy(params) + params_new[i] += delta + d_new = d_ansatz(params_new, d_type) + grad[i] = (dbi_object.loss(0.0, d_new) - dbi_object.loss(0.0, d)) / delta + return grad + + +def gradient_descent_dbr_d_ansatz( + dbi_object, + params, + nmb_iterations, + lr=1e-2, + analytic=True, + d_type=d_ansatz_type.element_wise, +): + r""" + Optimizes the D operator using gradient descent evaluated at the at the rotaion angle found using the polynomial expansion. + - Declare variables + - Calculate initial loss + - Iterate, learning at each the optimal D and measure loss + - Return values + Args: + dbi_object(DoubleBracketIteration): DoubleBracketIteration object. + params(np.array): Initial parameters for the ansatz (note that the dimension must be 2**nqubits for full ansazt and nqubits for Pauli ansatz). + nmb_iterations(int): Number of gradient descent iterations. + lr(float): Learning rate. + analytic(bool): If True, the gradient is calculated analytically, otherwise numerically. + d_type(d_ansatz_type): Ansatz used for the D operator. + Returns: + d(np.array): Optimized D operator. + loss(np.array): Loss function evaluated at each iteration. + grad(np.array): Gradient evaluated at each iteration. + params_hist(np.array): Parameters evaluated at each iteration. + """ + + h = dbi_object.h.matrix + d = d_ansatz(params, d_type) + loss = np.zeros(nmb_iterations + 1) + grad = np.zeros((nmb_iterations, len(params))) + dbi_new = deepcopy(dbi_object) + s = polynomial_step(dbi_object, n=3, d=d) + dbi_new(s, d=d) + loss[0] = dbi_new.loss(0.0, d) + params_hist = np.empty((len(params), nmb_iterations + 1)) + params_hist[:, 0] = params + + for i in range(nmb_iterations): + dbi_new = deepcopy(dbi_object) + grad[i, :] = gradientDiagonalEntries( + dbi_object, params, h, analytic=analytic, d_type=d_type + ) + for j in range(len(params)): + params[j] = params[j] - lr * grad[i, j] + d = d_ansatz(params, d_type) + s = polynomial_step(dbi_new, n=3, d=d) + dbi_new(s, d=d) + loss[i + 1] = dbi_new.loss(0.0, d=d) + params_hist[:, i + 1] = params + + return d, loss, grad, params_hist diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 4284c6caef..54c728e5f5 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -95,7 +95,7 @@ def polynomial_step( n_max: int = 5, d: np.array = None, coef: Optional[list] = None, - cost: str = None, + cost=None, ): r""" Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. @@ -107,7 +107,7 @@ def polynomial_step( backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. """ if cost is None: - cost = dbi_object.cost.name + cost = dbi_object.cost if d is None: d = dbi_object.diagonal_h_matrix @@ -117,17 +117,7 @@ def polynomial_step( "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." ) if coef is None: - if cost == "off_diagonal_norm": - coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n) - elif cost == "least_squares": - coef = least_squares_polynomial_expansion_coef(dbi_object, d, n) - elif cost == "energy_fluctuation": - coef = energy_fluctuation_polynomial_expansion_coef( - dbi_object, d, n, dbi_object.state - ) - else: - raise ValueError(f"Cost function {cost} not recognized.") - + coef = dbi_object.cost_expansion(d=d, n=n) roots = np.roots(coef) real_positive_roots = [ np.real(root) for root in roots if np.imag(root) < error and np.real(root) > 0 From de80cb05d9f244ecd63ab4917c632e3039883377 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Thu, 2 May 2024 18:16:08 +0200 Subject: [PATCH 101/116] Thanks Edoardo for pointing out the lint issues --- src/qibo/models/dbi/group_commutator_iteration_transpiler.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 55cfdb32a5..8eb544456e 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -118,10 +118,10 @@ def __call__( before_circuit.unitary() @ self.h.matrix @ after_circuit.unitary() ) - elif self.mode_evolution_oracle is EvolutionOracleType.text_strings: + elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings: raise_error(NotImplementedError) else: - super().__call__(step, d) + super().__call__(step_duration, diagonal_association.h.dense.matrix) def eval_gcr_unitary( self, step_duration: float, From fd1737b54468f97179cfa339fad0f52b0611ae0f Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Sun, 19 May 2024 10:34:44 +0800 Subject: [PATCH 102/116] Fix minor errors in notebook, add new test files --- ...t_functions_and_d_gradients_tutorial.ipynb | 17 ++- src/qibo/models/dbi/utils_strategies.py | 2 +- tests/test_models_dbi.py | 102 ++++++------------ tests/test_models_dbi_strategies.py | 63 +++++++++++ 4 files changed, 102 insertions(+), 82 deletions(-) create mode 100644 tests/test_models_dbi_strategies.py diff --git a/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb b/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb index 6607eaf6dc..569fef850f 100644 --- a/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb +++ b/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb @@ -187,13 +187,12 @@ "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", "\n", "# define the energy fluctuation cost function\n", - "cost = DoubleBracketCostFunction.energy_fluctuation\n", + "cost = DoubleBracketCostFunction.off_diagonal_norm\n", "# define the state\n", "state = np.zeros(2**nqubits)\n", "state[3] = 1\n", "# initialize class\n", - "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, ref_state=state)\n", - "\n" + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, ref_state=state)" ] }, { @@ -411,7 +410,7 @@ "metadata": {}, "outputs": [], "source": [ - "cost = DoubleBracketCost.least_squares\n", + "cost = DoubleBracketCostFunction.least_squares\n", "nqubits = 5\n", "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n", "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", @@ -455,7 +454,7 @@ "metadata": {}, "outputs": [], "source": [ - "cost = DoubleBracketCost.least_squares\n", + "cost = DoubleBracketCostFunction.least_squares\n", "nqubits = 5\n", "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n", "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", @@ -508,7 +507,7 @@ " H_TFIM = hamiltonians.TFIM(nqubits=nqubits[q], h=h)\n", "\n", " # define the least-squares cost function\n", - " cost = DoubleBracketCost.least_squares\n", + " cost = DoubleBracketCostFunction.least_squares\n", " # initialize class\n", " dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", " loss_max [q] = dbi.least_squares(d=np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q])))\n", @@ -567,7 +566,7 @@ "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", "\n", "# define the least-squares cost function\n", - "cost = DoubleBracketCost.least_squares\n", + "cost = DoubleBracketCostFunction.least_squares\n", "\n", "# initialize class\n", "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" @@ -634,7 +633,7 @@ "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", "\n", "# define the least-squares cost function\n", - "cost = DoubleBracketCost.least_squares\n", + "cost = DoubleBracketCostFunction.least_squares\n", "\n", "# initialize class\n", "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)" @@ -692,7 +691,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.19" + "version": "3.11.7" }, "orig_nbformat": 4, "vscode": { diff --git a/src/qibo/models/dbi/utils_strategies.py b/src/qibo/models/dbi/utils_strategies.py index dfc5a00ae1..34a5531f1b 100644 --- a/src/qibo/models/dbi/utils_strategies.py +++ b/src/qibo/models/dbi/utils_strategies.py @@ -1,7 +1,7 @@ import hyperopt from qibo.models.dbi.double_bracket import * -from qibo.models.dbi.utils import cs_angle_sgn +from qibo.models.dbi.utils import cs_angle_sgn, generate_pauli_operator_dict from qibo.models.dbi.utils_analytical import * from qibo.models.dbi.utils_scheduling import polynomial_step diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 01f2cd7f0c..1fd60480d8 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -19,6 +19,7 @@ @pytest.mark.parametrize("nqubits", [1, 2]) def test_double_bracket_iteration_canonical(backend, nqubits): + """Check default (canonical) mode.""" h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -33,6 +34,7 @@ def test_double_bracket_iteration_canonical(backend, nqubits): @pytest.mark.parametrize("nqubits", [1, 2]) def test_double_bracket_iteration_group_commutator(backend, nqubits): + """Check group commutator mode.""" h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( @@ -51,6 +53,7 @@ def test_double_bracket_iteration_group_commutator(backend, nqubits): @pytest.mark.parametrize("nqubits", [1, 2]) def test_double_bracket_iteration_single_commutator(backend, nqubits): + """Check single commutator mode.""" h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( @@ -69,95 +72,50 @@ def test_double_bracket_iteration_single_commutator(backend, nqubits): @pytest.mark.parametrize("nqubits", [3, 4]) -def test_hyperopt_step(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) - d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) - dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) - dbi.scheduling = DoubleBracketScheduling.hyperopt - # find initial best step with look_ahead = 1 - initial_step = 0.01 - delta = 0.02 - step = dbi.choose_step( - step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100 - ) - - assert step != initial_step - - # evolve following with optimized first step - for generator in DoubleBracketGeneratorType: - dbi(mode=generator, step=step, d=d) - - # find the following step size with look_ahead - look_ahead = 3 - - step = dbi.choose_step( - step_min=initial_step - delta, - step_max=initial_step + delta, - max_evals=10, - look_ahead=look_ahead, - ) - - # evolve following the optimized first step - for gentype in range(look_ahead): - dbi(mode=DoubleBracketGeneratorType(gentype + 1), step=step, d=d) - - -def test_energy_fluctuations(backend): - h0 = np.array([[1, 0], [0, -1]]) - h0 = backend.cast(h0, dtype=backend.dtype) - - dbi = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend)) - energy_fluctuation = dbi.energy_fluctuation() - assert energy_fluctuation == 0.0 - - @pytest.mark.parametrize( "scheduling", [ DoubleBracketScheduling.grid_search, DoubleBracketScheduling.hyperopt, + DoubleBracketScheduling.polynomial_approximation, DoubleBracketScheduling.simulated_annealing, ], ) -@pytest.mark.parametrize("nqubits", [3, 4, 5]) -def test_double_bracket_iteration_scheduling_grid_hyperopt_annealing( - backend, nqubits, scheduling -): +def test_variational_scheduling(backend, nqubits, scheduling): + """Check schduling options.""" h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) - d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( - Hamiltonian(nqubits, h0, backend=backend), - mode=DoubleBracketGeneratorType.single_commutator, + Hamiltonian(nqubits, h0, backend=backend), scheduling=scheduling ) + # find initial best step with look_ahead = 1 initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - step1 = dbi.choose_step(d=d, scheduling=scheduling) - dbi(d=d, step=step1) - step2 = dbi.choose_step() - dbi(step=step2) + step = dbi.choose_step() + dbi(step=step) assert initial_off_diagonal_norm > dbi.off_diagonal_norm -@pytest.mark.parametrize("nqubits", [3, 4, 6]) -@pytest.mark.parametrize("n", [2, 4]) -@pytest.mark.parametrize( - "cost", - [ - DoubleBracketCostFunction.least_squares, - DoubleBracketCostFunction.off_diagonal_norm, - ], -) -def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n, cost): +def test_energy_fluctuations(backend): + """Check energy fluctuation cost function.""" + nqubits = 3 + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) + dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) + # define the state + state = np.zeros(2**nqubits) + state[3] = 1 + assert dbi.energy_fluctuation(state=state) < 1e-5 + + +def test_least_squares(backend): + """Check least squares cost function.""" + nqubits = 3 h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) - d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), - mode=DoubleBracketGeneratorType.single_commutator, - scheduling=DoubleBracketScheduling.polynomial_approximation, - cost=cost, + cost=DoubleBracketCostFunction.least_squares, ) - initial_off_diagonal_norm = dbi.off_diagonal_norm - for _ in range(NSTEPS): - step1 = dbi.choose_step(d=d, n=n) - dbi(d=d, step=step1) - assert initial_off_diagonal_norm > dbi.off_diagonal_norm + d = np.diag(np.linspace(1, 2**nqubits, 2**nqubits)) / 2**nqubits + initial_potential = dbi.least_squares(d=d) + step = dbi.choose_step(d=d) + dbi(d=d, step=step) + assert dbi.least_squares(d=d) < initial_potential diff --git a/tests/test_models_dbi_strategies.py b/tests/test_models_dbi_strategies.py new file mode 100644 index 0000000000..89aad6ea9f --- /dev/null +++ b/tests/test_models_dbi_strategies.py @@ -0,0 +1,63 @@ +"""Testing DoubleBracketIteration strategies""" + +import numpy as np +import pytest + +from qibo.hamiltonians import Hamiltonian +from qibo.models.dbi.double_bracket import ( + DoubleBracketCostFunction, + DoubleBracketGeneratorType, + DoubleBracketIteration, + DoubleBracketScheduling, +) +from qibo.models.dbi.utils import * +from qibo.models.dbi.utils_strategies import ( + gradient_descent_pauli, + select_best_dbr_generator, +) +from qibo.quantum_info import random_hermitian + +NSTEPS = 1 +seed = 5 +"""Number of steps for evolution.""" + + +@pytest.mark.parametrize("nqubits", [2, 3]) +def test_select_best_dbr_generator(backend, nqubits): + scheduling = DoubleBracketScheduling.grid_search + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + scheduling=scheduling, + ) + initial_off_diagonal_norm = dbi.off_diagonal_norm + generate_local_Z = generate_Z_operators(nqubits) + Z_ops = list(generate_local_Z.values()) + for _ in range(NSTEPS): + dbi, idx, step, flip_sign = select_best_dbr_generator( + dbi, Z_ops, scheduling=scheduling, compare_canonical=True + ) + assert dbi.off_diagonal_norm < initial_off_diagonal_norm + + +@pytest.mark.parametrize("nqubits", [2, 3]) +def test_gradient_descent_pauli(backend, nqubits): + scheduling = DoubleBracketScheduling.grid_search + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + scheduling=scheduling, + ) + initial_off_diagonal_norm = dbi.off_diagonal_norm + pauli_operator_dict = generate_pauli_operator_dict( + nqubits=nqubits, parameterization_order=2 + ) + d_coef = decompose_into_Pauli_basis( + dbi.h.matrix, list(pauli_operator_dict.values()) + ) + d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)]) + step, d_coef, d = gradient_descent_pauli(dbi, d_coef, d) + dbi(d=d, step=step) + assert dbi.off_diagonal_norm < initial_off_diagonal_norm From b6f220a592bc2147a3f6e2cec8cf7f5b2e0a5288 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 20 May 2024 13:18:33 +0800 Subject: [PATCH 103/116] Fix test_dbi.py with pytorch (backend.cast) --- examples/dbi/dbi_strategies_compare.ipynb | 3 ++- src/qibo/models/dbi/double_bracket.py | 6 ++++-- src/qibo/models/dbi/utils_analytical.py | 4 +++- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb index 7dfe2c5c60..54d7fe4dff 100644 --- a/examples/dbi/dbi_strategies_compare.ipynb +++ b/examples/dbi/dbi_strategies_compare.ipynb @@ -67,7 +67,7 @@ "h0 = random_hermitian(2**nqubits, seed=2)\n", "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))\n", "cost = DoubleBracketCostFunction.off_diagonal_norm\n", - "print(\"Initial loss\", dbi.least_squares(D=dbi.diagonal_h_matrix))\n", + "print(\"Initial loss\", dbi.least_squares(d=dbi.diagonal_h_matrix))\n", "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')" ] }, @@ -133,6 +133,7 @@ "outputs": [], "source": [ "# initialize DBI class for the Pauli-Z strategy\n", + "set_backend(\"pytorch\", platform=\"numba\")\n", "dbi_pauli = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling, cost=cost)" ] }, diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 27b94d2cfb..a997dc1f61 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -225,8 +225,10 @@ def energy_fluctuation(self, state): """ h_np = self.backend.cast(np.diag(np.diag(self.backend.to_numpy(self.h.matrix)))) h2 = h_np @ h_np - a = state.conj() @ h2 @ state - b = state.conj() @ h_np @ state + state_cast = self.backend.cast(state) + state_conj = self.backend.cast(state.conj()) + a = state_conj @ h2 @ state_cast + b = state_conj @ h_np @ state_cast return (np.sqrt(np.real(a - b**2))).item() r # return np.real(self.h.energy_fluctuation(state)) diff --git a/src/qibo/models/dbi/utils_analytical.py b/src/qibo/models/dbi/utils_analytical.py index 6d09a76ffd..3910b7c9d8 100644 --- a/src/qibo/models/dbi/utils_analytical.py +++ b/src/qibo/models/dbi/utils_analytical.py @@ -163,7 +163,9 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + W = dbi_object.commutator( + dbi_object.backend.cast(d), dbi_object.sigma(dbi_object.h.matrix) + ) Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) From 37a129b5f162dde27d65626220ab51f6621f46fd Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 20 May 2024 07:26:30 +0200 Subject: [PATCH 104/116] extrating number of gates --- examples/dbi/extracting_dbi_circuits.ipynb | 3563 +++++++++++++++++++- 1 file changed, 3542 insertions(+), 21 deletions(-) diff --git a/examples/dbi/extracting_dbi_circuits.ipynb b/examples/dbi/extracting_dbi_circuits.ipynb index 1028017fa2..f281e4232a 100644 --- a/examples/dbi/extracting_dbi_circuits.ipynb +++ b/examples/dbi/extracting_dbi_circuits.ipynb @@ -20,7 +20,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-30 09:44:18]: Using numpy backend on /CPU:0\n" + "[Qibo 0.2.7|INFO|2024-05-03 09:28:36]: Using numpy backend on /CPU:0\n" ] } ], @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 105, "id": "d8eac22c", "metadata": {}, "outputs": [ @@ -49,13 +49,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|WARNING|2024-04-30 09:44:18]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.7|WARNING|2024-04-30 09:44:18]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.7|WARNING|2024-05-03 09:52:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.7|WARNING|2024-05-03 09:52:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], "source": [ - "r=0.1\n", + "r=0.01\n", "mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n", "h_x = SymbolicHamiltonian(\n", " symbols.X(0)\n", @@ -71,10 +71,10 @@ "\n", "evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle) \n", "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n", - "\n", + "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_reduced\n", "evolution_oracle_diagonal_target = EvolutionOracle(d_0, \"D0\",\n", " mode_evolution_oracle)\n", - "\n", + "evolution_oracle.eps_trottersuzuki = 1e-1\n", "from numpy.linalg import norm\n", "\n", "for _ in range(4):\n", @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 106, "id": "cad5fe99", "metadata": {}, "outputs": [], @@ -99,33 +99,3466 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "1d8388e6", + "execution_count": 107, + "id": "e6bebcb8", + "metadata": {}, + "outputs": [], + "source": [ + "q = u.queue" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "efa7f839", "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "'Circuit' object has no attribute 'conj'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_143211/1837199151.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mh0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mh_input\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mh_end\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mh0\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m: 'Circuit' object has no attribute 'conj'" + "name": "stdout", + "output_type": "stream", + "text": [ + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n", + "Unitary\n" ] } ], + "source": [ + "for g in q:\n", + " print(g.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "c8eded43", + "metadata": {}, + "outputs": [], + "source": [ + "it = 0\n", + "for g in u.queue:\n", + " if g.matrix().shape[0] == 4:\n", + " it = it+1" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "6a1bd68f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1932" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "it" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "1d8388e6", + "metadata": {}, + "outputs": [], "source": [ "h0 = h_input.dense.matrix\n", - "h_end = u.conj().T @ h0 @ u" + "h_end = u.unitary().conj().T @ h0 @ u.unitary()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 112, "id": "fc364e18", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.0011754492342204688" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "norm(h_end - dbi.h.matrix)" ] @@ -164,6 +3597,94 @@ "id": "3a9ea4c1", "metadata": {}, "outputs": [], + "source": [ + "c= qibo.Circuit(nqubits=4)\n", + "c.add(gates.CNOT(1,3))\n", + "c.add(gates.Z(2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5dc9d7fe", + "metadata": {}, + "outputs": [], + "source": [ + "g = c.queue[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "3a39c34c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3,)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.target_qubits" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7d4ffd2a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "eea836f5", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'TNS' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_44195/2756981244.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mqueue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mqibo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgates\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgates\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCNOT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mTNS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_CNOT\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_qubits\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontrol_qubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'TNS' is not defined" + ] + } + ], + "source": [ + "for g in c.queue:\n", + " if isinstance(g,qibo.gates.gates.CNOT):\n", + " TNS.apply_CNOT(g.target_qubits,g.control_qubits)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "400168cb", + "metadata": {}, + "outputs": [], "source": [] } ], From d3ab311ba55374fc506507ce48e6c237b9ba89c7 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 20 May 2024 15:07:56 +0800 Subject: [PATCH 105/116] Fix test_gci_implementation_normal_and_oracles assertion error, increased trotter steps limit --- .../dbi/double_bracket_evolution_oracles.py | 110 +++----- tests/test_models_dbi.py | 237 +++++++++++------- 2 files changed, 172 insertions(+), 175 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py index 9ae5360866..95bf5e0250 100644 --- a/src/qibo/models/dbi/double_bracket_evolution_oracles.py +++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py @@ -47,92 +47,33 @@ def __init__( self.eps_trottersuzuki = 0.0001 self.please_be_verbose = False - def __call__(self, t_duration: float = None): + def __call__(self, t_duration: float): """Returns either the name or the circuit""" - if t_duration is None: - return self.name - else: - return self.circuit(t_duration=t_duration) + return self.circuit(t_duration=t_duration) def eval_unitary(self, t_duration): - """ This wraps around `circuit` and always returns a unitary""" + """This wraps around `circuit` and always returns a unitary""" if self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.circuit(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: return self.circuit(t_duration).unitary() - else: - raise_error( - ValueError, - f"You are using an EvolutionOracle type which does not seem to return a unitary.", - ) - - def circuit(self, t_duration: float = None): """This function returns depending on `EvolutionOracleType` string, ndarray or `Circuit`. - In the hamiltonian_simulation mode we evaluate an appropriate Trotter-Suzuki discretization up to `self.eps_trottersuzuki` threshold.""" + In the hamiltonian_simulation mode we evaluate an appropriate Trotter-Suzuki discretization up to `self.eps_trottersuzuki` threshold. + """ if self.mode_evolution_oracle is EvolutionOracleType.text_strings: return self.name + str(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.numerical: return self.h.exp(t_duration) elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - - if self.please_be_verbose: - print( - "Calling circuit in Hamiltonian simulation mode for time t=" - + str(t_duration) - + " and next running discretization adjustment to reach precision eps = " - + str(self.eps_trottersuzuki) - ) return self.discretized_evolution_circuit_binary_search( t_duration, eps=self.eps_trottersuzuki ) - else: - raise_error( - ValueError, - f"You are using an EvolutionOracle type which is not yet supported.", - ) - - def discretized_evolution_circuit(self, t_duration, eps=None): - - nmb_trottersuzuki_steps = 3 - if eps is None: - eps = self.eps_trottersuzuki - target_unitary = self.h.exp(t_duration) - - from copy import deepcopy - - proposed_circuit_unitary = np.linalg.matrix_power( - deepcopy(self.h.circuit(t_duration / nmb_trottersuzuki_steps)).unitary(), - nmb_trottersuzuki_steps, - ) - norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) - - if self.please_be_verbose: - print(nmb_trottersuzuki_steps, norm_difference) - while norm_difference > eps: - nmb_trottersuzuki_steps = nmb_trottersuzuki_steps * 2 - proposed_circuit_unitary = np.linalg.matrix_power( - deepcopy(self.h) - .circuit(t_duration / nmb_trottersuzuki_steps) - .unitary(), - nmb_trottersuzuki_steps, - ) - norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) - if self.please_be_verbose: - print(nmb_trottersuzuki_steps, norm_difference) - from functools import reduce - - circuit_1_step = deepcopy(self.h.circuit(t_duration / nmb_trottersuzuki_steps)) - combined_circuit = reduce( - Circuit.__add__, [circuit_1_step] * nmb_trottersuzuki_steps - ) - assert np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps - return combined_circuit def discretized_evolution_circuit_binary_search(self, t_duration, eps=None): - nmb_trottersuzuki_steps = 3 # this is the smallest size - nmb_trottersuzki_steps_right = 50 # this is the largest size for binary search + nmb_trottersuzuki_steps = 1 # this is the smallest size + nmb_trottersuzki_steps_right = 800 # this is the largest size for binary search if eps is None: eps = self.eps_trottersuzuki target_unitary = self.h.exp(t_duration) @@ -145,16 +86,20 @@ def check_accuracy(n_steps): n_steps, ) norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary) - if self.please_be_verbose: - print(n_steps, norm_difference) return norm_difference < eps - while nmb_trottersuzuki_steps < nmb_trottersuzki_steps_right: - mid = (nmb_trottersuzuki_steps + nmb_trottersuzki_steps_right) // 2 + nmb_trottersuzuki_steps_used = nmb_trottersuzki_steps_right + while nmb_trottersuzuki_steps <= nmb_trottersuzki_steps_right: + mid = ( + nmb_trottersuzuki_steps + + (nmb_trottersuzki_steps_right - nmb_trottersuzuki_steps) // 2 + ) if check_accuracy(mid): - nmb_trottersuzki_steps_right = mid + nmb_trottersuzuki_steps_used = mid + nmb_trottersuzki_steps_right = mid - 1 else: nmb_trottersuzuki_steps = mid + 1 + nmb_trottersuzuki_steps = nmb_trottersuzuki_steps_used from functools import reduce @@ -162,7 +107,9 @@ def check_accuracy(n_steps): combined_circuit = reduce( Circuit.__add__, [circuit_1_step] * nmb_trottersuzuki_steps ) - assert np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps + assert ( + np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps + ), f"{np.linalg.norm(combined_circuit.unitary() - target_unitary)},{eps}, {nmb_trottersuzuki_steps}" return combined_circuit @@ -177,7 +124,6 @@ def __init__( assert isinstance(before_circuit, type(after_circuit)) - self.h = base_evolution_oracle.h self.base_evolution_oracle = base_evolution_oracle self.name = name + "(" + base_evolution_oracle.name + ")" @@ -190,9 +136,13 @@ def circuit(self, t_duration: float = None): if self.mode_evolution_oracle is EvolutionOracleType.text_strings: return self.name + "(" + str(t_duration) + ")" elif self.mode_evolution_oracle is EvolutionOracleType.numerical: - return self.before_circuit @ self.base_evolution_oracle(t_duration) @ self.after_circuit + return ( + self.before_circuit + @ self.base_evolution_oracle(t_duration) + @ self.after_circuit + ) elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: - + return ( self.after_circuit + self.base_evolution_oracle.circuit(t_duration) @@ -203,16 +153,16 @@ def circuit(self, t_duration: float = None): ValueError, f"You are using an EvolutionOracle type which is not yet supported.", ) + def get_composed_circuit(self): c = self.circuit(0) fseo = self - while isinstance( fseo, FrameShiftedEvolutionOracle): + while isinstance(fseo, FrameShiftedEvolutionOracle): if self.mode_evolution_oracle is EvolutionOracleType.numerical: c = fseo.after_circuit @ c - elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + elif ( + self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation + ): c = c + fseo.after_circuit fseo = fseo.base_evolution_oracle return c - - - diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 9166481407..c9fddcd6b2 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -1,9 +1,12 @@ """Testing DoubleBracketIteration model""" +from copy import deepcopy + import numpy as np import pytest -from qibo.hamiltonians import Hamiltonian +from qibo import symbols +from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian from qibo.models.dbi.double_bracket import ( DoubleBracketCostFunction, DoubleBracketGeneratorType, @@ -11,7 +14,10 @@ DoubleBracketScheduling, ) from qibo.models.dbi.double_bracket_evolution_oracles import EvolutionOracle -from qibo.models.dbi.group_commutator_iteration_transpiler import * +from qibo.models.dbi.group_commutator_iteration_transpiler import ( + EvolutionOracleType, + GroupCommutatorIterationWithEvolutionOracles, +) from qibo.quantum_info import random_hermitian NSTEPS = 1 @@ -72,23 +78,27 @@ def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits): s, d=d, mode=DoubleBracketGeneratorType.group_commutator ) - norms.append(np.linalg.norm(u - v) ) - w = dbi.commutator(h0,d) - norms_bound.append(0.5*s**1.48 * ( - np.linalg.norm(dbi.commutator(h0,w)) + np.linalg.norm(dbi.commutator(d,w)) - )) + norms.append(np.linalg.norm(u - v)) + w = dbi.commutator(h0, d) + norms_bound.append( + 0.5 + * s**1.48 + * ( + np.linalg.norm(dbi.commutator(h0, w)) + + np.linalg.norm(dbi.commutator(d, w)) + ) + ) assert np.linalg.norm(u - v) < 10 * s**1.49 * ( - np.linalg.norm(h0) + np.linalg.norm(d) - ) * np.linalg.norm(h0) * np.linalg.norm(d) - + np.linalg.norm(h0) + np.linalg.norm(d) + ) * np.linalg.norm(h0) * np.linalg.norm(d) @pytest.mark.parametrize("nqubits", [3]) -def test_dbi_evolution_oracle(backend, nqubits, t_step = 0.1, eps = 0.001 ): - """ We test the basic functionality provided by `EvolutionOracle`: +def test_dbi_evolution_oracle(backend, nqubits, t_step=0.1, eps=0.001): + """We test the basic functionality provided by `EvolutionOracle`: - hamiltonian_simulation: will use `SymbolicHamiltonian.circuit()` and should match with the corresponding evolution unitary up to the discretization error threshold - numerical is just exponential $e^{-1jt_{step} H}$ - - text_strings will have strings which just have the name of the evolution oracle + - text_strings will have strings which just have the name of the evolution oracle """ from numpy.linalg import norm @@ -119,18 +129,20 @@ def test_dbi_evolution_oracle(backend, nqubits, t_step = 0.1, eps = 0.001 ): h_input, "ZX numpy", mode_evolution_oracle=EvolutionOracleType.numerical ) U_np = evolution_oracle_np.circuit(t_step) - assert norm(U_np - V_target) < 1e-12 + assert norm(U_np - V_target) < 1e-10 evolution_oracle_txt = EvolutionOracle( h_input, "ZX test", mode_evolution_oracle=EvolutionOracleType.text_strings ) - U_txt = evolution_oracle_txt.circuit(t_step) + U_txt = evolution_oracle_txt.circuit(t_step) assert isinstance(U_txt, str) - -def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps): - """ +@pytest.mark.parametrize("nqubits", [3]) +@pytest.mark.parametrize("t_step", [1e-3]) +@pytest.mark.parametrize("eps", [1e-3]) +def test_gci_evolution_oracles_types_numerical(backend, nqubits, t_step, eps): + r""" This is testing the following: @@ -147,6 +159,7 @@ def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps): $$||J_1-K_1||\le2 ||H_0||\,||R-Q||\le \epsilon$$ """ from numpy.linalg import norm + h_x = SymbolicHamiltonian( symbols.X(0) + symbols.Z(0) * symbols.X(1) @@ -159,66 +172,88 @@ def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps): dbi = DoubleBracketIteration(deepcopy(h_input.dense)) - w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix) - norms_bound = 0.5*t_step**1.48 * ( - np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w)) + w = dbi.commutator(h_input.dense.matrix, d_0.dense.matrix) + norms_bound = ( + 0.5 + * t_step**1.48 + * ( + np.linalg.norm(dbi.commutator(h_input.dense.matrix, w)) + + np.linalg.norm(dbi.commutator(d_0.matrix, w)) + ) ) - v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator) - v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator) + v_exact = dbi.eval_dbr_unitary( + t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator + ) + v_gc = dbi.eval_dbr_unitary( + t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator + ) assert norm(v_exact - v_gc) < norms_bound - dbi(t_step, d = d_0.dense.matrix ) + dbi(t_step, d=d_0.dense.matrix) h_1 = dbi.h.matrix dbi.h = deepcopy(h_input.dense) - dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) + dbi(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator) k_1 = dbi.h.matrix - assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound + assert norm(h_1 - k_1) < 2 * norm(h_input.dense.matrix) * norms_bound - evolution_oracle = EvolutionOracle(h_input, "ZX", - mode_evolution_oracle = EvolutionOracleType.numerical) + evolution_oracle = EvolutionOracle( + h_input, "ZX", mode_evolution_oracle=EvolutionOracleType.numerical + ) - evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", - mode_evolution_oracle = EvolutionOracleType.numerical) + evolution_oracle_diagonal_target = EvolutionOracle( + d_0, "D0", mode_evolution_oracle=EvolutionOracleType.numerical + ) - gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle )) + gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) - u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target ) - assert norm(u_gc_from_oracles['forwards'].conj().T - u_gc_from_oracles['backwards']) < 1e-12 + u_gc_from_oracles = gci.group_commutator(t_step, evolution_oracle_diagonal_target) + assert ( + norm(u_gc_from_oracles["forwards"].conj().T - u_gc_from_oracles["backwards"]) + < 1e-10 + ) - assert norm(v_exact - gci.eval_gcr_unitary(t_step, evolution_oracle_diagonal_target)) < norms_bound + assert ( + norm(v_exact - gci.eval_gcr_unitary(t_step, evolution_oracle_diagonal_target)) + < norms_bound + ) - gci(t_step, diagonal_association= evolution_oracle_diagonal_target ) + gci(t_step, diagonal_association=evolution_oracle_diagonal_target) j_1 = gci.h.matrix - assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound - - assert norm(j_1-k_1) < 1e-12 - - - -def test_gci_frame_shifted_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation): - """In a group commutator iteration (GCI) we have -$$J_{k+1}= U_k^\dagger J_k U_k$$ -which is obtained by a product formula for $U_k$. -We will use two examples -$$A_k = e^{is D} e^{is J_k} e^{-isD}$$ - -This means that $A_k$ and $B_k$ schemes should give the same `Groupand -$$B_k = e^{-is J_k}e^{is D} e^{is J_k} e^{-isD}$$ -In both cases $D$ is fixed, which amounts to a product formula approximation of the BHMM scheme. - -For $B_k$ we have the group commutator bound, see below. For $A_k$ we will have that -$$J_{k+1}= A_k^\dagger J_k A_k= B_k^\dagger J_k B_k$$ -because of a reduction by means of a commutator vanishing (the ordering was chosen on purpose). -CommutatorIterationWithEvolutionOracles.h`. Additionally that should be also `DoubleBracketIteration.h` as long as the ordering is correct. - -If we operate in the `EvolutionOracleType.hamiltonian_simulation` there will be deviations based on the `EvolutionOracle.eps_trottersuzuki` threshold.""" - + assert norm(h_1 - j_1) < 2 * norm(h_input.dense.matrix) * norms_bound + + assert norm(j_1 - k_1) < 1e-10 + + +@pytest.mark.parametrize("nqubits", [3]) +@pytest.mark.parametrize( + "mode_evolution_oracle", + [EvolutionOracleType.hamiltonian_simulation, EvolutionOracleType.numerical], +) +def test_gci_frame_shifted_oracles(backend, nqubits, mode_evolution_oracle): + r"""In a group commutator iteration (GCI) we have + $$J_{k+1}= U_k^\dagger J_k U_k$$ + which is obtained by a product formula for $U_k$. + We will use two examples + $$A_k = e^{is D} e^{is J_k} e^{-isD}$$ + + This means that $A_k$ and $B_k$ schemes should give the same `Groupand + $$B_k = e^{-is J_k}e^{is D} e^{is J_k} e^{-isD}$$ + In both cases $D$ is fixed, which amounts to a product formula approximation of the BHMM scheme. + + For $B_k$ we have the group commutator bound, see below. For $A_k$ we will have that + $$J_{k+1}= A_k^\dagger J_k A_k= B_k^\dagger J_k B_k$$ + because of a reduction by means of a commutator vanishing (the ordering was chosen on purpose). + CommutatorIterationWithEvolutionOracles.h`. Additionally that should be also `DoubleBracketIteration.h` as long as the ordering is correct. + + If we operate in the `EvolutionOracleType.hamiltonian_simulation` there will be deviations based on the `EvolutionOracle.eps_trottersuzuki` threshold. + """ + h_x = SymbolicHamiltonian( - symbols.X(0) + symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), @@ -229,84 +264,96 @@ def test_gci_frame_shifted_oracles(backend,nqubits,mode_evolution_oracle = Evolu dbi = DoubleBracketIteration(deepcopy(h_input.dense)) - evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle) - gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle )) + evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle) + gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) - evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", - mode_evolution_oracle) + evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", mode_evolution_oracle) from numpy.linalg import norm - + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: threshold = evolution_oracle.eps_trottersuzuki * 10 else: - threshold = 1e-12 - - r = .01 + threshold = 1e-10 + + r = 0.01 for _ in range(3): a = dbi.h.exp(r) b = gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r) - assert norm(a-b) < threshold - a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator) + assert norm(a - b) < threshold + a = dbi.eval_dbr_unitary( + r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator + ) b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target) - assert norm(a-b) < threshold - dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) - gci(r, diagonal_association= evolution_oracle_diagonal_target ) - + assert norm(a - b) < threshold + dbi(r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator) + gci(r, diagonal_association=evolution_oracle_diagonal_target) + k_r = dbi.h.matrix j_r = gci.h.matrix - assert norm(a-b) < threshold - - assert norm(norm(dbi.sigma(k_r))-norm(dbi.sigma(j_r))) < threshold + assert norm(a - b) < threshold + + assert norm(norm(dbi.sigma(k_r)) - norm(dbi.sigma(j_r))) < threshold + gci.iterated_hamiltonian_evolution_oracle.get_composed_circuit() -def test_gci_implementation_normal_and_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.numerical): + +@pytest.mark.parametrize("nqubits", [3]) +@pytest.mark.parametrize("mode_evolution_oracle", [EvolutionOracleType.numerical]) +def test_gci_implementation_normal_and_oracles(backend, nqubits, mode_evolution_oracle): """The regular implementation in `DoubleBracketIteration` should be viewed as using classical dynamic programming: memoization of the updated Hamiltonian is used explicitly. Instead, using `FrameShiftedEvolutionOracle` we can store a sequence of recursive rotations such that eventually the iteration gives the same result. This function tests numerical agreement using the numpy backend. """ h_x = SymbolicHamiltonian( - symbols.X(0) + symbols.X(0) + symbols.Z(0) * symbols.X(1) + symbols.Y(2) + symbols.Y(1) * symbols.Y(2), nqubits=3, - ) + ) d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3) h_input = h_x + d_0 dbi = DoubleBracketIteration(deepcopy(h_input.dense)) - evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle) - gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle )) + evolution_oracle = EvolutionOracle(h_input, "ZX", mode_evolution_oracle) + gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) - evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", - mode_evolution_oracle) + evolution_oracle_diagonal_target = EvolutionOracle(d_0, "D0", mode_evolution_oracle) from numpy.linalg import norm - times = np.linspace(1e-5,1,5) + if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: + threshold = evolution_oracle.eps_trottersuzuki * 10 + else: + threshold = 1e-10 + + times = np.linspace(1e-5, 1, 5) for r in times: - dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) + dbi(r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator) k_r = dbi.h.matrix - dbi.h = deepcopy(h_input.dense) - gci(r, diagonal_association= evolution_oracle_diagonal_target ) + dbi.h = deepcopy(h_input.dense) + gci(r, diagonal_association=evolution_oracle_diagonal_target) j_r = gci.h.matrix - gci.h = deepcopy(h_input.dense) - gci.iterated_hamiltonian_evolution_oracle = deepcopy(evolution_oracle) + gci.h = deepcopy(h_input.dense) + gci.iterated_hamiltonian_evolution_oracle = deepcopy(evolution_oracle) - assert norm(k_r-j_r) < 1e-12 + assert norm(k_r - j_r) < threshold r = 1 + for _ in range(3): - dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator ) - gci(r, diagonal_association= evolution_oracle_diagonal_target ) + dbi(r, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator) + gci(r, diagonal_association=evolution_oracle_diagonal_target) k_r = dbi.h.matrix j_r = gci.h.matrix - - assert norm(k_r-j_r) < 1e-12 + + assert norm(k_r - j_r) < threshold + + @pytest.mark.parametrize("nqubits", [1, 2]) def test_double_bracket_iteration_single_commutator(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) From b3b19e4879cf0794e5762ffecabe55c024b3783e Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 21 May 2024 10:33:18 +0800 Subject: [PATCH 106/116] Fix errors with pytorch: backend.cast --- ...bracket_flow_as_a_diagonalization_quantum_algorithm | 1 + src/qibo/models/dbi/double_bracket.py | 10 ++++++---- src/qibo/models/dbi/utils_analytical.py | 4 ++-- src/qibo/models/dbi/utils_strategies.py | 1 + 4 files changed, 10 insertions(+), 6 deletions(-) create mode 160000 double_bracket_flow_as_a_diagonalization_quantum_algorithm diff --git a/double_bracket_flow_as_a_diagonalization_quantum_algorithm b/double_bracket_flow_as_a_diagonalization_quantum_algorithm new file mode 160000 index 0000000000..808dd6325b --- /dev/null +++ b/double_bracket_flow_as_a_diagonalization_quantum_algorithm @@ -0,0 +1 @@ +Subproject commit 808dd6325b327a756a4b6ae5a4d560e01d1790cb diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index a997dc1f61..b9e02fef91 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -109,7 +109,7 @@ def __call__( d = self.diagonal_h_matrix operator = self.backend.calculate_matrix_exp( 1.0j * step, - self.commutator(d, self.h.matrix), + self.commutator(self.backend.cast(d), self.h.matrix), ) elif mode is DoubleBracketGeneratorType.group_commutator: if d is None: @@ -157,7 +157,7 @@ def backend(self): def least_squares(self, d: np.array): """Least squares cost function.""" - h_np = self.backend.to_numpy(self.h.matrix) + h_np = self.backend.cast(self.h.matrix) return np.real(0.5 * np.linalg.norm(d) ** 2 - np.trace(h_np @ d)) @@ -233,11 +233,13 @@ def energy_fluctuation(self, state): r # return np.real(self.h.energy_fluctuation(state)) def sigma(self, h: np.array): - return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) + return self.backend.cast(h) - self.backend.cast( + np.diag(np.diag(self.backend.to_numpy(h))) + ) def generate_Gamma_list(self, n: int, d: np.array): r"""Computes the n-nested Gamma functions, where $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" - W = self.commutator(d, self.sigma(self.h.matrix)) + W = self.commutator(self.backend.cast(d), self.sigma(self.h.matrix)) Gamma_list = [self.h.matrix] for _ in range(n - 1): Gamma_list.append(self.commutator(W, Gamma_list[-1])) diff --git a/src/qibo/models/dbi/utils_analytical.py b/src/qibo/models/dbi/utils_analytical.py index 3910b7c9d8..240003ee7e 100644 --- a/src/qibo/models/dbi/utils_analytical.py +++ b/src/qibo/models/dbi/utils_analytical.py @@ -21,8 +21,8 @@ def dGamma_di_Pauli(dbi_object, n: int, Z_i: np.array, d: np.array): nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) dGamma_di = [np.zeros((2**nqubits, 2**nqubits))] * (n + 1) Gamma_list = dbi_object.generate_Gamma_list(n=n + 2, d=d) - W = dbi_object.commutator(d, dbi_object.h.matrix) - dW_di = dbi_object.commutator(Z_i, dbi_object.h.matrix) + W = dbi_object.commutator(dbi_object.backend.cast(d), dbi_object.h.matrix) + dW_di = dbi_object.commutator(dbi_object.backend.cast(Z_i), dbi_object.h.matrix) for k in range(n + 1): if k == 0: continue diff --git a/src/qibo/models/dbi/utils_strategies.py b/src/qibo/models/dbi/utils_strategies.py index 34a5531f1b..86be56f55f 100644 --- a/src/qibo/models/dbi/utils_strategies.py +++ b/src/qibo/models/dbi/utils_strategies.py @@ -35,6 +35,7 @@ def select_best_dbr_generator( for i, d in enumerate(d_list): # prescribed step durations dbi_eval = deepcopy(dbi_object) + d = dbi_eval.backend.cast(d) flip_list[i] = cs_angle_sgn(dbi_eval, d) if flip_list[i] != 0: if step is None: From b90a357aafb5b8b32cc5e42cca4dd676d0a2f9ac Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 21 May 2024 10:57:48 +0800 Subject: [PATCH 107/116] Missing import --- tests/test_models_dbi.py | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index c9fddcd6b2..ec882364d8 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -15,6 +15,7 @@ ) from qibo.models.dbi.double_bracket_evolution_oracles import EvolutionOracle from qibo.models.dbi.group_commutator_iteration_transpiler import ( + DoubleBracketRotationType, EvolutionOracleType, GroupCommutatorIterationWithEvolutionOracles, ) @@ -138,10 +139,9 @@ def test_dbi_evolution_oracle(backend, nqubits, t_step=0.1, eps=0.001): assert isinstance(U_txt, str) -@pytest.mark.parametrize("nqubits", [3]) -@pytest.mark.parametrize("t_step", [1e-3]) -@pytest.mark.parametrize("eps", [1e-3]) -def test_gci_evolution_oracles_types_numerical(backend, nqubits, t_step, eps): +def test_gci_evolution_oracles_types_numerical( + backend, nqubits=3, t_step=1e-3, eps=1e-3 +): r""" This is testing the following: @@ -227,6 +227,17 @@ def test_gci_evolution_oracles_types_numerical(backend, nqubits, t_step, eps): assert norm(j_1 - k_1) < 1e-10 + # test single_commutator case + gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) + gci.mode_double_bracket_rotation = DoubleBracketRotationType.single_commutator + u_gc_from_oracles = gci.group_commutator(t_step, evolution_oracle_diagonal_target) + assert ( + norm(u_gc_from_oracles["forwards"].conj().T - u_gc_from_oracles["backwards"]) + < 1e-10 + ) + + # make 2 new objects with DoubleBracketRotationType.group_commutator_reduced and group_commutator, compare h matrix rotation + @pytest.mark.parametrize("nqubits", [3]) @pytest.mark.parametrize( From 1cd33d4536f673844cf21e24d7cebb4f19af4653 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 21 May 2024 11:05:35 +0800 Subject: [PATCH 108/116] Pylint error delete comment line --- src/qibo/models/dbi/double_bracket.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index e267978bbe..a5815e4ed6 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -250,7 +250,6 @@ def energy_fluctuation(self, state): a = state_conj @ h2 @ state_cast b = state_conj @ h_np @ state_cast return (np.sqrt(np.real(a - b**2))).item() - r # return np.real(self.h.energy_fluctuation(state)) def sigma(self, h: np.array): return self.backend.cast(h) - self.backend.cast( From 3839a32b6d40f365027442e71b750dc8070b78fe Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 21 May 2024 06:30:13 +0200 Subject: [PATCH 109/116] suggesting fix --- .../dbi/group_commutator_iteration_transpiler.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 8eb544456e..593990c0d9 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -186,6 +186,19 @@ def group_commutator( eo2.circuit(-s_step), eo1.circuit(-s_step), ] + + ## @TODO Sam, please run with the above. Please try also replacing 1 minus sign as follows (if both times are flipped then the bracket is invariant so I flip only eo2 which is self.h by default and eo1 is the variational operator) + # query_list_forward = [ + # eo1.circuit(s_step), + # eo2.circuit(-s_step), + # eo1.circuit(-s_step), + # ] + # query_list_backward = [ + # eo1.circuit(s_step), + # eo2.circuit(s_step), + # eo1.circuit(-s_step), + # ] + else: raise_error( ValueError, From 3e6cc7381a2673b6af650a05026c031fe06ad7ad Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 21 May 2024 06:31:36 +0200 Subject: [PATCH 110/116] suggesting fix --- .../models/dbi/group_commutator_iteration_transpiler.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 593990c0d9..db01959824 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -178,27 +178,28 @@ def group_commutator( elif gc_type is DoubleBracketRotationType.group_commutator_reduced: query_list_forward = [ eo1.circuit(s_step), - eo2.circuit(s_step), + eo2.circuit(-s_step), eo1.circuit(-s_step), ] query_list_backward = [ eo1.circuit(s_step), - eo2.circuit(-s_step), + eo2.circuit(s_step), eo1.circuit(-s_step), ] ## @TODO Sam, please run with the above. Please try also replacing 1 minus sign as follows (if both times are flipped then the bracket is invariant so I flip only eo2 which is self.h by default and eo1 is the variational operator) # query_list_forward = [ # eo1.circuit(s_step), - # eo2.circuit(-s_step), + # eo2.circuit(s_step), # eo1.circuit(-s_step), # ] # query_list_backward = [ # eo1.circuit(s_step), - # eo2.circuit(s_step), + # eo2.circuit(-s_step), # eo1.circuit(-s_step), # ] + else: raise_error( ValueError, From c0eff708f9e05337a084adcd62a0445b4169b2ad Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 21 May 2024 14:28:56 +0800 Subject: [PATCH 111/116] Test fixes --- src/qibo/models/dbi/double_bracket.py | 5 ++- .../group_commutator_iteration_transpiler.py | 33 +++++++++++-------- tests/test_dbi.ipynb | 0 tests/test_models_dbi.py | 32 +++++++++++++----- 4 files changed, 47 insertions(+), 23 deletions(-) create mode 100644 tests/test_dbi.ipynb diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index a5815e4ed6..6fc2066239 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -15,6 +15,7 @@ grid_search_step, hyperopt_step, polynomial_step, + simulated_annealing_step, ) @@ -39,6 +40,8 @@ class DoubleBracketScheduling(Enum): """Use greedy grid search.""" polynomial_approximation = polynomial_step """Use polynomial expansion (analytical) of the loss function.""" + simulated_annealing = simulated_annealing_step + """Use simulated annealing algorithm""" class DoubleBracketCostFunction(Enum): @@ -128,7 +131,7 @@ def eval_dbr_unitary( if d is None: d = self.diagonal_h_matrix operator = self.backend.calculate_matrix_exp( - 1.0j * step, + -1.0j * step, self.commutator(self.backend.cast(d), self.h.matrix), ) elif mode is DoubleBracketGeneratorType.group_commutator: diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 8eb544456e..3f7b5245af 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -69,8 +69,9 @@ def __init__( self.gci_unitary = [] self.gci_unitary_dagger = [] - self.iterated_hamiltonian_evolution_oracle = deepcopy( self.input_hamiltonian_evolution_oracle ) - + self.iterated_hamiltonian_evolution_oracle = deepcopy( + self.input_hamiltonian_evolution_oracle + ) def __call__( self, @@ -91,17 +92,18 @@ def __call__( # This will run the appropriate group commutator step double_bracket_rotation_step = self.group_commutator( - step_duration, diagonal_association, mode_dbr = mode_dbr) - + step_duration, diagonal_association, mode_dbr=mode_dbr + ) + before_circuit = double_bracket_rotation_step["backwards"] after_circuit = double_bracket_rotation_step["forwards"] self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle( - deepcopy(self.iterated_hamiltonian_evolution_oracle), - str(step_duration), - before_circuit, - after_circuit, - ) + deepcopy(self.iterated_hamiltonian_evolution_oracle), + str(step_duration), + before_circuit, + after_circuit, + ) if ( self.input_hamiltonian_evolution_oracle.mode_evolution_oracle @@ -118,10 +120,14 @@ def __call__( before_circuit.unitary() @ self.h.matrix @ after_circuit.unitary() ) - elif self.input_hamiltonian_evolution_oracle.mode_evolution_oracle is EvolutionOracleType.text_strings: + elif ( + self.input_hamiltonian_evolution_oracle.mode_evolution_oracle + is EvolutionOracleType.text_strings + ): raise_error(NotImplementedError) else: super().__call__(step_duration, diagonal_association.h.dense.matrix) + def eval_gcr_unitary( self, step_duration: float, @@ -129,13 +135,13 @@ def eval_gcr_unitary( eo2: EvolutionOracle = None, mode_dbr: DoubleBracketRotationType = None, ): - u = self.group_commutator( step_duration, eo1, eo2, mode_dbr = mode_dbr )["forwards"] + u = self.group_commutator(step_duration, eo1, eo2, mode_dbr=mode_dbr)[ + "forwards" + ] if eo1.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation: return u.unitary() elif eo1.mode_evolution_oracle is EvolutionOracleType.numerical: return u - else: - raise_error(NotImplementedError) def group_commutator( self, @@ -194,6 +200,7 @@ def group_commutator( eo_mode = eo1.mode_evolution_oracle from functools import reduce + if eo_mode is EvolutionOracleType.text_strings: return { "forwards": reduce(str.__add__, query_list_forward), diff --git a/tests/test_dbi.ipynb b/tests/test_dbi.ipynb new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 6af81b3ad6..b9e9b169de 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -21,7 +21,7 @@ ) from qibo.quantum_info import random_hermitian -NSTEPS = 1 +NSTEPS = 2 seed = 10 """Number of steps for evolution.""" @@ -41,7 +41,7 @@ def test_double_bracket_iteration_canonical(backend, nqubits): assert initial_off_diagonal_norm > dbi.off_diagonal_norm -@pytest.mark.parametrize("nqubits", [1, 2]) +@pytest.mark.parametrize("nqubits", [3, 4]) def test_double_bracket_iteration_group_commutator(backend, nqubits): """Check group commutator mode.""" h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) @@ -229,17 +229,30 @@ def test_gci_evolution_oracles_types_numerical( assert norm(j_1 - k_1) < 1e-10 - # test single_commutator case - gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) - gci.mode_double_bracket_rotation = DoubleBracketRotationType.single_commutator - u_gc_from_oracles = gci.group_commutator(t_step, evolution_oracle_diagonal_target) + # when gci mode is single_commutator, an error should be raised: + with pytest.raises(ValueError): + gci.mode_double_bracket_rotation = DoubleBracketRotationType.single_commutator + u_gc_from_oracles = gci.group_commutator( + t_step, evolution_oracle_diagonal_target + ) + + # compare DoubleBracketRotationType.group_commutator_reduced and group_commutator + u_gc_from_oracles = gci.group_commutator( + t_step, + evolution_oracle_diagonal_target, + mode_dbr=DoubleBracketRotationType.group_commutator, + ) + u_gc_reduced_from_oracles = gci.group_commutator( + t_step, + evolution_oracle_diagonal_target, + mode_dbr=DoubleBracketRotationType.group_commutator_reduced, + ) + assert ( - norm(u_gc_from_oracles["forwards"].conj().T - u_gc_from_oracles["backwards"]) + norm(u_gc_from_oracles["forwards"] - u_gc_reduced_from_oracles["forwards"]) < 1e-10 ) - # make 2 new objects with DoubleBracketRotationType.group_commutator_reduced and group_commutator, compare h matrix rotation - @pytest.mark.parametrize("nqubits", [3]) @pytest.mark.parametrize( @@ -381,6 +394,7 @@ def test_double_bracket_iteration_single_commutator(backend, nqubits): # test first iteration with default d dbi(mode=DoubleBracketGeneratorType.single_commutator, step=0.01) for _ in range(NSTEPS): + d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi(step=0.01, d=d) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 17a40aeadff8ca0f3aee889d1ac7e6bd65ad4adf Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Tue, 21 May 2024 09:29:55 +0200 Subject: [PATCH 112/116] adding reordered gc --- .../dbi/group_commutator_iteration_transpiler.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index db01959824..94057a338e 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -21,6 +21,9 @@ class DoubleBracketRotationType(Enum): group_commutator = auto() """Use group commutator approximation""" + group_commutator_reordered = auto() + """Use group commutator approximation with reordering of the operators""" + group_commutator_reduced = auto() """Use group commutator approximation with a reduction using symmetry @@ -175,6 +178,19 @@ def group_commutator( eo1.circuit(-s_step), eo2.circuit(s_step), ] + elif gc_type is DoubleBracketRotationType.group_commutator_reordered: + query_list_forward = [ + eo1.circuit(s_step), + eo2.circuit(-s_step), + eo1.circuit(-s_step), + eo2.circuit(s_step), + ] + query_list_backward = [ + eo2.circuit(-s_step), + eo1.circuit(s_step), + eo2.circuit(s_step), + eo1.circuit(-s_step), + ] elif gc_type is DoubleBracketRotationType.group_commutator_reduced: query_list_forward = [ eo1.circuit(s_step), From b99725109d1731ca4c239d9e488d0e8552a033de Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 21 May 2024 15:45:31 +0800 Subject: [PATCH 113/116] Fix GC and reduced GC sign --- .../group_commutator_iteration_transpiler.py | 17 ++--------------- tests/test_models_dbi.py | 16 +++++++++++++--- 2 files changed, 15 insertions(+), 18 deletions(-) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 304ca4e702..07fc1af4fb 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -200,28 +200,15 @@ def group_commutator( elif gc_type is DoubleBracketRotationType.group_commutator_reduced: query_list_forward = [ eo1.circuit(s_step), - eo2.circuit(-s_step), + eo2.circuit(s_step), eo1.circuit(-s_step), ] query_list_backward = [ eo1.circuit(s_step), - eo2.circuit(s_step), + eo2.circuit(-s_step), eo1.circuit(-s_step), ] - ## @TODO Sam, please run with the above. Please try also replacing 1 minus sign as follows (if both times are flipped then the bracket is invariant so I flip only eo2 which is self.h by default and eo1 is the variational operator) - # query_list_forward = [ - # eo1.circuit(s_step), - # eo2.circuit(s_step), - # eo1.circuit(-s_step), - # ] - # query_list_backward = [ - # eo1.circuit(s_step), - # eo2.circuit(-s_step), - # eo1.circuit(-s_step), - # ] - - else: raise_error( ValueError, diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index b9e9b169de..acc8f19fa5 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -237,6 +237,7 @@ def test_gci_evolution_oracles_types_numerical( ) # compare DoubleBracketRotationType.group_commutator_reduced and group_commutator + gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target, @@ -247,11 +248,20 @@ def test_gci_evolution_oracles_types_numerical( evolution_oracle_diagonal_target, mode_dbr=DoubleBracketRotationType.group_commutator_reduced, ) - - assert ( - norm(u_gc_from_oracles["forwards"] - u_gc_reduced_from_oracles["forwards"]) + h_update_gc = ( + u_gc_from_oracles["backwards"] @ gci.h.matrix @ u_gc_from_oracles["forwards"] + ) + h_update_gc_reduced = ( + u_gc_reduced_from_oracles["backwards"] + @ gci.h.matrix + @ u_gc_reduced_from_oracles["forwards"] + ) + assert norm( + u_gc_reduced_from_oracles["forwards"].conj().T + - u_gc_reduced_from_oracles["backwards"] < 1e-10 ) + assert norm(h_update_gc - h_update_gc_reduced) < 1e-10 @pytest.mark.parametrize("nqubits", [3]) From 976989e756e9c4eb15bfc019e495d2f2a9f687e9 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 21 May 2024 16:00:49 +0800 Subject: [PATCH 114/116] Test coverage --- .../group_commutator_iteration_transpiler.py | 17 +------------ tests/test_models_dbi.py | 24 +++++++++++++------ 2 files changed, 18 insertions(+), 23 deletions(-) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index 07fc1af4fb..f12e10eedd 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -21,9 +21,6 @@ class DoubleBracketRotationType(Enum): group_commutator = auto() """Use group commutator approximation""" - group_commutator_reordered = auto() - """Use group commutator approximation with reordering of the operators""" - group_commutator_reduced = auto() """Use group commutator approximation with a reduction using symmetry @@ -184,19 +181,7 @@ def group_commutator( eo1.circuit(-s_step), eo2.circuit(s_step), ] - elif gc_type is DoubleBracketRotationType.group_commutator_reordered: - query_list_forward = [ - eo1.circuit(s_step), - eo2.circuit(-s_step), - eo1.circuit(-s_step), - eo2.circuit(s_step), - ] - query_list_backward = [ - eo2.circuit(-s_step), - eo1.circuit(s_step), - eo2.circuit(s_step), - eo1.circuit(-s_step), - ] + elif gc_type is DoubleBracketRotationType.group_commutator_reduced: query_list_forward = [ eo1.circuit(s_step), diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index acc8f19fa5..c3a593bbfd 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -229,13 +229,6 @@ def test_gci_evolution_oracles_types_numerical( assert norm(j_1 - k_1) < 1e-10 - # when gci mode is single_commutator, an error should be raised: - with pytest.raises(ValueError): - gci.mode_double_bracket_rotation = DoubleBracketRotationType.single_commutator - u_gc_from_oracles = gci.group_commutator( - t_step, evolution_oracle_diagonal_target - ) - # compare DoubleBracketRotationType.group_commutator_reduced and group_commutator gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) u_gc_from_oracles = gci.group_commutator( @@ -263,6 +256,23 @@ def test_gci_evolution_oracles_types_numerical( ) assert norm(h_update_gc - h_update_gc_reduced) < 1e-10 + # when gci mode is single_commutator, an error should be raised: + with pytest.raises(ValueError): + gci.mode_double_bracket_rotation = DoubleBracketRotationType.single_commutator + u_gc_from_oracles = gci.group_commutator( + t_step, evolution_oracle_diagonal_target + ) + + # when gci eo_mode is unrecognized, an errorr should be raised: + with pytest.raises(ValueError): + gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator + evolution_oracle_diagonal_target = EvolutionOracle( + d_0, "D0", mode_evolution_oracle=DoubleBracketRotationType.group_commutator + ) + u_gc_from_oracles = gci.group_commutator( + t_step, evolution_oracle_diagonal_target + ) + @pytest.mark.parametrize("nqubits", [3]) @pytest.mark.parametrize( From 97e3e44d69faeac3dda78fa6cf386ca7250084e1 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Tue, 21 May 2024 15:10:13 +0200 Subject: [PATCH 115/116] added an imperfect inversion example --- examples/dbi/dbi_imperfect_inversions.ipynb | 229 ++++++++++++++++++++ 1 file changed, 229 insertions(+) create mode 100644 examples/dbi/dbi_imperfect_inversions.ipynb diff --git a/examples/dbi/dbi_imperfect_inversions.ipynb b/examples/dbi/dbi_imperfect_inversions.ipynb new file mode 100644 index 0000000000..1592dc5bc5 --- /dev/null +++ b/examples/dbi/dbi_imperfect_inversions.ipynb @@ -0,0 +1,229 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-05-21 13:57:42]: Using numpy backend on /CPU:0\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from qibo.hamiltonians import SymbolicHamiltonian\n", + "from qibo import symbols\n", + "from scipy.linalg import expm\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", + "\n", + "from copy import deepcopy\n", + "# Hamiltonian\n", + "set_backend(\"numpy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "def h(nqubits, alpha, beta):\n", + " \"\"\"\n", + " $H_nn = \\sum_{i=0}^{n-1}+\\alpha*\\sum_{i=0}^{n-2} Z_i Z_{i+2} + \\beta*\\sum_{i=0}^{n} X_i$\n", + " \"\"\"\n", + " op_list = [symbols.Z(i)*symbols.Z(i+1) for i in range(nqubits-1)]\n", + " symbolHam = 0\n", + " for op in op_list:\n", + " symbolHam += op\n", + " \n", + " op_list = [symbols.Z(i)*symbols.Z(i+2) for i in range(nqubits-2)]\n", + " for op in op_list:\n", + " symbolHam += alpha*op\n", + " op_list = [symbols.X(i) for i in range(nqubits)]\n", + " for op in op_list:\n", + " symbolHam += beta*op\n", + " h = SymbolicHamiltonian(symbolHam, nqubits=nqubits)\n", + " h = h.dense.matrix\n", + " return h\n", + "\n", + "def x_inv_odd(nqubits):\n", + " \"\"\"\n", + " returns product of X_i for odd i\n", + " $X_{odd} = \\prod_{i=0}^{n-1} X_{2i+1}$\n", + " \"\"\"\n", + " op_list = [symbols.X(i) for i in range(nqubits) if i%2==1]\n", + " symbolHam = 1\n", + " for op in op_list:\n", + " symbolHam *= op\n", + " h = SymbolicHamiltonian(symbolHam, nqubits=nqubits)\n", + " h = h.dense.matrix\n", + " return h\n", + "\n", + "def z_product(nqubits):\n", + "\n", + " op_list = [symbols.Z(i) for i in range(nqubits)]\n", + " symbolHam = 1\n", + " for op in op_list:\n", + " symbolHam *= op\n", + " h = SymbolicHamiltonian(symbolHam, nqubits=nqubits)\n", + " h = h.dense.matrix\n", + " return h" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "alpha = np.linspace(0,1,50)\n", + "beta = np.linspace(0,1,50)\n", + "nqubits = 5\n", + "x = x_inv_odd(nqubits)\n", + "inversion_measure = np.empty((len(alpha),len(beta)))\n", + "for a in range(len(alpha)):\n", + " for b in range(len(beta)):\n", + " ham = h(nqubits,alpha[a],beta[b])\n", + " inversion_measure[a,b] = np.linalg.norm(ham+x@ham@x)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAHJCAYAAADD+5A6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABn00lEQVR4nO3deXhU5dk/8O/MJDNhScJmSJDQAILsoAg0oAKagmARxLdQQVlcKhpUiCJSxYBUQ60i/VUKLRXRvlLQKkiBgoAGZBMJREARRUDiEhCQBALJTGbO7w/ejAzZ5izPds79ua65LjPbeTIyM9/cz/08x6VpmgZCCCGEEAbcogdACCGEEPuioEEIIYQQZihoEEIIIYQZChqEEEIIYYaCBiGEEEKYoaBBCCGEEGYoaBBCCCGEGQoahBBCCGGGggYhhBBCmKGgQQghhBBmKGgQQgghhBkKGoT8n7S0NMyYMaPW64g90P9vQvigoEGIAevWrYPL5cKSJUuqvP22225DvXr1EAqFmI1h5syZcLvdOHDgQKXb7rnnHng8HqxevZrZ8QFjr4MM4yaE8ENBgxADPv30UwDAddddV+XteXl56NSpE9xudm+xBx98ED6fD3Pnzo24/i9/+Qtee+01PPvss7j11luZHR8w9jrIMG5CCD8UNAgxYO/evUhISECbNm0q3VZYWIjvv/8eXbt2jeq5+vXrh3HjxukeQ1JSEkaPHo1//vOfOHnyJABg06ZNyMrKwh133IGnnnpK93PqZeR1kGHchBB+KGgQYsCnn36Ka665Bi6Xq9JteXl5ABB10DBj8uTJuHDhAhYsWICCggKMGDEC7dq1w+LFi5kfGzD+OogeNyGEnxjRAyBENX6/HwcPHsSdd96JQ4cOVbr9gw8+AAB06dKF+Vg6duyIAQMGYN68eVixYgUCgQBWrFiB+vXrMz+2mddB5LgJIXxR0CBEp88//xyBQABvvPEG3njjjWrvxyNoAEBWVhZuueUWnDhxAmvWrEHr1q25HNfs6yBq3IQQvihoEKLT3r17AQBz587FlVdeWen2CRMmID4+HomJiZVuCwQCKCoqqnRdWVlZuF+hQqNGjaJqJq1YvdGqVSsMHDgw6t+jOr/+9a8xatQojBo1qsbby8vLARh7HUSOu7rbCSFsUNAgRKdPP/0UHo8HEyZMgM/ni7jtwoUL+Omnn3D99ddX+ditW7eif//+la7ftm0bli5dGnHdkSNHkJaWVuNYNmzYgMcffxxt2rTBV199hffffx8DBgzQ9wtd5sCBA+jUqVOtt7/++uuGXweR4yaE8EVBgxCd9u7di9atW1f6cgUufpmFQqFqpwu6du2K9evXR1z32GOPITk5GVOmTIm4Pjk5ucZxHD58GCNHjsQ111yDDRs2oG3btnj55ZdNfWGXlpbi22+/Rbt27Wq93ejrIHrchBC+aNUJITrt3bsXHTt2rPK2zz77DED1K04aNmyIjIyMiEvDhg2RkpJS6fq4uLhqx3Du3DkMHToUsbGxWL58ORITE/HQQw9h3bp1lTbCKi8vx/Tp09GsWTM0adIEWVlZ0DQtfNu0adPQsGFDXHXVVViyZAlat24Nr9db6+1GXgcZxk0I4YuCBiE6FBYW4sSJE4aDhhU0TcPdd9+NgwcP4p133kHz5s0BAA899FCVG2E99thj+Oyzz/DZZ5/hq6++woYNG/D2228DAKZOnYpPP/0UR44cwYcffojs7OyI6YXqbjfyOsgwbkIIfzR1QogOFTth1vQFW79+faYrKGbMmIEVK1bgb3/7G/r06RO+/oorrsBdd92Ff/7zn3j++efRuHFjfPvtt3jjjTdw9OjRcFPmoEGDkJeXh+uvvx4LFy7EoUOH0KBBAzRo0AC9e/cO/27ff/99tbcbeR1kGDchhD+qaBCiQ8WKk5q+YDt16lTlBlZWWL58OWbNmoUJEybgd7/7XaXbJ0+ejNLSUixYsAAAsHnzZvTq1Sti5cfp06fRtGlTbNy4ET169EBSUlL4th9//DH8l39Nt+t9HWQZNyGEP6poEKLDlClTKjVtXurw4cO6nzM3Nzfq+95+++01nqitQ4cOEbefOnUKDRo0CP8cCASwbt06jB8/Hh9//DGaNGkSvq2wsBDbtm0Lf9mfPHmy2tuHDx+u63WQZdyEEP6ookGIjXXv3h2bN2/Gd999hzNnzuCBBx5At27d0Lt3b1x99dXIzc1FQUEBfvzxR4wdOxYulwtXXXUVANR6O42bEBINqmgQYmO9e/fGhAkTcM011yAYDOI3v/kN/vWvfwEAbrnlFgwaNAgdO3ZE8+bNcdNNN+HHH38MbxJW2+00bkJINFxaxXoxQhwuLS0N48aNw4wZM2q8jtgD/f8mhA+hEX/z5s0YMmQImjVrBpfLhRUrVtT6mNzcXFx77bXw+Xy46qqr6GyPxDJHjx6t9AVT1XXEHuj/N3G6+fPno0uXLkhISEBCQgLS09Px3//+F8DF5uuHH34YV199NerUqYMWLVrgkUceqXQKhWgIDRolJSXo2rUr5s2bF9X9jxw5gltvvRX9+/dHfn4+Jk2ahPvuuw/r1q1jPFJCCCHEXpo3b47Zs2cjLy8Pu3btwk033YShQ4fis88+w/fff4/vv/8eL774Ivbv34/Fixdj7dq1uPfee3UfR5qpE5fLheXLl2PYsGHV3mfq1KlYvXo19u/fH77ut7/9Lc6cOYO1a9dyGCUhhBBiX40aNcKf/vSnKgPF22+/jbvuugslJSWIiYm+xVOpZtDt27cjIyMj4rqBAwdi0qRJ1T6mrKwMZWVl4Z9DoRBOnz6Nxo0bM9vrgBBCiD1omoazZ8+iWbNmTBuKS0tL4ff7TT+PpmmVvtt8Pl+V5yS6VDAYxNtvv42SkhKkp6dXeZ+ioiIkJCToChmAYkGjsLAQTZs2jbiuadOmKC4uxoULF1CnTp1Kj8nJycHMmTN5DZEQQogNFRQUhLfNt1ppaSnSflEfx08ETT9X/fr1ce7cuYjrsrOzq+092rdvH9LT01FaWor69etj+fLl6NChQ6X7nTx5ErNmzapyw73aKBU0jJg2bRqysrLCPxcVFaFFixZIW/AY3HVqTnh25/Oa/0fNW1xsQPQQUDfW/F8d0R+L/e9bn9HvkxBzwfLnjI8tq/1OOjSIKbHsuRI81vy+iZ7zljxPI481v1ui29zv1chdanoMCSYLCQlu45/1Z8+F0Kb7t4iPjzc3iBr4/X4cPxHEl7uaIyHe+C9bfDaEttd9i4KCAiQkJISvr6macfXVVyM/Px9FRUX497//jbFjx2LTpk0RYaO4uBi33norOnToYKhZWqmgkZycjOPHj0dcd/z4cSQkJFRZzQCqLxm56/jgqVv92TGdoPyyn33ey6+RTwA//78UFTrK/m8M9bzsA4e/4lgMw00ZvEzCxgV4kRhrbdgogxcJsea/uCpcQAM0tChs+BFrSUjwI8GS57mARDSOOVf7HWtRz+R0QRnqorHJsBECkGhiGBoCSDQRNgBwmWpPiHebChrh5/m/VSTR8Hq94c3sunfvjk8++QR//vOf8be//Q0AcPbsWdxyyy2Ij4/H8uXLERsbq3s8Su1gk56ejo0bN0Zct379+mrnk4g+Zf6Y8EUFpYFYlAb0/6O3Somf3ynHSwJsj3WO0fMXBeqgKFD1HwFGFQes/QPhp/J6lj1XUbCuVM9zqry+6ec4EzI/llMh8X/UFYWsrYbZVSgUCvc1FhcXY8CAAfB6vVi5ciXi4oz9fxQaNM6dO4f8/Hzk5+cDuLh8NT8/H8eOHQNwcdpjzJgx4ftPmDABhw8fxhNPPIEvvvgCf/3rX/HWW29h8uTJIoZva5eGDtmDh8jAUeL3cgscJQEv08BxLuBlGjisRGEjenYJG0XVnyqHGDRt2jRs3rwZR48exb59+zBt2jTk5uZi9OjR4ZBRUlKCV199FcXFxSgsLERhYSGCQX3T7kK/QXbt2oX+/fuHf67opRg7diwWL16MH374IRw6AKBly5ZYvXo1Jk+ejD//+c9o3rw5/vGPf2DgwIHcx+40l4YNWadYKsKGiCmVirDBYzqlJOBlOpVyLsBmKqUoUMfSqZTiQJyl0yg/ldezbBqlKFjXkukPq57HCmdCddHALXYsRSFzUyhFoTLTUyh2cuLECYwZMwY//PADEhMT0aVLF6xbtw6/+tWvkJubi48//hgAKp0n6MiRI0hLS4v6ONLso8FLcXExEhMT0er13zu+R8MKsoYOQFwPB4+wET4Ww8DBqknU6r4NK8MGAMvCBmBdY6cVz2NFv4YVQcNsv4aZoPHzc0QfNorPhpB89bHw0k4WKr6XCg+2MN0MynqsRijVo0HkI/P0iqgpFd7TKazQNIp5Mk2j0BQKEcWxQSPo96Bc54XUTNbQYffAoWLfhpPChkxkCRtmmQ0b1BjKl1zfCJLTGzZiFNynwioy9nSI6uEo8XuZT6dUhA1WUyks+jac0rMhW7/GqfL6pqdRzPZrnArFmZ5CsaPiUBm0kPG//8+G5Cz3OLaiwQNVSS6SrcohosJhl+qG1ZxS2ZBpCkUWoqdQqKrBDwUNwZwUQGSbWhEVOJgfg8KGpc9nx7AhyxQKhQ1noKAhKbsHECcHDh7VDZZ7blDYMI7CBnEiChqKsVv4kKnKISJwMD8Gw7BhdeCwehdRq8OGVWSa/pAhbFBVw/4oaNiAXYKHTIGDF17VDVZkr25YGTZkW/YqU2Axi8KGvVHQsCHVg4cMVQ67VTecPJUia9iwAk2hEBVQ0HAAlYOHkwKHytUNChv6Ub/GZWOgqoZtUdBwIBWDh9MCB9Pnp7BhGoUNNihs2BMFDaJU8JAhcPDAurrBaiqFwoZ+duq1oCkUUhUKGqQSFUKHyMBB1Y2aUdjQT5bmUJpCEVvVKA5dHL/RS7GcG4NS0CA1kz10OCFw8KhuWI3V8lerUNioHk2hEKtR0CBRkzl0iA4cPKgWNgDrqxt2DxtWkCFsqD6FQr0a1qKgQQyRNXSIWhrLs7rB7LkpbAgnU3OoWTSFQio4NmiEyj0IBaK7kJrJHDp44xE4WE6lqNIkKmPYkGkKxQrUr0Gs4tigoUe0gYTCiXyhQ9SUClU3KqOwET3q15ADVTWsQUGDEQoicHzg4FXdYPbcFDYMobARiaoahIKGIE4KITJVOUQFDpZYT6VYjcIGXzJMxYgOG2YUU1XDNAoaErJz+HBq4FC5ukFhwxgrwoYMIQFQfwqFqhpiiT9VJolKVWHDHRsUMBJrXBo2Yrzifo+KsOHzlnM5XmkgFnGxAWbPX+L3op7Xb/3zBryoF2vt854LeFHfwucsCtRBYuwFy57PCj+V10PDmBJTz1EUrItEz3nhz3GqvD4ax5wz/Pgzobpo4DY+hlOhODR2lxp+fFEISJT8T+vToTiUhYwPsiQkZ6KS/GUnNbFL5UOGKoedqhusplJYrEiRtbJhx2WvMlRHVJ5CIcZR0LAZlYOH6MAhYjqFJVWmUuweNuzUHEpTKMQICho2p2LwcFLgoLBxEYUNddAqFKIXBQ2HUSl0iF6twitw8JhKYfK8FDZ0kaU5lKZQCG8UNBxMpWqH6MDBg6p9G1ZiceZXK1DYiERTKEQPChokTIXQISpwUHWjhueUOGzIuOzVCjJUJVSfQiH8UNAgVZI9dDghcLBCYcM4K8KGLP0adtg11AyqavBDQYPUSubQITJwsEZhQ86wYQW7TKGIRo2haqANu4gul4YNmTYMqwgbPDf/4rHZV0XYYLHJF4vNvaze2MvKTb2s2tCrOBCHhFjjG0dVsMtmXqpv5CWTolAdBELG/3A6H5LnM/lSzq1olLlrv5AayVjpEFHhULm6waJJ1AmVDbs1h5pFUyikJvRtWpNowggFFABwfODg0buh0lQKhQ21yBBWzKDGULk581uRNQcHEdmqHHarbrBclcIibFgZOOwaNmSpaohe8kpVDfuy97eerBwSQGQJHFTdiJ7sTaIUNqonQ1VC5P4a1BgqL/t9u6nMpgFEliqHiMDBEoUN82RajSJD2BAdVmhvDb5ycnLQo0cPxMfHIykpCcOGDcPBgwcj7lNYWIi7774bycnJqFevHq699lq88847uo6j/reYE9gofDgtcLCublDYkAP1a/yMplDUsWnTJmRmZmLHjh1Yv349AoEABgwYgJKSn1dDjRkzBgcPHsTKlSuxb98+DB8+HCNGjMCePXuiPo6631hOp3jwkCVw8MI6bLAIHE4JGzSFYj2Vp1CcZO3atRg3bhw6duyIrl27YvHixTh27Bjy8vLC99m2bRsefvhh9OzZE61atcLTTz+NBg0aRNynNup9Q5GqKRo8RE+r8K5usERhwzgKG9Y+3iyqaphTXFwccSkrK4vqcUVFRQCARo0aha/r3bs3li1bhtOnTyMUCmHp0qUoLS1Fv379oh4PbdhlV5eHDZ/8756KsCFiIzBeG36x3uSrNBBr+eZeFWHDys29rNzYy6pNvWTa0MuKzbzMUnkjL1U38TodrIcL5ca/li8EL36upKamRlyfnZ2NGTNm1PjYUCiESZMmoU+fPujUqVP4+rfeegsjR45E48aNERMTg7p162L58uW46qqroh4XBQ2nUCh4iA4cPHYXLfPHKBU2AOt3ErVz2LCC2bBhxa6hKjMTNopCQKI6heFKCgoKkJCQEP7Z5/PV+pjMzEzs378fW7Zsibh++vTpOHPmDDZs2IAmTZpgxYoVGDFiBD766CN07tw5qvFQ0HCqS4OHpKFDVOCwQ3WD1dblMocNq1gRNqzaptwss2FD5aqGWSqHjYSEhIigUZuJEydi1apV2Lx5M5o3bx6+/uuvv8Yrr7yC/fv3o2PHjgCArl274qOPPsK8efOwYMGCqJ5f0ZeRWEry3g5RPRy8+jdUW5Ui6y6idlyJYod+DWoMlZemaZg4cSKWL1+ODz74AC1btoy4/fz5iyHP7Y78bvB4PAiFov8DVc5vFiKOxKFDZOBgzelhwyrUHGo/1BjKTmZmJv73f/8XS5YsQXx8PAoLC1FYWIgLFy5W9Nq1a4errroKDzzwAHbu3Imvv/4aL730EtavX49hw4ZFfRz5vk2IPCQNHSICB4/qBss9N2QPG7QShS3VqxpmwgZVNao3f/58FBUVoV+/fkhJSQlfli1bBgCIjY3FmjVrcMUVV2DIkCHo0qUL3njjDbz++usYPHhw1MehHg0SHQl7OkT0cPBoFmXVKMpqRYpVPRvUHFo9GU4pL7pfwwwzjaHFcnzcMaFpWq33adOmje6dQC8n15+qHLn87movpBaSVTp4Vzh4VTdYoMqGflZUNmgKxTyRUyjEHDm+KSRTUwihgHIZhwcOllhNpbDYSZTCRu1kCBuqT6GYOjZNoQgjxzeETTg6iEhU5eAZOKi68TO7hw0rUL+GOVTVUBP1aHBUU9jQvDaaCKwIG4J7OUIBD7f+Dda9G6r0bcjas2EFO/VriEQ7hlavKFgX/qD5nUFlI/7PTwKg6mqI8iSocNipukGVDeNoCiWS6KqGyCkUwp8Nvs3syzbhQ4JpFd6BgxUKG8bZLWyYJTpsmEHLXdWi6DeXcykfPCQIHDywrG6wbBK1EoWNmpkNG6qvQqHGUOdQ8JuKXErZqofAwEHVjepR2FCLk6dQqDFUHYp8KxE9lAodDggcFDbsGTZkqGoA6ocNM2gKRQ0KfBMRM5SpdggOHKyxnkqxGoWN6MgSNlRGjaH2J/E3D2FB+tAhKHCoXt1wWtiQiQxhg6oaxlBVgw9Jv20ID1KHDoGBgzWVmkRlDRsyVTVkITpsmEFVDXujDbsIgMjNxKTaPEzA5l88TtZWETZYbPJl9eZesm7qZdWGXlacgM2KzbyKA3FIiJV3M6naiDzpml028SoO1oE/aDzclwatPWmiVST8U5aIJmWlQ0CFQ/XqhpWoslE7mkIRWxUh8pLom4TISLrQwTlw8OjdoLBh8nlsFjbMEh02zBC13JV6NdiS5NuDP3fABbffJXoYSnF64GCJwobJ57FRr4Xqq1CoqkEuJ8m3hjhuv8uSi5NIVeXgGDhYVzdYLYGVPWxYxYqwIUtVQ/UpFDOoqmE/wr8p5s2bh7S0NMTFxaFXr17YuXNnjfefO3curr76atSpUwepqamYPHkySkvFN/I4NYhIFTg4UbG6IXPYkG3ZqyxhwyyRW5TTcldyKaHfEMuWLUNWVhays7Oxe/dudO3aFQMHDsSJEyeqvP+SJUvw5JNPIjs7GwcOHMCrr76KZcuW4fe//z3nketn9wAiRZXDZtUNqzkhbNipX0P0FIrIxlBa7movQoPGnDlzcP/992P8+PHo0KEDFixYgLp162LRokVV3n/btm3o06cPRo0ahbS0NAwYMAB33nlnrVUQmdkxgDgtcLBCYcPg80gUNsyiKRRjqKohF2HfBn6/H3l5ecjIyPh5MG43MjIysH379iof07t3b+Tl5YWDxeHDh7FmzRoMHjy42uOUlZWhuLg44qICO4QPpwQOFcOGlYHDzmHDLDv0a5hBjaEEELhh18mTJxEMBtG0adOI65s2bYovvviiyseMGjUKJ0+exPXXXw9N01BeXo4JEybUOHWSk5ODmTNnWjp2US4PGyGvJmgk+lSEDWEbgZW5mW/4xXKTL1abe1m5sZeVm3rJtKGXLJt5iWR2Iy4znLaJ15nyevCVGw/uZeW0YZdpubm5eP755/HXv/4Vu3fvxrvvvovVq1dj1qxZ1T5m2rRpKCoqCl8KCgo4jpgt1SoeQvs4qLpRJaps1M4O/Roip1CoqkGEVTSaNGkCj8eD48ePR1x//PhxJCcnV/mY6dOn4+6778Z9990HAOjcuTNKSkrwu9/9Dk899RTc7spfJD6fDz6fz/pfQEKXhg3Zqx3Cqhw2qG5QZYM/KyobZpndovyn8npoGFNi4YiiZ6Yq4rSqhh0Jq2h4vV50794dGzduDF8XCoWwceNGpKenV/mY8+fPVwoTHs/FD3VNk/uLlTdVqh1CKhyKVzecVNmwgp36NUSiygQxSujUSVZWFhYuXIjXX38dBw4cwIMPPoiSkhKMHz8eADBmzBhMmzYtfP8hQ4Zg/vz5WLp0KY4cOYL169dj+vTpGDJkSDhwkKrJHjrsGjgobJhDUyiRRE+hmCFquSutQBFP6NlbR44ciR9//BHPPPMMCgsL0a1bN6xduzbcIHrs2LGICsbTTz8Nl8uFp59+Gt999x2uuOIKDBkyBM8995yoX0FJMk+xCJlSYTydEgp4aBrFBLs1h5ol8iyvIhtDibpcmsPmHIqLi5GYmIi0556DO47S6qVkCx2AgB4Oxv0bLAIHi1PNW3maeat6Nqzq17Di1PJmw4bZVShmg4bZXg0zYcPMY432agAw3KtRcjaEAZ2/QVFRERISEgwfvyYV30sTt9wOX30Tq07OBfDK9cuZjtUIpVadELZknF4RMp3CEIupFBbnSLHzNIoMnDyFYgbtGKomChqkSjKFDu79G4x7N1Tp27Br2JClX8MskVuUq7jc1UyvBjFHaI8GUUNF2BA9tcK9f4Nh74YqfRt27dmQoV9D9EZetNxVPmcDPpSZCLH+gJy1AzlHxQGdHl4/WX5vrhUOxpUNVlMpVrL6/CiykGHZq8pTKLTclUTLsUHDKk4NIzL8blzDhmJTKbKGDZmmUKwgwxSKSKKmUEQtdyXGUNDgwM4BRPTvYqfqhtUobETxHBL0a6hc1SAkGhQ0BLJT+BD9O3ALHAyrGyqEDatQ2IgkOmyYQVUNUhsKGpKxQ/gQHTi4cGjYoJUo9kRVDWfKyclBjx49EB8fj6SkJAwbNgwHDx6s8r6apmHQoEFwuVxYsWKFruNQ0FCAqsFD1Hi5VjcYYNEkavewIQPVqxqiGkOpqiHOpk2bkJmZiR07dmD9+vUIBAIYMGAASkoqr0aaO3cuXC5jn+f2bCe3ucu/vEUvO62NqOWxXJbDKrQE1sqlr7Ite6UlrxeJ3J6cqGft2rURPy9evBhJSUnIy8vDjTfeGL4+Pz8fL730Enbt2oWUlBTdx6GKhg2oUvEQWeFgSqG+DVkrG1agKRTzqKrhbEVFRQCARo0aha87f/48Ro0ahXnz5iE5OdnQ81LQsCHZQ4eIsXGZTqGwYZid+jVUn0IxQ8UdQ+2ouLg44lJWVlbrY0KhECZNmoQ+ffqgU6dO4esnT56M3r17Y+jQoYbHI9efJMRyMp+pVcSUisvvVnIqxQnTKFbtHCoD0VMoZojcMdQou+wWWlxeB7Emgmqg/OIfEampqRHXZ2dnY8aMGTU+NjMzE/v378eWLVvC161cuRIffPAB9uzZY3hMAAUNR5E1dPAOHMx7NyoqGxYHDgob0ZGlX0MkVU8lT6eht0ZBQUHE2Vt9Pl+N9584cSJWrVqFzZs3o3nz5uHrP/jgA3z99ddo0KBBxP3vuOMO3HDDDcjNzY1qPBQ0HErG0CEicKhW3aCwER0ZwoboqoaZsEFVDbUlJCREdZp4TdPw8MMPY/ny5cjNzUXLli0jbn/yySdx3333RVzXuXNnvPzyyxgyZEjU46GgQaQLHTwDB5fqBoUN3WQJG2aJDhtmmAkbVNVQQ2ZmJpYsWYL33nsP8fHxKCwsBAAkJiaiTp06SE5OrrIBtEWLFpVCSU2oGZREkKmJlOc4mDaKMmgSdUKDqBXMNoeqvgpFZGOoCGZWoDjR/PnzUVRUhH79+iElJSV8WbZsmaXHkecTgUhFlioH7+oGVTasP3W9UbI0h6o+hWKGk6oadps+iYam6f9cNfIYx1Y0XAHAbfLiFDJUOXiNgekyWAb7bcha2ZBp2avTl7xSVYOI5tigYQWnBREZ9ufgdWyVplIobNROltPKi2ImbKi4iZdRtIEXGxQ0GLJzCBEZOHhWN5ihsKGLDOdEUbmq4TRU1ZAL9WgIUlXYCIn/LNVN1HlMeB2b6aoUi/s2ZO3ZsPK8KGbYYcmrGaKWu1KvRvTOBbzmNuyS9I9YqmhIROWqh+gKB2tM+zYsZOfKBk2hiK1qqHYqeapqyIOChsRUnHIRFTh4HNepYUMmMoQNladQRDWGUq+Gs1HQUIwqoUNk4GCJ2aoUicOGTFUNgPo1zFKxMdQoqmrIgYKGwlSodogIHMpWNyhscENTKGqhqobaKGjYiMyhQ1TgYIlZ2LAwcNg1bNAUijlU1SA8UdCwKVlDB+/Awfp4KvRtUNhgR+QW5VTVYI+qGtagoOEAMoYOEYGDFRX6NihsVE30FIqqjaFU1SB6UNBwGNlCB8/AoWR1w+ZhQwZOnkJRjYiQUhRyVuWIBTk6s4gQl4YN0ZuF8dz4y+13MTsOkxOzWbixl5WbelmxoZcVm3nJcEp5sxt5mWHmpGsqbuJl1Kny+mgcc47rMfU6H4hFjIngWR4QdwLMmlBFgwCQp8rBs7rBipMqG1aQYQpFNKpqRE9EVYOYQ0GDRJBhaoXXdArL4zglbFC/xiWPFziFQr0a0aFeDTEcGzQ8fsBTZvziBE4KHCxQ2FCP6LAhimqnkqeqhlocGzTMclIQkSFwqHoMJitSbBo2ZKhqiCaqqmEGVTVIbShoMGLHACIycPCobig1lUJho1qqT6GYoeJ5UIyiqoY6KGhwZofwIbKPQ/XqhqUkDBtWkGGbcpH7a6jYGKpaVYPwRUFDAiqHDxGBg1d1gwWZw4YVZOnXED2FQlUNPoyGFJo+4UuuTykSplrwEBU4VHx+WcMGTaFEEjmFQlUNYifia5QkKpeHjaBPzDhqUxE2eG0AxnqjL1bPb/nGXhZt6mXVhl6ybOZlltmNvMw4F/CivsFNwERt4iWC0c2/ZNzA63zAC4+JgBukDbuIlWSvdvCucKhY3aDKRu3MVjacPIUiAlU1SFUoaNiAzKGDd9hgGTgobKhJ9BSKGSpu4qUS6tXgg4KGzcgYOuxU3aCwoY8MVQ3RqKrBHlVD5EZBw8ZkCx08AwfL6gaL52ayi6gF7BI2RFc1RDWGqlbVoA287EnOTzdiOZlCB+/AocpzWxo2bLjsVfWwIYqIHUOpqkEuJdenEeFCpsDB5TgUNkyRqTlUZSoud3VKVYOwRUHDwWSocvCqbrCeSrGSncOGWU6uaqh2HhSVqho0fcIWBQ0CwFmBQ4XntWvYcPoUioqNoVTVIGap3c5tgtsPuA18N4TU+5zQ5dKwIWJTMHeA/WZfbr+LyQZfVj+vpZt6SbShlxWbeamsJOBFPYMbcYnaxMuon8rroWFMCddjqryBV2kgFh4TQTgYsHATQAtRRUMnt7/2i12IqnLwqG6wmkqhykZ0zFY2VK5qqIiqGsQMChoM2C2A2D1wyP6cMoYNGYgOG2aouNzVKBG9GkZRrwYb9vnUUYDq4UNk4GD6/E4LGxaQoaohGlU12DNa1aBqiFzk+vRyIBWDh4jAwbq64aiwQVMoYao2hlJVg6iEgoZkVAoeogIHs+dmFDasfF47hg2zRIcNJ3FCVcNJ0yc5OTno0aMH4uPjkZSUhGHDhuHgwYMR9yktLUVmZiYaN26M+vXr44477sDx48d1HYeChuRUCB68AwfL6oYKTaKyhQ2znDyFQlUNItKmTZuQmZmJHTt2YP369QgEAhgwYABKSn5eKTR58mT85z//wdtvv41Nmzbh+++/x/Dhw3Udx7HLW1V1adiQbaltRdjgtSyW5VJYFktgrXxOy5a+WrDsVYYlr2X+GPi85YYfXxqIRVwsxzP/XcLMclcRigNxSIgtFT2MqKi81JWHtWvXRvy8ePFiJCUlIS8vDzfeeCOKiorw6quvYsmSJbjpppsAAK+99hrat2+PHTt24Je//GVUx5HjTxpiiKyVDp4VDhWnUqwiU2XDDv0aZohqDHVKVYOaO/koKioCADRq1AgAkJeXh0AggIyMjPB92rVrhxYtWmD79u1RPy8FDZuQMXTwDBssp1Jkfk6ZVqPI0K9hhhOXuxololeDRK+4uDjiUlZW+4dxKBTCpEmT0KdPH3Tq1AkAUFhYCK/XiwYNGkTct2nTpigsLIx6PPJ8ShHLyBQ67FDdkD1sWMIm/RoiG0NVXO7qhKqGSk2hZX4PyvwxJi4X3z+pqalITEwMX3Jycmo9dmZmJvbv34+lS5da/ntF9a5s2LAhXK7oPhhPnz5takDEWrL0dPDq32DVtyFzzwb1a0Qy269hRonfi3peYwlf1NbkRqnUq+E0BQUFSEhICP/s89X8wTtx4kSsWrUKmzdvRvPmzcPXJycnw+/348yZMxFVjePHjyM5OTnq8UQVNObOnRv+71OnTuEPf/gDBg4ciPT0dADA9u3bsW7dOkyfPj3qAxP+KkKH6MDBI2wA1geOiiqElYGDwoZ8RDaGiiDiHChGGW3uNNMUWgdFuh8nWkJCQkTQqI6maXj44YexfPly5ObmomXLlhG3d+/eHbGxsdi4cSPuuOMOAMDBgwdx7Nix8Pd/NKIKGmPHjg3/9x133IFnn30WEydODF/3yCOP4JVXXsGGDRswefLkqA9OxBAdOKi6wYadwgZVNfRTqaoh4mRrpLLMzEwsWbIE7733HuLj48N9F4mJiahTpw4SExNx7733IisrC40aNUJCQgIefvhhpKenR73iBDDQo7Fu3Trccsstla6/5ZZbsGHDBr1PRwQS3cvBo39Dhb4NuzaHmiWyX8Npm3iJ6NXgjVauVDZ//nwUFRWhX79+SElJCV+WLVsWvs/LL7+MX//617jjjjtw4403Ijk5Ge+++66u4+j+VGrcuDHee++9Ste/9957aNy4sd6nw7x585CWloa4uDj06tULO3furPH+Z86cQWZmJlJSUuDz+dC2bVusWbNG93E9fn0XuxMdOFiisGGAJEteRRLVGOqUFSiqLHU9HbTvRmOaplV5GTduXPg+cXFxmDdvHk6fPo2SkhK8++67uvozAAMbds2cORP33XcfcnNz0atXLwDAxx9/jLVr12LhwoW6nmvZsmXIysrCggUL0KtXL8ydOxcDBw7EwYMHkZSUVOn+fr8fv/rVr5CUlIR///vfuPLKK/HNN99UWnrDQjRhI6he03kloqZVWE+nsOzbsGoaRboNvWgKxVFU6tUgatH9Z8u4ceOwdetWJCQk4N1338W7776LhIQEbNmyJSIFRWPOnDm4//77MX78eHTo0AELFixA3bp1sWjRoirvv2jRIpw+fRorVqxAnz59kJaWhr59+6Jr1656fw0m7FQNEVXhULG6IWtlwxISLHsVuUU5VTXYUmWpKzHH0CRmr1698Oabb5o6sN/vR15eHqZNmxa+zu12IyMjo9odx1auXIn09HRkZmbivffewxVXXIFRo0Zh6tSp8Hiq/jAqKyuL2KykuLjY1LiNqCpsqFL9EFHh4FHdcEJlQ5bmUNGrUFRtDBXBaFWDlrqSmkQVNPR8OUezpAYATp48iWAwiKZNm0Zc37RpU3zxxRdVPubw4cP44IMPMHr0aKxZswaHDh3CQw89hEAggOzs7Cofk5OTg5kzZ0Y9fl5UCx+iAgeFDXMsCxsmqTyFImq5q2orUIwyugKF91JXHoJ+D7QY4xW8kKQnKIwqaDRo0KDWDbs0TYPL5UIwyO4vl1AohKSkJPz973+Hx+NB9+7d8d133+FPf/pTtUFj2rRpyMrKCv9cXFyM1NRUZmM049LwIWvo4B04KGxIEjZs0K9hhpmwoVpVwyiqapDqRBU0PvzwQ8sP3KRJE3g8nkrnta9px7GUlBTExsZGTJO0b98ehYWF8Pv98Horf/v5fL5ad0WT0eUVD9mCB8/AwXIqhUWTKIUNOanYGCqiqkFNocRqUQWNvn37Wn5gr9eL7t27Y+PGjRg2bBiAixWLjRs3RmwGdqk+ffpgyZIlCIVCcLsvNql9+eWXSElJqTJk2Ims1Q7egUOV6oaMYUMGVNWwN94beNlx+sSODLWUf/TRR7jrrrvQu3dvfPfddwCAf/7zn9iyZYuu58nKysLChQvx+uuv48CBA3jwwQdRUlKC8ePHAwDGjBkT0Sz64IMP4vTp03j00Ufx5ZdfYvXq1Xj++eeRmZlp5NdQlowrWnitUmG5yZfVK1JkW41C+2uIPZW8UWZWoBjlhA28CD+6PzXeeecdDBw4EHXq1MHu3bvDKzqKiorw/PPP63qukSNH4sUXX8QzzzyDbt26IT8/H2vXrg03iB47dgw//PBD+P6pqalYt24dPvnkE3Tp0gWPPPIIHn30UTz55JN6fw3bkC108FoS68SwYQVZwoYZqu4YKuLsrrSBl/WPI/rpfsf94Q9/wIIFCzBmzJiI08n26dMHf/jDH3QPYOLEidVOleTm5la6Lj09HTt27NB9HCeQZXqF13QKq6kUWadR7NSvofIUighmejWMol4NYhXdf5ocPHgQN954Y6XrExMTcebMGSvGRCwgQ5WDx3SK0yobVj2PDOdEUXUKhaoahOij+9MmOTkZhw4dqnT9li1b0KpVK0sGRawjw9QKj7DBInDYPWyYpvgUimpU6tWg6RNyKd2fFPfffz8effRRfPzxx3C5XPj+++/x5ptv4vHHH8eDDz7IYozEIiIDh6rVDTuHDRn6NcxWNcyEDapqENmEyj0IBUxcyuUM37rfaU8++SRCoRBuvvlmnD9/HjfeeCN8Ph8ef/xxPPzwwyzGSCxWETZE9HG4/Wx7N1j0bdi5Z0OGnUNFb1GuEpV6NVRZ6krY0x00XC4XnnrqKUyZMgWHDh3CuXPn0KFDB9SvX5/F+JhxBwB3lH8U8j6TKS+iAgfrZlEnhQ0rmA4bgjfyMtMYKmprchH7aqi0LTlPFFDYM1w79Hq96NChg5VjkVY0JX+Vw4io1SosqxssdhNlsWW5WdIEFoVPvKbaeVBEVDWMom3JCRBl0Bg+fDgWL16MhIQEDB8+vMb7vvvuu5YMTDXVhRHVAgjvKodq1Q0rwwZNoVhHxeWuKlU1eC91pZ1C7SWqoJGYmBg+qVpiYiLTAdlNVQFEhfAhInBQ2BD7PKKnUKiqET2VqhqERBU0XnvtNXzwwQe48cYb8dprr7Eek+1dHj5kDh4evz2qGxQ2oqNy2KCqRnR4VzWoKZREvTbtV7/6FU6fPh3++Ze//GX4PCfEnIqln7zOF6IX72WxrF4Dq5e/Wrn0VZq9MRSn4nJXo0Tsq2FntKcGO1EHDU2L/Evps88+C5/nhFhL1tDBM3BQ2BD3HKb31xC8t4ZqROyrYRTvDbyIPYjfh5jUSMbQwStwsPq9KWzUTnTYMIOqGrVTZQMv3juFClfmNn+RUNSjcrlc4YbQqn4m7MkWOlSubli9bbnVO4iapfpUDFU1iAjKBhTJRR3fNU3DzTffjJiYiw85f/48hgwZAq838g2ye/dua0dIqnTpl6/IZlJeq1NYrUqxsknUqgZRWfbGcGpjqFNWoNi9KZTII+qgkZ2dHfHz0KFDLR8MMUaG0MEjcFDY4P8cosOGk4hYgWJntPpEHoaDBpET6w2wasN6OSyr34/ChpyoqsGWKlUNniigWE/OzhFimsheDh7NorI3iVrVsyFDc6hTG0NFMNqrYfelrkabQokcKGjYnMgGUgob1j2XaCLDhqjGUNVWoJDKqLlTDhQ0HERE4GBd3XBC2JChqiGambBBVY2aGV3qyntPDZ5VDQoo1nJs0PD4tVovdiUqcLAie9iwggxhQ+UpFKOoqqE+Cg3iqffO58juYYR34GBZ3ZA5bFC/hjWcVNUwSpWqhgoooFgnqrj+//7f/4v6CR955BHDg1FRdWEj6FWnVM17pQqrlSksfg+rVqPItBJFKAWXu4pYgWL3pa60p0bVXH43XB7jYV7kHwI1iSpovPzyy1E9mcvlclzQqE5VAUT28MEzcLDcd8Pq/TZkCxumx2EyrIjcW8NpZ3flyehSVxXQklWxogoaR44cYT0OR7g8fMgaPHgHDhXChlWsCBsy7K9hOmwoxkxVwyijVQ2jO4UaZfc9NbwoFj0M5clZZ3EI2fs9ePVvqNC3YceVKEIJWu4qoleDmkKtRXtqqMdQS/W3336LlStX4tixY/D7Iz/N58yZY8nAnOjSsCFLtYNXdUOFyoaVu4dawWxVgqoa+jihqsF7p1CeaPpEHN1/VmzcuBFXX3015s+fj5deegkffvghXnvtNSxatAj5+fkMhuhMslU6eKxQYbUqRcbKhiybeQldhUJVDcczuqcGT3ZffbJ582YMGTIEzZo1g8vlwooVKyrd58CBA7jtttuQmJiIevXqoUePHjh27FjUx9D9Tp82bRoef/xx7Nu3D3FxcXjnnXdQUFCAvn374je/+Y3epyNRkCl08JhOobCh4zloCoUrM/tqGKXKBl480fSJdUpKStC1a1fMmzevytu//vprXH/99WjXrh1yc3Oxd+9eTJ8+HXFx0YdE3e+aAwcO4F//+tfFB8fE4MKFC6hfvz6effZZDB06FA8++KDepyQ6yDC9wmM6hcVUiozTKDI0hzpxCkXEChSVTrZmBE2fqGnQoEEYNGhQtbc/9dRTGDx4MF544YXwda1bt9Z1DN1/TtSrVy/cl5GSkoKvv/46fNvJkyf1Ph0xQXSVg8dUitXsWtkwPQaRlRGqajiaCtMnqikuLo64lJUZ+7AKhUJYvXo12rZti4EDByIpKQm9evWqcnqlJrrf4b/85S+xZcsWAMDgwYPx2GOP4bnnnsM999yDX/7yl3qfjlhA5NQK694NFn0bMoYNs0RPoci6UVBNVOrVoOmTyuw4feIOuOD2m7gELn4OpKamIjExMXzJyckxNJ4TJ07g3LlzmD17Nm655Ra8//77uP322zF8+HBs2rQp6ufRHc3nzJmDc+fOAQBmzpyJc+fOYdmyZWjTpg2tOJFARdjgPa3Cet8Kq6dSZJtGscMUiimCNvEySsQKFBWosKeGE6ZPCgoKkJCQEP7Z5zP2ARUKXXxPDh06FJMnTwYAdOvWDdu2bcOCBQvQt2/fqJ5Hd9Bo1apV+L/r1auHBQsW6H0KwoGIwMG6d4PCRhTPITBsUK9GdHhvS857Ay8iXkJCQkTQMKpJkyaIiYlBhw4dIq5v3759eGYjGoYnG/1+P06cOBFOPBVatGhh9CkJA6IChxPDhhVk2abcKFNhg6oaUlFhTw27n/tENK/Xix49euDgwYMR13/55Zf4xS9+EfXz6A4aX375Je69915s27Yt4npN0+ByuRAMqnEuAU8Z4KnhDzeZNmayAu/AwbK6IWvYkGVDL6WnUASgc6DIgaZPxDh37hwOHToU/vnIkSPIz89Ho0aN0KJFC0yZMgUjR47EjTfeiP79+2Pt2rX4z3/+g9zc3KiPoTtojB8/HjExMVi1ahVSUlLgcim+jr8a0TT5yfClopeIwEFhQ+dYJJhCMYOqGrVTZfpEhROtUVXDnF27dqF///7hn7OysgAAY8eOxeLFi3H77bdjwYIFyMnJwSOPPIKrr74a77zzDq6//vqoj6E7aOTn5yMvLw/t2rXT+1DbqS6MqBBAeAYOChsGxiJ4CoWqGsQMFfbUIBf169cPmlbze/2ee+7BPffcY/gYutekdejQgfbLqIWnLPIiM17LYlktg5V16asV/9/N7q9hdsmrmceruDW5UUb31VBlqStPPPfUsPvW4jLR/Y7+4x//iCeeeAK5ubk4depUpY1BSGWXBw8ZwwfPwGE1WcOGDETur6Ha3hoi9tVQgQp7ahC56Y7iGRkZAICbb7454nrVmkFFuzRsyDTV4vFrzKdTWEylyDiNQlMoJijWq2GUnbclp9Un+rn9LrjdJj5/JT33ke6g8eGHH7IYh6PJFjp49G+wWJXC6lTzZsgQNpzYGGqU0V4N3ktd7bynBq0+sR9dQSMQCODZZ5/FggUL0KZNG1ZjcjSZQgevwCFr2JCpOVQkFRtDVapqqECF1SdEXromUWNjY7F3715WYyGXkaWng3XvhtU9EVb2bMjSHEqNofwY7dVQpSmUp6JAHW7HsuO5T+xC97v4rrvuwquvvspiLKQGokMH62ZRJ4QNs0SHDdWIWIGiAhVOtEZndLUX3RG8vLwcixYtwoYNG9C9e3fUqxeZIunEauxVhA0R5XiWzaJ2n0Zx8hSKar0aRvHewIuYR30a7OkOGvv378e1114L4OJ25Jey6y6hshIVOFj2blDYqGUMCjeGimC0V0OVDbxUaAql1SeEVp3YgMjAwSpsABaeWVXC1ShmiAwbVNVwNp5NoTxXnxC2DHdaHTp0COvWrcOFCxeTam1bmBL2RPRxqNK3YVXPhhVjEt3cS6JDTaHOQbuEsqU7aJw6dQo333wz2rZti8GDB+OHH34AANx777147LHHLB8gMYZn4GDZKEpho5oxCGwMVW0FCjWFVo3nluS0+iQ6rsDF97bRi0vSNh/d79zJkycjNjYWx44dQ926P6fAkSNHYu3atZYOjiW3X4OnrPLFbuxQ3aCwUc0YBH6oOGUFiypVDZ5o9QnRS/e74f3338e6devQvHnziOvbtGmDb775xrKBiRJt2Aj61Pmg5dnDwbJvQ7aeDVZnpeVFVGOoqV4Ng+y+gZfRplDyM1p9wo7uikZJSUlEJaPC6dOn4fMpvHZPJxWrIbymU1hNpchY2TBLdFVD1BSKYQI28LIzmj4hPOh+195www144403wj+7XC6EQiG88MIL6N+/v6WDU40q4YNn4LCabGHD6VMoRok4s6vRXg2aPqmMpk+IHrrfCS+88AJuvvlm7Nq1C36/H0888QQ+++wznD59Glu3bmUxRqVdHjZkmnLhsYEUi6kU2aYsZBuPXqKWuxpGS12rRNMnRFa6/6zo1KkTvvzyS1x//fUYOnQoSkpKMHz4cOzZswetW7dmMUZbka3awaO6IXNlQ5bmUKpq8KFKVYMnu06fGEHLXNnQ/S44duwYUlNT8dRTT1V5W4sWLSwZmBNcGjZEVzpYN4zKXNmQZUMvkVuUU1VDLipsSS77GV1pl1B56P6TomXLlvjxxx8rXX/q1Cm0bNnSkkE5kSyVDpbVDRZNojJVNkSffI2qGmwZrWrwZNfNu6hPQ2263+WaplV5TpNz584hLo7+MVhBdOhgPZ1CYaOGMQicQnHKChTeG3ip0BRK0yc/o+kT60X9DsjKygJwcZXJ9OnTI5a4BoNBfPzxx+jWrZvlA3S6irAhYmqFZSnf6qkUmaZRzI5F9bO86iViXw0749kUStMn1vL4AY+Zj0VJ/1dEHTT27NkD4GJFY9++ffB6f/4k9Xq96Nq1Kx5//HHrR0gAiOvnYNm7wfKU805m5qRrTunV4H1WV6Onjyc/o5OsqSvqoFFx1tbx48fjz3/+MxISEpgNitRMRJWD1V/ZVoYNqmpYQ0RgoKpG1Xg2hdr11PFEPN2TnC+88EK1IWPfvn2mB0Six7uPg1XfhpU9G9Sv8X/HFtQYqtI5UOx8sjWeTaE8N+/ihfo0rKU7aHTu3BmrV6+udP2LL76Inj17WjIoog/PwMGqUdSuYUMkUY2hRhlegcJ5W3I776lhR7QduXi636FZWVm444478OCDD+LChQv47rvvcPPNN+OFF17AkiVLDA1i3rx5SEtLQ1xcHHr16oWdO3dG9bilS5fC5XJh2LBhho5rN7wDh+XPKWHYMEv0KhQRVKpqqMCuq0+MoGWuatIdNJ544gls374dH330Ebp06YIuXbrA5/Nh7969uP3223UPYNmyZcjKykJ2djZ2796Nrl27YuDAgThx4kSNjzt69Cgef/xx3HDDDbqPCQAxZaGIi53wChxOCBsyTKGYOjZVNWrEe6dQnmTfU0P2Za7EOobenVdddRU6deqEo0ePori4GCNHjkRycrKhAcyZMwf3338/xo8fjw4dOmDBggWoW7cuFi1aVO1jgsEgRo8ejZkzZ6JVq1aGjnu5y4NHdReVUNiQJ2yYOj5VNWzDrtMnsvdpGJk+oT4N6+gOGlu3bkWXLl3w1VdfYe/evZg/fz4efvhhjBw5Ej/99JOu5/L7/cjLy0NGRsbPA3K7kZGRge3bt1f7uGeffRZJSUm49957az1GWVkZiouLIy5mqBZAeFQ3WPRt2C1sqNoYqlRgUGQDLyNo+uRnNH2iHt3vzJtuugkjR47Ejh070L59e9x3333Ys2cPjh07hs6dO+t6rpMnTyIYDKJp06YR1zdt2hSFhYVVPmbLli149dVXsXDhwqiOkZOTg8TExPAlNTVV1xijJXvw4BU4LH0+BidjE0mWvhFejIYUVbYlp+kT82j6JJLbb/4iI93v6Pfffx+zZ89GbOzPCbt169bYunUrHnjgAUsHd7mzZ8/i7rvvxsKFC9GkSZOoHjNt2jQUFRWFLwUFBUzHWEHW4OHUsCFDVcP08amqYQs0faIOmj6xhu5/8X379q3yerfbjenTp+t6riZNmsDj8eD48eMR1x8/frzKno+vv/4aR48exZAhQ8LXhUIXv8RjYmJw8ODBSqeq9/l88PnE7+d8adgo94n9i431hl9WbzZl1aZeVmzoZXYzL6s2FVOF0c2/DG/gpchOoUbYdfMuXlTbjtxOov7GGzx4MIqKisI/z549G2fOnAn/fOrUKXTo0EHXwb1eL7p3746NGzeGrwuFQti4cSPS09Mr3b9du3bYt28f8vPzw5fbbrsN/fv3R35+PrNpEavJUulgWd2gygabMVBVwx54VjVknz4xgvo01BL1v/Z169ahrOznT7nnn38eI0aMQIMGDQAA5eXlOHjwoO4BZGVlYezYsbjuuuvQs2dPzJ07FyUlJRg/fjwAYMyYMbjyyiuRk5ODuLg4dOrUKeLxFce//HpViK50sKxu2LmyIZJTTrqmSlWD/MzISdZoO3L7i/qbTdO0Gn82auTIkXjxxRfxzDPPoFu3bsjPz8fatWvDDaLHjh3DDz/8YMmxZCey0sGquiFrZcMs0atQDB9XQFXD7tUQnk2htPqEv+KgvRtWN2/ejCFDhqBZs2ZwuVxYsWJF+LZAIICpU6eic+fOqFevHpo1a4YxY8bg+++/13UMKbqSJk6ciIkTJ1Z5W25ubo2PXbx4sfUDkkBF2OBZ5WBV3ZCxsiFDv4apYzukqmFndEZXc4yczZX6NCorKSlB165dcc8992D48OERt50/fx67d+/G9OnT0bVrV/z000949NFHcdttt2HXrl1RHyPqoOFyueByuSpdR9gSFThYhA1Ari9H0VMooo4v4jTydm8KlV2J34t6XnmbO2n6RJxBgwZh0KBBVd6WmJiI9evXR1z3yiuvoGfPnjh27BhatGgR1TGiDhqapmHcuHHhFRylpaWYMGEC6tW7uOPapf0bxHq8AweLsHHxea0JG7L0a4hchUJVDXnYdfWJEUb6NIi1Lt+Y0srVl0VFRXC5XOH+yGhEHTTGjh0b8fNdd91V6T5jxoyJ+sDEGJ6BQ/apFKvChvlxiJtCMcpMVcPwMRWpavAk+/SJHZe5yszjBzxmPtL+73/V5Ssws7OzMWPGDBNPfFFpaSmmTp2KO++8EwkJCVE/Luqg8dprrxkaGGGDd+Cwc9hQeQpFRFXDaGBQBU2fqIP6NKpWUFAQEQSsqGYEAgGMGDECmqZh/vz5uh6rxl6/pFq8VqmwWJVi1YoUK1aimD4XiYKf32ZWoBg+po23Jbfr6hNeaDty6yQkJERczAaNipDxzTffYP369bqqGYCDg4bbL3dJVS8egYPH2WCNkmXZq1GiNvEySpklqwZPtMaT7FuSG1nmasftyJ2qImR89dVX2LBhAxo3bqz7OeT+F86YW+cXc0jw1uHRiCkLMZ1OsXoaRaaGRtGNoSKI6NVQAU2fEKc4d+4cDh06FP75yJEjyM/PR6NGjZCSkoL/+Z//we7du7Fq1SoEg8HwCU8bNWoErze6Dzz5vzkl4i4LVbrIiHV1w+ozwdIUivljq1TVoOkTa9hx+sQII9uR/1Rej8FI1LRr1y5cc801uOaaawBc3K37mmuuwTPPPIPvvvsOK1euxLfffotu3bohJSUlfNm2bVvUx3B0RcMKVYUNWSofKlU3ZGoOdRrbVzUUWH1iR7QduRr69etX407fVuwCLsc3os3IVPHgUd2w7rkseh6TlQ2qakTPztuShwL8qhN27NMgpAIFDcZkCR1OCxtmiToXiahji1iBYoTh6ROOTaE8p0+MsOPZXIncKGhwJDp0sKxuyBY2RK9CEbXcVZagZhc8qxpGUJ/GRXbp03AHLv6hYfgi6R8MFDQEERk6KGxER9UpFMPHNPghRU2h1pB9+sQII8tcaT8N+7HnO1YxIgIHq+oGhQ3xqKpRDZo+CTMyfUJ9GsQoChoSERU4rCbzxl68UVWDzePIz2j6hMiOgoaEeAcOmcMGVTWMsXtVg+f0Ca0+IcQcChoS4xk4KGzUzNSyU8WqGrZG0yfc8erTsEtDqB1R0FAAr8DBom9DprDhNEZfM5o+cQbq0yC8UNBQCM/AYSVZejaoqmEvdp0+MYL6NIjMKGgoiEfgkDFsyDCFohpVqhpcSX5GV+rTIHYj9zuO1IjCBn9U1WBDiYBigB37NHidNp76NOzDsdHZUxaCJxjdF2lQkpOkVaUibLA6kRvrE7MZYfYEbGZPvGbmdPIqnUpehZOtufxuaF4+DdN2PHU8nTZeLh6/Bg9M/EEmacVWrm8QSXnKQlVeZMJyOsXKyoYszaEqTqEYrWrwrgIp0RRqw+kT6tMgspL73SY5GYOHk8KGSKKmUIh67Dh9QogeFDQsJEvoYFXdkC1sUFUjenZuCqXVJ2qg8544FwUNRmQIHRQ2oni8ibBBVQ3r0fSJOUamT+y2nwY1hMrHfu80CYkMHU4IGyQ6vKsaxBxa5krsgoIGZyICh+xhwyynVTVUWepq1+kTI6hPgziZ3O9OG+Nd5WDRt2FV2JBhCoXIQ/Y9NahPgxB9KGhIgHfgsJJMYcPU8QVVNXgfk6ZPLkN9GgD49WnIvHEXYYcmASVSETZYbxDmLgtZusGXVZt6eco0BH3G/5o1u5GXCCpt4GWE2+9CyMsnRPLcvMuIcr8HMV59G36V+WPg85YzGhG51E/l9dAwpkToGDxlgMfM20XSaVX7xXkb4FHhkLWyYZaZKRSqasiDpk8IsQ8KGhJzYthQeQrF+DG5H9IQmj4hhBhB7zDJsa5u2DFsiPqLXZXVILzR6hP+ZO7TIM5D70pFsAwcVq9IkSFsmDq2QlUNOzeFyj59YoSRZa5220+DGkKdh4KGYlSqbohEVQ2ii4HpE+rTsB/aIZQNe0VlHTyl5fDE1N7NHYyT7yViuTrFqhUpVqxEEbkKxeyp5I0d09gKFKOnree5SodWnxDiXFTRqIWntLzSRRYsp1KsoPoUilF2r2rYtimUEMIEBQ0DZAoeTggbZoha7mr8mNwPKTXq07jISJ+GzA2hRvo0iLrkmxdQ0KVhQ8RUC6upFKs39jLK7BSKCEanM3gfz67TJ4aUuQGfvmAcCnjgjtW3CRcxpihQB4mxF0QPgym3X4NHM/4e0QJyvr/Ef4vYjMhKh8hT0teEqhr2I/v0CS1zJQCtPJEFvRsZEhE6rA4bskyhOKlXw+5nddXLjtMnRF608sR6FDQ44Rk4rN5zww5hg6oa1eO5FJhCw0V269MgpCYUNDjjHTisYoc9NkTsrcG7qsGT7NMnhtB+GoZQQyipCQUNQXgFDtnChqpTKKpUNWj65GfUp2E/RnYIJdULBoOYPn06WrZsiTp16qB169aYNWsWNBMNqVWhVSeCVYQNlqtVPGUhy1akWLESxexmXmZWoah4KnkeaPUJsaviQBwSYktFD0NKf/zjHzF//ny8/vrr6NixI3bt2oXx48cjMTERjzzyiGXHoaAhCdaBQ7awoSKju4UaXnpqcKdQQog5P5XXQ8OYEtHDYG7btm0YOnQobr31VgBAWloa/vWvf2Hnzp2WHsd53xaSYzmdItM0iqqNoSrgOX0ie5+GoekTTn0a1BBKWCkuLo64lJVV/aHXu3dvbNy4EV9++SUA4NNPP8WWLVswaNAgS8dDFQ0JsaxuWFnZMMuK86HwZueqhuzTSjTlIreSgBf1Ym3aJMRJTFkIMSETf4QFLj42NTU14urs7GzMmDGj0t2ffPJJFBcXo127dvB4PAgGg3juuecwevRo42OoAgUNiXlKy6UOG6KnUKhXo3q8dybVi0IDAS6uPKlP4cRyBQUFSEhICP/s81X9YffWW2/hzTffxJIlS9CxY0fk5+dj0qRJaNasGcaOHWvZeChoSI5VdUOWsKFiVYNEcgeAkP7qPCGGOGErcrMSEhIigkZ1pkyZgieffBK//e1vAQCdO3fGN998g5ycHEuDhmM/4V1lQbhKy2u8yIRF74ZVPRsi+zVE9GoYXeqqwp4aduxfoT4NQluRV+38+fNwuyP/rXs8HoTMTN9Ugf7F1qCqsKEJOGlaBRZTKTL1bBBr2XH6hKZcjCkNxCIuVvLOXcLdkCFD8Nxzz6FFixbo2LEj9uzZgzlz5uCee+6x9DgUNHS6NHyICB0splKsCBsip1BE9GrwbgqVHU2f2E+J34t6Xuf2Tzhhietf/vIXTJ8+HQ899BBOnDiBZs2a4YEHHsAzzzxj6XEoaJggMnRYXd2QIWyQ6tHqE6ICWnmilvj4eMydOxdz585lehz6VrCIiN4OEaeiZ0lUr4bhYyqyLTkhMqNzntgfBQ0GeAYOK8OGFc2hojfyMoJ3AyTXDbUk/+PSyDlMuJ33ROKGUKejc56ohYIGQ7wCh93ChlGiTrjGi+xndJV9l1A74bVDqJ3QyhNxqEeDg4qwwbKPw8qeDdErUUTsrcG7KVR21KdBAGoI5c3tD8FtYmmpu1zMH3m1oYoGR6wrHDJVNqiqUTOaPiF2VWKjnoufyuuJHoItUNAQgGXgkKlB1EzYcEKvhhGyT58YYbc+DUJIJHoXCSR72LDybK888a5q2HX1iZHgRX0a1BBqBK08sTcKGoKxqm7IEjZUq2rwRNMnxAzaipyoQoqgMW/ePKSlpSEuLg69evXCzp07q73vwoULccMNN6Bhw4Zo2LAhMjIyary/KuwcNkQwWtXgff4TY8fidihiM3ZaeUJLXNUhPGgsW7YMWVlZyM7Oxu7du9G1a1cMHDgQJ06cqPL+ubm5uPPOO/Hhhx9i+/btSE1NxYABA/Ddd99xHrn1WFQ3ZOjZoKoGqQ2vPg2iX4nfPtMatMRVDOFBY86cObj//vsxfvx4dOjQAQsWLEDdunWxaNGiKu//5ptv4qGHHkK3bt3Qrl07/OMf/0AoFMLGjRs5j5wdGcOGiqtQeFc1jJB9SsNufRrUEEoIf0LfQX6/H3l5ecjIyAhf53a7kZGRge3bt0f1HOfPn0cgEECjRo2qvL2srAzFxcURFwBwl/qrvcjAjmHDKFWqGrI3hcoeauzESEOondhpiesZWuJqmtCgcfLkSQSDQTRt2jTi+qZNm6KwsDCq55g6dSqaNWsWEVYulZOTg8TExPAlNTW11ueUJXzIGDbMELW3hh1Rn4b9OH3lCbn4x5zZi4yUrgnOnj0bS5cuxfLlyxEXV/Xc27Rp01BUVBS+FBQUGDqWqODB8yRt0VCtqkHTJ8TO7LTyhJa42pfQf6VNmjSBx+PB8ePHI64/fvw4kpOTa3zsiy++iNmzZ2PDhg3o0qVLtffz+Xzw+azfS7kibITi2L85rNzC3Iqtys1sUW73U8nbcUtyI9uRuwNASOcCB7ffhZBXXzA08hinKw3EIi5W4kYaYjtCP/G9Xi+6d+8e0chZ0diZnp5e7eNeeOEFzJo1C2vXrsV1113HY6jV4lnhsKq6IXoKxSjeVQ3ZGZk+oeoJNYTaCS1xVYPwd09WVhYWLlyI119/HQcOHMCDDz6IkpISjB8/HgAwZswYTJs2LXz/P/7xj5g+fToWLVqEtLQ0FBYWorCwEOfOnRP1KwAAt2kVWcKGmSkUVXo1aPqEmGGnhlA7LXEl/Amf4Bs5ciR+/PFHPPPMMygsLES3bt2wdu3acIPosWPH4Hb/nIfmz58Pv9+P//mf/4l4nuzsbMyYMYPn0KvFelrFVVrO9EywMhNxZle97Dh9QohdFAfikBBbKnoYjiLFt9XEiRMxceLEKm/Lzc2N+Pno0aPsB2QRd6lf6rBhtl9DpV4NT5mGoI++/IGL1ZOQzn+WvPo0nK7c70GMNyh6GJYoCXhRL5ZKdUSCqRO7YzmdYsU0iqr9GrzIfkZXuy1zpR1C9bPTyhNiTxQ0OJFlIzCriejVsGtTKPVp8GOoIZQwR0tc7YmiMEcsejdkmEIhlVGfhg2VuQGfGo3MtaElrnLylJbDE2O8yqyVy1mhplgvgNXVDdFTKCI28eK5Lbns0yeEECIzChqCWN27IXoHUaNhg/dSVztOn/DaT8NuJ1jjgZa4skd7aciPgoZgMoUNagy1luwnWZOV05s76ZwnxG4oaEjALmGDd1WDpk9IBaeHE0Jk5tygUVYGlFZxEcSuq1JkJPv0CeHDTitPZF3iKuvp4osDVZ+Ek7Bhn3eaVQQGD6vChopTKKpsS86DzH0ahBCiFwWN2nAOHbKEDaN4r0DhOX1ihN36NBw/hUQnV2OO9tKwH3rX6MEpdMgwjWL3xlAj0yeO/5I1iFaeyNncWRqg/eEJH3JO7KmgImzE6TwBRJSsOE+KqJOvGT0HCu/znxB5uf0uhLz2qgYRUhtXWRAuE5tuuYJynieHPtXNYljhsKKyYWYKRZWqhuzTJ4QPWnnCnqx7aRC5UdCwisRhQwRVNvDSy8j0iZE+DWoIdTbaS0Mf2rRLbhQ0rMSoumE2bDihqmEELXM1xk69KnZa4kqIrOhdxoLA/TiqI3qLctZo+kRuTm8I5UHWvTQIoaDBisXVDZFTKEarGnadPiEOR0tcdZF10y5S2ezZs+FyuTBp0iRLn5feMaxJFDbsXtXgReY+DTuh5k7CEu0OGumTTz7B3/72N3Tp0sXy56agwYNEYcMo3lUNI4xMn9itT8NIQyhhj/bSIDI7d+4cRo8ejYULF6Jhw4aWPz8FDV4k6dtQpapB0yf82KlyQlUQe6DdQfnKzMzErbfeioyMDCbPT91DPJWWWbLBlxWbeRnhKS1HUMAGYEQ+njIgyGavOkKIScXFxRE/+3w++HxVv2GXLl2K3bt345NPPmE2Hqpo8GZRk6iZKRTeVQ3e5z/hwU5LPJ1O1iWutJeG87hL/aYvAJCamorExMTwJScnp8rjFRQU4NFHH8Wbb76JuDh2PSvO/fO01P9zzGK0jTjhL6YshHKd25h7yjQEfexL7h6/hqDXuaV9dwAIUUuA8kr8XtTz2mi+zYYKCgqQkJAQ/rm6akZeXh5OnDiBa6+9NnxdMBjE5s2b8corr6CsrAwej/nA69ygcamqKgysw4cF0yhmplCMngeF5/QJnfvkYv9EiKarCSE6JCQkRASN6tx8883Yt29fxHXjx49Hu3btMHXqVEtCBkBBo3qXhg9WocOing0VGD3RGtHP4weCNgkn0p5crcwN+Ow3JaiyokAdJMZeED0MpcTHx6NTp04R19WrVw+NGzeudL0Z9MkfDZanhjf5vCr1ahB52WnliZPR7qBERvSvUg9Wp4ZXrLIh+/QJrz4NWnlBCLGb3Nxcy5+TKhpGsKxwGKDKGV7tuPpELyM7hMpK1pU3tJeGfGgbcmejoGGGlWFD0BSK0ekTO5/VlRAWZN0dlBDWKGiYJVHYIPZE/ROEJSdvQ07nO+GDejSsYGXvhol+DaPLXY0udeWFlrnqJ+vKE1n30nD53dC8NLVHBCsrM/fnf0jOP1bp09tKVJGoFa8+DTrBGiGEyIGChtWsCBuKBBbq05C3IZLYg5O3IacTq9kHBQ0WBAYF3k2hxD5k7QWhVSSEqI2CBitmw4YiVQ2in52WuBJCSG0oaNgQz301jEyfGOnTcNMeHEQ2Zc79+Czx07QGiZ5z3yk8KFbVsNv0iZGGUFnJOq1BPSqEkNo4NmhoFzidfIemQJRCK0/swcl9HXS+EyIbR/+L1M5XDhuuunWsP5CZc5kYfKyZU8gTQgghVnF00KhKRfhgEjhsiudJ1mQk68nVZN20ixBWlD9VfKnf5IZdcs6xOnbqpDba+QtVVjwMMzOFwnH6hVefBp1gzbncAdEjEIfOd0KciIJGLaQJGwaoclbXaNHKE0IIUQ8FjShYXt0g3Mi68oT20iBOQ6eKdy4KGjpYEjaMVjVo9QrhQNZltDy4/PRxSAgL9M7SSbXKhpHpEyN9GnY67wktcSWEEOtQ0DDAdNigqgYAagjVy8nVBifvi8FDaSBW9BCIjVHQMEi1ygYhhBAiAgUNUWxWnSCEEEKq4txdliygnb9AG3tx5i4LIeSTLx/LumkXD07+3Xko93sQ4w2KHgbhQLtwAZrL+P9rTZNzflW+T2zFcJ9CMVAJ4dUQSgghhFyOgoZINH1CCCFCFQfiRA/B9ihoWIAaQy+SdYmrrJt28eCRs5JqH2X0EUpIbehdYhEKG4QQQkhljg0aoQtlCF0oFT0MY9MnNppycfJeGrQNOSHECRwbNCqELpTKETgYs9sJ1gipDW3ypb5zdH4UW3B80KhgReCg6RNCCCEkEgWNyzihukFqR+c7IYQQa9CGXVUIXSiFuw4teXKVlkOLo38ihBDCQ+hCGUIu431rIS1g4WisQxWNahitbBiaPrFRcych0XDL+XlICGGAgoaqHBxO3A5eqUKILEr81KhJokNBowbUr0EIIYSYQ0GDEEIIIcxIETTmzZuHtLQ0xMXFoVevXti5c2eN93/77bfRrl07xMXFoXPnzlizZg2nkRJCCCH2ovc7WC/hQWPZsmXIyspCdnY2du/eja5du2LgwIE4ceJElffftm0b7rzzTtx7773Ys2cPhg0bhmHDhmH//v2cR149J++nIev5Tkj03LS3GyGOofc72AjhQWPOnDm4//77MX78eHTo0AELFixA3bp1sWjRoirv/+c//xm33HILpkyZgvbt22PWrFm49tpr8corrzAZH/VpEEIIsSu938FGCA0afr8feXl5yMjICF/ndruRkZGB7du3V/mY7du3R9wfAAYOHFjt/QkhhBBSmZHvYCOE7sZ08uRJBINBNG3aNOL6pk2b4osvvqjyMYWFhVXev7CwsMr7l5WVoazs56WgRUVFAIByHRubuDX9ecwV8uh7gJEVm0Gd9y8pQyhO35I0rVz/VEiwXN8/q6BH/+sbcut7TLnO+wNAyKXvXBlBA6fWCELfg0IGNiwNGniM3uMYOYam899vyMAvH9I5MC1o4I0Y0vmYgN43LhAs1/cYvfcHgGCs/s1NygP65tkCBo4RiNV3DH+M/rm/shrG5S+5eJumsd8tuBwBwMRhynFxrMXFxRHX+3w++Hy+Svc38h1shO23fczJycHMmTMrXf9R8L3on+SsgQMbeQwhhBApnTp1ComJiUye2+v1Ijk5GR8V6vheqkb9+vWRmpoacV12djZmzJhh+rmNEho0mjRpAo/Hg+PHj0dcf/z4cSQnJ1f5mOTkZF33nzZtGrKyssI/nzlzBr/4xS9w7NgxZv9o7Ky4uBipqakoKChAQkKC6OEohV474+i1M4deP+OKiorQokULNGrUiNkx4uLicOTIEfj95juxNU2D67JqbFXVDMDYd7ARQoOG1+tF9+7dsXHjRgwbNgwAEAqFsHHjRkycOLHKx6Snp2Pjxo2YNGlS+Lr169cjPT29yvtXVzJKTEykN5wJCQkJ9PoZRK+dcfTamUOvn3FuA9OvesTFxSEuju85tox8BxshfOokKysLY8eOxXXXXYeePXti7ty5KCkpwfjx4wEAY8aMwZVXXomcnBwAwKOPPoq+ffvipZdewq233oqlS5di165d+Pvf/y7y1yCEEEKUU9t3sBWEB42RI0fixx9/xDPPPIPCwkJ069YNa9euDTenHDt2LCJJ9u7dG0uWLMHTTz+N3//+92jTpg1WrFiBTp06ifoVCCGEECXV9h1sBeFBAwAmTpxYbZkmNze30nW/+c1v8Jvf/MbQsXw+H7Kzs6udsyI1o9fPOHrtjKPXzhx6/YxzwmtX03ewFVwajzU7hBBCCHEk4TuDEkIIIcS+KGgQQgghhBkKGoQQQghhhoIGIYQQQpixZdCYN28e0tLSEBcXh169emHnzp013v/tt99Gu3btEBcXh86dO2PNmjWcRionPa/fwoULccMNN6Bhw4Zo2LAhMjIyan297Uzvv70KS5cuhcvlCm+a40R6X7szZ84gMzMTKSkp8Pl8aNu2raPfu3pfv7lz5+Lqq69GnTp1kJqaismTJ6O01Hlnq968eTOGDBmCZs2aweVyYcWKFbU+Jjc3F9deey18Ph+uuuoqLF68mPk4labZzNKlSzWv16stWrRI++yzz7T7779fa9CggXb8+PEq779161bN4/FoL7zwgvb5559rTz/9tBYbG6vt27eP88jloPf1GzVqlDZv3jxtz5492oEDB7Rx48ZpiYmJ2rfffst55OLpfe0qHDlyRLvyyiu1G264QRs6dCifwUpG72tXVlamXXfdddrgwYO1LVu2aEeOHNFyc3O1/Px8ziOXg97X780339R8Pp/25ptvakeOHNHWrVunpaSkaJMnT+Y8cvHWrFmjPfXUU9q7776rAdCWL19e4/0PHz6s1a1bV8vKytI+//xz7S9/+Yvm8Xi0tWvX8hmwgmwXNHr27KllZmaGfw4Gg1qzZs20nJycKu8/YsQI7dZbb424rlevXtoDDzzAdJyy0vv6Xa68vFyLj4/XXn/9dVZDlJaR1668vFzr3bu39o9//EMbO3asY4OG3tdu/vz5WqtWrTS/389riFLT+/plZmZqN910U8R1WVlZWp8+fZiOU3bRBI0nnnhC69ixY8R1I0eO1AYOHMhwZGqz1dSJ3+9HXl4eMjIywte53W5kZGRg+/btVT5m+/btEfcHgIEDB1Z7fzsz8vpd7vz58wgEAkxPQCQjo6/ds88+i6SkJNx77708hiklI6/dypUrkZ6ejszMTDRt2hSdOnXC888/j2BQ/+nRVWfk9evduzfy8vLC0yuHDx/GmjVrMHjwYC5jVhl9Z+gnxc6gVjl58iSCwWClrVObNm2KL774osrHFBYWVnn/wsJCZuOUlZHX73JTp05Fs2bNKr0R7c7Ia7dlyxa8+uqryM/P5zBCeRl57Q4fPowPPvgAo0ePxpo1a3Do0CE89NBDCAQCyM7O5jFsaRh5/UaNGoWTJ0/i+uuvh6ZpKC8vx4QJE/D73/+ex5CVVt13RnFxMS5cuIA6deoIGpm8bFXRIGLNnj0bS5cuxfLly7mfhVA1Z8+exd13342FCxeiSZMmooejnFAohKSkJPz9739H9+7dMXLkSDz11FNYsGCB6KEpITc3F88//zz++te/Yvfu3Xj33XexevVqzJo1S/TQiA3ZqqLRpEkTeDweHD9+POL648ePIzk5ucrHJCcn67q/nRl5/Sq8+OKLmD17NjZs2IAuXbqwHKaU9L52X3/9NY4ePYohQ4aErwuFQgCAmJgYHDx4EK1bt2Y7aEkY+XeXkpKC2NhYeDye8HXt27dHYWEh/H4/vF4v0zHLxMjrN336dNx999247777AACdO3dGSUkJfve73+Gpp55ifkp0lVX3nZGQkEDVjGrY6l+T1+tF9+7dsXHjxvB1oVAIGzduRHp6epWPSU9Pj7g/AKxfv77a+9uZkdcPAF544QXMmjULa9euxXXXXcdjqNLR+9q1a9cO+/btQ35+fvhy2223oX///sjPz0dqairP4Qtl5N9dnz59cOjQoXA4A4Avv/wSKSkpjgoZgLHX7/z585XCREVo0+j0VzWi7wwDRHejWm3p0qWaz+fTFi9erH3++efa7373O61BgwZaYWGhpmmadvfdd2tPPvlk+P5bt27VYmJitBdffFE7cOCAlp2d7fjlrXpev9mzZ2ter1f797//rf3www/hy9mzZ0X9CsLofe0u5+RVJ3pfu2PHjmnx8fHaxIkTtYMHD2qrVq3SkpKStD/84Q+ifgWh9L5+2dnZWnx8vPavf/1LO3z4sPb+++9rrVu31kaMGCHqVxDm7Nmz2p49e7Q9e/ZoALQ5c+Zoe/bs0b755htN0zTtySef1O6+++7w/SuWt06ZMkU7cOCANm/ePFreWgvbBQ1N07S//OUvWosWLTSv16v17NlT27FjR/i2vn37amPHjo24/1tvvaW1bdtW83q9WseOHbXVq1dzHrFc9Lx+v/jFLzQAlS7Z2dn8By4Bvf/2LuXkoKFp+l+7bdu2ab169dJ8Pp/WqlUr7bnnntPKy8s5j1oeel6/QCCgzZgxQ2vdurUWFxenpaamag899JD2008/8R+4YB9++GGVn2EVr9fYsWO1vn37VnpMt27dNK/Xq7Vq1Up77bXXuI9bJXSaeEIIIYQwY6seDUIIIYTIhYIGIYQQQpihoEEIIYQQZihoEEIIIYQZChqEEEIIYYaCBiGEEEKYoaBBCCGEEGYoaBCioNzcXLhcLpw5c0b0UGp0+TgXL16MBg0aCB0TIYQvChqEMJSTk4MePXogPj4eSUlJGDZsGA4ePCh6WMKMHDkSX375pehhEEI4oqBBCEObNm1CZmYmduzYgfXr1yMQCGDAgAEoKSkRPTQh6tSpg6SkJNHDIIRwREGDEIbWrl2LcePGoWPHjujatSsWL16MY8eOIS8vL3wfl8uFf/zjH7j99ttRt25dtGnTBitXrox4njVr1qBt27aoU6cO+vfvj6NHj9Z67DNnzuCBBx5A06ZNERcXh06dOmHVqlXh29955x107NgRPp8PaWlpeOmllyIe73K5sGLFiojrGjRogMWLFwMAjh49CpfLhaVLl6J3797hY2zatKnaMV0+dTJjxgx069YN//znP5GWlobExET89re/xdmzZ8P3OXv2LEaPHo169eohJSUFL7/8Mvr164dJkybV+hoQQsSjoEEIR0VFRQCARo0aRVw/c+ZMjBgxAnv37sXgwYMxevRonD59GgBQUFCA4cOHY8iQIcjPz8d9992HJ598ssbjhEIhDBo0CFu3bsX//u//4vPPP8fs2bPDpwLPy8vDiBEj8Nvf/hb79u3DjBkzMH369HCI0GPKlCl47LHHsGfPHqSnp2PIkCE4depU1I//+uuvsWLFCqxatQqrVq3Cpk2bMHv27PDtWVlZ2Lp1K1auXIn169fjo48+wu7du3WPkxAiiOizuhHiFMFgULv11lu1Pn36RFwPQHv66afDP587d04DoP33v//VNE3Tpk2bpnXo0CHiMVOnTtUAVHu2zXXr1mlut1s7ePBglbePGjVK+9WvfhVx3ZQpUyKOA0Bbvnx5xH0SExPDZ6o8cuSIBkCbPXt2+PZAIKA1b95c++Mf/6hp2s9nxqwY52uvvaYlJiaG75+dna3VrVtXKy4ujhhHr169NE3TtOLiYi02NlZ7++23w7efOXNGq1u3rvboo49W+bsRQuRCFQ1COMnMzMT+/fuxdOnSSrd16dIl/N/16tVDQkICTpw4AQA4cOAAevXqFXH/9PT0Go+Vn5+P5s2bo23btlXefuDAAfTp0yfiuj59+uCrr75CMBiM6vepaiwxMTG47rrrcODAgagfn5aWhvj4+PDPKSkp4d/98OHDCAQC6NmzZ/j2xMREXH311brGSAgRJ0b0AAhxgokTJ2LVqlXYvHkzmjdvXun22NjYiJ9dLhdCoZDh49WpU8fwYy8dg6ZpEdcFAgHTz3s5q393QohcqKJBCEOapmHixIlYvnw5PvjgA7Rs2VL3c7Rv3x47d+6MuG7Hjh01PqZLly749ttvq11K2r59e2zdujXiuq1bt6Jt27bhPo4rrrgCP/zwQ/j2r776CufPn6/0XJeOpby8HHl5eWjfvn3Nv1SUWrVqhdjYWHzyySfh64qKimiJLCEKoYoGIQxlZmZiyZIleO+99xAfH4/CwkIAF8v/0VYdJkyYgJdeeglTpkzBfffdh7y8vFqbNvv27Ysbb7wRd9xxB+bMmYOrrroKX3zxBVwuF2655RY89thj6NGjB2bNmoWRI0di+/bteOWVV/DXv/41/Bw33XQTXnnlFaSnpyMYDGLq1KmVqg8AMG/ePLRp0wbt27fHyy+/jJ9++gn33HNP9C9SDeLj4zF27FhMmTIFjRo1QlJSErKzs+F2u+FyuSw5BiGELapoEMLQ/PnzUVRUhH79+iElJSV8WbZsWdTP0aJFC7zzzjtYsWIFunbtigULFuD555+v9XHvvPMOevTogTvvvBMdOnTAE088Ee6/uPbaa/HWW29h6dKl6NSpE5555hk8++yzGDduXPjxL730ElJTU3HDDTdg1KhRePzxx1G3bt1Kx5k9ezZmz56Nrl27YsuWLVi5ciWaNGkS9e9Xmzlz5iA9PR2//vWvkZGRgT59+qB9+/aIi4uz7BiEEHZc2uWTsIQQEoWjR4+iZcuW2LNnD7p168btuCUlJbjyyivx0ksv4d577+V2XEKIMTR1QgiR2p49e/DFF1+gZ8+eKCoqwrPPPgsAGDp0qOCREUKiQUGDECK9F198EQcPHoTX60X37t3x0UcfWTo9Qwhhh6ZOCCGEEMIMNYMSQgghhBkKGoQQQghhhoIGIYQQQpihoEEIIYQQZihoEEIIIYQZChqEEEIIYYaCBiGEEEKYoaBBCCGEEGYoaBBCCCGEmf8PXVbMRPtNZXEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mesh_alpha, mesh_beta = np.meshgrid(alpha,beta)\n", + "plt.contourf(mesh_alpha,mesh_beta,inversion_measure,levels=50)\n", + "plt.title(r\"$||H+X_{odd} H X_{odd}||$\")\n", + "plt.xlabel(r\"2nd coupling\")\n", + "plt.ylabel(r\"External Field\")\n", + "plt.colorbar()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "def imperfect_gci(H,D,s,inversion,order):\n", + " U = expm(1j*np.sqrt(s/order)*D)@expm(1j*np.sqrt(s/order)*H)@expm(-1j*np.sqrt(s/order)*D)\n", + " U_order = np.linalg.matrix_power(U,order) \n", + " U_dag = expm(-1j*np.sqrt(s/order)*D)@inversion@expm(1j*np.sqrt(s/order)*H)@inversion@expm(1j*np.sqrt(s/order)*D)\n", + " U_dag_order = np.linalg.matrix_power(U_dag,order)\n", + "\n", + " return U_dag_order@H@U_order\n" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "H = h(nqubits,1,3)\n", + "d = np.diag(np.linspace(0,2**nqubits,2**nqubits))\n", + "hamiltonian = hamiltonians.Hamiltonian(nqubits, H)\n", + "dbi = DoubleBracketIteration(deepcopy(hamiltonian),mode=DoubleBracketGeneratorType.single_commutator,cost=DoubleBracketCostFunction.least_squares)\n", + "s = np.linspace(0,0.1,100)\n", + "inversion = x_inv_odd(nqubits)\n", + "off_diagonal_norm = np.empty((len(s),3))\n", + "for step in range(len(s)):\n", + " dbi_eval = deepcopy(dbi)\n", + " h_gci = imperfect_gci(H,d,s[step],inversion,1)\n", + " off_diagonal_norm[step,0] = np.linalg.norm(h_gci-np.diag(np.diag(h_gci)))\n", + " dbi_eval(s[step],d=d)\n", + " off_diagonal_norm[step,1] = dbi_eval.off_diagonal_norm\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval.mode = DoubleBracketGeneratorType.group_commutator\n", + " order = 1\n", + " for _ in range(order):\n", + " dbi_eval(s[step]/order,d=d)\n", + " off_diagonal_norm[step,2] = dbi_eval.off_diagonal_norm\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(s,off_diagonal_norm[:,1],label=\"DBI\")\n", + "plt.plot(s,off_diagonal_norm[:,2],label=\"GCI\")\n", + "plt.plot(s,off_diagonal_norm[:,0],label=\"Imperfect GCI\")\n", + "plt.xlabel(r\"Step Size\")\n", + "plt.ylabel(r\"Off Diagonal Norm\")\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dbi", + "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.9.19" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "43f1f904380137ff38e17e8a93371c4872e6bababc18e270d8a0497ea5c7ea38" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From d4ce53367b7788878f34caa5fe0e6eb2a0e58631 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Tue, 21 May 2024 16:21:55 +0200 Subject: [PATCH 116/116] Revert "Test coverage" This reverts commit 976989e756e9c4eb15bfc019e495d2f2a9f687e9. --- .../group_commutator_iteration_transpiler.py | 17 ++++++++++++- tests/test_models_dbi.py | 24 ++++++------------- 2 files changed, 23 insertions(+), 18 deletions(-) diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py index f12e10eedd..07fc1af4fb 100644 --- a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py +++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py @@ -21,6 +21,9 @@ class DoubleBracketRotationType(Enum): group_commutator = auto() """Use group commutator approximation""" + group_commutator_reordered = auto() + """Use group commutator approximation with reordering of the operators""" + group_commutator_reduced = auto() """Use group commutator approximation with a reduction using symmetry @@ -181,7 +184,19 @@ def group_commutator( eo1.circuit(-s_step), eo2.circuit(s_step), ] - + elif gc_type is DoubleBracketRotationType.group_commutator_reordered: + query_list_forward = [ + eo1.circuit(s_step), + eo2.circuit(-s_step), + eo1.circuit(-s_step), + eo2.circuit(s_step), + ] + query_list_backward = [ + eo2.circuit(-s_step), + eo1.circuit(s_step), + eo2.circuit(s_step), + eo1.circuit(-s_step), + ] elif gc_type is DoubleBracketRotationType.group_commutator_reduced: query_list_forward = [ eo1.circuit(s_step), diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index c3a593bbfd..acc8f19fa5 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -229,6 +229,13 @@ def test_gci_evolution_oracles_types_numerical( assert norm(j_1 - k_1) < 1e-10 + # when gci mode is single_commutator, an error should be raised: + with pytest.raises(ValueError): + gci.mode_double_bracket_rotation = DoubleBracketRotationType.single_commutator + u_gc_from_oracles = gci.group_commutator( + t_step, evolution_oracle_diagonal_target + ) + # compare DoubleBracketRotationType.group_commutator_reduced and group_commutator gci = GroupCommutatorIterationWithEvolutionOracles(deepcopy(evolution_oracle)) u_gc_from_oracles = gci.group_commutator( @@ -256,23 +263,6 @@ def test_gci_evolution_oracles_types_numerical( ) assert norm(h_update_gc - h_update_gc_reduced) < 1e-10 - # when gci mode is single_commutator, an error should be raised: - with pytest.raises(ValueError): - gci.mode_double_bracket_rotation = DoubleBracketRotationType.single_commutator - u_gc_from_oracles = gci.group_commutator( - t_step, evolution_oracle_diagonal_target - ) - - # when gci eo_mode is unrecognized, an errorr should be raised: - with pytest.raises(ValueError): - gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator - evolution_oracle_diagonal_target = EvolutionOracle( - d_0, "D0", mode_evolution_oracle=DoubleBracketRotationType.group_commutator - ) - u_gc_from_oracles = gci.group_commutator( - t_step, evolution_oracle_diagonal_target - ) - @pytest.mark.parametrize("nqubits", [3]) @pytest.mark.parametrize(