From be3c3a262feca8345e87017f18beadae574140d1 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 28 Nov 2023 20:06:43 +0800 Subject: [PATCH 01/48] Added files, successful canonical iterations. - [x] Run loop - [ ] Store values - [ ] Visualization --- examples/dbi/E1_canonical.ipynb | 143 ++++++++++++++++++ .../additional_double_bracket_functions.py | 140 +++++++++++++++++ 2 files changed, 283 insertions(+) create mode 100644 examples/dbi/E1_canonical.ipynb create mode 100644 src/qibo/models/dbi/additional_double_bracket_functions.py diff --git a/examples/dbi/E1_canonical.ipynb b/examples/dbi/E1_canonical.ipynb new file mode 100644 index 0000000000..2708a5e90a --- /dev/null +++ b/examples/dbi/E1_canonical.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "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", + "import seaborn as sns\n", + "\n", + "from hyperopt import hp, tpe\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", + "from qibo.models.dbi.additional_double_bracket_functions import DoubleBracketIterationStrategies" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.3|INFO|2023-11-28 20:06:03]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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 = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# vosualize the matrix\n", + "dbi = DoubleBracketIterationStrategies(h)\n", + "dbi.visualize_matrix(h.matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:00<00:00, 444.60trial/s, best loss: 830.2774977128281]\n", + "100%|██████████| 100/100 [00:00<00:00, 422.80trial/s, best loss: 474.4316051273737]\n", + "100%|██████████| 100/100 [00:00<00:00, 469.73trial/s, best loss: 448.1933574259392]\n", + "100%|██████████| 100/100 [00:00<00:00, 576.34trial/s, best loss: 447.4682151186124]\n", + "100%|██████████| 100/100 [00:00<00:00, 590.37trial/s, best loss: 447.4468900493539]\n", + "100%|██████████| 100/100 [00:00<00:00, 554.71trial/s, best loss: 447.4449228421336]\n", + "100%|██████████| 100/100 [00:00<00:00, 485.92trial/s, best loss: 447.4449179215651]\n", + "100%|██████████| 100/100 [00:00<00:00, 544.33trial/s, best loss: 447.44491768369426]\n", + "100%|██████████| 100/100 [00:00<00:00, 563.48trial/s, best loss: 447.4449176482752]\n", + "100%|██████████| 100/100 [00:00<00:00, 532.58trial/s, best loss: 447.44491764811585]\n", + "100%|██████████| 100/100 [00:00<00:00, 522.57trial/s, best loss: 447.44491764810607]\n", + "100%|██████████| 100/100 [00:00<00:00, 556.17trial/s, best loss: 447.44491764810533]\n", + "100%|██████████| 100/100 [00:00<00:00, 552.90trial/s, best loss: 447.4449176481053]\n", + "100%|██████████| 100/100 [00:00<00:00, 496.37trial/s, best loss: 447.4449176481053]\n", + "100%|██████████| 100/100 [00:00<00:00, 467.01trial/s, best loss: 447.4449176481053]\n" + ] + } + ], + "source": [ + "dbi.NSTEPS = 15\n", + "dbi.flow_forwards_invariant()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dbi.visualize_matrix(dbi.h.matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DBF", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py new file mode 100644 index 0000000000..41a5b446c2 --- /dev/null +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -0,0 +1,140 @@ +from copy import deepcopy + +import matplotlib.pyplot as plt +import numpy as np +import seaborn as sns +from hyperopt import hp, tpe + +from qibo.config import raise_error +from qibo.hamiltonians import Hamiltonian +from qibo.models.dbi.double_bracket import ( + DoubleBracketGeneratorType, + DoubleBracketIteration, +) + + +class DoubleBracketIterationStrategies(DoubleBracketIteration): + def __init__( + self, + hamiltonian: Hamiltonian, + NSTEPS: int = 5, + please_be_verbose=True, + please_use_hyperopt=True, + mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + ): + super().__init__(hamiltonian, mode) + self.NSTEPS = NSTEPS + self.please_be_verbose = please_be_verbose + self.pleas_use_hyperopt = please_use_hyperopt + + @staticmethod + def visualize_matrix(matrix, title=""): + """Visualize hamiltonian in a heatmap form.""" + fig, ax = plt.subplots(figsize=(5, 5)) + ax.set_title(title) + try: + im = ax.imshow(np.absolute(matrix), cmap="inferno") + except TypeError: + im = ax.imshow(np.absolute(matrix.get()), cmap="inferno") + fig.colorbar(im, ax=ax) + + @staticmethod + def visualize_drift(h0, h): + """Visualize drift (absolute difference) of the evolved hamiltonian w.r.t. h0.""" + fig, ax = plt.subplots(figsize=(5, 5)) + ax.set_title(r"Drift: $|\hat{H}_0 - \hat{H}_{\ell}|$") + try: + im = ax.imshow(np.absolute(h0 - h), cmap="inferno") + except TypeError: + im = ax.imshow(np.absolute((h0 - h).get()), cmap="inferno") + + fig.colorbar(im, ax=ax) + + @staticmethod + def plot_histories(histories, labels): + """Plot off-diagonal norm histories over a sequential evolution.""" + colors = sns.color_palette("inferno", n_colors=len(histories)).as_hex() + plt.figure(figsize=(5, 5 * 6 / 8)) + for i, (h, l) in enumerate(zip(histories, labels)): + plt.plot(h, lw=2, color=colors[i], label=l, marker=".") + plt.legend() + plt.xlabel("Iterations") + plt.ylabel(r"$\| \sigma(\hat{H}) \|^2$") + plt.title("Loss function histories") + plt.grid(True) + plt.show() + + def flow_step( + self, + step: float, + mode: DoubleBracketGeneratorType = None, + d: np.array = None, + update_h=False, + ): + """ "Computes the flowed hamiltonian after one double bracket iteration (and updates)""" + if mode is None: + mode = self.mode + + 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 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 DoubleBracketGeneratorType.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() + ) + if update_h is True: + self.h.matrix = operator @ self.h.matrix @ operator_dagger + return operator @ self.h.matrix @ operator_dagger + + def iterate_forwards_fixed_generator(self, H=None, step=0.1): + """Execute multiple Double Bracket iterations with fixed flow generator""" + if H is None: + H = deepcopy(self.h) + self.store_outputs() + for s in range(self.NSTEPS): + if self.pleas_use_hyperopt is True: + step = self.hyperopt_step( + step_min=1e-5, + step_max=1, + space=hp.uniform, + optimizer=tpe, + max_evals=100, + verbose=True, + ) + self.flow_step(step, update_h=True) + + if self.pleas_be_verbose is True: + print("try") + + def store_outputs(self, **outputs): + """Stores ('key', item) or (key = item) as a dictionary""" + for output_key in outputs: + if output_key in self.flow_outputs: + self.flow_outputs[output_key].append(outputs[output_key]) + else: + self.flow_outputs[output_key] = [outputs[output_key]] + + def store_iteration_outputs( + self, flowed_H, iteration_steps, energy_fluctuations, off_diagonal_norms + ): + self.store_outputs("flowed_h", flowed_H) + self.store_outputs("iteration_steps", iteration_steps) + self.store_outputs("off_diagonal_norms", off_diagonal_norms) + self.store_outputs("energy_fluctuations", energy_fluctuations) From af58414c6b46164ad4aa5319e8848a2111ce00bf Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 29 Nov 2023 08:24:09 +0800 Subject: [PATCH 02/48] Updates of names: flow->DBI, flowed->iterated --- examples/dbi/E1_canonical.ipynb | 2 +- .../additional_double_bracket_functions.py | 20 +++++++++---------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/examples/dbi/E1_canonical.ipynb b/examples/dbi/E1_canonical.ipynb index 2708a5e90a..ef9b380ff8 100644 --- a/examples/dbi/E1_canonical.ipynb +++ b/examples/dbi/E1_canonical.ipynb @@ -88,7 +88,7 @@ ], "source": [ "dbi.NSTEPS = 15\n", - "dbi.flow_forwards_invariant()" + "dbi.iterate_forwards_fixed_generator()" ] }, { diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index 41a5b446c2..88ad14c8cd 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -25,7 +25,7 @@ def __init__( super().__init__(hamiltonian, mode) self.NSTEPS = NSTEPS self.please_be_verbose = please_be_verbose - self.pleas_use_hyperopt = please_use_hyperopt + self.please_use_hyperopt = please_use_hyperopt @staticmethod def visualize_matrix(matrix, title=""): @@ -64,7 +64,7 @@ def plot_histories(histories, labels): plt.grid(True) plt.show() - def flow_step( + def double_bracket_rotation( self, step: float, mode: DoubleBracketGeneratorType = None, @@ -109,7 +109,7 @@ def iterate_forwards_fixed_generator(self, H=None, step=0.1): H = deepcopy(self.h) self.store_outputs() for s in range(self.NSTEPS): - if self.pleas_use_hyperopt is True: + if self.please_use_hyperopt is True: step = self.hyperopt_step( step_min=1e-5, step_max=1, @@ -118,23 +118,23 @@ def iterate_forwards_fixed_generator(self, H=None, step=0.1): max_evals=100, verbose=True, ) - self.flow_step(step, update_h=True) + self.double_bracket_rotation(step, update_h=True) - if self.pleas_be_verbose is True: + if self.please_be_verbose is True: print("try") def store_outputs(self, **outputs): """Stores ('key', item) or (key = item) as a dictionary""" for output_key in outputs: - if output_key in self.flow_outputs: - self.flow_outputs[output_key].append(outputs[output_key]) + if output_key in self.DBI_outputs: + self.DBI_outputs[output_key].append(outputs[output_key]) else: - self.flow_outputs[output_key] = [outputs[output_key]] + self.DBI_outputs[output_key] = [outputs[output_key]] def store_iteration_outputs( - self, flowed_H, iteration_steps, energy_fluctuations, off_diagonal_norms + self, iterated_H, iteration_steps, energy_fluctuations, off_diagonal_norms ): - self.store_outputs("flowed_h", flowed_H) + self.store_outputs("iterated_h", iterated_H) self.store_outputs("iteration_steps", iteration_steps) self.store_outputs("off_diagonal_norms", off_diagonal_norms) self.store_outputs("energy_fluctuations", energy_fluctuations) From 2ba60f76c883ced2eccc0b0c07f89364c934eff6 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 29 Nov 2023 14:53:49 +0800 Subject: [PATCH 03/48] Setup plot visualization: a)cost, b)initial matrix, c)final matrix --- examples/dbi/E1_canonical.ipynb | 76 +++++++++--- .../additional_double_bracket_functions.py | 114 ++++++++++++++++-- 2 files changed, 161 insertions(+), 29 deletions(-) diff --git a/examples/dbi/E1_canonical.ipynb b/examples/dbi/E1_canonical.ipynb index ef9b380ff8..004f0ba3c0 100644 --- a/examples/dbi/E1_canonical.ipynb +++ b/examples/dbi/E1_canonical.ipynb @@ -21,14 +21,15 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|INFO|2023-11-28 20:06:03]: Using qibojit (numba) backend on /CPU:0\n" + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", + "[Qibo 0.2.3|INFO|2023-11-29 14:50:47]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -61,39 +62,54 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [00:00<00:00, 444.60trial/s, best loss: 830.2774977128281]\n", - "100%|██████████| 100/100 [00:00<00:00, 422.80trial/s, best loss: 474.4316051273737]\n", - "100%|██████████| 100/100 [00:00<00:00, 469.73trial/s, best loss: 448.1933574259392]\n", - "100%|██████████| 100/100 [00:00<00:00, 576.34trial/s, best loss: 447.4682151186124]\n", - "100%|██████████| 100/100 [00:00<00:00, 590.37trial/s, best loss: 447.4468900493539]\n", - "100%|██████████| 100/100 [00:00<00:00, 554.71trial/s, best loss: 447.4449228421336]\n", - "100%|██████████| 100/100 [00:00<00:00, 485.92trial/s, best loss: 447.4449179215651]\n", - "100%|██████████| 100/100 [00:00<00:00, 544.33trial/s, best loss: 447.44491768369426]\n", - "100%|██████████| 100/100 [00:00<00:00, 563.48trial/s, best loss: 447.4449176482752]\n", - "100%|██████████| 100/100 [00:00<00:00, 532.58trial/s, best loss: 447.44491764811585]\n", - "100%|██████████| 100/100 [00:00<00:00, 522.57trial/s, best loss: 447.44491764810607]\n", - "100%|██████████| 100/100 [00:00<00:00, 556.17trial/s, best loss: 447.44491764810533]\n", - "100%|██████████| 100/100 [00:00<00:00, 552.90trial/s, best loss: 447.4449176481053]\n", - "100%|██████████| 100/100 [00:00<00:00, 496.37trial/s, best loss: 447.4449176481053]\n", - "100%|██████████| 100/100 [00:00<00:00, 467.01trial/s, best loss: 447.4449176481053]\n" + "100%|██████████| 100/100 [00:00<00:00, 454.67trial/s, best loss: 828.696721346618]\n", + "try\n", + "100%|██████████| 100/100 [00:00<00:00, 568.67trial/s, best loss: 477.5937131732331]\n", + "try\n", + "100%|██████████| 100/100 [00:00<00:00, 502.28trial/s, best loss: 449.51810589452566]\n", + "try\n", + "100%|██████████| 100/100 [00:00<00:00, 594.40trial/s, best loss: 447.5614766965182]\n", + "try\n", + "100%|██████████| 100/100 [00:00<00:00, 623.14trial/s, best loss: 447.456670925868]\n", + "try\n" ] } ], "source": [ - "dbi.NSTEPS = 15\n", + "dbi.NSTEPS = 5\n", "dbi.iterate_forwards_fixed_generator()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "447.456670925868" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dbi.off_diagonal_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -111,6 +127,26 @@ "dbi.visualize_matrix(dbi.h.matrix)" ] }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dbi.visualize_iteration_results()" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index 88ad14c8cd..b611d668b9 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -27,10 +27,20 @@ def __init__( self.please_be_verbose = please_be_verbose self.please_use_hyperopt = please_use_hyperopt + self.DBI_outputs = { + "iterated_h": [], + "iteration_steps": [], + "off_diagonal_norm_histories": [], + "energy_fluctuations": [], + } + @staticmethod - def visualize_matrix(matrix, title=""): + def visualize_matrix(matrix, title="", ax=None): """Visualize hamiltonian in a heatmap form.""" - fig, ax = plt.subplots(figsize=(5, 5)) + if ax is None: + fig, ax = plt.subplots(figsize=(5, 5)) + else: + fig = ax.figure ax.set_title(title) try: im = ax.imshow(np.absolute(matrix), cmap="inferno") @@ -69,7 +79,7 @@ def double_bracket_rotation( step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None, - update_h=False, + update_h: bool = False, ): """ "Computes the flowed hamiltonian after one double bracket iteration (and updates)""" if mode is None: @@ -107,7 +117,7 @@ def iterate_forwards_fixed_generator(self, H=None, step=0.1): """Execute multiple Double Bracket iterations with fixed flow generator""" if H is None: H = deepcopy(self.h) - self.store_outputs() + self.store_initial_inputs() for s in range(self.NSTEPS): if self.please_use_hyperopt is True: step = self.hyperopt_step( @@ -119,6 +129,7 @@ def iterate_forwards_fixed_generator(self, H=None, step=0.1): verbose=True, ) self.double_bracket_rotation(step, update_h=True) + self.store_iteration_outputs(step) if self.please_be_verbose is True: print("try") @@ -131,10 +142,95 @@ def store_outputs(self, **outputs): else: self.DBI_outputs[output_key] = [outputs[output_key]] + def store_initial_inputs(self): + # self.store_outputs("iterated_h", self.h0) + # self.store_outputs("iteration_steps", 0.0) + # self.store_outputs("off_diagonal_norms", self.off_diagonal_norm()) + # # TODO: discuss what state to use + # self.store_outputs("energy_fluctuations", self.energy_fluctuation(self.h0.ground_state())) + self.store_outputs( + iterated_h=self.h0, + iteration_steps=0.0, + off_diagonal_norms=self.off_diagonal_norm, + energy_fluctuations=self.energy_fluctuation(self.h0.ground_state()), + ) + def store_iteration_outputs( - self, iterated_H, iteration_steps, energy_fluctuations, off_diagonal_norms + self, + iteration_step: float, + off_diagonal_norm: float = None, + energy_fluctuation=None, ): - self.store_outputs("iterated_h", iterated_H) - self.store_outputs("iteration_steps", iteration_steps) - self.store_outputs("off_diagonal_norms", off_diagonal_norms) - self.store_outputs("energy_fluctuations", energy_fluctuations) + if off_diagonal_norm is None: + off_diagonal_norm = self.off_diagonal_norm + # self.store_outputs("iterated_h", self.h) + # self.store_outputs("iteration_steps", iteration_step) + # self.store_outputs("off_diagonal_norm_histories", off_diagonal_norm) + # self.store_outputs("energy_fluctuations", energy_fluctuation) + self.store_outputs( + iterated_h=self.h, + iteration_steps=iteration_step, + off_diagonal_norms=off_diagonal_norm, + energy_fluctuations=energy_fluctuation, + ) + + def visualize_iteration_results( + self, DBI_outputs=None, cost_function_type="off_diagonal_norm" + ): + """a. Plot the cost function wrt to iterations time, default being off diagoanl cost_function_histories + b. Visualize the initial matrix + c. Visualize the final iterated matrix + """ + if DBI_outputs is None: + DBI_outputs = self.DBI_outputs + + # limit options for cost functions + cost_function_type_options = ["off_diagonal_norm", "energy_fluctuation"] + if cost_function_type not in cost_function_type_options: + raise ValueError( + f"cost_function_type must be in {cost_function_type_options}" + ) + + f = plt.figure(figsize=(15, 4)) + # a + ax_a = f.add_subplot(1, 3, 1) + if cost_function_type == "off_diagonal_norm": + cost_function_histories = DBI_outputs["off_diagonal_norms"] + title_a = r"Off-diagonal Norm $\vert\vert\sigma(H_k)\vert\vert$" + elif cost_function_type == "energy_fluctuation": + cost_function_histories = DBI_outputs["energy_fluctuations"] + title_a = r"Energy Fluctuation $\Xi(\mu)$" + # = \sqrt{\langle \mu | \hat{H}_k^2 | \mu \rangle - \langle \mu | \hat{H}_k | \mu \rangle^2} + x_axis = [ + sum(DBI_outputs["iteration_steps"][:k]) + for k in range(1, len(DBI_outputs["iteration_steps"]) + 1) + ] + + plt.plot(x_axis, cost_function_histories, "-o") + x_labels_rounded = [round(x, 2) for x in x_axis] + x_labels_rounded = [0] + x_labels_rounded[0:5] + [max(x_labels_rounded)] + x_labels_rounded.pop(3) + plt.xticks(x_labels_rounded) + + y_labels_rounded = [round(y, 1) for y in cost_function_histories] + y_labels_rounded = y_labels_rounded[0:5] + [min(y_labels_rounded)] + plt.yticks(y_labels_rounded) + + plt.grid() + plt.xlabel(r"Flow duration $s$") + plt.title(title_a) + + # panel label + a = -0.1 + b = 1.05 + plt.annotate("a)", xy=(a, b), xycoords="axes fraction") + + # b + ax_b = f.add_subplot(1, 3, 2) + plt.annotate("b)", xy=(a, b), xycoords="axes fraction") + self.visualize_matrix(self.h0.matrix, "Initial Matrix", ax_b) + + # c + ax_c = f.add_subplot(1, 3, 3) + plt.annotate("b)", xy=(a, b), xycoords="axes fraction") + self.visualize_matrix(self.h.matrix, "Final Matrix", ax_c) From 49e80ccccd5716eb767e6dab386c7d47c55ac04f Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 29 Nov 2023 15:50:32 +0800 Subject: [PATCH 04/48] Deleted unused comments --- .../models/dbi/additional_double_bracket_functions.py | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index b611d668b9..e31d383783 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -143,11 +143,6 @@ def store_outputs(self, **outputs): self.DBI_outputs[output_key] = [outputs[output_key]] def store_initial_inputs(self): - # self.store_outputs("iterated_h", self.h0) - # self.store_outputs("iteration_steps", 0.0) - # self.store_outputs("off_diagonal_norms", self.off_diagonal_norm()) - # # TODO: discuss what state to use - # self.store_outputs("energy_fluctuations", self.energy_fluctuation(self.h0.ground_state())) self.store_outputs( iterated_h=self.h0, iteration_steps=0.0, @@ -163,10 +158,6 @@ def store_iteration_outputs( ): if off_diagonal_norm is None: off_diagonal_norm = self.off_diagonal_norm - # self.store_outputs("iterated_h", self.h) - # self.store_outputs("iteration_steps", iteration_step) - # self.store_outputs("off_diagonal_norm_histories", off_diagonal_norm) - # self.store_outputs("energy_fluctuations", energy_fluctuation) self.store_outputs( iterated_h=self.h, iteration_steps=iteration_step, From 3f4e0c0657d4c1e65b8b665a97a505b84cf492fd Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 29 Nov 2023 16:05:52 +0800 Subject: [PATCH 05/48] Structure for best Zsearch --- .../models/dbi/additional_double_bracket_functions.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index e31d383783..b038a4a360 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -134,6 +134,16 @@ def iterate_forwards_fixed_generator(self, H=None, step=0.1): if self.please_be_verbose is True: print("try") + def iterate_forwards_from_optimal_prescribed( + self, H=None, prescribed_operators=None, step=0.1 + ): + """Execute double bracket iterations with the optimal operator form a prescribed list""" + if H is None: + H = deepcopy(self.h) + # Use best Z search as default + if prescribed_operators is None: + prescribed_operators = [] # TODO: list all instances + def store_outputs(self, **outputs): """Stores ('key', item) or (key = item) as a dictionary""" for output_key in outputs: From 77b3389285867f212e792572c3257dc14d88d04c Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 30 Nov 2023 15:05:15 +0800 Subject: [PATCH 06/48] Remove redundant H input --- .../additional_double_bracket_functions.py | 146 ++++++++++++++++-- 1 file changed, 131 insertions(+), 15 deletions(-) diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index b038a4a360..ab3d5490e9 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -1,4 +1,5 @@ from copy import deepcopy +from itertools import product import matplotlib.pyplot as plt import numpy as np @@ -11,6 +12,19 @@ DoubleBracketGeneratorType, DoubleBracketIteration, ) +from qibo.symbols import I, X, Z + + +class DoubleBracektStrategyType(Enum): + """Determines how to variationally choose the diagonal operator""" + + local_Z_search = auto() + """Search through Z permutations""" + gradient_descent_search = auto() + """Search by gradient descent (magnetic field)""" + # TODO: how to input list + prescribed_search = auto() + """Search within a prescribed list of operators""" class DoubleBracketIterationStrategies(DoubleBracketIteration): @@ -18,14 +32,16 @@ def __init__( self, hamiltonian: Hamiltonian, NSTEPS: int = 5, - please_be_verbose=True, - please_use_hyperopt=True, + please_be_verbose: bool = True, + please_use_hyperopt: bool = True, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + variation_strategy_type: DoubleBracketStrategyType = DoubleBracketStrategyType.local_Z_search, ): super().__init__(hamiltonian, mode) self.NSTEPS = NSTEPS self.please_be_verbose = please_be_verbose self.please_use_hyperopt = please_use_hyperopt + self.variation_strategy = variation_strategy self.DBI_outputs = { "iterated_h": [], @@ -81,7 +97,7 @@ def double_bracket_rotation( d: np.array = None, update_h: bool = False, ): - """ "Computes the flowed hamiltonian after one double bracket iteration (and updates)""" + """ "Computes the iterated hamiltonian after one double bracket iteration (and updates)""" if mode is None: mode = self.mode @@ -113,10 +129,8 @@ def double_bracket_rotation( self.h.matrix = operator @ self.h.matrix @ operator_dagger return operator @ self.h.matrix @ operator_dagger - def iterate_forwards_fixed_generator(self, H=None, step=0.1): + def iterate_forwards_fixed_generator(self, step=0.1): """Execute multiple Double Bracket iterations with fixed flow generator""" - if H is None: - H = deepcopy(self.h) self.store_initial_inputs() for s in range(self.NSTEPS): if self.please_use_hyperopt is True: @@ -134,15 +148,45 @@ def iterate_forwards_fixed_generator(self, H=None, step=0.1): if self.please_be_verbose is True: print("try") - def iterate_forwards_from_optimal_prescribed( - self, H=None, prescribed_operators=None, step=0.1 + def generate_local_Z_operators(self, L: int = None): + if L is None: + L = self.h.nqubits + combination_strings = product("ZI", repeat=L) + operator_map = {"Z": Z, "I": I} + operators = [] + + for op_string in combination_strings: + product = 1 + # except for the identity + if "Z" in op_string: + for qubit, char in enumerate(op_string): + if char in operator_map: + product *= operator_map[char](qubit) + operators.append(product) + return operators + + def iterate_forwards_via_local_Z_search( + self, step: float = 0.1, Z_list: list = [], check_canonical: bool = False ): """Execute double bracket iterations with the optimal operator form a prescribed list""" - if H is None: - H = deepcopy(self.h) - # Use best Z search as default - if prescribed_operators is None: - prescribed_operators = [] # TODO: list all instances + # prepare iteration + self.store_initial_inputs(self.h) + + # generate local Z operators + L = self.h.nqubits + if Z_list is []: + Z_list = self.generate_local_Z_operators(L) + + # search for best flow generator + for Z_operator in Z_list: + # stash values -> min -> store + step = self.hyp + iterated_h = self.double_bracekt_rotation( + H, step, d=Z_operator, update_h=False + ) + if check_canonical is True: + # compare + print("Check") def store_outputs(self, **outputs): """Stores ('key', item) or (key = item) as a dictionary""" @@ -154,10 +198,10 @@ def store_outputs(self, **outputs): def store_initial_inputs(self): self.store_outputs( - iterated_h=self.h0, + iterated_h=self.h, iteration_steps=0.0, off_diagonal_norms=self.off_diagonal_norm, - energy_fluctuations=self.energy_fluctuation(self.h0.ground_state()), + energy_fluctuations=self.energy_fluctuation(self.h.ground_state()), ) def store_iteration_outputs( @@ -235,3 +279,75 @@ def visualize_iteration_results( ax_c = f.add_subplot(1, 3, 3) plt.annotate("b)", xy=(a, b), xycoords="axes fraction") self.visualize_matrix(self.h.matrix, "Final Matrix", ax_c) + + def hyperopt_iteration_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, + d: np.array = None, + ): + """ + 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. + d: diagonal operator for iteration generator. + + Returns: + (float): optimized best iteration step. + """ + try: + import hyperopt + except: # pragma: no cover + raise_error( + ImportError, "hyperopt_step function requires hyperopt to be installed." + ) + + 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.iteration_loss(d), look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + + return best["step"] + + def iteration_loss(self, step: float, look_ahead: int = 1, d: np.array = None): + """ + 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, d=d) + + # off_diagonal_norm's value after the steps + loss = self.off_diagonal_norm + + # set back the initial configuration + self.h = h_copy + + return loss From e33421389c8d2d767441b1a79281ae1858f46800 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 30 Nov 2023 17:13:24 +0800 Subject: [PATCH 07/48] Update dependency: seaborn --- poetry.lock | 45 ++++++++++++++++++++++++++++++++++++++++++++- pyproject.toml | 3 +++ 2 files changed, 47 insertions(+), 1 deletion(-) diff --git a/poetry.lock b/poetry.lock index ab543ddbf8..9174dfce99 100644 --- a/poetry.lock +++ b/poetry.lock @@ -2121,6 +2121,8 @@ description = "Clang Python Bindings, mirrored from the official LLVM repo: http optional = false python-versions = "*" files = [ + {file = "libclang-16.0.6-1-py2.py3-none-manylinux2014_aarch64.whl", hash = "sha256:88bc7e7b393c32e41e03ba77ef02fdd647da1f764c2cd028e69e0837080b79f6"}, + {file = "libclang-16.0.6-1-py2.py3-none-manylinux2014_armv7l.whl", hash = "sha256:d80ed5827736ed5ec2bcedf536720476fd9d4fa4c79ef0cb24aea4c59332f361"}, {file = "libclang-16.0.6-py2.py3-none-macosx_10_9_x86_64.whl", hash = "sha256:da9e47ebc3f0a6d90fb169ef25f9fbcd29b4a4ef97a8b0e3e3a17800af1423f4"}, {file = "libclang-16.0.6-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:e1a5ad1e895e5443e205568c85c04b4608e4e973dae42f4dfd9cb46c81d1486b"}, {file = "libclang-16.0.6-py2.py3-none-manylinux2010_x86_64.whl", hash = "sha256:9dcdc730939788b8b69ffd6d5d75fe5366e3ee007f1e36a99799ec0b0c001492"}, @@ -2210,6 +2212,16 @@ files = [ {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5bbe06f8eeafd38e5d0a4894ffec89378b6c6a625ff57e3028921f8ff59318ac"}, {file = "MarkupSafe-2.1.3-cp311-cp311-win32.whl", hash = "sha256:dd15ff04ffd7e05ffcb7fe79f1b98041b8ea30ae9234aed2a9168b5797c3effb"}, {file = "MarkupSafe-2.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:134da1eca9ec0ae528110ccc9e48041e0828d79f24121a1a146161103c76e686"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:f698de3fd0c4e6972b92290a45bd9b1536bffe8c6759c62471efaa8acb4c37bc"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:aa57bd9cf8ae831a362185ee444e15a93ecb2e344c8e52e4d721ea3ab6ef1823"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffcc3f7c66b5f5b7931a5aa68fc9cecc51e685ef90282f4a82f0f5e9b704ad11"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47d4f1c5f80fc62fdd7777d0d40a2e9dda0a05883ab11374334f6c4de38adffd"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1f67c7038d560d92149c060157d623c542173016c4babc0c1913cca0564b9939"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:9aad3c1755095ce347e26488214ef77e0485a3c34a50c5a5e2471dff60b9dd9c"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:14ff806850827afd6b07a5f32bd917fb7f45b046ba40c57abdb636674a8b559c"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8f9293864fe09b8149f0cc42ce56e3f0e54de883a9de90cd427f191c346eb2e1"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-win32.whl", hash = "sha256:715d3562f79d540f251b99ebd6d8baa547118974341db04f5ad06d5ea3eb8007"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:1b8dd8c3fd14349433c79fa8abeb573a55fc0fdd769133baac1f5e07abf54aeb"}, {file = "MarkupSafe-2.1.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8e254ae696c88d98da6555f5ace2279cf7cd5b3f52be2b5cf97feafe883b58d2"}, {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb0932dc158471523c9637e807d9bfb93e06a95cbf010f1a38b98623b929ef2b"}, {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9402b03f1a1b4dc4c19845e5c749e3ab82d5078d16a2a4c2cd2df62d57bb0707"}, @@ -4116,6 +4128,27 @@ files = [ numpy = "*" scipy = "*" +[[package]] +name = "seaborn" +version = "0.13.0" +description = "Statistical data visualization" +optional = false +python-versions = ">=3.8" +files = [ + {file = "seaborn-0.13.0-py3-none-any.whl", hash = "sha256:70d740828c48de0f402bb17234e475eda687e3c65f4383ea25d0cc4728f7772e"}, + {file = "seaborn-0.13.0.tar.gz", hash = "sha256:0e76abd2ec291c655b516703c6a022f0fd5afed26c8e714e8baef48150f73598"}, +] + +[package.dependencies] +matplotlib = ">=3.3,<3.6.1 || >3.6.1" +numpy = ">=1.20,<1.24.0 || >1.24.0" +pandas = ">=1.2" + +[package.extras] +dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"] +docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx (<6.0.0)", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] +stats = ["scipy (>=1.7)", "statsmodels (>=0.12)"] + [[package]] name = "setuptools" version = "69.0.0" @@ -4848,6 +4881,16 @@ files = [ {file = "wrapt-1.14.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8ad85f7f4e20964db4daadcab70b47ab05c7c1cf2a7c1e51087bfaa83831854c"}, {file = "wrapt-1.14.1-cp310-cp310-win32.whl", hash = "sha256:a9a52172be0b5aae932bef82a79ec0a0ce87288c7d132946d645eba03f0ad8a8"}, {file = "wrapt-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:6d323e1554b3d22cfc03cd3243b5bb815a51f5249fdcbb86fda4bf62bab9e164"}, + {file = "wrapt-1.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ecee4132c6cd2ce5308e21672015ddfed1ff975ad0ac8d27168ea82e71413f55"}, + {file = "wrapt-1.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2020f391008ef874c6d9e208b24f28e31bcb85ccff4f335f15a3251d222b92d9"}, + {file = "wrapt-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2feecf86e1f7a86517cab34ae6c2f081fd2d0dac860cb0c0ded96d799d20b335"}, + {file = "wrapt-1.14.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:240b1686f38ae665d1b15475966fe0472f78e71b1b4903c143a842659c8e4cb9"}, + {file = "wrapt-1.14.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9008dad07d71f68487c91e96579c8567c98ca4c3881b9b113bc7b33e9fd78b8"}, + {file = "wrapt-1.14.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6447e9f3ba72f8e2b985a1da758767698efa72723d5b59accefd716e9e8272bf"}, + {file = "wrapt-1.14.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:acae32e13a4153809db37405f5eba5bac5fbe2e2ba61ab227926a22901051c0a"}, + {file = "wrapt-1.14.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:49ef582b7a1152ae2766557f0550a9fcbf7bbd76f43fbdc94dd3bf07cc7168be"}, + {file = "wrapt-1.14.1-cp311-cp311-win32.whl", hash = "sha256:358fe87cc899c6bb0ddc185bf3dbfa4ba646f05b1b0b9b5a27c2cb92c2cea204"}, + {file = "wrapt-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:26046cd03936ae745a502abf44dac702a5e6880b2b01c29aea8ddf3353b68224"}, {file = "wrapt-1.14.1-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:43ca3bbbe97af00f49efb06e352eae40434ca9d915906f77def219b88e85d907"}, {file = "wrapt-1.14.1-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:6b1a564e6cb69922c7fe3a678b9f9a3c54e72b469875aa8018f18b4d1dd1adf3"}, {file = "wrapt-1.14.1-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:00b6d4ea20a906c0ca56d84f93065b398ab74b927a7a3dbd470f6fc503f95dc3"}, @@ -4913,4 +4956,4 @@ testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "p [metadata] lock-version = "2.0" python-versions = ">=3.9,<3.12" -content-hash = "17f4fa7be9ead59d5867dd3bba8fb3ae1d1028418a5ddb0ef139a4b73edca8a6" +content-hash = "2a4b58c544efe3a089934d0a8db6265beef20cf3e22dedddcdaeab67236dd437" diff --git a/pyproject.toml b/pyproject.toml index e2d0867d82..a10be08a73 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,6 +29,7 @@ joblib = "^1.2.0" matplotlib = "^3.7.0" psutil = "^5.9.4" tabulate = "^0.9.0" +seaborn = "^0.13.0" [tool.poetry.group.dev] optional = true @@ -76,6 +77,7 @@ docs-clean = "make -C doc clean" test-docs = "make -C doc doctest" + [tool.poetry.group.cuda11] optional = true @@ -85,6 +87,7 @@ cuquantum-python-cu11 = "^23.3.0" qibojit = { git = "https://github.com/qiboteam/qibojit.git" } + [tool.poetry.group.cuda12] optional = true From 25854b92cdb0fe08d23081c7ee8b0242bf8c6444 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 4 Dec 2023 10:39:47 +0800 Subject: [PATCH 08/48] Fix lint errors --- examples/dbi/E1_canonical.ipynb | 63 +++---------------- .../additional_double_bracket_functions.py | 19 +++--- 2 files changed, 18 insertions(+), 64 deletions(-) diff --git a/examples/dbi/E1_canonical.ipynb b/examples/dbi/E1_canonical.ipynb index 004f0ba3c0..027db9a026 100644 --- a/examples/dbi/E1_canonical.ipynb +++ b/examples/dbi/E1_canonical.ipynb @@ -29,12 +29,12 @@ "output_type": "stream", "text": [ "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", - "[Qibo 0.2.3|INFO|2023-11-29 14:50:47]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.3|INFO|2023-12-04 10:38:02]: Using qibojit (numba) backend on /CPU:0\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -69,15 +69,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [00:00<00:00, 454.67trial/s, best loss: 828.696721346618]\n", + "100%|██████████| 100/100 [00:00<00:00, 332.08trial/s, best loss: 830.4134776010231]\n", "try\n", - "100%|██████████| 100/100 [00:00<00:00, 568.67trial/s, best loss: 477.5937131732331]\n", + "100%|██████████| 100/100 [00:00<00:00, 415.18trial/s, best loss: 503.9069738017741]\n", "try\n", - "100%|██████████| 100/100 [00:00<00:00, 502.28trial/s, best loss: 449.51810589452566]\n", + "100%|██████████| 100/100 [00:00<00:00, 453.15trial/s, best loss: 448.59524987707096]\n", "try\n", - "100%|██████████| 100/100 [00:00<00:00, 594.40trial/s, best loss: 447.5614766965182]\n", + "100%|██████████| 100/100 [00:00<00:00, 363.89trial/s, best loss: 447.4602359483543]\n", "try\n", - "100%|██████████| 100/100 [00:00<00:00, 623.14trial/s, best loss: 447.456670925868]\n", + "100%|██████████| 100/100 [00:00<00:00, 475.05trial/s, best loss: 447.4454403192258]\n", "try\n" ] } @@ -94,47 +94,7 @@ "outputs": [ { "data": { - "text/plain": [ - "447.456670925868" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dbi.off_diagonal_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "dbi.visualize_matrix(dbi.h.matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -146,13 +106,6 @@ "source": [ "dbi.visualize_iteration_results()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index ab3d5490e9..43bffa56c1 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -1,4 +1,6 @@ from copy import deepcopy +from enum import Enum, auto +from functools import partial from itertools import product import matplotlib.pyplot as plt @@ -15,7 +17,7 @@ from qibo.symbols import I, X, Z -class DoubleBracektStrategyType(Enum): +class DoubleBracketStrategyType(Enum): """Determines how to variationally choose the diagonal operator""" local_Z_search = auto() @@ -35,7 +37,7 @@ def __init__( please_be_verbose: bool = True, please_use_hyperopt: bool = True, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, - variation_strategy_type: DoubleBracketStrategyType = DoubleBracketStrategyType.local_Z_search, + variation_strategy: DoubleBracketStrategyType = DoubleBracketStrategyType.local_Z_search, ): super().__init__(hamiltonian, mode) self.NSTEPS = NSTEPS @@ -156,13 +158,13 @@ def generate_local_Z_operators(self, L: int = None): operators = [] for op_string in combination_strings: - product = 1 + tensor_op = 1 # except for the identity if "Z" in op_string: for qubit, char in enumerate(op_string): if char in operator_map: - product *= operator_map[char](qubit) - operators.append(product) + tensor_op *= operator_map[char](qubit) + operators.append(tensor_op) return operators def iterate_forwards_via_local_Z_search( @@ -170,7 +172,7 @@ def iterate_forwards_via_local_Z_search( ): """Execute double bracket iterations with the optimal operator form a prescribed list""" # prepare iteration - self.store_initial_inputs(self.h) + self.store_initial_inputs() # generate local Z operators L = self.h.nqubits @@ -180,9 +182,8 @@ def iterate_forwards_via_local_Z_search( # search for best flow generator for Z_operator in Z_list: # stash values -> min -> store - step = self.hyp - iterated_h = self.double_bracekt_rotation( - H, step, d=Z_operator, update_h=False + iterated_h = self.double_bracket_rotation( + self.h, step, d=Z_operator, update_h=False ) if check_canonical is True: # compare From 81f4f53e04e5ec78fe1df7821d6397893233636d Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 18 Dec 2023 18:03:58 +0800 Subject: [PATCH 09/48] Iteration from list, most changes contained in additional file --- examples/dbi/Z_search.ipynb | 335 ++++++++++++ examples/dbi/dbi.ipynb | 373 ++++++++++++-- .../additional_double_bracket_functions.py | 480 ++++++------------ src/qibo/models/dbi/double_bracket.py | 19 +- 4 files changed, 813 insertions(+), 394 deletions(-) create mode 100644 examples/dbi/Z_search.ipynb diff --git a/examples/dbi/Z_search.ipynb b/examples/dbi/Z_search.ipynb new file mode 100644 index 0000000000..971463a04e --- /dev/null +++ b/examples/dbi/Z_search.ipynb @@ -0,0 +1,335 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-Bracket Iteration Strategy: Local Z search\n", + "\n", + "In this example, we demonstrate the usage of the DBI strategy: local_Z_search, where the diagonal operator is chosen as the optimal local Z operator for the system." + ] + }, + { + "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", + "import seaborn as sns\n", + "\n", + "from hyperopt import hp, tpe\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", + "from qibo.models.dbi.additional_double_bracket_functions import *\n", + "from qibo.symbols import I, X, Z\n", + "import warnings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The initial setup\n", + "\n", + "As an example, we consider the Transverse Field Ising Model (TFIM):\n", + "$$ H_{\\rm TFIM} = - \\sum_{q=0}^{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": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.3|INFO|2023-12-18 17:06:14]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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 = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# initialize class\n", + "# Note: use deepcopy to prevent h being edited\n", + "dbi = DoubleBracketIteration(h,mode=DoubleBracketGeneratorType.single_commutator)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", + "visualize_matrix(h.matrix)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Local Z operators\n", + "Denoted as local Z operators, the diagonal operators used for this strategy are tensor products of pauli Z and identity." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: 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 = generate_local_Z[\"Z_operators\"]\n", + "Z_names = generate_local_Z[\"Z_words\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Iteration from list" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "NSTEPS = 10\n", + "Z_optimal = []\n", + "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", + "steps = [0]\n", + "for _ in range(NSTEPS):\n", + " idx, step = iteration_from_list(dbi, Z_ops)\n", + " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", + " steps.append(step)\n", + " if idx == len(Z_ops):\n", + " Z_optimal.append(\"canonical\")\n", + " else:\n", + " Z_optimal.append(Z_names[idx])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histories(off_diagonal_norm_history, steps, Z_optimal)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare with canonical" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.3|INFO|2023-12-18 17:06:27]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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 = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# initialize class|\n", + "# Note: use deepcopy to prevent h being edited\n", + "dbi_canonical = DoubleBracketIteration(h,mode=DoubleBracketGeneratorType.canonical)\n", + "print(\"Initial off diagonal norm\", dbi_canonical.off_diagonal_norm)\n", + "visualize_matrix(h.matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 1/10: 0.6618196053082266\n", + "New optimized step at iteration 2/10: 0.00897069231489455\n", + "New optimized step at iteration 3/10: 0.005579747395507664\n", + "New optimized step at iteration 4/10: 0.007148149109245057\n", + "New optimized step at iteration 5/10: 0.009653931903544686\n", + "New optimized step at iteration 6/10: 0.006626957341795923\n", + "New optimized step at iteration 7/10: 0.005725219594592742\n", + "New optimized step at iteration 8/10: 0.010203997361858506\n", + "New optimized step at iteration 9/10: 0.006111173495106144\n" + ] + } + ], + "source": [ + "off_diagonal_norm_history = [dbi_canonical.off_diagonal_norm]\n", + "steps = [0]\n", + "for s in range(NSTEPS):\n", + " if s != 0:\n", + " step = dbi_canonical.hyperopt_step(\n", + " step_min = 1e-5,\n", + " step_max = 1,\n", + " space = hp.uniform,\n", + " optimizer = tpe,\n", + " max_evals = 100,\n", + " )\n", + " print(f\"New optimized step at iteration {s}/{NSTEPS}: {step}\")\n", + " dbi_canonical(step=step)\n", + " off_diagonal_norm_history.append(dbi_canonical.off_diagonal_norm)\n", + " steps.append(step)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcAAAAF1CAYAAAB/Ijq1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKnUlEQVR4nO3dd1gUV/828Ht2YekdaYKoWLChsQYbi733FH0s+ETjYy8BY0zyRuMvMVFsMaIxwRKNmpigMdFYoiyiQcWCDbsoFtCA0qXuef8wbFwBKYIL7P25rr3Mzp45+50x2TszZ86MJIQQICIi0jMyXRdARESkCwxAIiLSSwxAIiLSSwxAIiLSSwxAIiLSSwxAIiLSSwxAIiLSSwxAIiLSSwxAIiLSSwxAqlAbNmyAJEk4efKkrksp1sqVK1GvXj0oFApIkoSkpCSd1bJnzx7Mmzev0M9q164NPz+/V1oPULq/S6VSCaVSWar+o6OjMW/ePNy6datsBRbDz88PtWvXrpC+qWoy0HUBRJVBVFQUpk2bhnHjxmHMmDEwMDCAhYWFzurZs2cPVq1aVWgI7tixA5aWlq++qFIICgoq9TrR0dGYP38+lEplhQTVxx9/jOnTp5d7v1R1MQCJAFy8eBEAMH78eLRt21bH1bzYa6+9pusSitW4cWNdl6CRkZEBU1NTeHh46LoUqmR4CpQqhSNHjqBr166wsLCAqakp2rdvj927d2u1ycjIgL+/P+rUqQNjY2PY2tqidevW2Lp1q6bNzZs38fbbb8PFxQVGRkZwdHRE165dERUVVeR3K5VKjBw5EgDQrl07SJKkOcVY1OnG50/xqVQqSJKErVu34sMPP4SLiwssLS3RrVs3XLlypcD6e/fuRdeuXWFlZQVTU1M0atQICxcuBPD0VN2qVasAAJIkaV75pwYLqyk2NhYjR46Eg4MDjIyM0KhRIyxZsgRqtVrT5tatW5AkCYGBgVi6dCnq1KkDc3NzeHt749ixY0Xun+elpqZi4sSJsLe3h52dHYYMGYL79++/cP8AwOrVq9G8eXOYm5vDwsICnp6emDt3LoCnp1ffeOMNAICvr69mmzds2KBZf926dWjevLnm737w4MG4dOmS1nf4+fnB3Nwc58+fR48ePWBhYYGuXbtqPnv+yFIIgaCgILRo0QImJiawsbHBsGHDcPPmTa12Z86cQb9+/TT718XFBX379sXdu3dLvN+o8uERIOlcWFgYunfvDi8vLwQHB8PIyAhBQUHo378/tm7dirfeegsAMGvWLGzatAn/93//h9deew3p6em4cOECEhMTNX316dMHeXl5WLRoEWrVqoWEhAT89ddfLxzPCwoKwtatW/F///d/WL9+PTw9PVGjRo0ybcvcuXPRoUMHfPfdd0hJScH777+P/v3749KlS5DL5QCA4OBgjB8/Hj4+PlizZg0cHBxw9epVXLhwAcDTU3Xp6en4+eefERERoenb2dm50O/8+++/0b59e2RnZ2PBggWoXbs2fv/9d/j7++PGjRsFTkeuWrUKnp6eWL58ueb7+vTpg5iYGFhZWRW7jePGjUPfvn2xZcsW3LlzBwEBARg5ciQOHTpU5Drbtm3DpEmTMHXqVAQGBkImk+H69euIjo4GAPTt2xeff/455s6di1WrVqFly5YAoDlqW7hwIebOnYvhw4dj4cKFSExMxLx58+Dt7Y3IyEjUr19f813Z2dkYMGAAJkyYgDlz5iA3N7fIuiZMmIANGzZg2rRp+PLLL/Ho0SN8+umnaN++Pc6ePQtHR0ekp6eje/fuqFOnDlatWgVHR0fEx8cjNDQUqampxe4vqsQEUQVav369ACAiIyOLbPP6668LBwcHkZqaqlmWm5srmjZtKlxdXYVarRZCCNG0aVMxaNCgIvtJSEgQAMTy5cvLrU53d3cxZsyYAu19fHyEj4+P5n1oaKgAIPr06aPV7qeffhIAREREhBBCiNTUVGFpaSk6duyo2a7CTJ48WRT1n+fzNc2ZM0cAEMePH9dqN3HiRCFJkrhy5YoQQoiYmBgBQDRr1kzk5uZq2p04cUIAEFu3bi2yHiH+3UeTJk3SWr5o0SIBQMTFxWmWPb9/pkyZIqytrV/Y//bt2wUAERoaqrX88ePHwsTEpMC+jY2NFUZGRmLEiBGaZWPGjBEAxLp16wr0P2bMGOHu7q55HxERIQCIJUuWaLW7c+eOMDExEbNnzxZCCHHy5EkBQOzcufOF9VPVw1OgpFPp6ek4fvw4hg0bBnNzc81yuVyOUaNG4e7du5pTiG3btsUff/yBOXPmQKVS4cmTJ1p92drawsPDA4sXL8bSpUtx5swZrVOAr8KAAQO03nt5eQEAbt++DQD466+/kJKSgkmTJkGSpHL5zkOHDqFx48YFxi79/PwghChwZNa3b1/N0WhhNRanuG0sTNu2bZGUlIThw4fj119/RUJCQom+CwAiIiLw5MmTAqd93dzc0KVLFxw8eLDAOkOHDi22399//x2SJGHkyJHIzc3VvJycnNC8eXOoVCoAQL169WBjY4P3338fa9as0Ry1UtXHACSdevz4MYQQhZ7ec3FxAQDNKc6vvvoK77//Pnbu3AlfX1/Y2tpi0KBBuHbtGoCn42UHDx5Ez549sWjRIrRs2RI1atTAtGnTXtmpKjs7O633RkZGAKAJ67///hsA4OrqWm7fmZiYWKL9V9Iai1OW9UeNGoV169bh9u3bGDp0KBwcHNCuXTscOHCg2O/Lr7+obXx++0xNTUt0leyDBw8ghICjoyMMDQ21XseOHdOEtJWVFcLCwtCiRQvMnTsXTZo0gYuLCz755BPk5OQU+z1UeTEASadsbGwgk8kQFxdX4LP8Cyvs7e0BAGZmZpg/fz4uX76M+Ph4rF69GseOHUP//v0167i7uyM4OBjx8fG4cuUKZs6ciaCgIAQEBJSpPmNjY2RlZRVYXpojmGfljy2W58UTdnZ2Jdp/ujZ27Fj89ddfSE5Oxu7duyGEQL9+/Yo98swP3KK28fntK+mRtb29PSRJwpEjRxAZGVngtXPnTk3bZs2aYdu2bUhMTERUVBTeeustfPrpp1iyZEmJvosqJwYg6ZSZmRnatWuHkJAQrSMItVqNzZs3w9XVFQ0aNCiwnqOjI/z8/DB8+HBcuXIFGRkZBdo0aNAAH330EZo1a4bTp0+Xqb7atWvj3LlzWsuuXr1a6JWdJdG+fXtYWVlhzZo1EEIU2a40R2Vdu3ZFdHR0gW38/vvvIUkSfH19y1RrRTEzM0Pv3r3x4YcfIjs7WzMFpaht9vb2homJCTZv3qy1/O7duzh06JDmKs/S6tevH4QQuHfvHlq3bl3g1axZswLrSJKE5s2bY9myZbC2ti7zv1dUOfAqUHolDh06VOgdPvr06YOFCxeie/fu8PX1hb+/PxQKBYKCgnDhwgVs3bpV83/07dq1Q79+/eDl5QUbGxtcunQJmzZtgre3N0xNTXHu3DlMmTIFb7zxBurXrw+FQoFDhw7h3LlzmDNnTpnqHjVqFEaOHIlJkyZh6NChuH37NhYtWlTmq0TNzc2xZMkSjBs3Dt26dcP48ePh6OiI69ev4+zZs/j6668BQPPj++WXX6J3796Qy+Xw8vKCQqEo0OfMmTPx/fffo2/fvvj000/h7u6O3bt3IygoCBMnTiz0fyBetfHjx8PExAQdOnSAs7Mz4uPjsXDhQlhZWaFNmzYAgKZNmwIA1q5dCwsLCxgbG6NOnTqws7PDxx9/jLlz52L06NEYPnw4EhMTMX/+fBgbG+OTTz4pU00dOnTAu+++i7Fjx+LkyZPo3LkzzMzMEBcXhyNHjqBZs2aYOHEifv/9dwQFBWHQoEGoW7cuhBAICQlBUlISunfvXm77iHRAhxfgkB7Iv3KwqFdMTIwQQojw8HDRpUsXYWZmJkxMTMTrr78ufvvtN62+5syZI1q3bi1sbGyEkZGRqFu3rpg5c6ZISEgQQgjx4MED4efnJzw9PYWZmZkwNzcXXl5eYtmyZVpXPb6ozuevAlWr1WLRokWibt26wtjYWLRu3VocOnSoyKtAt2/frrV+/pWX69ev11q+Z88e4ePjI8zMzISpqalo3Lix+PLLLzWfZ2VliXHjxokaNWoISZK09lVhV6bevn1bjBgxQtjZ2QlDQ0PRsGFDsXjxYpGXl1eglsWLFxfYfgDik08+KdM+yt/2Z6/efH7/bNy4Ufj6+gpHR0ehUCiEi4uLePPNN8W5c+e0+lq+fLmoU6eOkMvlBfbbd999J7y8vIRCoRBWVlZi4MCB4uLFi1rrjxkzRpiZmRVa//NXgeZbt26daNeunebfPQ8PDzF69Ghx8uRJIYQQly9fFsOHDxceHh7CxMREWFlZibZt24oNGza8cH9R5ScJ8YLzMERERNUUxwCJiEgvMQCJiEgvMQCJiEgvMQCJiEgvMQCJiEgvMQCJiEgvVZuJ8Gq1Gvfv34eFhUW53WSYiIiqFiEEUlNT4eLiApnsxcd41SYA79+/Dzc3N12XQURElcCdO3eKvel8tQlACwsLAE83uiR3gi9MSkoKwsPD0alTpzL3QURU3eTk5GD//v3o0aMHDA0NC7wv7/5fRkpKCtzc3DSZ8CLVJgDzT3taWlq+VHjlP0qFAUhE9FROTo7mtzE/AJ99X979l4eSDIXxIhgiItJLDEAiItJLDEAiItJLDEAiItJLDEAiItJLDMB/5KkFIm8n4VSChMjbSchT8zGJRETVWbWZBvEy9l6Iw/zfohGXnAlAju+vnYez1TV80r8xejV11nV5RERUAUp1BLh69Wp4eXlp5sl5e3vjjz/+0HwuSVKhr8WLFxfZZ05ODj799FN4eHjA2NgYzZs3x969e8u+RaW090IcJm4+/U/4/Ss+ORMTN5/G3gtxr6wWIiJ6dUoVgK6urvjiiy9w8uRJnDx5El26dMHAgQNx8eJFAEBcXJzWa926dZAkCUOHDi2yz48++gjffPMNVq5ciejoaPzvf//D4MGDcebMmZfbshLIUwvM/y0ahZ3szF82/7dong4lIqqGShWA/fv3R58+fdCgQQM0aNAAn332GczNzXHs2DEAgJOTk9br119/ha+vL+rWrVtkn5s2bcLcuXPRp08f1K1bFxMnTkTPnj2xZMmSl9uyEjgR86jAkd+zBIC45EyciHlU4bUQEdGrVeYxwLy8PGzfvh3p6enw9vYu8PmDBw+we/dubNy48YX9ZGVlwdjYWGuZiYkJjhw5Uux6WVlZmvcpKSkAnp5SzcnJKdE2xCWll7hdTg5vjUZE+in/N7WoP8u7//LoqyRKHYDnz5+Ht7c3MjMzYW5ujh07dqBx48YF2m3cuBEWFhYYMmTIC/vr2bMnli5dis6dO8PDwwMHDx7Er7/+iry8vBeut3DhQsyfP7/A8v3798PU1LRE23IzWQIgL77dxSjsuVvxp2SJiCqzAwcOvPB9efdfFhkZGSVuKwkhSjXAlZ2djdjYWCQlJeGXX37Bd999h7CwsAIh6Onpie7du2PlypUv7O/vv//G+PHj8dtvv0GSJHh4eKBbt25Yv379CzeksCNANzc3JCQklPhG1nlqAeWSw3iQklXoOKAEwMnKCKGzOkMu4zMGiUg/5eTk4MCBA+jevbvmZtjPvi/v/l9GSkoK7O3tkZycXGwWlPoIUKFQoF69egCA1q1bIzIyEitWrMA333yjaRMeHo4rV67gxx9/LLa/GjVqYOfOncjMzERiYiJcXFwwZ84c1KlT54XrGRkZwcjIqMByQ0PDEu9AQwDzBjTBxM2nIQEFQlAA+KR/ExgbKUrUHxFRdfb872tpfm/L0n9Z+yipl54IL4TQOhIDgODgYLRq1QrNmzcvcT/GxsaoWbMmcnNz8csvv2DgwIEvW1qJ9GrqjNUjW8LKtOBOsy5kGRERVQ+lCsBevXrBw8MDFhYWMDc3h6urK0JDQ/Gf//wHwL/zADdu3IhTp04VOg9w9OjR+OCDDzTvjx8/jpCQENy8eRPz5s2DQqFAXFwcZs+eXU6bWDLJGQUHTpMzcjgXkIiomipVAObl5SEtLQ1ZWVlQKBQwNDSEXC6Hi4sLgKfzABctWgRjY2NcuXKl0HmAsbGxiIv7N1AyMzPx0UcfoVGjRliwYAEcHBzQqVMnWFtbl88WFrdNnAtIRKSXShWABw4cwIMHD5CdnY1Hjx4hJiYGFhYWWvMAAwIC8OTJEzRo0KDQeYAqlQobNmzQvPfx8cH58+fRpk0brF27Fr179y4wLaIicS4gEZF+0vk8QAD49NNPUaNGDbzzzjsIDw8v0feXxzxAgHMBiYiKw3mA/yjveYBHjx5FcHAwoqKiSlVHecwDBEo+F/DC2SjIOReQiPQY5wGW4zzA1NRUeHl5ISgoCL179wYA+Pn5ISkpCTt37nxhHeUxDxAofi5gPjOFHJN962L06+4wMuBTpIhIf3Ae4D/Kcx7gjRs3cOvWLfTv31+zTK1WPy3MwABXrlyBh4dHoeuWxzxA4MVzAfPfu9ma4M6jJ1i07xq2Rd7DB7090aupEySJk+OJSH9wHuBzXmYeoKenJ86fP4+oqCjNa8CAAfD19UVUVBTc3NxetrwSyZ8L6GChPeHdycoYa0a2RJi/LxYP84KDhRFiH2Vg4g+n8dbaY7hwL/mV1EdEROWvVEeAc+fORe/eveHm5obU1FRs27YNKpVK6/l9KSkp2L59e5FPcxg9ejRq1qyJhQsXwtjYGE2bNtX6PH/6w/PLK1qvps5o52qK4F1hcK3fGO4ONmhbx1ZzC7Q3WruhTzNnrAm7gbWHb+JEzCP0//oIhrV0RUDPhnCwfHVXrhIR0csrVQA+ePAAo0aNQlxcHKysrODl5YW9e/eie/fumjbbtm2DEALDhw8vtI/Y2FjIZJVzDE0uk1DfSsC3iUOh547NjAzwXo+GeLttLXz5x2XsOnsf20/dxe7zcZik9MC4TnVhbFj8BTVERKR7pQrA4ODgYtu8++67ePfdd4v8XKVSvXD9Z+cIVlY1rU3w1fDXMKZ9bSz4PRpRd5IQuP8qtp64g/d7e6K/lzPHB4mIKrnKeShWRbRyt0HIxPZY8XYLOFsZ417SE0zbegbD1kQg6k6SrssjIqIXYAC+JJlMwsAWNXHoPSVmdW8AE0M5Tt1+jEGrjmLmj1GIS36i6xKJiKgQDMByYqKQY1rX+gj1V2JoS1cAwI4z9+AbqMKyA1eRkZ2r4wqJiOhZDMBy5mRljCVvNseuKR3QprYNMnPUWHHwGroEhiHk9F2oeVNtIqJKgQFYQbxcrfHTBG+sGtESrjYmiE/JxKyfzmJQ0FGcvMUbaxMR6RoDsAJJkoS+Xs74c5YPZvdqCDOFHOfuJmPYmghM3nIadx6V/J51RERUvhiAr4CxoRyTlPUQGqDE223cIEnA7nNx6Lo0DIv2XkZaFscHiYheNQbgK+RgYYwvhnrh96kd4V3XDtm5agSpbkC5WIUfI2P50F0ioleIAagDTVyssGV8O6wd1QrudqZISMvC+7+cR/+VRxBxI1HX5RER6QUGoI5IkoQeTZywf2ZnfNinESyMDRAdl4Lh3x7DhE0ncTuxZA/qJSKismEA6piRgRzjO9eFyl+Jka/XgkwC9l18gG5Lw/D5nktIySyfJy4TEZE2BmAlYWduhP8b1Ax/TO+MTvXtkZMnsPbwTfguVmHzsdvIzVPrukQiomqFAVjJNHSywPf/bYv1fm1Qt4YZEtOz8dHOC+jzVTjCr/2t6/KIiKoNBmAlJEkSfD0dsG9GZ8zr3xhWJoa4+iANo4JP4J0Nkbjxd5quSyQiqvIYgJWYoVwGvw51EBagxNgOtWEgk3Dw8kP0XHYY83+7iKSMbF2XSERUZTEAqwBrUwU+6d8E+2Z2RldPB+SqBdYfvQWfxSpsOBqDHI4PEhGVGgOwCvGoYY5gvzbY9E5bNHS0QPKTHMz7LRq9lh9G6OWHEIIT6YmISooBWAV1ql8Du6d1xP8NagpbMwVu/J2OsRsiMXrdCVx9kKrr8oiIqgQGYBVlIJdh5OvuCPVX4t3OdWEolxB+LQG9lh/GRzvPIzEtS9clEhFVagzAKs7KxBBz+zTCgZk+6NnEEWoBbD4WC2WgCt8evonsXI4PEhEVhgFYTdS2N8M3o1pj6/jX0djZEqmZufhszyX0WBaGfRfjOT5IRPQcBmA14+1hh9+mdsSioV6wNzfCrcQMTNh0CiO+PY7o+ym6Lo+IqNJgAFZDcpmEN9u4QRWgxGRfDygMZIi4mYi+K8Mx55dzeJiaqesSiYh0jgFYjZkbGSCgpycOzvJBPy9nCAFsi7wD38UqBKmuIzMnT9clEhHpDANQD7jZmuLrES3x8/+80dzVCunZeVi09wq6LQ3D7nNxHB8kIr3EANQjrWvbYsekDlj6ZnM4WRrj7uMnmLzlNN78JgLn7ibpujwioleKAahnZDIJQ1q64pC/D6Z3rQ9jQxkibz3GgK+PYtZPUYhP5vggEekHBqCeMlUYYGb3Bgj1V2LwazUBACGn78E3UIUVf17Dk2yODxJR9cYA1HPOViZY9lYL7JzcAS1rWeNJTh6W/XkVXZaosPPMPajVHB8kouqJAUgAgBZu1vhlYnusHP4aalqbIC45EzN+jMKQ1X/hdOxjXZdHRFTuGICkIUkS+jd3wcH3fODfowFMFXJE3UnCkKC/MG3rGdxLeqLrEomIyg0DkAowNpRjSpf6UPkr8UYrV0gSsOvsfXQJVGHJ/itIz8rVdYlERC+NAUhFcrA0xuI3muO3KR3Rto4tsnLVWHnoOnwDVdh+8g7HB4moSmMAUrGa1rTCj+++jjUjW6KWrSkepmYh4OdzGLjqKE7EPNJ1eUREZcIApBKRJAm9mjrjwKzO+KC3J8yNDHD+XjLe/CYCk344hTuPMnRdIhFRqTAAqVSMDOSY4OMBVYASI9rVgkwC9pyPR9clYVj4xyWkZuboukQiohJhAFKZ2Jsb4fPBzbBneid0rGeP7Dw1vgm7Cd9AFbaeiEUexweJqJJjANJL8XSyxKZ32iJ4TGvUtTdDQlo2Pgg5j75fheOv6wm6Lo+IqEgMQHppkiShayNH7J3RGR/3awxLYwNcjk/FiO+OY9zGk4hJSNd1iUREBTAAqdwoDGR4p2MdhAX4Yoy3O+QyCX9eeoAey8Kw4PdoJGdwfJCIKg8GIJU7GzMF5g9sin0zOkHZsAZy8gSCj8RAGRiKTRG3kJun1nWJREQMQKo49RwssGFsW2wY2wb1HczxOCMHH/96Eb1XhEN15aGuyyMiPccApAqnbOiAP6Z3woKBTWBjaohrD9Pgtz4SfutP4PrDVF2XR0R6igFIr4SBXIZR3rWh8vfFuI51YCCToLryN3ouD8cnv17A4/RsXZdIRHqGAUivlJWpIT7q1xgHZvmge2NH5KkFNkbchs/iUAQfiUF2LscHiejVYACSTtSxN8O3o1tjy7h28HSyQEpmLhb8Ho2eyw/jz+gHEIIT6YmoYjEASafa17PH7mmdsHBIM9ibKxCTkI5x35/EyODjuBSXouvyiKgaYwCSzsllEoa3rYVQfyX+5+MBhVyGo9cT0fercHwQch4JaVm6LpGIqiEGIFUaFsaGmNPbE3/O8kGfZk5QC2DriVj4Llbhm7AbyMrN03WJRFSNMACp0qllZ4qg/7TCj+++jqY1LZGalYuFf1xG96WH8cf5OI4PElG5YABSpdWurh12Te6IwDeaw8HCCLGPMjDxh9N4a+0xXLiXrOvyiKiKYwBSpSaTSRjWyhWh/kpM7VIPRgYynIh5hP5fH0HA9rN4mJKp6xKJqIpiAFKVYGZkgPd6NMQhfyUGNHeBEMD2U3ehDFTh60PXkJnD8UEiKh0GIFUpNa1N8NXw1/DLxPZo4WaNjOw8BO6/iq5LwrDr7H2ODxJRiTEAqUpq5W6DkIntseLtFnCxMsa9pCeYtvUMhq2JQNSdJF2XR0RVAAOQqiyZTMLAFjVx8D0lZnVvABNDOU7dfoxBq45i5o9RiEt+ousSiagSYwBSlWeikGNa1/oI9VdiaEtXAMCOM/fgG6jCsgNXkZGdq+MKiagyYgBSteFkZYwlbzbHrikd0Ka2DTJz1Fhx8Bq6BIYh5PRdqNUcHySifzEAqdrxcrXGTxO8EfSflnC1MUF8SiZm/XQWg4KO4uStR7ouj4gqCQYgVUuSJKFPM2f8OcsHs3s1hJlCjnN3kzFsTQQmbzmNO48ydF0iEekYA5CqNWNDOSYp6yE0QIm327hBkoDd5+LQdWkYFu29jLQsjg8S6SsGIOkFBwtjfDHUC79P7QjvunbIzlUjSHUDysUq/BgZizyODxLpHQYg6ZUmLlbYMr4d1o5qhdp2pkhIy8L7v5xH/5VHEHEjUdflEdErxAAkvSNJEno0ccL+mT74qG8jWBgbIDouBcO/PYYJm07idmK6rkskoleAAUh6S2Egw7hOdaHyV2LU6+6QScC+iw/QbWkYPt9zCSmZOboukYgqEAOQ9J6duREWDGqKvTM6o1N9e+TkCaw9fBO+i1XYfOw2cvPUui6RiCoAA5DoHw0cLfD9f9tivV8beNQwQ2J6Nj7aeQF9vgpH+LW/dV0eEZUzBiDRMyRJgq+nA/bO6Ix5/RvD2tQQVx+kYVTwCbyzIRI3/k7TdYlEVE4YgESFMJTL4NehDlT+SoztUBsGMgkHLz9Ez2WHMf+3i0jKyNZ1iUT0khiARC9gbarAJ/2bYN/Mzujq6YBctcD6o7fgs1iFDUdjkMPxQaIqiwFIVAIeNcwR7NcGm95pi4aOFkh+koN5v0Wj1/LDCL38kA/iJaqCGIBEpdCpfg3sntYRnw1uClszBW78nY6xGyIxet0JXH2QquvyiKgUGIBEpWQgl+E/7dyhClBiQue6MJRLCL+WgF7LD+OjneeRmJal6xKJqAQYgERlZGlsiA/6NMKBmT7o2cQRagFsPhYLZaAK3x6+iexcjg8SVWYMQKKXVNveDN+Mao2t419HY2dLpGbm4rM9l9BjWRj2XYzn+CBRJcUAJCon3h52+G1qRywa6oUaFka4lZiBCZtOYcS3xxF9P0XX5RHRcxiAROVILpPwZhs3hPorMdnXAwoDGSJuJqLvynDM+eUcHqZm6rpEIvoHA5CoApgbGSCgpycOzvJBPy9nCAFsi7wD38UqBKmuIzMnT9clEuk9BiBRBXKzNcXXI1ri5/95o7mrFdKz87Bo7xV0WxqG3efiOD5IpEMMQKJXoHVtW+yY1AHL3moOJ0tj3H38BJO3nMab30Tg3N0kXZdHpJcYgESviEwmYfBrrjjk74PpXevD2FCGyFuPMeDro5j1UxTikzk+SPQqMQCJXjFThQFmdm+AUH8lBr9WEwAQcvoefANVWPHnNTzJ5vgg0avAACTSEWcrEyx7qwV2Tu6AlrWs8SQnD8v+vIouS1TYeeYe1GqODxJVJAYgkY61cLPGLxPbY+Xw11DT2gRxyZmY8WMUhqz+C6djH+u6PKJqiwFIVAlIkoT+zV1w8D0fBPRsCFOFHFF3kjAk6C9M23oG95Ke6LpEomqHAUhUiRgbyjHZtx5U/kq82doVkgTsOnsfXQJVWLL/CtKzcnVdIlG1wQAkqoQcLI2xaFhz/DalI9rVsUVWrhorD12Hb6AK20/e4fggUTlgABJVYk1rWmHbu69jzciWqGVrioepWQj4+RwGrjqKEzGPdF0eUZXGACSq5CRJQq+mzjgwqzM+6O0JCyMDnL+XjDe/icCkH07hzqMMXZdIVCUxAImqCCMDOSb4eCA0QIkR7WpBJgF7zsej65IwfPHHZaRm5ui6RKIqhQFIVMXYmxvh88HNsGd6J3SsZ4/sPDXWhN2Ab6AKW0/EIo/jg0QlwgAkqqI8nSyx6Z22CB7TGnXtzZCQlo0PQs6j71fh+Ot6gq7LI6r0GIBEVZgkSejayBF7Z3TG/+vXGJbGBrgcn4oR3x3HuI0nEZOQrusSiSotBiBRNaAwkOG/HesgLMAXfu1rQy6T8OelB+ixLAwLfo9GcgbHB4mexwAkqkZszBSYN6AJ9s3oBN+GNZCTJxB8JAbKwFBsiriF3Dy1rkskqjQYgETVUD0HC6wf2xYb/9sW9R3M8TgjBx//ehG9V4RDdeWhrssjqhQYgETVmE+DGvhjeicsGNgENqaGuPYwDX7rI+G3/gSuP0zVdXlEOsUAJKrmDOQyjPKuDVWAL8Z1rANDuQTVlb/Rc3k4Pvn1Ah6nZ+u6RCKdYAAS6QkrE0N81K8x9s/0QffGjshTC2yMuA2fxaEIPhKD7FyOD5J+YQAS6Zk69mb4dnRrbBnXDp5OFkjJzMWC36PRc/lh/Bn9AEJwIj3pBwYgkZ5qX88eu6d1whdDmsHeXIGYhHSM+/4kRgYfx6W4FF2XR1ThGIBEekwuk/B221oI9Vfifz4eUMhlOHo9EX2/CscHIeeRkJal6xKJKgwDkIhgYWyIOb098ecsH/Rp5gS1ALaeiIXvYhW+CbuBrNw8XZdIVO4YgESkUcvOFEH/aYWfJnijaU1LpGblYuEfl9F96WH8cT6O44NUrTAAiaiAtnVssWtyRwS+0RwOFkaIfZSBiT+cxltrj+HCvWRdl0dULhiARFQomUzCsFauCPVXYlqXejAykOFEzCP0//oIArafxcOUTF2XSPRSGIBE9EJmRgaY1aMhDvkrMbCFC4QAtp+6C2WgCl8fuobMHI4PUtXEACSiEqlpbYIVb7+GkEnt0cLNGhnZeQjcfxVdl4Rh19n7HB+kKocBSESl0rKWDXZMao8Vb7eAi5Ux7iU9wbStZzBsTQSi7iTpujyiEmMAElGpSZKEgS1q4uB7Sszq3gAmhnKcuv0Yg1YdxcwfoxCX/ETXJRIViwFIRGVmopBjWtf6UAUoMbSlKwBgx5l78A1UYdmBq8jIztVxhURFYwAS0UtztDTGkjebY9eUDmhT2waZOWqsOHgNXQLDEHL6LtRqjg9S5cMAJKJy4+VqjZ8meCPoPy3hamOC+JRMzPrpLAYFHcXJW490XR6RFgYgEZUrSZLQp5kz/pzlg/d7ecLcyADn7iZj2JoITN5yGnceZei6RCIADEAiqiDGhnJMVHog1F+J4W3dIEnA7nNx6Lo0DIv2XkZaFscHSbcYgERUoWpYGGHhEC/sntoJ3nXtkJ2rRpDqBpSLVfgxMhZ5HB8kHWEAEtEr0djFElvGt8PaUa1Q284UCWlZeP+X8+i/8ggibiTqujzSQwxAInplJElCjyZO2D/TBx/1bQQLYwNEx6Vg+LfHMGHTSdxOTNd1iaRHGIBE9MopDGQY16kuwgJ8Mep1d8hlEvZdfIBuS8Pw+Z5LSMnM0XWJpAcYgESkM7ZmCiwY1BR/TO+ETvXtkZMnsPbwTfguVmHzsdvIzVPrukSqxhiARKRzDRwt8P1/22K9Xxt41DBDYno2Ptp5AX2+Ckf4tb91XR5VUwxAIqoUJEmCr6cD9s7ojPkDmsDa1BBXH6RhVPAJvLMhEjf+TtN1iVTNMACJqFIxlMswpn1tqPyVGNuhNgxkEg5efoieyw5j/m8XkZSRresSqZpgABJRpWRtqsAn/Ztg38zO6OrpgFy1wPqjt+CzWIUNR2OQw/FBekkMQCKq1DxqmCPYrw02vdMWDR0tkPwkB/N+i0av5YcRevkhH8RLZcYAJKIqoVP9Gtg9rSM+G9wUdmYK3Pg7HWM3RGL0uhO4+iBV1+VRFcQAJKIqw0Auw3/auSM0QIkJnevCUC4h/FoCei0/jI92nkdiWpauS6QqhAFIRFWOpbEhPujTCH/O8kGvJk5QC2DzsVgoA1X49vBNZOdyfJCKxwAkoirL3c4Ma0a1wtbxr6OJiyVSM3Px2Z5L6LEsDPsuxnN8kF6IAUhEVZ63hx12TemIRUO9UMPCCLcSMzBh0ymM+PY4ou+n6Lo8qqQYgERULchlEt5s44ZQfyUm+3pAYSBDxM1E9F0Zjjm/nMPD1Exdl0iVDAOQiKoVcyMDBPT0xKH3fNDPyxlCANsi78B3sQpBquvIzMnTdYlUSTAAiahacrUxxdcjWuLn/3mjuasV0rPzsGjvFXRbGobd5+I4PkgMQCKq3lrXtsWOSR2w7K3mcLI0xt3HTzB5y2m8+U0Ezt1N0nV5pEMMQCKq9mQyCYNfc8Uhfx/M6FYfxoYyRN56jAFfH8Wsn6IQn8zxQX3EACQivWGqMMCMbg0Q6q/EkNdqAgBCTt+Db6AKK/68hifZHB/UJwxAItI7zlYmWPpWC+yc3AGt3G3wJCcPy/68ii5LVNh55h7Uao4P6gMGIBHprRZu1vj5f95YOfw11LQ2QVxyJmb8GIUhq//C6djHui6PKhgDkIj0miRJ6N/cBQff80FAz4YwU8gRdScJQ4L+wrStZ3Av6YmuS6QKwgAkIgJgbCjHZN96CPVX4s3WrpAkYNfZ++gSqMKS/VeQnpWr6xKpnDEAiYie4WBpjEXDmuO3KR3Rro4tsnLVWHnoOnwDVdh+8g7HB6sRBiARUSGa1rTCtndfx5qRLVHL1hQPU7MQ8PM5DFx1FCdiHum6PCoHDEAioiJIkoReTZ1xYFZnzO3jCQsjA5y/l4w3v4nApB9O4c6jDF2XSC+BAUhEVAwjAzne7eyB0AAlRrSrBZkE7Dkfj65LwvDFH5eRmpmj6xKpDBiAREQlZG9uhM8HN8Oe6Z3QsZ49svPUWBN2A76BKmw9EYs8jg9WKQxAIqJS8nSyxKZ32iJ4TGvUtTdDQlo2Pgg5j75fheOv6wm6Lo9KiAFIRFQGkiShayNH7J3RGf+vX2NYmRjicnwqRnx3HOM2nkRMQrquS6RiMACJiF6CwkCG/3asA5W/En7ta0Muk/DnpQfosSwMC36PRnIGxwcrKwYgEVE5sDFTYN6AJtg3oxN8G9ZATp5A8JEYKANDsSniFnLz1LoukZ7DACQiKkf1HCywfmxbbPxvW9R3MMfjjBx8/OtF9F4RDtWVh7ouj57BACQiqgA+DWrgj+mdsGBQU9iYGuLawzT4rY+E3/oTuP4wVdflERiAREQVxkAuw6jX3aEK8MW4jnVgKJeguvI3ei4Pxye/XsDj9Gxdl6jXGIBERBXMysQQH/VrjP0zfdCjsSPy1AIbI27DZ3Eogo/EIDuX44O6wAAkInpF6tibYe3o1tgyrh08nSyQkpmLBb9Ho+fyw/gz+gGE4ET6V4kBSET0irWvZ4/d0zrhiyHNYG+uQExCOsZ9fxIjg4/jUlyKrsvTGwxAIiIdkMskvN22FkL9lZio9IBCLsPR64no+1U4Pgg5j4S0LF2XWO0xAImIdMjC2BDv9/LEwfd80LeZM9QC2HoiFr6LVfgm7AaycvN0XWK1xQAkIqoE3GxNseo/LfHTBG80q2mF1KxcLPzjMrovPYw/zsdxfLACMACJiCqRtnVs8evkDgh8ozkcLIwQ+ygDE384jbfWHsOFe8m6Lq9aYQASEVUyMpmEYa1cEeqvxLQu9WBkIMOJmEfo//URBGw/i4cpmbousVpgABIRVVJmRgaY1aMhDvkrMbCFC4QAtp+6C2WgCl8fuobMHI4PvgwGIBFRJVfT2gQr3n4NIZPao4WbNTKy8xC4/yq6LgnDrrP3OT5YRgxAIqIqomUtG+yY1B4r3m4BFytj3Et6gmlbz2DYmghE3UnSdXlVDgOQiKgKkSQJA1vUxMH3lHivewOYGMpx6vZjDFp1FDN/jEJc8hNdl1hlMACJiKogE4UcU7vWhypAiaEtXQEAO87cg2+gCssOXEVGdq6OK6z8GIBERFWYo6UxlrzZHLumdECb2jbIzFFjxcFr6BIYhpDTd6FWc3ywKAxAIqJqwMvVGj9N8EbQf1rC1cYE8SmZmPXTWQwKOoqTtx7purxKiQFIRFRNSJKEPs2c8ecsH7zfyxPmRgY4dzcZw9ZEYPKW07jzKEPXJVYqDEAiomrG2FCOiUoPhPorMbytGyQJ2H0uDl2XhmHR3stIy+L4IMAAJCKqtmpYGGHhEC/sntoJ3nXtkJ2rRpDqBpSLVfgxMhZ5ej4+yAAkIqrmGrtYYsv4dlg7qhVq25kiIS0L7/9yHv1XHkHEjUSttnlqgYgbifg16h4ibiRW65AsVQAuXLgQbdq0gYWFBRwcHDBo0CBcuXJFq42fnx8kSdJ6vf766y/sV6lUFlhHkiT07du39FtEREQFSJKEHk2csH+mDz7q2wgWxgaIjkvB8G+PYcKmk7idmI69F+LQ8ctDGP7tMUzfFoXh3x5Dxy8PYd/FB7ouv0IYlKZxWFgYJk+ejDZt2iA3NxcffvghevTogejoaJiZmWna9erVC+vXr9e8VygUL+w3JCQE2dnZmveJiYlo3rw53njjjdKUR0RExVAYyDCuU10MaemKZQeuYsuJWOy7+AB/XnqAPHXB9vHJmZi67SzGNpDQ59WXW6FKFYB79+7Ver9+/Xo4ODjg1KlT6Ny5s2a5kZERnJycStyvra2t1vtt27bB1NSUAUhEVEFszRRYMKgpRnu749PfoxF+LaHQdgKABCDklgyz1QKGr7TKivVSY4DJyU+fTfV8gKlUKjg4OKBBgwYYP348Hj58WKp+g4OD8fbbb2sdVRIRUfmr72iBScp6L2wjACRlSzh5+/GrKeoVKdUR4LOEEJg1axY6duyIpk2bapb37t0bb7zxBtzd3RETE4OPP/4YXbp0walTp2BkZFRsvydOnMCFCxcQHBz8wnZZWVnIysrSvE9JSQEA5OTkICcnp0zblJubq/mzrH0QEVU1cUnpJWyXofUbW16/k+XZX2n6kEQZn6MxefJk7N69G0eOHIGrq2uR7eLi4uDu7o5t27ZhyJAhxfY7YcIE/PXXXzh//vwL282bNw/z588vsHzLli0wNTUtfgOIiAgAcC1ZwtfR8mLbTWmch/pWlfuq0IyMDIwYMQLJycmwtLR8YdsyBeDUqVOxc+dOHD58GHXq1Cm2ff369TFu3Di8//77L2yXkZEBZ2dnfPrpp5g+ffoL2xZ2BOjm5oaEhIRiN7ooqampCA8PR6dOnWBhYVGmPoiIqpo8tYByyWE8SMlCYYEgAbBSCITP9oWxkQI5OTk4cOAAunfvDkPDlx8VLM/+UlJSYG9vX6IALNUpUCEEpk6dih07dkClUpUo/BITE3Hnzh04OzsX2/ann35CVlYWRo4cWWxbIyOjQk+pGhoalnkHGhgYaP4sj79UIqKqwBDAvAFNMHHzaUiAVghK//w5pLYaxkYKrd/Gl/m9LbSOcuivNOuX6iKYyZMnY/PmzdiyZQssLCwQHx+P+Ph4PHny9PlTaWlp8Pf3R0REBG7dugWVSoX+/fvD3t4egwcP1vQzevRofPDBBwX6Dw4OxqBBg2BnZ1easoiI6CX1auqM1SNbwsnKWGu5k5UxVr7dHM3tKvepz7Io1RHg6tWrATyduP6s9evXw8/PD3K5HOfPn8f333+PpKQkODs7w9fXFz/++KPWKcXY2FjIZNrZe/XqVRw5cgT79+8v46YQEdHL6NXUGd0bO+Grg9ew4uA1eDpaYPf0TlDn5WLPbV1XV/5KfQr0RUxMTLBv375i+1GpVAWWNWjQoNj+iYioYsllEtrU/mdqm/T0vTpPtzVVFN4LlIiItFiaPD02Sn5SvaeDMQCJiEiLpfHTC0lSGIBERKRPrEyeBmB6dh5yCrtBaDXBACQiIi0Wxv9eHpKaWX0fnssAJCIiLQZyGcyNnoZgdT4NygAkIqICLI2r/4UwDEAiIirA8p9xwJRMBiAREekRTQA+4RggERHpkfypEDwFSkREeiV/MjxPgRIRkV7JnwvII0AiItIr+nA3GAYgEREVYKW5CpQXwRARkR6x5ClQIiLSR/kT4XkKlIiI9IoVJ8ITEZE++nciPAOQiIj0yLN3ghFC6LiaisEAJCKiAvJPgWbnqZGZUz2fCcgAJCKiAswUcshlEoDqOw7IACQiogIkSfr3StBqOheQAUhERIWq7hfCMACJiKhQmtuh8QiQiIj0iRWPAImISB/9+0gkHgESEZEe4SlQIiLSSzwFSkREesmymj8SiQFIRESFsqzmN8RmABIRUaGq+yORGIBERFQongIlIiK9xItgiIhIL3EaBBER6aX8ifCpWblQV8NHAjIAiYioUPlHgEIAmXk6LqYCMACJiKhQxoZyGBk8jYkn1fAsKAOQiIiKlH8hzBMeARIRkT7JnwrxJFfScSXljwFIRERFyp8Mn8FToEREpE94CpSIiPTSv6dAdVxIBWAAEhFRkfKnQnAMkIiI9Er+KdAMngIlIiJ9kn83GJ4CJSIivcKLYIiISC/ljwFmcAyQiIj0Ca8CJSIivWTFACQiIn2kmQbBMUAiItIn+VeBZqslZOeqdVxN+WIAEhFRkSz+OQIEgNTMHB1WUv4YgEREVCS5TIK50dOjwJTM6jUQyAAkIqIXsjJhABIRkR7KPw2a8oSnQImISI/kPxOQR4BERKRX8ucCJvMIkIiI9InFP0eAqTwCJCIifWJuJAcAnI59jIgbichTCx1XVD5KFYALFy5EmzZtYGFhAQcHBwwaNAhXrlzRahMSEoKePXvC3t4ekiQhKiqq2H5DQkLQunVrWFtbw8zMDC1atMCmTZtKtSFERFT+9l6IQ8iZ+wCAQ1cSMPzbY1AuOYyziVX/5tilCsCwsDBMnjwZx44dw4EDB5Cbm4sePXogPT1d0yY9PR0dOnTAF198UeJ+bW1t8eGHHyIiIgLnzp3D2LFjMXbsWOzbt6805RERUTnaeyEOEzefRlqW9n3Q4lOysO6qDH+cj9dRZeXDoDSNhRCYPHkyMjIyIEkSatSogYcPH+LUqVPo3LkzAOD8+fNYt24dHj16BADYt28fWrRo8cJ+161bh19//RWpqakAAGtra7i4uODIkSPo2bNnGTaLiIheRp5aYP5v0Sj6ZKeE6T+dw83EJ6hTwwwOFsZoW8cWAHAi5hEepmbC3swIkICEtCytf36+bVxSOq4nSbC+kYikzDzN53JZxR5llioAT506heHDh6N///7IysrCxIkTATwNxnwpKSnw8vKCjY0NQkJCStTv4cOH0bt3bwwePBjm5uaYMGEC7ty5AycnpyLXycrKQlZWltb3AkBOTg5ycsp2pVJubq7mz7L2QURUHRyPeYS45MwXthEAlh+8pnlvbWIAQEJSCa4WLdhWjqBLpzSfO1ka4aM+nujZxLFUdZfmt7tUAZiQkKD5ZyEEVq9eDZVKhXPnzsHHxwcAsGbNGgDA9u3bSxyAt27dQnJyMmrWrImsrCxI0tPUP3v2bJHrLFy4EPPnzy+wfP/+/TA1NS3xNhUmPDz8pdYnIqrqTiVIAOSlWuffMCv+yK24tvEpmZiyLQr/baBGc7uSX3STkZFR4ralCsBnTZkyBdHR0QAAV1fXsnajYWFhgaioKKSlpSEkJAQLFizQOsJ73uTJk/HWW29p3qelpaFt27bo1KkTLC0ty1RDWloaIiMj0aZNG5ibm5epDyKi6sD8dhK+v3a+lGuV5pRlcW0lSAD2xJti6pA2JT4dmn82sCTKFIBTp07Fzp07oVarYWlpicGDB5elGy0ymQz16tUDAIwaNQqSJCE2NrbI9m+88QbCwsIKLA8PD3/pI8DIyMiXWp+IqKpTC8BaIUdSNlC6YCs/Ak8vuAneFYb6ViU7CqywI0AhBKZOnYodO3bAzMwMDx48QERERGm6KFafPn1w8eJFKJVKqNVFP3tq165dWkmfmpqKxo0bw9fX96WOACMiIuDt7c0jQCLSezK3vzF9+wVdlwF3z2bo3rRkY4EVdgQ4efJkbNmyBXZ2drhx4wZ++eUXuLm54cmTJzAxMQEAPHr0CLGxsbh16xYA4P79+4iKioKTk5PmopbRo0ejZs2aWLhwIYCn43mtW7fGwoULERoaiuHDh2P79u1YvXp1kbVYWlpqBV3+Rpuampb5CDD/IhhjY+OXPookIqrqBrZyh6GhIaZsPQNdzn13tbMs8W9y/u94SZRqHuDq1auRnJyMmzdvQq1WY/DgwXB2dsaPP/6oabNr1y689tprmD17NgDgq6++wmuvvaa5OAYAYmNjERcXp3mfnp6OQYMGITQ0FKamprh16xY2b96McePGlaY8IiIqZ328XLD8TS/gBRMiKooEwNnq3ykT5a1UR4BNmjTBxYsXsXz5cvj6+mqWP3sRTKdOnbBt2zZcvnwZ8+bNw7Rp09C+fXs0atRI0+bOnTtaF7icPn0aGRkZ8Pf3x6hRozTL4+PjXzgVgoiIKl7vpk7475kz2BNviviUoi9OLE/5o46f9G9cYfMBJfHsJL7iGkuFF/HOO+/gu+++AwCMGzcOwcHBBdr4+PhApVIBeDrR3d7eHtevXwcAGBgYIC8v74XrFCclJQVWVlZITk4u8xhgSkoKQkNDX2ockYiousnJycGePXvQs1dvnLmbirikdByIiMKZFO1AtDZ9+tSIpIwSzAMspq2zlTE+6d8YvZo6l6rW0mRBqS+CKc53332nCcOiJCUlab0vzTlbIiLSDblMgreHHXJyLCG/ewbLenXGmbupeJia+fJ3grkQhXbt2lbeO8EQERHlyw/E5xW2rCj5gbrn7hm097CDoaFheZb4QnwcEhER6SUGIBER6SUGIBER6SUGIBER6SUGIBER6aVqcxVo/hSN0twH7nkpKSnIyMh4qT6IiKqbnJwczW+joaFhgffl3f/LyP/9Lsm0vWoTgPlPk3dzc9NxJUREpGupqamwsrJ6YZtS3QmmMlOr1bh//z4sLCyKvGNNca5cuYK2bdvixIkTaNiwYTlXSERUNaWkpMDNzQ137tyBpaVlgffl3f/LEEIgNTUVLi4ukMlePMpXbY4AZTLZSz+YN/8RSObm5rwVGhHRc55/Cs/z78u7/7Iq7sgvHy+CISIivcQAJCIivcQAfIa9vT3c3d1hb2+v61KIiCoNIyMjfPLJJzAyMir0fXn3/6pUm4tgiIiISoNHgEREpJcYgEREpJcYgEREpJcYgEREpJeqfQC2atUKkiRBkiTIZDLMmDHjhe2nTp0KmUymWadNmzYF2gwcOFDzuSRJGDx4cAVVT0RU/oKCglCnTh0YGxujVatWCA8PL3RZvqysLHz44Ydwd3eHkZERPDw88M0332iWPfub+exLJpPB2NgYRkZGcHNzw8yZM5GZmalVi5+fX6HrNmnSRNPm22+/RadOnWBjYwMbGxt069YNJ06cePkdIaqxXr16CQDC29tbBAUFCXt7ewFAhISEFNp+27ZtAoCwt7cXQUFBwtvbWwAQAwYM0LSZPXu2ACDq1asn1qxZI+rVqycAiLlz576qzSIiKrNt27YJQ0ND8e2334ro6Ggxffp0YWRkVGCZmZmZuH37thBCiAEDBoh27dqJAwcOiJiYGHH8+HHRsWNHzbIzZ86IPXv2iF27dok1a9YIAwMDAUDI5XLRq1cvYWpqKjZt2iScnZ3FjBkztOpJSkoScXFxmtedO3eEra2t+OSTTzRtRowYIVatWiXOnDkjLl26JMaOHSusrKzE3bt3X2pfVOtpEHK5HFZWVnj06JFmmSRJcHFxwb179wq0d3FxQVxcnNZdxG1sbJCSkoK8vDwAgKmpKXJzc5Gdna1po1AoYGhoiPT09ArcGiKil9euXTu0bNkSq1ev1iwzMTFBo0aNcPr0ac2yRo0aYdCgQfDx8cHbb7+NmzdvwtbWFgCwd+/eAsue7d/AwACRkZFo3749VCqVpq/s7GycOHFC6+jyeTt37sSQIUMQExMDd3f3Qtvk5eXBxsYGX3/9NUaPHl3mfVFtT4E+evQIarUaPj4+Wsvt7e3x4MGDQtd5+PBhgUnwSqUSarUaycnJAIAnT54UuFF2w4YNkZGRUY7VExGVv+zsbJw6dQo9evTQWpaVlYWsrCyttj169MBff/2FXbt2oXXr1li0aBFq1qyJBg0aYM6cOWjZsqXWMn9/fyQnJ+PUqVO4e/cuOnXqhKioKJw4cQI9evTAoUOHsGfPHvTt2/eFNQYHB6Nbt25Fhh8AZGRkICcnp0D4lla1uRn28yIjIwEA9evX11pubW2NhISEQtfJy8uDtbW11rL89U+cOIHu3bsDAJycnLTaODk54cKFC+VRNhFRhUlISEBeXh4cHR21lol/nqDwLEdHR8THx8PExARHjhyBsbExduzYgYSEBAwdOhQ5OTkwNTXVLJs0aRLu3r2LvLw8xMbGYvv27Th+/Dg6duyIvLw8qNVqTJw4EXPmzCmyvri4OPzxxx/YsmXLC7djzpw5qFmzJrp16/ZS+6PaBmC+5x+NVNozvmq1GsDT06n5nn/ERjU+i0xE1VBhj4wr7LdSkiSo1WpIkoQffvhB85SFhg0b4uzZs/juu+80BwRLly7F0KFDAQB169ZFRkYGPvvsMwQFBeHs2bPYsWMHfv/9dzg7O+Pjjz8utK4NGzbA2toagwYNKrL2RYsWYevWrVCpVDA2Ni7L5mtU21Og+VdvXr16VWt5cnKyVpg9Sy6XIykpSWvZjRs3ADy9mjTf/fv3tdoUdUqViKgysbe3h1wuR3x8vNYySZI0j4PL9/DhQzg6OsLZ2Rk1a9bUesRQ7dq1AUDrqLFRo0aaf1Yqlfj4448xatQojBs3DjKZDB4eHvj888+xcOFCzYHFs4QQWLduHUaNGgWFQlFo/YGBgfj888+xf/9+eHl5lWkfPKvaBqCtrS1kMhnCwsK0lickJGgd/j/LwcGhwOnRsLAwyGQyzV++iYlJgVC9cuUKTE1Ny7F6IqLyp1Ao0KpVKxw4cEBrmZGRUYEbUR84cADt27dHhw4dcP/+faSlpWk+c3FxAQCtIaOrV69qpjAIIZCRkaE5W5bfl1wuhxCi0LNmYWFhuH79Ot55551Ca1+8eDEWLFiAvXv3onXr1mXeB1pe6hrSSi5/GkSHDh1EUFCQqFGjhgAgfv75ZyGEEC4uLsLc3FzTPn8ahIODgwgKChIdOnQoMA0iICBAABANGjQQa9asEQ0aNOA0CCKqMvKnQQQHB4vo6GgxY8YMzTSI4OBgMW7cOOHp6SnMzMzErVu3RGpqqrCwsBC1atUSFy9eFGFhYcLDw0OYmZmJYcOGaZbVr19fODo6Cm9vb2FoaCgGDBggTE1NRe/evTXTIDw8PISnp6cYNWpUgbpGjhwp2rVrV2jNX375pVAoFOLnn3/WmjKRmpr6UvuiWgegEEK0bNlSABAAhCRJYtq0aZrPLCwshFwu12o/ZcoUIUmSZp3WrVsX6LNfv36azwGIgQMHVvRmEBGVm1WrVgl3d3ehUChEy5YtRVhYmGaZTCYT5ubmIiwsTNN+0KBBwtraWpiYmAhXV1cxa9YscebMGdGtWzfNsrFjxwoAYv/+/Zq+5HK5UCgUQqFQCDc3NzFp0iQxfPhw4ePjo1VPUlKSMDExEWvXri20Xnd3d63f3PzXs3MFy6JazwMkIiIqSrUdAyQiInoRBiAREeklBiAREeklBiAREeklBiAREeklBiAREeklBiAREeklBiAREeklBiDRCyiVSsyYMUPXZei8Dl1/P1FFYACS3vPz89PcxPfZ1/Xr13Vd2itXVNCFhIRgwYIFr74gogpU7Z8HSFQSvXr1wvr167WW1ahRQ0fVlL/s7OwiHzFTEi/75G2iyohHgEQAjIyM4OTkpPUq7LmRWVlZmDZtGhwcHGBsbIyOHTsiMjJS8/lvv/0Ga2trzfPOoqKiIEkSAgICNG0mTJiA4cOHF1lLeno6Ro8eDXNzczg7O2PJkiVan9euXRvLly/XWtaiRQvMmzdP816pVGLKlCmYNWsW7O3t0b17dwDA3r170bFjR1hbW8POzg79+vXTPPPSz88PYWFhWLFiheYo+NatW5r+nj0yLG4/KJVKTJs2DbNnz4atrS2cnJy06iuMWq3G559/jvr168PY2BiOjo4YNWrUC9chehkMQKJSmD17Nn755Rds3LgRp0+fRr169dCzZ088evQIANC5c2ekpqbizJkzAJ4+48ze3l7ruZQqlQo+Pj5FfkdAQABCQ0OxY8cO7N+/HyqVCqdOnSp1rRs3boSBgQGOHj2Kb775BsDTcJ01axYiIyNx8OBByGQyDB48GGq1GitWrIC3tzfGjx+PuLg4xMXFwc3NrUz7If/7zczMcPz4cSxatAiffvqp1nPonrdw4UJs2bIFa9euxZUrVxASEgKlUlnq7SYqsZd6lgRRNTBmzBghl8uFmZmZ5jVs2DAhhBA+Pj5i+vTpQggh0tLShKGhofjhhx8062ZnZwsXFxexaNEizbKWLVuKwMBAIcTTx8h89tlnQqFQiJSUFBEXFycAiEuXLhVaS2pqqlAoFGLbtm2aZYmJicLExERTh7u7u1i2bJnWes2bN9d6NIyPj49o0aJFsdv+8OFDAUCcP3++wPY+q7T7wcfHR3Ts2FGrjzZt2oj333+/yFo6deokZs+eXWzNROWFR4BEAHx9fREVFaV5ffXVVwXa3LhxAzk5OejQoYNmmaGhIdq2bYtLly5plimVSqhUKgghEB4ejoEDB6Jp06Y4cuQIQkND4ejoCE9Pz0LruHHjBrKzs+Ht7a1ZZmtri4YNG5Z6mwp7avaNGzcwYsQI1K1bF5aWlqhTpw4AIDY2tsT9lnQ/eHl5aa3n7OyMhw8fFtnvgAEDEBgYiB49emDNmjVaR5NEFYEBSATAzMwM9erV07ycnZ0LtBH/PDpTkqQCy59dplQqER4ejrNnz0Imk6Fx48bw8fFBWFhYsac/RQkezymTyQq0y8nJKXSbnte/f38kJibi22+/xfHjx3H8+HEATy+SKamS7gdDQ0OtzyVJ0oyNFsbf3x+XLl1Ct27dsHLlStSrVw8xMTElrouotBiARCVUr149KBQKHDlyRLMsJycHJ0+eRKNGjTTL8scBly9fDh8fH0iSBB8fH6hUqmIDsF69ejA0NMSxY8c0yx4/foyrV69q3teoUQNxcXGa9ykpKSUKisTERFy6dAkfffQRunbtikaNGuHx48dabRQKBfLy8splP5RFgwYNMHv2bJw+fRoZGRmIjo5+qf6IXoTTIIhKyMzMDBMnTkRAQABsbW1Rq1YtLFq0CBkZGXjnnXc07aysrNCiRQts3rwZK1asAPA0FN944w3k5OS88MIOc3NzvPPOOwgICICdnR0cHR3x4YcfQib79/9Vu3Tpgg0bNqB///6wsbHBxx9/XOgVq8+zsbGBnZ0d1q5dC2dnZ8TGxmLOnDlabWrXro3jx4/j1q1bMDc3h62trdZ3l2Y/lMaiRYvg6OiINm3aQC6X47vvvoONjQ3at29fpv6ISoIBSFQKX3zxBdRqNUaNGoXU1FS0bt0a+/btg42NjVY7X19fnD59WhN2NjY2aNy4Me7fv1/sUdLixYuRlpaGAQMGwMLCAu+99x6Sk5M1n3/wwQe4efMm+vXrBysrKyxYsKBER4AymQzbtm3DtGnT0LRpUzRs2BBfffWVViD7+/tjzJgxaNy4MZ48eYKYmBjUrl27zPuhpDIzM/H5558jNjYW5ubm6NChAw4dOlTm/ohKQhIlGXQgIiKqZjgGSEREeokBSEREeokBSEREeokBSEREeokBSEREeokBSEREeokBSEREeokBSEREeokBSEREeokBSEREeokBSEREeokBSEREeun/A/g/G6v/GKJcAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histories(off_diagonal_norm_history, steps)" + ] + } + ], + "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.ipynb b/examples/dbi/dbi.ipynb index ed2e3ba4e7..88a7e01062 100644 --- a/examples/dbi/dbi.ipynb +++ b/examples/dbi/dbi.ipynb @@ -16,10 +16,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "e1f362b8-eb73-456e-ae48-94c5f2a12649", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: seaborn in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (0.13.0)\n", + "Requirement already satisfied: numpy!=1.24.0,>=1.20 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from seaborn) (1.26.2)\n", + "Requirement already satisfied: pandas>=1.2 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from seaborn) (2.1.4)\n", + "Requirement already satisfied: matplotlib!=3.6.1,>=3.3 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from seaborn) (3.8.2)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (1.2.0)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (4.46.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (23.2)\n", + "Requirement already satisfied: pillow>=8 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (10.1.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (3.1.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from pandas>=1.2->seaborn) (2023.3.post1)\n", + "Requirement already satisfied: tzdata>=2022.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from pandas>=1.2->seaborn) (2023.3)\n", + "Requirement already satisfied: six>=1.5 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib!=3.6.1,>=3.3->seaborn) (1.16.0)\n", + "Requirement already satisfied: hyperopt in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (0.2.7)\n", + "Requirement already satisfied: numpy in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (1.26.2)\n", + "Requirement already satisfied: scipy in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (1.11.4)\n", + "Requirement already satisfied: six in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (1.16.0)\n", + "Requirement already satisfied: networkx>=2.2 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (3.2.1)\n", + "Requirement already satisfied: future in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (0.18.3)\n", + "Requirement already satisfied: tqdm in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (4.66.1)\n", + "Requirement already satisfied: cloudpickle in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (3.0.0)\n", + "Requirement already satisfied: py4j in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (0.10.9.7)\n" + ] + } + ], "source": [ "!python -m pip install seaborn # plotting library\n", "!python -m pip install hyperopt # required to optimize the DBF step" @@ -27,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "f270b1ea-ee6a-4eac-a0ff-3d7dae296cf0", "metadata": {}, "outputs": [], @@ -54,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "4aec7b46-19b9-4004-93c0-a90255e58fd9", "metadata": {}, "outputs": [], @@ -106,10 +137,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "2c4ed408-68ed-4054-825c-2a7df0979a4f", "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.3|INFO|2023-12-18 16:59:36]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# set the qibo backend (we suggest qibojit if N >= 20)\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -147,10 +197,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "26a487e9-366b-4203-b660-e3d4af2bcb68", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DoubleBracketGeneratorType.canonical\n", + "DoubleBracketGeneratorType.single_commutator\n", + "DoubleBracketGeneratorType.group_commutator\n" + ] + } + ], "source": [ "# we have a look inside the DoubleBracketGeneratorType class\n", "for generator in DoubleBracketGeneratorType:\n", @@ -159,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "da8dce89-27f6-403d-982a-58d531fade48", "metadata": {}, "outputs": [], @@ -180,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "055870ec-55f2-4b99-a622-e3aa4c7dd0e9", "metadata": {}, "outputs": [], @@ -198,10 +258,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "9e278c3d-9f34-4a40-b453-4e030c751ef5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Backend: qibojit (numba)\n" + ] + } + ], "source": [ "# on which qibo backend am I running the algorithm?\n", "print(f\"Backend: {dbf.backend}\")" @@ -209,10 +277,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "5b8e142b-a0a2-41bd-a16a-265a420b7360", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial form of the target hamiltonian:\n", + "[[-5.-0.j -3.-0.j -3.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n", + " [-3.-0.j -1.-0.j -0.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n", + " [-3.-0.j -0.-0.j -1.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n", + " ...\n", + " [-0.-0.j -0.-0.j -0.-0.j ... -1.-0.j -0.-0.j -3.-0.j]\n", + " [-0.-0.j -0.-0.j -0.-0.j ... -0.-0.j -1.-0.j -3.-0.j]\n", + " [-0.-0.j -0.-0.j -0.-0.j ... -3.-0.j -3.-0.j -5.-0.j]]\n" + ] + } + ], "source": [ "# the initial target hamiltonian is a qibo hamiltonian\n", "# thus the matrix can be accessed typing h.matrix\n", @@ -221,10 +304,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "4f9d1d41-3df7-49cf-96ca-fa1019c00c33", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# let's visualize it in a more graphical way\n", "visualize_matrix(dbf.h0.matrix, r\"$H_0$\")" @@ -232,10 +326,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "7b864712-219c-44b6-8337-19ef0100e318", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# since we didn't perform yet any evolutionary step they are the same\n", "visualize_drift(dbf.h0.matrix, dbf.h.matrix)" @@ -251,21 +356,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "da3d3aaa-17e1-492e-bcd3-b510f44a5391", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# diagonal part of the H target\n", "visualize_matrix(dbf.diagonal_h_matrix)" ] }, + { + "cell_type": "markdown", + "id": "ca0ce252", + "metadata": {}, + "source": [ + "The Hilbert-Schmidt norm of a Hamiltonian is defined as:\n", + "\n", + "$\\lang A\\rang_{HS}=\\sqrt{A^\\dagger A}$" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "24d0dfa1-7039-4d7d-8aa3-5a937b9ab0b8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HS norm of the off diagonal part of H: 37.94733192202055\n" + ] + } + ], "source": [ "# Hilbert-Schmidt norm of the off-diagonal part\n", "# which we want to bring to be close to zero\n", @@ -286,10 +420,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "95f8d86f-07d4-498c-acb1-f6f6a4614c24", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "6.708203932499369" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# define a quantum state\n", "# for example the ground state of a multi-qubit Z hamiltonian\n", @@ -312,10 +457,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "9a886261-8aa6-4df0-a31b-9c39847db124", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial value of the off-diagonal norm: 37.94733192202055\n", + "One step later off-diagonal norm: 34.179717587686405\n" + ] + } + ], "source": [ "# perform one evolution step\n", "\n", @@ -338,10 +492,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "cc74812d-7c2c-44e4-afc2-e235968801b4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "visualize_drift(dbf.h0.matrix, dbf.h.matrix)" ] @@ -356,10 +521,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "aad79966-7a11-4a45-aba5-4a4bb8315c50", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "visualize_matrix(dbf.h.matrix)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "6bdaf7f9-7e49-4a16-8b29-ae1f9746cd9b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "visualize_drift(dbf.h0.matrix, dbf.h.matrix)" ] @@ -409,7 +611,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "59a6a485-a714-4e14-b27a-1df2930068ee", "metadata": {}, "outputs": [], @@ -432,10 +634,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "7e0b2f18-ca53-4f34-9fcf-0052dcc31dc5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_histories(histories, labels)" ] @@ -450,10 +663,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "a6fd1e33-3620-4f3b-b705-a120f6da0027", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [00:00<00:00, 685.54trial/s, best loss: 28.7860881989508] \n", + "New optimized step at iteration 1/20: 0.004518769188329906\n", + "New optimized step at iteration 2/20: 0.009025775499129824\n", + "New optimized step at iteration 3/20: 0.006735227175805928\n", + "New optimized step at iteration 4/20: 0.008985994777717705\n", + "New optimized step at iteration 5/20: 0.006694566091224997\n", + "New optimized step at iteration 6/20: 0.007442596156470098\n", + "New optimized step at iteration 7/20: 0.008626256490322911\n", + "New optimized step at iteration 8/20: 0.00644190837439307\n", + "New optimized step at iteration 9/20: 0.009847781961679946\n", + "New optimized step at iteration 10/20: 0.003183204501257452\n", + "New optimized step at iteration 11/20: 0.007594562059229289\n", + "New optimized step at iteration 12/20: 0.006009602422684977\n", + "New optimized step at iteration 13/20: 0.011524210883291907\n", + "New optimized step at iteration 14/20: 0.0008441411991430689\n", + "New optimized step at iteration 15/20: 0.015716482154367724\n", + "New optimized step at iteration 16/20: 0.0019653861946552133\n", + "New optimized step at iteration 17/20: 0.002849630894901091\n", + "New optimized step at iteration 18/20: 0.006854467411576207\n", + "New optimized step at iteration 19/20: 0.0020424257684723878\n" + ] + } + ], "source": [ "# restart\n", "dbf_2 = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)\n", @@ -491,10 +731,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "0f0212bf-b642-4fea-9203-037876e0b266", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_histories(histories, labels)" ] @@ -509,31 +760,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "82b89092-07e5-4788-9ae0-8907df2428eb", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "visualize_matrix(dbf_1.h.matrix)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "ac8ed320-04a8-42af-a980-48ab4f1fff7c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAacAAAGdCAYAAAC2DrxTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxq0lEQVR4nO3df3RV1Z3//9flRy5Bk9So+SUhpgNUBaQWFMFfYCVjqgyInaJ2HLSjXxnAKZN2VKTV1FZi7ZIPXaXSYrsQlyL8UWFYlSLpAKEuSgcQhEW7LBlCiUomI8UEk3BDcvf3j5hbLwlkX84O95yb58N11vKeu7PvPvcQ3ux99n7vkDHGCAAAH+mX7AYAAHA6ghMAwHcITgAA3yE4AQB8h+AEAPAdghMAwHcITgAA3yE4AQB8Z0CyGwAASNzJkyfV2trqpK60tDQNGjTISV2uEJwAIGBOnjyp4uI81dU1OKkvLy9PNTU1vgpQBCcACJjW1lbV1TXo0F/+nzIz0z3V1djYos8X/btaW1sJTgAA7zIz0z0HJ78iOAFAQBnTJmPaPNfhRwQnAAgoY9plTLvnOvyIqeQAAN+h5wQAARU1bYp6HJbz+vO9heAEAAGVys+cGNYDAPgOPScACKiOCRFee07+nBBBcAKAgDLRNpmox+Dk8ed7C8N6AADfoecEAEFl2joOr3X4EMEJAAKK2XoAAJxH9JwAIKiibVL0lPc6fIjgBAAB1TGs199zHX7EsB4AwHfoOQFAUEXbpKi3nhPDegAAt1I4ODGsBwDwHXpOABBY7Q4W0ZJbDwDgUCjaplDU2wBYiGE9AADs0HMCgKCKtkkee05+nRBBcAKAoErh4MSwHgDAd+g5AUBAhUybQsbjhAifpi8iOAFAUEWjUtTjVPBo1E1bHGNYDwDgO/ScACCgOtY5hTzX4UcEJwAIqmi7g9l6/swQwbAeAMB36DkBQFBF2ySPw3p+XedEcAKAgApF2x3k1mNYDwAAK77rOUWjUX344YfKyMhQKOSxuwoAPmCM0YkTJ1RQUKB+/Rz2CYyDCREmsZ7Ttm3b9KMf/Ui7d+/W0aNHtXbtWk2fPl2SdOrUKX3nO9/Rhg0bdOjQIWVlZem2227Tc889p4KCgoQ+x3fB6cMPP1RhYWGymwEAztXW1mrIkCHO6gtFo56H5UIJLsJtamrSmDFj9OCDD+ruu++Oe6+5uVnvvPOOvvvd72rMmDE6fvy45s+fr3/4h3/Qrl27EvqcXgtOL774on70ox/p6NGjGjlypJYsWaKbbrqpx5/LyMiQJB0+8mNlZqaftWz252Y7aSsAeHFF+rSzvt9uTungyV/H/n4LstLSUpWWlnb7XlZWliorK+PO/eQnP9F1112nI0eOaOjQodaf0yvBac2aNZo/f75efPFF3XDDDfr5z3+u0tJS/fGPf+yxcZ1DeZmZ6crMHNzDJzHsByD5+ocGWpVz/qgi2u5gtl5Hz6uxsTHudDgcVjgc9la3pIaGBoVCIX3uc59L6Od6ZULE4sWL9S//8i966KGHdOWVV2rJkiUqLCzUsmXLeuPjAKBP6pit5/2QpMLCQmVlZcWOiooKz+07efKknnjiCd13333KzMxM6Ged95xaW1u1e/duPfHEE3HnS0pKtH379i7lI5GIIpFI7PXp0RsA0Ptqa2vjAojXXtOpU6d0zz33KBqN6sUXX0z4550Hp48++kjt7e3Kzc2NO5+bm6u6urou5SsqKvS9733PdTMAIPU5HNbLzMxMuHdzJqdOndLXvvY11dTUaPPmzedUb6+tczp9bNUY0+1464IFC9TQ0BA7amtre6tJAJBSXA7rudIZmA4ePKjf/va3uvjii8+pHuc9p0suuUT9+/fv0kuqr6/v0puS3D10AwD0vk8++UTV1dWx1zU1Ndq7d6+ys7NVUFCgr371q3rnnXf061//Wu3t7bFYkJ2drbS0NOvPcd5zSktL09ixY7tMJ6ysrNTEiRNdfxwA9F3RdjdHAnbt2qVrrrlG11xzjSSprKxM11xzjZ566im9//77Wr9+vd5//3198YtfVH5+fuzobs7B2fTKVPKysjLdf//9GjdunCZMmKDly5fryJEjmj2bdUkA4EooahJeRNtdHYmYNGmSjDnzz5ztvUT0SnCaOXOmjh07pmeeeUZHjx7VqFGjtGHDBhUVFVnX0bHA9uwP+ianP9RjPX+I/tbq8woGjLQqV930plU5G+lpdgvSQiG7Dm5z5LCH1gSH7fdmw/a7TcafDz/z859dl38+JCnSdrzHMgeaf9VDCTd/YfclvZYhYs6cOZozZ05vVQ8AiLZL3jpOvt1s0He59QAAloyD4JRg4tfzhS0zAAC+Q88JAAIqZKIKGW+LcEPGa9erdxCcACCoUviZE8N6AADfoecEAEEVjTrIrcewHgDAJYKTP9kssB3f7zarump11Krc4PDlVuVsFhVeNnC0VV2psLDTZmFkS+sRq7qSsbDzA8cPjW3+HPl5UbXtvXK5IDYZi2slKTzgoh7LtLSe8NocnCbQwQkA+rJQNKqQx383eU1/1FsITgAQVNGog9l6/gxOzNYDAPgOPScACKoU7jkRnAAgqFI4ODGsBwDwHXpOABBUpl1KcLPArnX4s+dEcAKAgErlqeQM6wEAfCfQPSebrbNtMz8URvOtyn1g9luVs2Gb+WHYBXc4rS/obDMn2GRhMJZDGrYZEWzZ/Nmt9nGGCNtsDS6/N9vMICdPHbMqZ5P5wfdSeEJEoIMTAPRpKRycGNYDAPgOPScACKqo8d7z8Trbr5cQnAAgqKLGwbCeP4MTw3oAAN+h5wQAQeVks0F/9pwITgAQVCkcnBjWAwD4Dj0nAAiqFJ4QEejgZJMRwSZLgGSf+eH6/iVW5bboFz2Wsc388GHbAatyNtdqm13BtcsGju6xTLXjLAzJulYbH5xyl2nENdvsDy7rsskkYZv5YdDAi63KJSs7iFMmKhmPw3rGn8GJYT0AgO8EuucEAH2acTCs59OeE8EJAIIqhZ85MawHAPAdek4AEFQp3HMiOAFAQJmo913WfbpLO8N6AAD/oecEAEHFsF5wuV6IabO4VpKqp1/XY5lh687/tuq2i5JtFyjaslkwnQrb0btcdGp7r2y2fJfsF/4mY9Fp9uAxPZb5a/O7VnU1R054bU5wROUgOLloiHvOh/XKy8sVCoXijry8PNcfAwBIYb3Scxo5cqR++9vfxl7379+/Nz4GAPq2FO459UpwGjBgAL0lAOht5tPDax0+1Cuz9Q4ePKiCggIVFxfrnnvu0aFDh85YNhKJqLGxMe4AAPRtzoPT+PHj9corr+itt97SSy+9pLq6Ok2cOFHHjnWfUbiiokJZWVmxo7Cw0HWTACAlmWjIyeFHzoNTaWmp7r77bo0ePVq33Xab3nyzY2bVypUruy2/YMECNTQ0xI7a2lrXTQKA1BR1dPhQr08lv+CCCzR69GgdPHiw2/fD4bDC4XBvNwMAECC9niEiEonoT3/6k/Lz83v7owCgbzEhKerx8LpZYS9xHpy+/e1vq6qqSjU1NfrDH/6gr371q2psbNSsWbNcfxQA9GnJeOa0bds2TZ06VQUFBQqFQlq3bl18m4xReXm5CgoKlJ6erkmTJunAAbvdvD/L+bDe+++/r3vvvVcfffSRLr30Ul1//fXasWOHioqKXH+U1Wp8m+3BJfusA7ZZDGyyP0xOf8iqrtp+R63K2WQA8PPW5a7vgctMEi4zP9iyvVfVju+pTWYK2wwikbbjVuVssj+4vge29YVCPf8b3s+/V641NTVpzJgxevDBB3X33Xd3ef/555/X4sWL9fLLL2vEiBH6wQ9+oClTpui9995TRkaG9ec4D06rV692XSUAoDudQ3Oe6kiseGlpqUpLS7t9zxijJUuWaOHChZoxY4akjslwubm5WrVqlR555BHrzyErOQAElQm5OaQu600jkUjCzampqVFdXZ1KSkpi58LhsG655RZt3749oboITgAAFRYWxq05raioSLiOuro6SVJubm7c+dzc3Nh7tlI+KzkApCoXi2g7Hx/W1tYqMzMzdt7LEp9QKL5Nxpgu53pCcAKAoIr2c/DMqSO5XmZmZlxwOhedOVXr6urilg/V19d36U31hGE9AIATxcXFysvLU2VlZexca2urqqqqNHHixITqoucEAEGVhNl6n3zyiaqrq2Ova2pqtHfvXmVnZ2vo0KGaP3++Fi1apOHDh2v48OFatGiRBg8erPvuuy+hzyE4AUBAGROS8ZjhwSS4ZcauXbs0efLk2OuysjJJ0qxZs/Tyyy/rscceU0tLi+bMmaPjx49r/Pjx2rRpU0JrnCSCEwAgAZMmTZI5S0QLhUIqLy9XeXm5p88JdHCyWbntOuvAh22Jp+E4E9vMD4VRu7yEH6jnDBGpwOU9tcmqIbnN/OB3BQNG9ljmUMs2q7rCAy6yKtfSesKqnI1kZZJICocTIvwm0MEJAPoyE5WDqeT+DE7M1gMA+A49JwAIKuNgtp5Pt8wgOAFAQLmZrefP4MSwHgDAd+g5AUBQRft1HJ7qcNMU1whOABBQbhK/MqwHAICVQPecXG6NbLuw02YLa1u2C0BtF9de37+kxzJb9AurulyzWRDr+h7YfL82C7ml5CzsTNbCX5sFtp9Pv9mqLpeL1m25/t78vAA7lSdEBDo4AUCflsLPnBjWAwD4Dj0nAAioVJ4QQXACgIBK5WdODOsBAHyHnhMABFUKT4ggOAFAQKXyMyeG9QAAvkPPCQACKpUnRBCcEmSblcImi4HLDBeSXfaH6unXWdV19W/qrcrZbOkt2WV/sMkiYVtXsrjMJOF6e/B0yy3T/9r8bo9lXN8DP2fM8DXj4JmTPzfCZVgPAOA/9JwAIKBSeUIEwQkAAsoY78+MDMN6AADYoecEAEHlYFhPDOsBAFwypp+M8TYAZnw6rsewHgDAd+g5AUBQRUPeh+UY1gMAuESGCCTMGH+m+rXN/LCvNMeq3O2VXloT74NT+91VliSh0PkfKbfN/NDSdryXW3LuLhs4uscy1WSI6FMS/k3atm2bpk6dqoKCAoVCIa1bty7ufWOMysvLVVBQoPT0dE2aNEkHDhxw1V4AwKc6F+F6Pfwo4eDU1NSkMWPGaOnSpd2+//zzz2vx4sVaunSpdu7cqby8PE2ZMkUnTpzw3FgAwN90ztbzevhRwsN6paWlKi0t7fY9Y4yWLFmihQsXasaMGZKklStXKjc3V6tWrdIjjzzirbUAgD7BacisqalRXV2dSkpKYufC4bBuueUWbd++vdufiUQiamxsjDsAAD1jWM9SXV2dJCk3NzfufG5ubuy901VUVCgrKyt2FBYWumwSAKSsztl6Xg8/6pXBxlAo/mKNMV3OdVqwYIEaGhpiR21tbW80CQAQIE6nkufl5Unq6EHl5+fHztfX13fpTXUKh8MKh8MumwEAfUIqr3Ny2nMqLi5WXl6eKiv/tviltbVVVVVVmjhxosuPAoA+zxgHz5x8GpwS7jl98sknqq6ujr2uqanR3r17lZ2draFDh2r+/PlatGiRhg8fruHDh2vRokUaPHiw7rvvPqcNBwCkroSD065duzR58uTY67KyMknSrFmz9PLLL+uxxx5TS0uL5syZo+PHj2v8+PHatGmTMjIy3LUa56xgwEircraZHzZO+T+rcsPW9VwmGdkVXHOZGSQVMj/Y+rCNhfrnIpWzkiccnCZNmnTWiwmFQiovL1d5ebmXdgEAepDK27QH/5+qAICUQ+JXAAioVJ6tR3ACgIBK5eDEsB4AwHfoOQFAQJmo9wkNPt16jp4TAARVMnLrtbW16Tvf+Y6Ki4uVnp6uz3/+83rmmWcUjbqNcvScAADWfvjDH+pnP/uZVq5cqZEjR2rXrl168MEHlZWVpW9+85vOPiflg1N62lCn9dlsJy1J1U1vOv1cG8MuuKPHMq7bZbO4VpImpz/UY5ktLb+w+0yL65TsFna6XDQrSS2WW4n369fzovS/Nr/rtTnnxOZ3xvY6bTVHDvdYxvZ32fZ31Hbhr03bksXNItzEfv73v/+9pk2bpjvu6Pg9vPzyy/X6669r165dntpxOob1ACCgoibk5JDUZV+9SCTS7WfeeOON+q//+i/9+c9/liS9++67evvtt/WVr3zF6bWlfM8JANCz0/fSe/rpp7vN9PP444+roaFBV1xxhfr376/29nY9++yzuvfee522h+AEAEHlYifbT3++trZWmZmZsdNn2spozZo1evXVV7Vq1SqNHDlSe/fu1fz581VQUKBZs2Z5a8tnEJwAIKBcLsLNzMyMC05n8h//8R964okndM8990iSRo8erb/85S+qqKhwGpx45gQAsNbc3Kx+/eJDR//+/ZlKDgDokIz0RVOnTtWzzz6roUOHauTIkdqzZ48WL16sb3zjG57acTqCEwAEVDKC009+8hN997vf1Zw5c1RfX6+CggI98sgjeuqppzy143QEJwCAtYyMDC1ZskRLlizp1c8hOAFAQEVNP0U9LsL1+vO9JeWDk+uV7NWW9SUjW4NNfbbZFT44td+qnO3W6jbZH6qnX2dV17B15z/7hq3swWOsytlkf7DNiGB7D2yzYbj+nbHhMiuF7e9oKjDGwU64bJkBAICdlO85AUCqSuXNBglOABBQqRycGNYDAPgOPScACKjPZhX3UocfEZwAIKAY1gMA4Dyi5wQAAZXKPSeCEwAEFM+cfMpmVbnt6vnmyGGPrYnnMluDbSaJweHLndXlms212mZ+mJz+kFW52n5Heyxjmwkj0nbcqpxN5gfJbUYE11y2zTbLhV+zUkjSZQNH91gmWb9XqSzQwQkA+jJjvA/LGeOoMY4RnAAgoFL5mROz9QAAvkPPCQACyjiYEOHXnhPBCQACimE9AADOI3pOABBQqdxzIjgBQECxCDfAbBfX2ixgTaQ+G7YL91xvrZ4MH7YdcFaXzeJaSSqM5vdY5lDbNqu6wgMusirX0nrCqpyf2SxcT4XFtbZt+9ByIT/cSvhb37Ztm6ZOnaqCggKFQiGtW7cu7v0HHnhAoVAo7rj++utdtRcA8KnOYT2vhx8lHJyampo0ZswYLV269Ixlbr/9dh09ejR2bNiwwVMjAQBddQ7reT38KOFhvdLSUpWWlp61TDgcVl5e3jk3CgDQt/XKYOrWrVuVk5OjESNG6OGHH1Z9ff0Zy0YiETU2NsYdAICeGYWcHH7kPDiVlpbqtdde0+bNm/XCCy9o586duvXWWxWJRLotX1FRoaysrNhRWFjoukkAkJJS+ZmT89l6M2fOjP3/qFGjNG7cOBUVFenNN9/UjBkzupRfsGCBysrKYq8bGxsJUADQx/X6VPL8/HwVFRXp4MGD3b4fDocVDod7uxkAkHJY5+TBsWPHVFtbq/z8ntecAADskSHiMz755BNVV1fHXtfU1Gjv3r3Kzs5Wdna2ysvLdffddys/P1+HDx/Wk08+qUsuuUR33XWX04YDAFJXwsFp165dmjx5cux15/OiWbNmadmyZdq/f79eeeUVffzxx8rPz9fkyZO1Zs0aZWRkuGv1p2y3YLdhTNRZXa7ZZn5w+X245vL7tf0+bLI/3BKe2WMZyT4rRbVl1oGg3yubrcsl++/DJdffrZ//bojKwbCeT2frJRycJk2aJHOWfX3feustTw0CACDlc+sBQKrimRMAwHeiCnkelvPrsJ5/B74BAH0WPScACCoXGR4Y1gMAuJTKi3AZ1gMA+A49JwAIKGbrAQB8J/rp4bUOPwp0cCoYMLLHMh9Yru5uScJK9vS0oVblbNtmW1/QRdqOW5ULD7ioxzK2mR8Ko3a5Iat7LiLJ7s9udeSwZW1u2WRYqG5606quYRfcYVXOtj4bzZbf2+Dw5Vbl/JwhIpUFOjgBQF/GsB4AwHeixvtsu+iZs9ElFbP1AAC+Q88JAALKKCTjMf2Q15/vLQQnAAgoFuECAPCpDz74QP/0T/+kiy++WIMHD9YXv/hF7d692+ln0HMCgIDqmBDhvY5EHD9+XDfccIMmT56s3/zmN8rJydH//M//6HOf+5y3hpyG4AQAAZWMZ04//OEPVVhYqBUrVsTOXX755Z7a0J1AByeXC/dcs1kQ63rhr019tgt1bbe6tl2gaNO27MFjrOr6a/O7lp95oscyttuI2y6urZ5+nVW5Yet6/rPrepGo9dbqDn+vXC7Wdf37brtYt69obGyMex0OhxUOh7uUW79+vf7+7/9e//iP/6iqqipddtllmjNnjh5++GGn7eGZEwAEVOeECK+HJBUWFiorKyt2VFRUdPuZhw4d0rJlyzR8+HC99dZbmj17tv7t3/5Nr7zyitNrC3TPCQD6MmM6Dq91SFJtba0yMzNj57vrNUlSNBrVuHHjtGjRIknSNddcowMHDmjZsmX653/+Z2+N+Qx6TgAAZWZmxh1nCk75+fm66qqr4s5deeWVOnLE7WMKek4AEFBGIUXP84SIG264Qe+9917cuT//+c8qKiry1I7TEZwAIKCSkfj13//93zVx4kQtWrRIX/va1/Tf//3fWr58uZYvX+6pHadjWA8AYO3aa6/V2rVr9frrr2vUqFH6/ve/ryVLlujrX/+608+h5wQAAZWs9EV33nmn7rzzTk+f2xOCEwAElPn08FqHHzGsBwDwnZTvOdmusrfZNluSPji136qcX7d9T0a7JKlfv4wey9hmfnC5Hb1tJgzbPx82mR8kaXL6Qz2W2dLyC6u6bNlmw0hGtgab+my3fLf9HbWVrN8ZG6mclTzlgxMApKrop4fXOvyIYT0AgO/QcwKAgErGOqfzheAEAAGVys+cGNYDAPgOPScACKhUXudEcAKAgGJYDwCA84ieEwAEVCqvc0r54NQcOWxVrtqynC2bzBS2bbNls5LdZXYFSUofcJFVOZvsD7ZtS8aKfds/H7YZSWyyP1RPv86qrtsrL7UqZ8t19gcbNvc+Ge3yu1SeSp7QsF5FRYWuvfZaZWRkKCcnR9OnT++y6ZQxRuXl5SooKFB6eromTZqkAwcOOG00ACC1JRScqqqqNHfuXO3YsUOVlZVqa2tTSUmJmpqaYmWef/55LV68WEuXLtXOnTuVl5enKVOm6MSJE84bDwB9mdHfhvbO9UiJ2XobN26Me71ixQrl5ORo9+7duvnmm2WM0ZIlS7Rw4ULNmDFDkrRy5Url5uZq1apVeuSRR9y1HAD6OCMHw3oet3nvLZ5m6zU0NEiSsrOzJUk1NTWqq6tTSUlJrEw4HNYtt9yi7du3d1tHJBJRY2Nj3AEA6NvOOTgZY1RWVqYbb7xRo0aNkiTV1dVJknJzc+PK5ubmxt47XUVFhbKysmJHYWHhuTYJAPqUqHFz+NE5B6d58+Zp3759ev3117u8FwrFdxONMV3OdVqwYIEaGhpiR21t7bk2CQD6FOPo8KNzmkr+6KOPav369dq2bZuGDBkSO5+XlyepoweVn58fO19fX9+lN9UpHA4rHA6fSzMAACkqoZ6TMUbz5s3TG2+8oc2bN6u4uDju/eLiYuXl5amysjJ2rrW1VVVVVZo4caKbFgMAJP0tfZHXw48S6jnNnTtXq1at0n/+538qIyMj9hwpKytL6enpCoVCmj9/vhYtWqThw4dr+PDhWrRokQYPHqz77ruvVy7Ar2y29Xa98Ncl28W1LW3HnX2m7ZbpfmaMu/X2totrN075P6tyV/+m3ktz4ENkiPjUsmXLJEmTJk2KO79ixQo98MADkqTHHntMLS0tmjNnjo4fP67x48dr06ZNysjIcNJgAEDqSyg4GdPzo7NQKKTy8nKVl5efa5sAABZSOX1RyufWA4BUlcrDesEf5AcApBx6TgAQUMZ0HF7r8COCEwAEVFQhRT3mxvP6872FYT0AgO/QcwKAgHKRG8+vufUITgAQVA6eOfk1uR7BqZd8cGp/spvQrWRkfrDlMrtCslw2cLRVuWqHW83bZn7YV5pjVW7YusMeWnNuUiE7CNwiOAFAQKXyhAiCEwAEVCpPJacvDQDwHXpOABBQqZy+iOAEAAGVylPJGdYDAPgOPScACCgj78uUfNpxIjgBQFB1DOt5nEru0+jEsB4AwHfoOSUoPW2oVbkWiwwAg8OXW9VVMGCkVblDLdt6LPPX5net6nLN5nuz+c5s65Lssg7YZqWwzWBQ3fSmVblhF9zhrC5btpkfJqc/1GOZHe2bPLYmXnPkcI9lbH9fbOpKFam8zongBAABlcpTyRnWAwD4Dj0nAAgohvUAAL7DsB4AAOcRwQkAAsqYv6UwOtfD67BeRUWFQqGQ5s+f7+SaOjGsBwABlewMETt37tTy5ct19dVXe2xFV/ScAAAJ++STT/T1r39dL730ki66yG6H7UQEuueUjIWdLtkuALVZXCtJn0+/uccyrhd22rK9Dy7rsrmn1tuqO/7eknUfbNgssL2+f4lVXbX9jlqVc7ltvc0CZ8n+Htgs/k3Wwl+XWckbGxvjzofDYYXD4TP+3Ny5c3XHHXfotttu0w9+8ANvjegGPScACKjOqeReD0kqLCxUVlZW7KioqDjj565evVrvvPPOWct4FeieEwDAjdraWmVmZsZen6nXVFtbq29+85vatGmTBg0a1GvtITgBQEC5XOeUmZkZF5zOZPfu3aqvr9fYsWNj59rb27Vt2zYtXbpUkUhE/fv399gqghMABFYydsL98pe/rP3798ede/DBB3XFFVfo8ccfdxKYJIITACABGRkZGjVqVNy5Cy64QBdffHGX814QnAAgoJK9zqk3EZwAIKCSMazXna1bt3qv5DRMJQcA+A49JwAIKLbM8CmbrbNdbqueSH02Im3HrcqFB9ilBvmw7YCX5gSGy3tqm5nAddaBoLPN/FAYzbcqV21RpmDASLu6LO+B7T394NT+ngslCVtmfKqiokLXXnutMjIylJOTo+nTp+u9996LK/PAAw8oFArFHddff73TRgMAUltCwamqqkpz587Vjh07VFlZqba2NpWUlKipqSmu3O23366jR4/Gjg0bNjhtNADg056T120zkn0RZ5DQsN7GjRvjXq9YsUI5OTnavXu3br75b0lHw+Gw8vLy3LQQANCtVJ5K7mm2XkNDgyQpOzs77vzWrVuVk5OjESNG6OGHH1Z9ff0Z64hEImpsbIw7AAB92zkHJ2OMysrKdOONN8atCi4tLdVrr72mzZs364UXXtDOnTt16623KhKJdFtPRUVFXCbcwsLCc20SAPQpftgJt7ec82y9efPmad++fXr77bfjzs+cOTP2/6NGjdK4ceNUVFSkN998UzNmzOhSz4IFC1RWVhZ73djYSIACAAvGOBjWS6Xg9Oijj2r9+vXatm2bhgwZctay+fn5Kioq0sGDB7t9v6cNrQAAfU9CwckYo0cffVRr167V1q1bVVxc3OPPHDt2TLW1tcrPt1vvAACwwzqnT82dO1evvvqqVq1apYyMDNXV1amurk4tLS2SOvaU//a3v63f//73Onz4sLZu3aqpU6fqkksu0V133dUrFwAAfVXHcyPj8Uj2VXQvZIz9iGMoFOr2/IoVK/TAAw+opaVF06dP1549e/Txxx8rPz9fkydP1ve//33r50iNjY3KyspSR9zs/vOCIHvwmB7L/LX53fPQkni22RUuGzjaqpxtVormyOEey7jO5pEMLjNJuMxGItllVJHs7pVr1dOv67HMsHX/fR5a0luMpKgaGhqsNvTrSeffk9MzH9HAUJqnuk6ZVq1r/LmztrmS8LDe2aSnp+utt97y1CAAgJ1UXucU6Nx6ANCXucjw4NdhPbbMAAD4Dj0nAAgo8+l/XuvwI4ITAAQUw3oAAJxH9JwAIKBSeREuwQkAAsoYB8+cfJpcj2E9AIDvpHzPyXaVve3q+ZOnjlmVs8n+4DoDgA3b7ArVjrMw2FyrnzM/2LLJ/CDZZZKwrcu1weHLndVVMGCkVblh63q+1snpD1nVtaN9k1U5P2fMsMWwHgDAdxjWAwDgPKLnBAAB1ZFO1nsdfkRwAoCAihqjqMfwEmVYDwAAO/ScACCgyK0HAPCdVJ5KzrAeAMB3At1zcrmI1XZx7aCBF1uVa46c6LGM7aLTVNi+3Gbb92Qs/E3WQswPTu13Wp9LNtfqcjt6W7aLa6/vX2JVrrbfUbsPtlhInKwF01E5mBDBsB4AwCVm6wEAcB7RcwKAgGK2HgDAd1L5mRPDegAA36HnBAABlco9J4ITAARUKj9zYlgPAOA79JwAIKCMg2E9v/acUj44RdqOW5ULD7jIqpwx7jJRpULmB1sfth1wVlcyvjfbrcv9vKW3Sy63o7etzzabh23mh8JovlW5P0R/a1UuGaKhqEIhb38nRX2aXY9hPQCA76R8zwkAUlVURiFm6wEA/MR8Opncax1+xLAeAMB3CE4AEFAdmw0aj0diKioqdO211yojI0M5OTmaPn263nvvPefXRnACgICKhqJOjkRUVVVp7ty52rFjhyorK9XW1qaSkhI1NTU5vTaeOQEArG3cuDHu9YoVK5STk6Pdu3fr5ptvdvY5BCcACKioogp5nNDQuc6psbEx7nw4HFY4HO7x5xsaGiRJ2dnZntpxOob1ACCgoo7+k6TCwkJlZWXFjoqKih4/3xijsrIy3XjjjRo1apTTa0uo57Rs2TItW7ZMhw8fliSNHDlSTz31lEpLS2MN/d73vqfly5fr+PHjGj9+vH76059q5MiRThvdySb7g23mB1susw7YrnhPhUwSLjMnXDZwtFW5Dy2+X9uMHy4zg0j+vlc2bDNmfHBqv7PPtP4zNMDu7xvbzA/j+93WY5kt+oVVXX5WW1urzMzM2GubXtO8efO0b98+vf32287bk1DPaciQIXruuee0a9cu7dq1S7feequmTZumAwc6UtM8//zzWrx4sZYuXaqdO3cqLy9PU6ZM0YkTJ5w3HAD6Oq/z9D47Xy8zMzPu6Ck4Pfroo1q/fr22bNmiIUOGOL+2hILT1KlT9ZWvfEUjRozQiBEj9Oyzz+rCCy/Ujh07ZIzRkiVLtHDhQs2YMUOjRo3SypUr1dzcrFWrVjlvOAD0dcmYrWeM0bx58/TGG29o8+bNKi4u7pVrO+dnTu3t7Vq9erWampo0YcIE1dTUqK6uTiUlJbEy4XBYt9xyi7Zv337GeiKRiBobG+MOAIA/zZ07V6+++qpWrVqljIwM1dXVqa6uTi0tLU4/J+HgtH//fl144YUKh8OaPXu21q5dq6uuukp1dXWSpNzc3Ljyubm5sfe6U1FREfcQrrCwMNEmAUCfZBxMhkh0Ge6yZcvU0NCgSZMmKT8/P3asWbPG6bUlPJX8C1/4gvbu3auPP/5Yv/rVrzRr1ixVVVXF3g+FQnHljTFdzn3WggULVFZWFnvd2NhIgAIAC0btMh4nXRu1J1benJ9EsQkHp7S0NA0bNkySNG7cOO3cuVM//vGP9fjjj0uS6urqlJ//t31S6uvru/SmPst2Lj0AoO/wvM7JGKNIJKLi4mLl5eWpsrIy9l5ra6uqqqo0ceJErx8DADiNy3VOfpNQz+nJJ59UaWmpCgsLdeLECa1evVpbt27Vxo0bFQqFNH/+fC1atEjDhw/X8OHDtWjRIg0ePFj33Xdfb7UfAPqsjr2YvGaISIH9nP73f/9X999/v44ePaqsrCxdffXV2rhxo6ZMmSJJeuyxx9TS0qI5c+bEFuFu2rRJGRkZCTfsivRp6h8aeNYyB5p/1WM9La3+XWPVV7b0ds12i3D0Hj//2XX958NmgW1bdOVZ329sbFb25/4/V03qExIKTr/85S/P+n4oFFJ5ebnKy8u9tAkAYKFjQsSZJ5zZ1uFHJH4FgIDqeF7kJvGr35D4FQDgO/ScACCgzm0v2651+BHBCQACKqp2yeMzp6hPnzkxrAcA8B16TgAQUAzrAQB8J2ocDOsZfw7r+S44dSYVbDenbEr3bmMAwEJjY3MP73dsJ3G+kqamAt8Fp85dcw+e/HWSWwIAdmyzP5w4cUJZWVnOPpdhvfOooKBAtbW1ysjIiG210bmNxul73AdJ0K8h6O2Xgn8NQW+/FPxrONf2G2N04sQJFRQUOG1PR3DyNixHcLLUr1+/M+5H37m3fZAF/RqC3n4p+NcQ9PZLwb+Gc2m/yx5TX+C74AQAsGNMVFGvufUMPScAgEMdQ3JeE7/6MzgFYhFuOBzW008/Hegdc4N+DUFvvxT8awh6+6XgX0PQ2x8kIcPcRgAIlMbGRmVlZSlr0FUKhfp7qsuYdjWc/KMaGhp89RyQYT0ACKiOJ04M6wEAcF7QcwKAgOqYacdsPQCAj7jYYt2v27QHYljvxRdfVHFxsQYNGqSxY8fqd7/7XbKbZKW8vFyhUCjuyMvLS3azzmrbtm2aOnWqCgoKFAqFtG7durj3jTEqLy9XQUGB0tPTNWnSJB04cCA5je1GT+1/4IEHutyT66+/PjmN7UZFRYWuvfZaZWRkKCcnR9OnT9d7770XV8bv98DmGvx8H5YtW6arr746ttB2woQJ+s1vfhN73+/ff6rwfXBas2aN5s+fr4ULF2rPnj266aabVFpaqiNHjiS7aVZGjhypo0ePxo79+/cnu0ln1dTUpDFjxmjp0qXdvv/8889r8eLFWrp0qXbu3Km8vDxNmTIllhMx2XpqvyTdfvvtcfdkw4YN57GFZ1dVVaW5c+dqx44dqqysVFtbm0pKStTU1BQr4/d7YHMNkn/vw5AhQ/Tcc89p165d2rVrl2699VZNmzYtFoD89P0bY2RM1OPh0wnbxueuu+46M3v27LhzV1xxhXniiSeS1CJ7Tz/9tBkzZkyym3HOJJm1a9fGXkejUZOXl2eee+652LmTJ0+arKws87Of/SwJLTy709tvjDGzZs0y06ZNS0p7zkV9fb2RZKqqqowxwbsHxnS9BmOCdx8uuugi84tf/MI3339DQ4ORZNLTLjeDw5/3dKSnXW4kmYaGhvPWfhu+7jm1trZq9+7dKikpiTtfUlKi7du3J6lViTl48KAKCgpUXFyse+65R4cOHUp2k85ZTU2N6urq4u5HOBzWLbfcEpj7IUlbt25VTk6ORowYoYcfflj19fXJbtIZNTQ0SJKys7MlBfMenH4NnYJwH9rb27V69Wo1NTVpwoQJgfz+g8rXwemjjz5Se3u7cnNz487n5uaqrq4uSa2yN378eL3yyit666239NJLL6murk4TJ07UsWPHkt20c9L5nQf1fkhSaWmpXnvtNW3evFkvvPCCdu7cqVtvvVWRSCTZTevCGKOysjLdeOONGjVqlKTg3YPurkHy/33Yv3+/LrzwQoXDYc2ePVtr167VVVdd5bvv35h2J4cfBWK2XufWGZ2MMV3O+VFpaWns/0ePHq0JEybo7/7u77Ry5UqVlZUlsWXeBPV+SNLMmTNj/z9q1CiNGzdORUVFevPNNzVjxowktqyrefPmad++fXr77be7vBeUe3Cma/D7ffjCF76gvXv36uOPP9avfvUrzZo1S1VVVbH3/fL9u5gG7tep5L7uOV1yySXq379/l3+R1NfXd/mXSxBccMEFGj16tA4ePJjsppyTzpmGqXI/JCk/P19FRUW+uyePPvqo1q9fry1btsRtIROke3Cma+iO3+5DWlqahg0bpnHjxqmiokJjxozRj3/840B9/0Hn6+CUlpamsWPHqrKyMu58ZWWlJk6cmKRWnbtIJKI//elPys/PT3ZTzklxcbHy8vLi7kdra6uqqqoCeT8k6dixY6qtrfXNPTHGaN68eXrjjTe0efNmFRcXx70fhHvQ0zV0x2/34XTGGEUiEd99/5074Xo9fClpUzEsrV692gwcOND88pe/NH/84x/N/PnzzQUXXGAOHz6c7Kb16Fvf+pbZunWrOXTokNmxY4e58847TUZGhq/bfuLECbNnzx6zZ88eI8ksXrzY7Nmzx/zlL38xxhjz3HPPmaysLPPGG2+Y/fv3m3vvvdfk5+ebxsbGJLe8w9naf+LECfOtb33LbN++3dTU1JgtW7aYCRMmmMsuu8w37f/Xf/1Xk5WVZbZu3WqOHj0aO5qbm2Nl/H4PeroGv9+HBQsWmG3btpmamhqzb98+8+STT5p+/fqZTZs2GWP88f13ztYb2D/XpA3I93QM7J/ry9l6vg9Oxhjz05/+1BQVFZm0tDTzpS99KW5Kqp/NnDnT5Ofnm4EDB5qCggIzY8YMc+DAgWQ366y2bNliJHU5Zs2aZYzpmMr89NNPm7y8PBMOh83NN99s9u/fn9xGf8bZ2t/c3GxKSkrMpZdeagYOHGiGDh1qZs2aZY4cOZLsZsd013ZJZsWKFbEyfr8HPV2D3+/DN77xjdjfN5deeqn58pe/HAtMxvjj++8LwYktMwAgYDq3zBjQ/1KFQt6ezhgTVVv7/7FlBgDAjY5p4N76F8zWAwDAEj0nAAgsI3mebefPJzsEJwAIKDf7OfkzODGsBwDwHXpOABBQHQtoPfacGNYDALjlPTj59ZkTw3oAAN+h5wQAQeVgQoR8OiGC4AQAAZXKz5wY1gMA+A7BCQACK+roSNyLL76o4uJiDRo0SGPHjtXvfvc7b5dyGoITAASW6Xhm5OU4h2G9NWvWaP78+Vq4cKH27Nmjm266SaWlpTpy5IizKyMrOQAETGdWcmmAQk6eObUllJV8/Pjx+tKXvqRly5bFzl155ZWaPn26KioqPLWnEz0nAAgs4/m/RHtOra2t2r17t0pKSuLOl5SUaPv27c6ujNl6ABBobga/Ghsb416Hw2GFw+Eu5T766CO1t7crNzc37nxubq7q6uqctEWi5wQAgZOWlqa8vDxJ7U6OCy+8UIWFhcrKyoodPQ3PhULxw4nGmC7nvKDnBAABM2jQINXU1Ki1tdVJfd0Flu56TZJ0ySWXqH///l16SfX19V16U14QnAAggAYNGqRBgwad989NS0vT2LFjVVlZqbvuuit2vrKyUtOmTXP2OQQnAEBCysrKdP/992vcuHGaMGGCli9friNHjmj27NnOPoPgBABIyMyZM3Xs2DE988wzOnr0qEaNGqUNGzaoqKjI2WewzgkA4DvM1gMA+A7BCQDgOwQnAIDvEJwAAL5DcAIA+A7BCQDgOwQnAIDvEJwAAL5DcAIA+A7BCQDgOwQnAIDvEJwAAL7z/wN5Ihh71LpGvAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "visualize_matrix(dbf_2.h.matrix)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "685ca784", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -552,7 +817,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index 43bffa56c1..a3b3735088 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -1,6 +1,4 @@ from copy import deepcopy -from enum import Enum, auto -from functools import partial from itertools import product import matplotlib.pyplot as plt @@ -9,7 +7,7 @@ from hyperopt import hp, tpe from qibo.config import raise_error -from qibo.hamiltonians import Hamiltonian +from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, @@ -17,338 +15,156 @@ from qibo.symbols import I, X, Z -class DoubleBracketStrategyType(Enum): - """Determines how to variationally choose the diagonal operator""" - - local_Z_search = auto() - """Search through Z permutations""" - gradient_descent_search = auto() - """Search by gradient descent (magnetic field)""" - # TODO: how to input list - prescribed_search = auto() - """Search within a prescribed list of operators""" - - -class DoubleBracketIterationStrategies(DoubleBracketIteration): - def __init__( - self, - hamiltonian: Hamiltonian, - NSTEPS: int = 5, - please_be_verbose: bool = True, - please_use_hyperopt: bool = True, - mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, - variation_strategy: DoubleBracketStrategyType = DoubleBracketStrategyType.local_Z_search, - ): - super().__init__(hamiltonian, mode) - self.NSTEPS = NSTEPS - self.please_be_verbose = please_be_verbose - self.please_use_hyperopt = please_use_hyperopt - self.variation_strategy = variation_strategy - - self.DBI_outputs = { - "iterated_h": [], - "iteration_steps": [], - "off_diagonal_norm_histories": [], - "energy_fluctuations": [], - } - - @staticmethod - def visualize_matrix(matrix, title="", ax=None): - """Visualize hamiltonian in a heatmap form.""" - if ax is None: - fig, ax = plt.subplots(figsize=(5, 5)) +def visualize_matrix(matrix, title=""): + """Visualize hamiltonian in a heatmap form.""" + fig, ax = plt.subplots(figsize=(5, 5)) + ax.set_title(title) + try: + im = ax.imshow(np.absolute(matrix), cmap="inferno") + except TypeError: + im = ax.imshow(np.absolute(matrix.get()), cmap="inferno") + fig.colorbar(im, ax=ax) + + +def visualize_drift(h0, h): + """Visualize drift of the evolved hamiltonian w.r.t. h0.""" + fig, ax = plt.subplots(figsize=(5, 5)) + ax.set_title(r"Drift: $|\hat{H}_0 - \hat{H}_{\ell}|$") + try: + im = ax.imshow(np.absolute(h0 - h), cmap="inferno") + except TypeError: + im = ax.imshow(np.absolute((h0 - h).get()), cmap="inferno") + + fig.colorbar(im, ax=ax) + + +def plot_histories(loss_histories: list, steps: list, labels: list = None): + """Plot off-diagonal norm histories over a sequential evolution.""" + plt.figure(figsize=(5, 5 * 6 / 8)) + if len(steps) == 1: + # fixed_step + x_axis = [i * steps[0] for i in range(len(loss_histories))] + else: + x_axis = [sum(steps[:k]) for k in range(1, len(steps) + 1)] + plt.plot(x_axis, loss_histories, "-o") + + x_labels_rounded = [round(x, 2) for x in x_axis] + x_labels_rounded = [0] + x_labels_rounded[0:5] + [max(x_labels_rounded)] + x_labels_rounded.pop(3) + plt.xticks(x_labels_rounded) + + y_labels_rounded = [round(y, 1) for y in loss_histories] + y_labels_rounded = y_labels_rounded[0:5] + [min(y_labels_rounded)] + plt.yticks(y_labels_rounded) + + if labels is not None: + labels_copy = labels + labels_copy.insert(0, "Initial") + for i, label in enumerate(labels_copy): + plt.text(x_axis[i], loss_histories[i], label) + + plt.grid() + plt.xlabel(r"Flow duration $s$") + plt.title("Loss function histories") + + +def generate_Z_operators(n_qubits: int): + """Generate a list of local_Z operators with n_qubits and their respective names.""" + combination_strings = product("ZI", repeat=n_qubits) + operator_map = {"Z": Z, "I": I} + operators = [] + operators_words = [] + + for op_string in combination_strings: + tensor_op = 1 + # except for the identity + if "Z" in op_string: + for qubit, char in enumerate(op_string): + if char in operator_map: + tensor_op *= operator_map[char](qubit) + op_string_cat = "".join(op_string) + operators_words.append(op_string_cat) + # append np.array operators + operators.append(SymbolicHamiltonian(tensor_op).dense.matrix) + return {"Z_operators": operators, "Z_words": operators_words} + + +def iteration_from_list( + class_dbi: DoubleBracketIteration, + d_list: list, + step: float = None, + compare_canonical: bool = True, +): + """Performs 1 double-bracket iteration using the optimal generator from operator_list. + Returns the index of the optimal operator + """ + h_before = deepcopy(class_dbi.h) + off_diagonal_norms = [] + for d in d_list: + # fixed step + if step is not None: + class_dbi(step=step, d=d) + # hyperopt else: - fig = ax.figure - ax.set_title(title) - try: - im = ax.imshow(np.absolute(matrix), cmap="inferno") - except TypeError: - im = ax.imshow(np.absolute(matrix.get()), cmap="inferno") - fig.colorbar(im, ax=ax) - - @staticmethod - def visualize_drift(h0, h): - """Visualize drift (absolute difference) of the evolved hamiltonian w.r.t. h0.""" - fig, ax = plt.subplots(figsize=(5, 5)) - ax.set_title(r"Drift: $|\hat{H}_0 - \hat{H}_{\ell}|$") - try: - im = ax.imshow(np.absolute(h0 - h), cmap="inferno") - except TypeError: - im = ax.imshow(np.absolute((h0 - h).get()), cmap="inferno") - - fig.colorbar(im, ax=ax) - - @staticmethod - def plot_histories(histories, labels): - """Plot off-diagonal norm histories over a sequential evolution.""" - colors = sns.color_palette("inferno", n_colors=len(histories)).as_hex() - plt.figure(figsize=(5, 5 * 6 / 8)) - for i, (h, l) in enumerate(zip(histories, labels)): - plt.plot(h, lw=2, color=colors[i], label=l, marker=".") - plt.legend() - plt.xlabel("Iterations") - plt.ylabel(r"$\| \sigma(\hat{H}) \|^2$") - plt.title("Loss function histories") - plt.grid(True) - plt.show() - - def double_bracket_rotation( - self, - step: float, - mode: DoubleBracketGeneratorType = None, - d: np.array = None, - update_h: bool = False, - ): - """ "Computes the iterated hamiltonian after one double bracket iteration (and updates)""" - if mode is None: - mode = self.mode - - 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 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 DoubleBracketGeneratorType.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) + step = class_dbi.hyperopt_step( + step_min=1e-5, + step_max=1, + space=hp.uniform, + optimizer=tpe, + max_evals=100, + d=d, ) - operator_dagger = self.backend.cast( - np.matrix(self.backend.to_numpy(operator)).getH() - ) - if update_h is True: - self.h.matrix = operator @ self.h.matrix @ operator_dagger - return operator @ self.h.matrix @ operator_dagger - - def iterate_forwards_fixed_generator(self, step=0.1): - """Execute multiple Double Bracket iterations with fixed flow generator""" - self.store_initial_inputs() - for s in range(self.NSTEPS): - if self.please_use_hyperopt is True: - step = self.hyperopt_step( - step_min=1e-5, - step_max=1, - space=hp.uniform, - optimizer=tpe, - max_evals=100, - verbose=True, - ) - self.double_bracket_rotation(step, update_h=True) - self.store_iteration_outputs(step) - - if self.please_be_verbose is True: - print("try") - - def generate_local_Z_operators(self, L: int = None): - if L is None: - L = self.h.nqubits - combination_strings = product("ZI", repeat=L) - operator_map = {"Z": Z, "I": I} - operators = [] - - for op_string in combination_strings: - tensor_op = 1 - # except for the identity - if "Z" in op_string: - for qubit, char in enumerate(op_string): - if char in operator_map: - tensor_op *= operator_map[char](qubit) - operators.append(tensor_op) - return operators - - def iterate_forwards_via_local_Z_search( - self, step: float = 0.1, Z_list: list = [], check_canonical: bool = False - ): - """Execute double bracket iterations with the optimal operator form a prescribed list""" - # prepare iteration - self.store_initial_inputs() - - # generate local Z operators - L = self.h.nqubits - if Z_list is []: - Z_list = self.generate_local_Z_operators(L) - - # search for best flow generator - for Z_operator in Z_list: - # stash values -> min -> store - iterated_h = self.double_bracket_rotation( - self.h, step, d=Z_operator, update_h=False + off_diagonal_norms.append(class_dbi.off_diagonal_norm) + class_dbi.h = deepcopy(h_before) + # canonical + if compare_canonical is True: + generator_type = class_dbi.mode + class_dbi.mode = DoubleBracketGeneratorType.canonical + if step is not None: + class_dbi(step=step) + else: + step = class_dbi.hyperopt_step( + step_min=1e-5, + step_max=1, + space=hp.uniform, + optimizer=tpe, + max_evals=100, ) - if check_canonical is True: - # compare - print("Check") - - def store_outputs(self, **outputs): - """Stores ('key', item) or (key = item) as a dictionary""" - for output_key in outputs: - if output_key in self.DBI_outputs: - self.DBI_outputs[output_key].append(outputs[output_key]) - else: - self.DBI_outputs[output_key] = [outputs[output_key]] - - def store_initial_inputs(self): - self.store_outputs( - iterated_h=self.h, - iteration_steps=0.0, - off_diagonal_norms=self.off_diagonal_norm, - energy_fluctuations=self.energy_fluctuation(self.h.ground_state()), - ) - - def store_iteration_outputs( - self, - iteration_step: float, - off_diagonal_norm: float = None, - energy_fluctuation=None, - ): - if off_diagonal_norm is None: - off_diagonal_norm = self.off_diagonal_norm - self.store_outputs( - iterated_h=self.h, - iteration_steps=iteration_step, - off_diagonal_norms=off_diagonal_norm, - energy_fluctuations=energy_fluctuation, - ) - - def visualize_iteration_results( - self, DBI_outputs=None, cost_function_type="off_diagonal_norm" - ): - """a. Plot the cost function wrt to iterations time, default being off diagoanl cost_function_histories - b. Visualize the initial matrix - c. Visualize the final iterated matrix - """ - if DBI_outputs is None: - DBI_outputs = self.DBI_outputs - - # limit options for cost functions - cost_function_type_options = ["off_diagonal_norm", "energy_fluctuation"] - if cost_function_type not in cost_function_type_options: - raise ValueError( - f"cost_function_type must be in {cost_function_type_options}" + off_diagonal_norms.append(class_dbi.off_diagonal_norm) + class_dbi.h = deepcopy(h_before) + class_dbi.mode = generator_type + # find best d + idx_max_loss = off_diagonal_norms.index(min(off_diagonal_norms)) + # run with optimal d + if idx_max_loss == len(d_list): + # canonical + generator_type = class_dbi.mode + class_dbi.mode = DoubleBracketGeneratorType.canonical + if step is not None: + class_dbi(step=step) + else: + step = class_dbi.hyperopt_step( + step_min=1e-5, + step_max=1, + space=hp.uniform, + optimizer=tpe, + max_evals=100, ) - - f = plt.figure(figsize=(15, 4)) - # a - ax_a = f.add_subplot(1, 3, 1) - if cost_function_type == "off_diagonal_norm": - cost_function_histories = DBI_outputs["off_diagonal_norms"] - title_a = r"Off-diagonal Norm $\vert\vert\sigma(H_k)\vert\vert$" - elif cost_function_type == "energy_fluctuation": - cost_function_histories = DBI_outputs["energy_fluctuations"] - title_a = r"Energy Fluctuation $\Xi(\mu)$" - # = \sqrt{\langle \mu | \hat{H}_k^2 | \mu \rangle - \langle \mu | \hat{H}_k | \mu \rangle^2} - x_axis = [ - sum(DBI_outputs["iteration_steps"][:k]) - for k in range(1, len(DBI_outputs["iteration_steps"]) + 1) - ] - - plt.plot(x_axis, cost_function_histories, "-o") - x_labels_rounded = [round(x, 2) for x in x_axis] - x_labels_rounded = [0] + x_labels_rounded[0:5] + [max(x_labels_rounded)] - x_labels_rounded.pop(3) - plt.xticks(x_labels_rounded) - - y_labels_rounded = [round(y, 1) for y in cost_function_histories] - y_labels_rounded = y_labels_rounded[0:5] + [min(y_labels_rounded)] - plt.yticks(y_labels_rounded) - - plt.grid() - plt.xlabel(r"Flow duration $s$") - plt.title(title_a) - - # panel label - a = -0.1 - b = 1.05 - plt.annotate("a)", xy=(a, b), xycoords="axes fraction") - - # b - ax_b = f.add_subplot(1, 3, 2) - plt.annotate("b)", xy=(a, b), xycoords="axes fraction") - self.visualize_matrix(self.h0.matrix, "Initial Matrix", ax_b) - - # c - ax_c = f.add_subplot(1, 3, 3) - plt.annotate("b)", xy=(a, b), xycoords="axes fraction") - self.visualize_matrix(self.h.matrix, "Final Matrix", ax_c) - - def hyperopt_iteration_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, - d: np.array = None, - ): - """ - 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. - d: diagonal operator for iteration generator. - - Returns: - (float): optimized best iteration step. - """ - try: - import hyperopt - except: # pragma: no cover - raise_error( - ImportError, "hyperopt_step function requires hyperopt to be installed." + class_dbi.mode = generator_type + else: + d_optimal = d_list[idx_max_loss] + # fixed step + if step is not None: + class_dbi(step=step, d=d_optimal) + # hyperopt + else: + step = class_dbi.hyperopt_step( + step_min=1e-5, + step_max=1, + space=hp.uniform, + optimizer=tpe, + max_evals=100, + d=d_optimal, ) - 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.iteration_loss(d), look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, - ) - - return best["step"] - - def iteration_loss(self, step: float, look_ahead: int = 1, d: np.array = None): - """ - 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, d=d) - - # off_diagonal_norm's value after the steps - loss = self.off_diagonal_norm - - # set back the initial configuration - self.h = h_copy - - return loss + return idx_max_loss, step diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 2291cb8d57..c425418d6f 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -1,6 +1,5 @@ from copy import deepcopy from enum import Enum, auto -from functools import partial import numpy as np @@ -101,12 +100,12 @@ def off_diag_h(self): @property def off_diagonal_norm(self): - """Norm of off-diagonal part of H matrix.""" + r"""Hilbert Schmidt norm of off-diagonal part of H matrix: \sqrt{A^\dag A}""" 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)) + return np.sqrt( + np.real(np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h))) ) @property @@ -123,6 +122,7 @@ def hyperopt_step( optimizer: callable = None, look_ahead: int = 1, verbose: bool = False, + d: np.array = None, ): """ Optimize iteration step. @@ -134,7 +134,8 @@ 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. + verbose: level of verbosity; + d: diagonal operator for generating double-bracket iterations. Returns: (float): optimized best iteration step. @@ -152,8 +153,9 @@ def hyperopt_step( optimizer = hyperopt.tpe space = space("step", step_min, step_max) + objective = lambda step: self.loss(step=step, d=d, look_ahead=look_ahead) best = hyperopt.fmin( - fn=partial(self.loss, look_ahead=look_ahead), + fn=objective, space=space, algo=optimizer.suggest, max_evals=max_evals, @@ -162,19 +164,20 @@ def hyperopt_step( return best["step"] - def loss(self, step: float, look_ahead: int = 1): + def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ Compute loss function distance between `look_ahead` steps. Args: step: iteration step. + d: diagonal operator, use canonical by default. 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) + self.__call__(mode=self.mode, step=step, d=d) # off_diagonal_norm's value after the steps loss = self.off_diagonal_norm From fc0b64bf445f0a879fd00dc7c272d643faebe056 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 20 Dec 2023 08:05:51 +0800 Subject: [PATCH 10/48] Added description in example notebook, deleted redundant notebook --- examples/dbi/E1_canonical.ipynb | 132 ------------------------------- examples/dbi/Z_search.ipynb | 133 +++++++++++++++++++------------- 2 files changed, 79 insertions(+), 186 deletions(-) delete mode 100644 examples/dbi/E1_canonical.ipynb diff --git a/examples/dbi/E1_canonical.ipynb b/examples/dbi/E1_canonical.ipynb deleted file mode 100644 index 027db9a026..0000000000 --- a/examples/dbi/E1_canonical.ipynb +++ /dev/null @@ -1,132 +0,0 @@ -{ - "cells": [ - { - "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", - "import seaborn as sns\n", - "\n", - "from hyperopt import hp, tpe\n", - "\n", - "from qibo import hamiltonians, set_backend\n", - "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", - "from qibo.models.dbi.additional_double_bracket_functions import DoubleBracketIterationStrategies" - ] - }, - { - "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.3|INFO|2023-12-04 10:38:02]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "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 = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", - "\n", - "# vosualize the matrix\n", - "dbi = DoubleBracketIterationStrategies(h)\n", - "dbi.visualize_matrix(h.matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 100/100 [00:00<00:00, 332.08trial/s, best loss: 830.4134776010231]\n", - "try\n", - "100%|██████████| 100/100 [00:00<00:00, 415.18trial/s, best loss: 503.9069738017741]\n", - "try\n", - "100%|██████████| 100/100 [00:00<00:00, 453.15trial/s, best loss: 448.59524987707096]\n", - "try\n", - "100%|██████████| 100/100 [00:00<00:00, 363.89trial/s, best loss: 447.4602359483543]\n", - "try\n", - "100%|██████████| 100/100 [00:00<00:00, 475.05trial/s, best loss: 447.4454403192258]\n", - "try\n" - ] - } - ], - "source": [ - "dbi.NSTEPS = 5\n", - "dbi.iterate_forwards_fixed_generator()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "dbi.visualize_iteration_results()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "DBF", - "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.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/dbi/Z_search.ipynb b/examples/dbi/Z_search.ipynb index 971463a04e..bcc138d93f 100644 --- a/examples/dbi/Z_search.ipynb +++ b/examples/dbi/Z_search.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 70, "metadata": {}, "outputs": [], "source": [ @@ -44,14 +44,14 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 71, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|INFO|2023-12-18 17:06:14]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.3|INFO|2023-12-20 08:04:16]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -101,44 +101,44 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 72, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-18 17:06:17]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -157,9 +157,26 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 73, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 0/10: 0.29989505456927656 with operator ZZZZI\n", + "New optimized step at iteration 1/10: 0.035384129145876984 with operator ZIIIZ\n", + "New optimized step at iteration 2/10: 0.038786197728363433 with operator ZZZZI\n", + "New optimized step at iteration 3/10: 0.00011833388056278796 with operator canonical\n", + "New optimized step at iteration 4/10: 0.02004113466142011 with operator ZIIIZ\n", + "New optimized step at iteration 5/10: 0.09822226181866325 with operator IIZII\n", + "New optimized step at iteration 6/10: 0.02440788629523319 with operator ZZZZI\n", + "New optimized step at iteration 7/10: 0.09019567032207426 with operator ZZZII\n", + "New optimized step at iteration 8/10: 0.06994887800695226 with operator ZIZZI\n", + "New optimized step at iteration 9/10: 0.0004138275217389264 with operator canonical\n" + ] + } + ], "source": [ "NSTEPS = 10\n", "Z_optimal = []\n", @@ -172,17 +189,18 @@ " if idx == len(Z_ops):\n", " Z_optimal.append(\"canonical\")\n", " else:\n", - " Z_optimal.append(Z_names[idx])" + " Z_optimal.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_}/{NSTEPS}: {step} with operator {Z_optimal[-1]}\")" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 74, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -204,14 +222,14 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 78, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|INFO|2023-12-18 17:06:27]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.3|INFO|2023-12-20 08:04:36]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -253,22 +271,22 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 79, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "New optimized step at iteration 1/10: 0.6618196053082266\n", - "New optimized step at iteration 2/10: 0.00897069231489455\n", - "New optimized step at iteration 3/10: 0.005579747395507664\n", - "New optimized step at iteration 4/10: 0.007148149109245057\n", - "New optimized step at iteration 5/10: 0.009653931903544686\n", - "New optimized step at iteration 6/10: 0.006626957341795923\n", - "New optimized step at iteration 7/10: 0.005725219594592742\n", - "New optimized step at iteration 8/10: 0.010203997361858506\n", - "New optimized step at iteration 9/10: 0.006111173495106144\n" + "New optimized step at iteration 1/10: 0.01793750114496096\n", + "New optimized step at iteration 2/10: 0.009205725351293752\n", + "New optimized step at iteration 3/10: 0.007968963636717416\n", + "New optimized step at iteration 4/10: 0.007300304878041382\n", + "New optimized step at iteration 5/10: 0.006149291001910284\n", + "New optimized step at iteration 6/10: 0.008468118348732902\n", + "New optimized step at iteration 7/10: 0.010900962182685027\n", + "New optimized step at iteration 8/10: 0.0096388986275741\n", + "New optimized step at iteration 9/10: 0.006651370934435026\n" ] } ], @@ -292,12 +310,12 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 80, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -309,6 +327,13 @@ "source": [ "plot_histories(off_diagonal_norm_history, steps)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we see that variationally chosen diagonal operators are less likely to converge to a local minimum compared to the GWW flow" + ] } ], "metadata": { From 6cf4a96038961ab41e63f8405e8f906a7bac04b9 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 20 Dec 2023 08:33:54 +0800 Subject: [PATCH 11/48] Fixed example code, added documentation --- .../additional_double_bracket_functions.py | 21 ++++++++++++++++--- src/qibo/models/dbi/double_bracket.py | 4 ++-- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index a3b3735088..e5a7eea793 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -69,7 +69,13 @@ def plot_histories(loss_histories: list, steps: list, labels: list = None): def generate_Z_operators(n_qubits: int): - """Generate a list of local_Z operators with n_qubits and their respective names.""" + """Generate the full permutations of local_Z operators with n_qubits and their respective names. + + Return: Dictionary with the following keys + + - *"Z_operators"* + - *"Z_words"* + """ combination_strings = product("ZI", repeat=n_qubits) operator_map = {"Z": Z, "I": I} operators = [] @@ -95,8 +101,17 @@ def iteration_from_list( step: float = None, compare_canonical: bool = True, ): - """Performs 1 double-bracket iteration using the optimal generator from operator_list. - Returns the index of the optimal operator + """Perform 1 double-bracket iteration with an optimal diagonal operator. + + Args: + class_dbi (_DoubleBracketIteration): The object intended for double bracket iteration. + d_list (list): List of diagonal operators (np.array) to run from. + step (float): Fixed iteration duration. + Defaults to ``None``, uses hyperopt. + compare_canonical (bool): If `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. + + Returns: + The index of the optimal diagonal operator and respective step duration. """ h_before = deepcopy(class_dbi.h) off_diagonal_norms = [] diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index c425418d6f..a4f151ea13 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -31,9 +31,9 @@ class DoubleBracketIteration: Example: .. testcode:: - import numpy as np - from qibo.models.double_bracket import DoubleBracketIteration, DoubleBracketGeneratorType + from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketGeneratorType from qibo.quantum_info import random_hermitian + from qibo.hamiltonians import Hamiltonian nqubits = 4 h0 = random_hermitian(2**nqubits) From 1c6d6ca89f71f7fae2cb9fb38b9a87e659ad7723 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 20 Dec 2023 12:03:54 +0800 Subject: [PATCH 12/48] added test codes --- examples/dbi/Z_search.ipynb | 149 ++++++++++-------- .../additional_double_bracket_functions.py | 118 +++++++------- 2 files changed, 149 insertions(+), 118 deletions(-) diff --git a/examples/dbi/Z_search.ipynb b/examples/dbi/Z_search.ipynb index bcc138d93f..e6abf2317f 100644 --- a/examples/dbi/Z_search.ipynb +++ b/examples/dbi/Z_search.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -44,14 +44,14 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|INFO|2023-12-20 08:04:16]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.3|INFO|2023-12-20 11:56:07]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -101,44 +101,44 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 08:04:16]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" ] } ], @@ -148,6 +148,27 @@ "Z_names = generate_local_Z[\"Z_words\"]" ] }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "# Verify the Z_ops are correct\n", + "# $\\Delta(A) =\\sum_{\\mu\\in\\{0,1\\}^{\\times L} Z_\\mu A Z_\\mu$\" we get $\\|\\Delta(A) - A.diag()\\| \\le eps\\|$.\n", + "dephasing_channel = (sum([Z_op @ h.matrix @ Z_op for Z_op in Z_ops]) + h.matrix)/2**nqubits\n", + "norm_diff = np.linalg.norm(dbi.diagonal_h_matrix - dephasing_channel)\n", + "print(norm_diff)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -157,23 +178,23 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "New optimized step at iteration 0/10: 0.29989505456927656 with operator ZZZZI\n", - "New optimized step at iteration 1/10: 0.035384129145876984 with operator ZIIIZ\n", - "New optimized step at iteration 2/10: 0.038786197728363433 with operator ZZZZI\n", - "New optimized step at iteration 3/10: 0.00011833388056278796 with operator canonical\n", - "New optimized step at iteration 4/10: 0.02004113466142011 with operator ZIIIZ\n", - "New optimized step at iteration 5/10: 0.09822226181866325 with operator IIZII\n", - "New optimized step at iteration 6/10: 0.02440788629523319 with operator ZZZZI\n", - "New optimized step at iteration 7/10: 0.09019567032207426 with operator ZZZII\n", - "New optimized step at iteration 8/10: 0.06994887800695226 with operator ZIZZI\n", - "New optimized step at iteration 9/10: 0.0004138275217389264 with operator canonical\n" + "New optimized step at iteration 0/10: 0.22461177968747748 with operator ZZZZI norm 31.966734538297906\n", + "New optimized step at iteration 1/10: 0.03845265033885956 with operator ZIIIZ norm 27.755939593307335\n", + "New optimized step at iteration 2/10: 0.027099927986183554 with operator ZIIIZ norm 26.044733973096722\n", + "New optimized step at iteration 3/10: 0.05949237161426739 with operator IIIZZ norm 23.92910659572215\n", + "New optimized step at iteration 4/10: 0.0004024883635361719 with operator canonical norm 23.670167587947244\n", + "New optimized step at iteration 5/10: 0.03839567611025839 with operator IZIIZ norm 21.759377111077235\n", + "New optimized step at iteration 6/10: 0.05508708960922482 with operator IZIIZ norm 20.5315164700773\n", + "New optimized step at iteration 7/10: 0.026984254777118407 with operator IIIZZ norm 18.615202254486412\n", + "New optimized step at iteration 8/10: 0.093631252308069 with operator ZIZZI norm 15.114330234612124\n", + "New optimized step at iteration 9/10: 0.004424997817894337 with operator canonical norm 13.533609007340472\n" ] } ], @@ -183,24 +204,24 @@ "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", - " idx, step = iteration_from_list(dbi, Z_ops)\n", + " idx, step = iteration_from_list(dbi, Z_ops, step_max=0.6)\n", " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", " steps.append(step)\n", " if idx == len(Z_ops):\n", " Z_optimal.append(\"canonical\")\n", " else:\n", " Z_optimal.append(Z_names[idx])\n", - " print(f\"New optimized step at iteration {_}/{NSTEPS}: {step} with operator {Z_optimal[-1]}\")" + " print(f\"New optimized step at iteration {_}/{NSTEPS}: {step} with operator {Z_optimal[-1]} norm {dbi.off_diagonal_norm}\")" ] }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAF1CAYAAAAX0biNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABrE0lEQVR4nO3dd1gUV9sH4N/sArvUpXcEBBUBARULaATEgh1jifqqoFGjxhhfXzGK5rMlsRtTxBgTQSVqYkSjYixRwIYoKpaAnaIC0qRIhz3fH4SNK3UBXcpzX9deujNnzjyz7PBwzsycwzHGGAghhBDSovDkHQAhhBBCZEcJnBBCCGmBKIETQgghLRAlcEIIIaQFogROCCGEtECUwAkhhJAWiBI4IYQQ0gJRAieEEEJaIErghBBCSAtECZy8VUFBQeA4DtHR0fIOpU7fffcdrK2toaSkBI7jkJ2dLbdYTpw4gZUrV1a7zsLCAr6+vu80HkC2n6W7uzvc3d1lqj82NhYrV65EQkJCwwKsg6+vLywsLN5K3YTIg4K8AyCkOYiJicH8+fMxY8YM+Pj4QEFBAerq6nKL58SJE9i2bVu1Sfzw4cPQ0NB490HJICAgQOZtYmNjsWrVKri7u7+VRPv555/j008/bfJ6CZEXSuCEAPj7778BADNnzkTPnj3lHE3tunbtKu8Q6mRrayvvECQKCgqgoqICKysreYdCSJOiLnTSLFy8eBGenp5QV1eHiooKXF1dERoaKlWmoKAAixYtgqWlJYRCIbS1teHs7Iz9+/dLyjx58gQTJkyAsbExBAIBDAwM4OnpiZiYmBr37e7ujsmTJwMAevXqBY7jJF3UNXVXv9lFHB4eDo7jsH//fixbtgzGxsbQ0NDAgAEDcP/+/Srbnzx5Ep6enhCJRFBRUUHnzp2xdu1aABVdvdu2bQMAcBwneVV2LVcXU1JSEiZPngx9fX0IBAJ07twZmzdvhlgslpRJSEgAx3HYtGkTtmzZAktLS6ipqcHFxQVXrlyp8fN5U15eHubMmQNdXV3o6Ojg/fffR3Jycq2fDwBs374djo6OUFNTg7q6OmxsbODv7w+gont+3LhxAAAPDw/JMQcFBUm237VrFxwdHSU/+9GjRyMuLk5qH76+vlBTU8OdO3cwaNAgqKurw9PTU7LuzZY9YwwBAQFwcnKCsrIytLS0MHbsWDx58kSq3M2bNzF8+HDJ52tsbIxhw4bh2bNn9f7cCGlq1AInchcREYGBAwfCwcEBP//8MwQCAQICAjBixAjs378fH3zwAQBg4cKF2Lt3L7744gt07doV+fn5uHv3LjIzMyV1DR06FOXl5diwYQPatWuHjIwMXL58udbr2QEBAdi/fz+++OILBAYGwsbGBnp6eg06Fn9/f/Tp0wc//fQTcnNz8dlnn2HEiBGIi4sDn88HAPz888+YOXMm3Nzc8MMPP0BfXx8PHjzA3bt3AVR09ebn5+P3339HZGSkpG4jI6Nq95meng5XV1eUlJRgzZo1sLCwwPHjx7Fo0SI8fvy4Snf2tm3bYGNjg61bt0r2N3ToUMTHx0MkEtV5jDNmzMCwYcOwb98+PH36FH5+fpg8eTLOnTtX4zYHDhzA3Llz8cknn2DTpk3g8Xh49OgRYmNjAQDDhg3DV199BX9/f2zbtg3dunUDAEmree3atfD398fEiROxdu1aZGZmYuXKlXBxccG1a9fQoUMHyb5KSkowcuRIfPTRR1iyZAnKyspqjOujjz5CUFAQ5s+fj/Xr1yMrKwurV6+Gq6srbt26BQMDA+Tn52PgwIGwtLTEtm3bYGBggNTUVISFhSEvL6/Oz4uQt4YR8hYFBgYyAOzatWs1lunduzfT19dneXl5kmVlZWXM3t6emZqaMrFYzBhjzN7ennl7e9dYT0ZGBgPAtm7d2mRxmpubMx8fnyrl3dzcmJubm+R9WFgYA8CGDh0qVe63335jAFhkZCRjjLG8vDymoaHB+vbtKzmu6nz88cesptPzzZiWLFnCALCoqCipcnPmzGEcx7H79+8zxhiLj49nAFiXLl1YWVmZpNzVq1cZALZ///4a42Hs389o7ty5Uss3bNjAALCUlBTJsjc/n3nz5jFNTc1a6z948CADwMLCwqSWv3z5kikrK1f5bJOSkphAIGCTJk2SLPPx8WEA2K5du6rU7+Pjw8zNzSXvIyMjGQC2efNmqXJPnz5lysrKbPHixYwxxqKjoxkAduTIkVrjJ+Rdoy50Ilf5+fmIiorC2LFjoaamJlnO5/MxZcoUPHv2TNIF3bNnT/z5559YsmQJwsPDUVhYKFWXtrY2rKyssHHjRmzZsgU3b96U6kJ+F0aOHCn13sHBAQCQmJgIALh8+TJyc3Mxd+5ccBzXJPs8d+4cbG1tq1y79/X1BWOsSst42LBhkt6A6mKsS13HWJ2ePXsiOzsbEydOxB9//IGMjIx67QsAIiMjUVhYWOWygZmZGfr374+zZ89W2WbMmDF11nv8+HFwHIfJkyejrKxM8jI0NISjoyPCw8MBANbW1tDS0sJnn32GH374QdJrQIi8UQIncvXy5UswxqrtHjY2NgYASRf5t99+i88++wxHjhyBh4cHtLW14e3tjYcPHwKouF589uxZDB48GBs2bEC3bt2gp6eH+fPnv7OuTh0dHan3AoEAACR/bKSnpwMATE1Nm2yfmZmZ9fr86htjXRqy/ZQpU7Br1y4kJiZizJgx0NfXR69evXDmzJk691cZf03H+Obxqaio1Osu/RcvXoAxBgMDAygqKkq9rly5IvkjQyQSISIiAk5OTvD394ednR2MjY2xYsUKlJaW1rkfQt4WSuBErrS0tMDj8ZCSklJlXeWNUbq6ugAAVVVVrFq1Cvfu3UNqaiq2b9+OK1euYMSIEZJtzM3N8fPPPyM1NRX379/Hf//7XwQEBMDPz69B8QmFQhQXF1dZLksL8nWV19ab8uYnHR2den1+8jZt2jRcvnwZOTk5CA0NBWMMw4cPr7PlX/kHQ03H+Obx1bdnQ1dXFxzH4eLFi7h27VqV15EjRyRlu3TpggMHDiAzMxMxMTH44IMPsHr1amzevLle+yLkbaAETuRKVVUVvXr1QkhIiFQLTiwWIzg4GKampujYsWOV7QwMDODr64uJEyfi/v37KCgoqFKmY8eOWL58Obp06YIbN240KD4LCwvcvn1batmDBw+qvbO8PlxdXSESifDDDz+AMVZjOVlaxZ6enoiNja1yjHv27AHHcfDw8GhQrG+LqqoqhgwZgmXLlqGkpETyCF9Nx+zi4gJlZWUEBwdLLX/27BnOnTsnuctcVsOHDwdjDM+fP4ezs3OVV5cuXapsw3EcHB0d8fXXX0NTU7PB3ytCmgLdhU7eiXPnzlU7wtbQoUOxdu1aDBw4EB4eHli0aBGUlJQQEBCAu3fvYv/+/ZIWVa9evTB8+HA4ODhAS0sLcXFx2Lt3L1xcXKCiooLbt29j3rx5GDduHDp06AAlJSWcO3cOt2/fxpIlSxoU95QpUzB58mTMnTsXY8aMQWJiIjZs2NDgu9TV1NSwefNmzJgxAwMGDMDMmTNhYGCAR48e4datW/j+++8BQJI81q9fjyFDhoDP58PBwQFKSkpV6vzvf/+LPXv2YNiwYVi9ejXMzc0RGhqKgIAAzJkzp9o/gN61mTNnQllZGX369IGRkRFSU1Oxdu1aiEQi9OjRAwBgb28PAPjxxx+hrq4OoVAIS0tL6Ojo4PPPP4e/vz+mTp2KiRMnIjMzE6tWrYJQKMSKFSsaFFOfPn0wa9YsTJs2DdHR0ejXrx9UVVWRkpKCixcvokuXLpgzZw6OHz+OgIAAeHt7o3379mCMISQkBNnZ2Rg4cGCTfUaEyEyON9CRNqDyzuWaXvHx8Ywxxi5cuMD69+/PVFVVmbKyMuvduzc7duyYVF1Llixhzs7OTEtLiwkEAta+fXv23//+l2VkZDDGGHvx4gXz9fVlNjY2TFVVlampqTEHBwf29ddfS911XVucb96FLhaL2YYNG1j79u2ZUChkzs7O7Ny5czXehX7w4EGp7Svv/A4MDJRafuLECebm5sZUVVWZiooKs7W1ZevXr5esLy4uZjNmzGB6enqM4zipz6q6O+MTExPZpEmTmI6ODlNUVGSdOnViGzduZOXl5VVi2bhxY5XjB8BWrFjRoM+o8thfv3v8zc9n9+7dzMPDgxkYGDAlJSVmbGzMxo8fz27fvi1V19atW5mlpSXj8/lVPreffvqJOTg4MCUlJSYSidioUaPY33//LbW9j48PU1VVrTb+N+9Cr7Rr1y7Wq1cvyXfPysqKTZ06lUVHRzPGGLt37x6bOHEis7KyYsrKykwkErGePXuyoKCgWj8vQt42jrFa+vEIIYQQ0izRNXBCCCGkBaIETgghhLRAlMAJIYSQFogSOCGEENICUQInhBBCWiBK4IQQQkgL1GoGchGLxUhOToa6unqTTRJBCCGkZWGMIS8vD8bGxuDxWncbtdUk8OTkZJiZmck7DEIIIc3A06dPm3TSoOao1SRwdXV1ABU/tPrMRFSdgoIChIWFwcPDAyoqKk0ZHiFVlJaW4vTp0xg0aBAUFRXlHQ4AOgeI/DX2vMjNzYWZmZkkJ7RmrSaBV3aba2hoNDiBKygoSKYilPWXF8dxOHz4MLy9vWss4+vri+zsbKlZjmqTkJAAS0tL3Lx5E05OTjLFQ5q/0tJSyfetuSTwxpwDhDSFpjov2sKl1FaTwJuarMk2JSUFWlpaAGpOvN98802tM1ARQggh9UUJvIkYGhrWWUYkEr2DSAghhLQFrfsWvSbi7u6O+fPnY/HixdDW1oahoSFWrlwpVYbjOElr3dLSEgDQtWtXcBwHd3d3ABWt+te72E+ePIm+fftCU1MTOjo6GD58OB4/fvwOjogQQkhLRwm8nnbv3g1VVVVERUVhw4YNWL16Nc6cOVNt2atXrwIA/vrrL6SkpCAkJKTacvn5+Vi4cCGuXbuGs2fPgsfjYfTo0RCLxW/tOAghhLQO1IVeTw4ODlixYgUAoEOHDvj+++9x9uxZDBw4sEpZPT09AICOjk6tXetjxoyRev/zzz9DX18fsbGxsLe3b8LoCSGEtDbUAv9HuZjhasJLXM/gcDXhJd6818zBwUHqvZGREdLS0hq1z8ePH2PSpElo3749NDQ0JF3vSUlJjaqXEEJI6ydTAt++fTscHBwkj2q5uLjgzz//lKznOK7a18aNG2uss7S0FKtXr4aVlRWEQiEcHR1x8uTJhh9RA5y8m4K+68/Bd08M9jzkw3dPDE7cTUFabpGkzJuPM3Ac1+iu7hEjRiAzMxM7d+5EVFQUoqKiAAAlJSWNqpcQQkjrJ1MXuqmpKdatWwdra2sAFdeFR40ahZs3b8LOzg4pKSlS5f/88098+OGHVbqKX7d8+XIEBwdj586dsLGxwalTpzB69GhcvnwZXbt2bcAhyebk3RTMCb6BNx/uKiwpR8yzfJy8m1LtdrVRUlICAJSXl9dYJjMzE3FxcdixYwfee+89AMDFixdl3hchhJC2SaYEPmLECKn3X375JbZv344rV67Azs6uyvXeP/74Ax4eHmjfvn2Nde7duxfLli3D0KFDAQBz5szBqVOnsHnzZgQHB8sSnszKxQyrjsVWSd6vW3UsFkoy1quvrw9lZWWcPHkSpqamEAqFVR4h09LSgo6ODn788UcYGRkhKSkJS5YskfkYCCGEtE0NvgZeXl6OAwcOID8/Hy4uLlXWv3jxAqGhofjwww9rrae4uBhCoVBqmbKy8jtpjV6Nz0JKTlGtZVJyipBXWCpTvQoKCvj222+xY8cOGBsbY9SoUVXK8Hg8HDhwANevX4e9vT3++9//1nqpgRBCCHmdzHeh37lzBy4uLigqKoKamhoOHz4MW1vbKuV2794NdXV1vP/++7XWN3jwYGzZsgX9+vWDlZUVzp49iz/++KPW7megIvEXFxdL3ufm5gKouKZeWlq/hJuSnV/jOt1h/5X8f/m2fRjhaCxV78GDByX7A/69bl353sfHBz4+PpLypaWl2Llzp1QZNzc33Lp1S2q/r9djYmJSpV7SelT+TJvTz7asrEzyb3OKi7QdjT0v2tL3lmMyju1ZUlKCpKQkZGdn49ChQ/jpp58QERFRJYnb2Nhg4MCB+O6772qtLz09HTNnzsSxY8fAcRysrKwwYMAABAYGoqCgoMbtVq5ciVWrVlVZvm/fvnqP4fwwh8P3sfw6y+kKGAaaitFNh0Gp7uKEEELkpKCgAJMmTUJOTk6D58VoKWRO4G8aMGAArKyssGPHDsmyCxcuoF+/foiJiYGjo2O96ikqKkJmZiaMjY2xZMkSHD9+HH///XeN5atrgZuZmSEjI6PeP7RyMYP75vN4kVtc63XwSloqipjgbIqJPc1gJBLWvQEhtSgtLcWZM2cwcODAZjOZSWFhoWQ2MmVlZXmHQ9qgxp4Xubm50NXVbRMJvNEDuTDGpBIpUDEgSffu3eudvAFAKBTCxMQEpaWlOHToEMaPH19reYFAAIFAUGW5oqJivX/oigBWjrTDnOAb4ACpJF45j82mcQ7IeFWCPZGJeJ5diO3n4/HjxQR42Rtieh8LdGun1SZmvSFvjyzf2betsvtRQUGh2cRE2qaGnhdt6XsrUwL39/fHkCFDYGZmhry8PBw4cADh4eFSz23n5ubi4MGD2Lx5c7V1TJ06FSYmJli7di0AICoqCs+fP4eTkxOeP3+OlStXQiwWY/HixY04rPrzsjfC9sndsOpYrNQNbYYiIVaMsIWXvREA4MO+lvgr7gUCLyUgKj4LobdTEHo7BV1MRJjWxwLDHIwgUKD+dUIIIe+GTAn8xYsXmDJlClJSUiASieDg4ICTJ09KDSd64MABMMYwceLEautISkoCj/fvze9FRUVYvnw5njx5AjU1NQwdOhR79+6FpqZmw46oAbzsjTDQ1hAX7iXjXOR19HfpjvdsjMHn/duyVuDz4GVvBC97I8Qm5yLocjyOxCTjzvMcLPztFr46EYdJvcwxuVc76GtQ9zohhJC3q9HXwJuL3NxciESiRl33KCgokFx7qc+NcFn5Jdh/NQl7IxOR+s+obYp8DsO6GGFaH0s4mmk2KA7SNpSWluLEiRMYOnRos+n2k/UcIKSpNfa8aIpc0FLQZCaNoK2qhI89rDGrX3uc+jsVgZcScD3xJY7EJONITDK6ttOEr6sFhnYxgiKfhp0nhBDSdCiBNwFFPg/DHYwx3MEYt59lI+hSAo7dTsbNpGzcTIrBVyfiMLmXOSb2agddtao33hFCCCGyomZhE3Mw1cSWD5xwaUl//HdAR+ipC/AitxibzzyA67pzWHTwFu4+z5F3mIQQQlo4aoG/JfrqQnw6oAPmuFvhxJ0UBF6Kx61nOfj9+jP8fv0Zelpow7ePBQbZGkCButcJIYTIiBL4W6akwIN3VxN4dzXBjaSXCLqUgBN3UnA1IQtXE7JgLBJiiosFJvQwg5aqrNOmEEIIaauo6fcOdWunhW8ndsXFz/rjk/7W0FFVQnJOEdafvAeXdWexNOQ27qXmyjtMQgghLQAlcDkwFAnxv0GdcGlJf2wc6wBbIw0UlYqx/+pTeG29gEk7r+D036koF7eKJ/wIIYS8BdSFLkdCRT7GOZthbHdTXEt4iaDL8Th5NxWXH2fi8uNMmGkrw8fFAuOczSBSbh7PCRNCCGkeKIE3AxzHoaelNnpaauN5diH2RibiwLUkPM0qxBehcdh8+gHGdDeBr6sFrPXV5R0uIYSQZoC60JsZE01lLBlig8glnlj7fhd0MlBHYWk5gq8kYcCW85jycxTO3XsBMXWvE0JIm0Yt8GZKWYmPiT3bYUIPM0Q+yUTgpQT8FfcCFx5m4MLDDFjoqMDH1QJju5tCXUjd64QQ0tZQAm/mOI6Dq5UuXK10kZRZgD2RCfg1+ikSMguw6lgsNp9+gLHdTeHjagFLXVV5h0sIIeQdoS70FqSdjgqWD7fFlaWeWONtDys9VbwqLkPQ5QT03xyO6UHXcP5BOlrJ/DSEEEJqQS3wFkhVoIApvc3xn57tcPFRBoIuJ+DcvTTJy1pfDT6uFni/qwlUBfQjJoSQ1oh+u7dgPB6Hfh310K+jHuIz8rH7cgJ+v/4Mj9Je4fMjd7Hh5D1M6GGGqS4WMNOmqSEJIaQ1oS70VsJSVxUrR9ohcml/rBhhCwsdFeQVlWHnhXj02xiGmXuicflxBnWvE0JIK0Et8FZGXaiIaX0s4eNigfAHaQi8lIALDzNwJvYFzsS+gI2hOnxdLTDKyQTKSnx5h0sIIaSBKIG3Ujweh/42BuhvY4BHaXkIupyAQ9ef415qHpaE3MG6k/cwoUc7THUxh7GmsrzDJYQQIiPqQm8DrPXV8YV3F1xZ6ollQzvDVEsZ2QWl+CHiMd7bEIa5v1zHtYQs6l4nhJAWhFrgbYhIRREz+7XH9L6WOBv3AoGXEhD5JBMn7qTixJ1U2BlrYFofSwx3MIJQkbrXCSGkOaMWeBvE53EYZGeI/bN64+SC9zChhxkECjz8nZyLRQdvoc+6c9h8+j5e5BbJO1RCCCE1oATextkYamDdGAdcWeqJz7xsYCwSIjO/BN+de4Q+685h/v6buJH0Ut5hEkIIeQN1oRMAgJaqEua4W2Hme5Y4HfsCQZcScDUhC0dvJePorWQ4mmlimqsFhnYxgpIC/d1HCCHyRr+JiRQFPg9Duxjht9kuOP5JX4ztbgolPg+3nmZjwa8x6LP+HL756yHS84rlHSohhLRplMBJjexNRNg0zhGXl/bH/wZ2hL66AOl5xfj6rwfos+4cFv4WgzvPcuQdJiGEtEnUhU7qpKsmwCeeHfCRmxX+vJuCoMsJuJmUjZAbzxFy4zm6m2thWh8LDLYzhCKf/iYkhJB3gRI4qTclBR5GOZlglJMJYp5mI+hSPELvpOB64ktcT3wJI5EQk3ubY2LPdtBWVZJ3uIQQ0qpRc4k0iJOZJrZO6IpLn/XHfM8O0FVTQkpOETaeuo/ea89i8e+3EJucK+8wCSGk1aIEThpFX0OIhQM74tKS/tg8zhH2JhooKRPjt+hnGPrtBXywIxIn76aiXEyjvBFCSFOiLnTSJAQKfIzpbor3u5ngRtJL7LqUgJN3UxEVn4Wo+CyYaCpjqos5JvRoB5GKorzDJYSQFo8SOGlSHMehu7k2uptrIyWnEHsjE7H/ahKeZxdi7Z/3sPWvhxjdzQS+rhboaKAu73AJIaTFoi508tYYiZSx2MsGkUs9sWGMA2wM1VFYWo59UUkY9PV5TP4pCn/FvoCYutcJIURm1AInb51QkY/xPcwwztkUUfFZCLqUgNOxqbj4KAMXH2XAXEcFU10sMM7ZFBpC6l4nhJD6oARO3hmO49C7vQ56t9fB06wCBF+p6F5PzCzAmuOx2HL6PsZ2N8VUVwtY6anJO1xCCGnWqAudyIWZtgqWDu2MK/6e+HK0PTroqyG/pBy7IxPhuTkCPruuIvx+GnWvE0JIDagFTuRKRUkB/+lljkk92+HSo0wEXY7H2XtpiHiQjogH6WivpwpfVwu8380UagL6uhJCSCX6jUiaBY7j0LeDLvp20EVCRj72RCbiYPRTPEnPx//98Tc2nryP8T3MMNXFHOY6qvIOlxBC5I660EmzY6Griv8bYYtIf0+sGmmH9rqqyCsuw88X4+G+KRwzdl/DpUcZYIy61wkhbRe1wEmzpSZQgI+rBab0NkfEw3QEXUpAxIN0/BWXhr/i0tDRQA2+rpYY3dUEykp8eYdLCCHvFCVw0uzxeBw8OunDo5M+Hqe/wu7LCfj9+jM8ePEK/ofvYP3Je5jQwwxTXMxhqqUi73AJIeSdoC500qJY6alh9Sh7XPH3xPJhndFOWwU5haXYcf4J+m0Iw+y913HlSSZ1rxNCWj1qgZMWSUOoiBnvtce0PpYIu5eGwMvxuPQoEyf/TsXJv1PR2UgD01wtMNLJGEJF6l4nhLQ+lMBJi8bncRhga4ABtgZ48CIPgZcScPjmM8Sl5GLxodtYd/IeJvY0w+Te5jASKcs7XEIIaTLUhU5ajY4G6lj7fhdcWeqJpUNsYKKpjKz8EmwLe4y+68Mwb98NXE/Mou51QkirQC1w0upoqijhIzcrfNjXEn/FvUDgpQRExWfh+O0UHL+dgi4mIkzrY4FhDkYQKFD3OiGkZaIWOGm1FPg8eNkb4dePXBA6vy/GO5tCSYGHO89zsPC3W+izLgxfn3mAtLwieYdKCCEyowRO2gQ7YxE2jHVE5JL+8BvcCYYaQmS8KsY3Zx+iz7pzWHDgJm49zZZ3mIQQUm/UhU7aFB01AT72sMasfu1x8m4qgi4n4HriSxyJScaRmGR0baeJaX0sMcTeEIp8+vuWENJ8UQInbZIin4cRjsYY4WiM28+yEXQpAcduJ+NmUjZuJt2EgYYAU3qbY2LPdtBRE8g7XEIIqYKaGKTNczDVxJYPnHBpSX8sGNABumoCvMgtxqbTD+Cy7hwWHbyFu89z5B0mIYRIoRY4If/QVxdiwYCOmOtujRN3UhB4KR63nuXg9+vP8Pv1Z+hpoQ3fPhYYZGsABepeJ4TIGf0WIuQNSgo8eHc1wZGP+yBkritGOBpDgcfhakIW5v5yA/02hGF7+GNkF5Q0yf4iIiLAcVyNLw8PD7i7u9daJiIiAuHh4XXWA6DWulRVVXH37l0AgK+vL7y9vZvkGAkhTY9a4ITUgOM4dGunhW7ttJA6tDOCryRi39UkJOcUYf3Je/jm7AOM7moCH1cL2BhqNHg/Li4uSElJqbL86NGjmD17NubOnQtPT0+UlEj/wVBSUoJhw4ZBKBSiV69e4PF4ddYDACEhITXWpaSkhI4dOzb4WAgh7w4lcELqwVAkxKLBnTCvvzWO3UpG4KUExKbkYv/Vp9h/9SlcrXTg62oBz84G4PM4mepWUlKCoaGh1LK4uDj4+fnB398f48aNq3a7mTNnIj09HdHR0RAKhRVx1qMebW3tGuu6cOECYmNjZYqfECIflMAJkYFQkY9xzmYY290U1xJeIuhyPE7eTcXlx5m4/DgTZtrK8HGxwDhnM4iUFRu0j+zsbHh7e8PNzQ1r1qyptkxAQAD27NmDsLAwmJqaNrieN+syMTGhBE5IC0EJnJAG4DgOPS210dNSG8+zC7E3MhH7rybhaVYhvgiNw5YzDzCmmyl8XC1gra9WZftyMUNUfBauZ3DQic+Ci7U++DwOYrEYkyZNAp/PR3BwMDiuamv+/PnzWLBgAQICAuDq6lptfPWpp7q6CgoKGvfBEELeGZluYtu+fTscHBygoaEBDQ0NuLi44M8//5SsDwkJweDBg6GrqwuO4xATE1NnnaWlpVi9ejWsrKwgFArh6OiIkydPynwghMiLiaYylgyxwZWlnlj7fhd0MlBHQUk59l5JxIAtEZjycxTC7qVBLK6YROXk3RT0XX8Ok3dFY89DPibvikbf9edw8m4K/P39ERkZiT/++AMaGlWvqyclJWHs2LGYNWsWZsyYUWNMddUjS12EkOZJpha4qakp1q1bB2trawDA7t27MWrUKNy8eRN2dnbIz89Hnz59MG7cOMycObNedS5fvhzBwcHYuXMnbGxscOrUKYwePRqXL19G165dZT8iQuREWYmPiT3bYUIPM0Q+zkTg5QT8FfcCFx5m4MLDDFjoqKCnpTYORj/Dm/OhpeYUYeqyrcgM3YwToaHo0KFDlfoLCwsxevRo2NnZYevWrTXG8euvv2LTpk0IraEeWeoihDRfMiXwESNGSL3/8ssvsX37dly5cgV2dnaYMmUKACAhIaHede7duxfLli3D0KFDAQBz5szBqVOnsHnzZgQHB8sSHiHNAsdxcLXWhau1LpIyC7AnMgG/Rj9FQmYBEjKr76IufvEEGX9+A7NBH2LAwEHVlpkxYwaysrJw6tQpKChUf+rGxMRg+vTpWLduHQYPHlxjjPWpixDSvDX4zC0vL8fBgweRn58PFxeXBgdQXFwsuYO2krKyMi5evFjndsXFxZL3ubm5ACq65EtLSxsUS1lZmeTfhtZByOuMNBTx2eAOmOduia//eojdV55WKVNekIO0kC8gNOsCcfv3cDzyLrq105Ss5/P52LNnDw4ePIjDhw+jsLAQT59K1yMSiZCfny+5ae2DDz6oUobP50NPTw+bN2+usa6ioiIUFxejrKwMYrEYYrGYzgXyTlV+3xr6vWtL31eZE/idO3fg4uKCoqIiqKmp4fDhw7C1tW1wAIMHD8aWLVvQr18/WFlZ4ezZs/jjjz9QXl5e63Zr167FqlWrqiw/ffo0VFRUGhwPAISFhTVqe0KqwzI5AFXnHy98HI3y3DQU5qbh2bYp8N4mvV5PTw8cx6G0tBTDhw+vtu5PPvkEHMchMTERiYmJaNeuXZUyenp62LlzJ77++us66xIIBHj27Bny8/Nx4sQJmY+VkMY6c+ZMg7ZrSzdicoyxNy/H1aqkpARJSUnIzs7GoUOH8NNPPyEiIkIqiSckJMDS0hI3b96Ek5NTrfWlp6dj5syZOHbsGDiOg5WVFQYMGIDAwMBafxDVtcDNzMyQkZFR4007dSksLERYWBg8PDygrKzcoDoIqUlUfBYm74qus1zwdGf0sqz6rPa7QOcAkbfS0lKcOXMGAwcOhKKi7I9i5ubmQldXFzk5OQ3OBS2FzC1wJSUlyU1szs7OuHbtGr755hvs2LGjQQHo6enhyJEjKCoqQmZmJoyNjbFkyRJYWlrWup1AIIBAUHWWKEVFxQb90IF/u14UFBQaXAchNXGx1oeRSIjUnKIqN7EBAIeKAWMqHymTBzoHSHPR0N/lbel72+ix0BljUi3hhhIKhTAxMUFZWRkOHTqEUaNGNbpOQpoTPo/DihEVPVU1pecVI2zllrwJIS2LTC1wf39/DBkyBGZmZsjLy8OBAwcQHh4ueW47KysLSUlJSE5OBgDcv38fQMXwjpVDPE6dOhUmJiZYu3YtACAqKgrPnz+Hk5MTnj9/jpUrV0IsFmPx4sVNdpCENBde9kbYPrkbVh2LRUpOkdS61aPs4GVvJKfICCEtjUwJ/MWLF5gyZQpSUlIgEong4OCAkydPYuDAgQAqJk2YNm2apPyECRMAACtWrMDKlSsBVAweweP92/AvKirC8uXL8eTJE6ipqWHo0KHYu3cvNDU1G3lohDRPXvZGGGhriMhHaTh9IQq3CrRw63kunr4slHdohJAWRKYE/vPPP9e63tfXF76+vrWWCQ8Pl3rv5uZGYy+TNofP49DLUhuZcQx9rKzwUfBN/Bb9FAsHdoRQseqd6oQQ8iaaD5wQOXProAsTTWVkF5Ti+O2q04ESQkh1KIETImd8HodJvSqe2w6+kijnaAghLQUlcEKagQ96mEGRzyHmaTbuPMuRdziEkBaAEjghzYCumgBDu1TcgU6tcEJIfVACJ6SZmNLbHADwx63nyCloO+M5E0IahhI4Ic1Ed3Mt2Biqo6hUjEM3nsk7HEJIM0cJnJBmguM4TP6nFR58JREyTlNACGljKIET0ox4dzWBmkABTzLycflxprzDIYQ0Y5TACWlG1AQKeL+bCQBgbyTdzEYIqRklcEKamcpu9DNxL5D6xnjphBBSiRI4Ic1MRwN19LTURrmYYf/VJHmHQwhppiiBE9IMVT5Stv9qEkrLxXKOhhDSHFECJ6QZGmxnCF01AdLyinEm9oW8wyGENEOUwAlphpQUeJjQwwwAjcxGCKkeJXBCmqmJvdqBxwGXH2fiUVqevMMhhDQzlMAJaaZMNJXh2dkAABB8hW5mI4RIowROSDNW+UjZoevPUFBSJudoCCHNCSVwQpqx96x1Ya6jgrziMhyNSZZ3OISQZoQSOCHNGI/HYXKvilb4nkgaH50Q8i9K4IQ0c2O7m0KgwENsSi5uPs2WdziEkGaCEjghzZyWqhKGOxgDAIJpfHRCyD8ogRPSAkxxqehGP34nBVn5JXKOhhDSHFACJ6QFcDQVoYuJCCVlYhyMfirvcAghzQAlcEJaAI7jJOOjB0clQiymm9kIaesogRPSQoxwNIaGUAFPswoR8TBd3uEQQuSMEjghLYSyEh9ju1eMj/4LjY9OSJtHCZyQFuQ/vdsBAM7eS8PTrAI5R0MIkSdK4IS0IFZ6auhrrQvGKuYKJ4S0XZTACWlhJv/TCv/12lMUl5VLloeHh4PjuBpfHh4eSEhIAMdxiImJAYAq7xMTE+Ht7Y1bt24BANzd3WutMyIi4p0eOyHkXwryDoAQIpsBnQ1goCHAi9xinLybilFOJgAAV1dXpKSkVCl/9OhRzJ49G3PnzpV5XyEhISgpkX7uvKSkBMOGDYNQKESvXr0adhCEkEajBE5IC6PA52FST3N8/dcDBF9JlCRwJSUlGBoaSpWNi4uDn58f/P39MW7cOCQkJMi0L21t7SrLZs6cifT0dERHR0MoFDb4OAghjUNd6IS0QBN6mkGBx+FawkvEpeRWWyY7Oxve3t5wc3PDmjVrmmS/AQEB2LNnD0JCQmBqatokdRJCGoYSOCEtkIGGEIPsDAAAwdU8UiYWizFp0iTw+XwEBweD47hG7/P8+fNYsGABtm3bBldX10bXRwhpHOpCJ6SFmtzbHCfupOLwjWfwtNFHXnEZ9NWF6GmpjWX+/oiMjMTVq1ehoaHR6H0lJSVh7NixmDVrFmbMmNEE0RNCGkumFvjatWvRo0cPqKurQ19fH97e3rh//75UmZruVt24cWON9ZaWlmL16tWwsrKCUCiEo6MjTp482bAjIqSNcGmvAwMNAQpKxZi+OxqfHojBxJ1XYPOfz7Fx0yYcOHAAHTp0aPR+CgsLMXr0aNjZ2WHr1q2ND5wQ0iRkSuARERH4+OOPceXKFZw5cwZlZWUYNGgQ8vPzJWVSUlKkXrt27QLHcRgzZkyN9S5fvhw7duzAd999h9jYWMyePRujR4/GzZs3G35khLRyp/5OxYvcYqllJS+e4PGhTRC95wNm4tAk+5kxYwaysrJw8OBBKChQpx0hzYVMZ+ObreLAwEDo6+vj+vXr6NevHwBUuQv2jz/+gIeHB9q3b19jvXv37sWyZcswdOhQAMCcOXNw6tQpbN68GcHBwbKESEibUC5mWHUsVnpZQQ7SQr6A0KwLVO08sGzfRXSZ1xd8XsX1bz6fL/N+Nm7ciIMHD+LYsWMoKytDamqq1HqRSARlZeWGHwghpMEa9ed0Tk4OgOofNQGAFy9eIDQ0FLt37661nuLi4iqPoygrK+PixYu1blNc/G/rIze34k7c0tJSlJaW1iv+N5WVlUn+bWgdhNRX5XesId+1qPgspOQUSS0rfByN8tw0FOam4dm2KXgGwHTtv+vNzc1x5swZyT5fP1cq/195DpSXl6O0tBQBAQEoLS2Fl5dXtXH89NNPmDp1qszxE1KTxpwXjdmuJeIYYw2al5AxhlGjRuHly5e4cOFCtWU2bNiAdevWITk5udbnRSdNmoRbt27hyJEjsLKywtmzZzFq1CiUl5dLJenXrVy5EqtWraqyfN++fVBRUWnIIRHSYlzP4LDnYd0t6qkdytFdl6YeJW1HQUEBJk2ahJycnCa5gbM5a3AC//jjjxEaGoqLFy/W+DyojY0NBg4ciO+++67WutLT0zFz5kwcO3YMHMfBysoKAwYMQGBgIAoKqp+woboWuJmZGTIyMhr8QyssLERYWBg8PDyoW5C8daWlpThz5gwGDhwIRUVFmbaNis/C5F3RdZYLnu6MXpbV95BVh84BIm+NOS+Ailygq6vbJhJ4g7rQP/nkExw9ehTnz5+vMXlfuHAB9+/fx6+//lpnfXp6ejhy5AiKioqQmZkJY2NjLFmyBJaWljVuIxAIIBAIqixXVFRs0A8d+LfrRUFBocF1ECKrhnxnXaz1YSQSIjWnCNX9Bc4BMBQJ4WKtL7kGXh90DpDmoqG/y9vS91amu9AZY5g3bx5CQkJw7ty5WhPszz//jO7du8PR0bHe9QuFQpiYmKCsrAyHDh3CqFGjZAmPkDaDz+OwYoQtgIpk/SYGYMUIW5mSNyGkZZEpgX/88ccIDg7Gvn37oK6ujtTUVKSmpqKwsFCqXG5uLg4ePFjjgA9Tp07F0qVLJe+joqIQEhKCJ0+e4MKFC/Dy8oJYLMbixYsbcEiEtA1e9kbYPrkbDEVV7y/pbKSOwXaG1WxFCGktZOpC3759O4CKKQZfFxgYCF9fX8n7AwcOgDGGiRMnVltPUlISeLx//3YoKirC8uXL8eTJE6ipqWHo0KHYu3cvNDU1ZQmPkDbHy94IA20NcTU+C2l5RRCLGRYfuo24lDyE3knBcAdjeYdICHlLZErg9b3fbdasWZg1a1aN68PDw6Xeu7m5ITY2tvrChJBa8XkcXKx0JO8Tswqw9a+HWH0sFm4d9aAubDvXBAlpS2gyE0JamdluVrDQUUFaXjG+PvNQ3uEQQt4SSuCEtDJCRT5Wj7IHAARdjsffyTlyjogQ8jZQAiekFerXUQ/DHIwgZsDyI3chFtNgLoS0NpTACWmlPh9mC1UlPm4mZePX6KfyDocQ0sQogRPSShmKhFg4qBMAYN2f95D5qvphiQkhLRMlcEJaMR8Xc9gYqiOnsBTr/rwn73AIIU2IEjghrZgCn4cvR1fc0Hbw+jNcS8iSc0SEkKZCCZyQVq67uTYm9DADACw/fBel5WI5R0QIaQqUwAlpAz7zsoGWiiLuv8hD0KUEeYdDCGkClMAJaQO0VJWwdEhnAMDXfz1ASk5hHVsQQpo7SuCEtBFju5uiu7kWCkrKsfoYDV1MSEtHCZyQNoLH4/CFtz34PA5/3k1F2P00eYdECGkESuCEtCGdjTQwzdUCALDij79RVFou34AIIQ1GCZyQNmbBwI4w1BAiKasAAeGP5R0OIaSBKIET0saoCRTwfyNsAQA/hD/Gk/RXco6IENIQlMAJaYOG2BvCraMeSsrF+L8//gZjNNkJIS0NJXBC2iCO47BqpB2UFHi4+CgDx2+nVCkTHh4OjuNqfHl4eMDd3b3WMhEREfWqB0C96gIAX19feHt7S8W6cuVKODk5NdnnExQUBE1NzSarj5C3QUHeARBC5MNCVxVz3a2w9a+HWHM8Fu6d9MB/bb2rqytSUqom9qNHj2L27NmYO3cuPD09UVJSIrW+pKQEw4YNg1AoRK9evcDj8eqsBwBCQkLqrKsmixYtwieffCLD0RPS8lECJ6QNm+1mhSM3nyMhswBbzjyAn6elZJ2SkhIMDQ2lysfFxcHPzw/+/v4YN25ctXXOnDkT6enpiI6OhlAoBIB61aOtrV2vuqqjpqYGNTW1+h00Ia0EdaET0oYJFflYPapispPdlxMQl5pXpYxYLMb69evRvn172NnZoaSkRJJMP/vsM3Ts2BEqKipo3749hgwZgt27dyMkJASmpqaSru29e/fCwsICIpEI77//PkaOHAk3NzesWbMGxcXFmD9/PvT19SEUCtG3b19cu3YNAQEB2LNnD5YvXw4zMzOcPXsWzs7OCA4Oxvnz53H//n1JjNV1oe/atQt2dnYQCAQwMjLCvHnzJOu2bNmCLl26QFVVFWZmZpg7dy5evaKb+UjLQgmckDauX0c9DHMwgpgBq0MfQPzG/WxLly7F+vXroaamhvbt2+PIkSOSFrW6ujqCgoIQGxuLmTNn4uTJkxg5ciRcXV0l2z9+/BhHjhzB8ePHcfToUZw4cQIvX75EcHAwOI7D4sWLcejQIezevRs3btyAtbU1PD098emnn2Lbtm2wt6/4A2PZsmXYvHkzhg8fDh6Ph+nTp9d4TNu3b8fHH3+MWbNm4c6dOzh69Cisra0l63k8Hr799lvcvXsXu3fvxrlz57B48eIm/FQJeQdYK5GTk8MAsJycnAbXkZ+fz44cOcLy8/ObMDJCqldSUsKOHDnCSkpK5B0KS8kuZLaf/8nMPzvOFv3wBwv7+xk7cvMZOxMTzwQCAfPy8mKamprswYMH1W6fmJjI9PT0mIuLC+vevbtk+YoVK5iKigrLzc1ljDH22WefMYFAwBwdHRljjL169YopKiqyX375RbLNo0ePGI/HYy4uLowxxsLCwhgA9tdffzHGGPPx8WG9e/dmAFhhYaFkP5V1MsaYsbExW7ZsWb2P/7fffmM6OjqS94GBgUwkEtV7e9J0GnteNEUuaClkaoGvXbsWPXr0gLq6OvT19eHt7S3VjfWmjz76CBzHYevWrbXWW1paitWrV8PKygpCoRCOjo44efKkLKERQhrBUCTEwkGdAAAH43nw3RODTw/EYMrmEBQXF+PU6dM4cOAAOnToILXd77//DldXV1hZWSEzMxM3btxAUlKSVBkLCwuoq6vj119/xaZNm+Dj44Pc3FwAFa3z0tJS9OnTBwBQWFiI8ePHQ1tbGx07dpSqx8HBQfJ/gUAAAEhLqzocbFpaGpKTk+Hp6Vnj8YaFhWHgwIEwMTGBuro6pk6diszMTOTn59f3IyNE7mRK4IGBgcjIyIBYLEZZWRmuXLkCDw+Par/0R44cwe+//w4Aksc/arJ8+XJs3rwZxcXFAICkpCQMHz4cV65ckSU8QkgjGGoI/vkfJ1lWlpsOAFDrMQbMxEGq/JUrVzBhwgTk5+dDT08Ply9fxrJly6rcSa6oqIiYmBhMnz4d69atQ+fOnSEWV8xJzv55/pzjKvY5Y8YMZGVloUePHuDz+VXqqVRZvrKe1ykrK9d6nImJiRg6dCjs7e1x6NAhXL9+Hdu2bQNQ0ZggpKWQKYG3b98eK1aswNWrVxEWFgYHBwekpKTg4sWLUuWeP3+ODz/8EHp6elVOwur8+OOPKCgowIYNG3Dv3j38+uuvUFBQwLRp02Q7GkJIg5SLGZYduSu9rCAHWed+BjgeFFQ08L/dEXienILU1FSkpqbi1KlTEIlEiIuLQ2BgIMzNzXHv3j0wxiRlSktLUVZWBm9vb7i7u2Py5MnIzc1FeXk5UlNToa6uDiUlJVy8eBEbN27EwYMH8f333yMmJgampqZITU1FVlYWgIrWeX2oq6vDwsICZ8+erXZ9dHQ0ysrKsHnzZvTu3RsdO3ZEcnJy4z5AQuRApsfI3uzWXrNmDc6cOSP1jKdYLMb48eNRXl6OQ4cOwdHRsc56CwsLYW1tjUmTJgGo6HKzsLBAfHx8jdsUFxdLWuwAJF1ypaWlDf4ruqysTPIv/SVO3rbK71hz+K5FPs5EdoF0HIWPoyHOq2iBvwz7GS/Dfobppn/X6+npSZKrl5eX1LZGRkYAgBEjRiA3NxdPnz5FYmKiZPnrZdTV1eHn5yc574YPHw4AWL16NVavXi0p//vvv2P27NkQi8WSlnfl+V5eXg7GmOSzXL58OebNmwcdHR0MHjwYr169wuXLl/Hxxx+jXbt2KCsrw9atWzFs2DBcvnwZP/zwQ5X6Kt+Td6ux50Vb+pk1+Dlwxhj8/f0BAM7OzpLla9euRVxcHFauXAk7O7t61dW9e3dcuXIFv//+O95//30EBwfjwYMH4PFq7iBYs2YNvvzyyyrLT58+DRUVFRmPRlpYWFijtidEFmfOnJF3CAhN4gBI95apdfGEWhdPMCZGbuRB5N06BZafBR1tLQwePBhjx45FUFAQzp49i9LSUjg7O6Njx444cOAA9u3bBwDYv38/+Hw+jhw5Iqn36NGjOHbsGHbu3AmgYrCW3bt348KFC1BUVIS1tTWmT58uud5+584dfP7559DW1saJEycwZswYPHnyBOfPn0dYWBgMDAzw8OFD5Obm4sSJEwAAXV1dTJs2DZs3b8bixYuhrq4OV1dXWFpWPOc+ffp0fPHFF1i6dCns7OwwduxYfPPNNzh9+jTU1NRw69YtlJaWSuoj715Dz4uCgoImjqT54hhr2CDIc+fORVBQEOzt7XH16lUAwPXr1+Hu7o5u3bpJhk9UUFDAiBEjcPjw4RrrSk9Ph6enJ+7cuSNZZmdnhydPntT4w1i+fHm1CXzfvn2NTuCEtDWhSTycfl73FbVBJmIMa1f1ujMhzUVBQQEmTZqEnJwcaGhoyDuct6pBCfyTTz5BYGAgNDU1ceXKFZiamgIA/ve//2HLli3g8XiSm0zKy8vBcRzatWuHhISEausLDw/HhAkTsGLFCnTo0AG5ubnw9fWFUCis9i5ToPoudDMzM2RkZDT4h1ZYWIiwsDB4eHjUeSMMIY1VWlqKM2fOYODAgVI3aMnD5ceZ8Am6Xme53b7d4Wql8w4iIm1VY8+L3Nxc6OrqtokELlMXOmMMn3zyCYKCgqCuro4LFy5IkjdQMRRi5cQDb6rtusTnn3+OKVOmYM6cOZKyysrKyMrKglgsrrYrXSAQSB4leZ2iomKDfxlWxqigoCD3X6ik7WjMd7ap9O1oAE0VxSrXwV+npaKIvh0NwOdVPb8JaWoNPS/kfS69SzLdhT537lzs3LkTysrKOHToEJSVlZGamiq5O3T27Nm4ffs2YmJiJC8+nw8PDw+cO3dOUs/UqVOxdOlSyfv09HQ8evQIT548wYULF+Dl5QXGGBQUFGiaQ0LeAT6Pw7r3u/zzrvpzbu37XSh5E9KMyJTAf/jhB5SUlCAjIwN9+vSBkZERjIyMsHfvXgCAjo4O7O3tpV4AoKGhgU6dOknqOX36NI4fPy5537t3bxw9ehSdOnXCyJEjwXEcVFVVMXLkyHo9hkYIaTwveyN8M84eIqWq62yNNOBlb1R1BSFEbppkNjIlpWrO+H+YmprCzc1NapmNjQ0sLCwk73/66SdYWlpi7969eP78OR48eIARI0ZUe5MaIeTtGdhZD+Kn5dDq6IycEkAsZvD7/RZiU3Jx/kE6+nXUk3eIhJB/yHwNXFbV3bgWHh4uHYSCAlasWIEVK1bIXD8hpGnxOKCnhZbkaY47z3Ox61I8vjoRhz7WutSNTkgzQbOREUJqNd/TGiJlRdxLzcPB6KfyDocQ8g9K4ISQWmmqKOGT/hVTcW4+8wD5xWVyjogQAlACJ4TUw1QXC5jrqCA9rxg7Ih5XWV85cFNNLw8PDyQkJIDjOMTExABAne/d3d1rrbOuSZIIae2a5CY2QkjrpqTAwxIvG8z55QZ+vPAEE3u1g5Ho38GOXF1dpeZEqHT06FHMnj0bc+fOlXmfISEhVWY2KykpwbBhwyAUCtGrVy/ZD4SQVoQSOCGkXrzsDdHDQgvXEl5i06kH2Dz+34mKlJSUYGhoKFU+Li4Ofn5+8Pf3x7hx42ocibEm2traVZbNnDkT6enpiI6OhlAobNBxENJaUBc6IaReOI7DsmG2AICQm89w93lOjWWzs7Ph7e0NNzc3rFmzpkn2HxAQgD179iAkJERqBEhC2ipK4ISQenMy08RIR2MwBnwZGlfto6VisRiTJk0Cn89HcHBwtUMry+r8+fNYsGABtm3bBldX10bXR0hrQF3ohBCZLPbqhJN/pyLySSa2hT2CmbYK9NWF6GmpDT6Pg7+/PyIjI3H16tUmmUwiKSkJY8eOxaxZszBjxowmOAJCWgdK4IQQmZhqqcC9ox5Ox77AptMPJMuNREK4Kz7Epk2bEBoaKpnPuzEKCwsxevRo2NnZYevWrY2uj5DWhBI4IUQmJ++m4EzsiyrLEx/EYv0vfpi+wB+DBw9ukn3NmDEDWVlZOHXqFBQU6NcVIa+jM4IQUm/lYoZVx2KrzFdWXpCDtJAvIDTrgptKXfA8OUVqyNWGTEq0ceNGHDx4EMeOHUNZWRlSU1Ol1otEIigrK9ewNSGtHyVwQki9XY3PQkpOUZXlhY+jUZ6bhsLcNNxYOx6ma6XXm5ubV5kDoS4BAQEoLS2Fl5dXtesDAwPh6+srU52EtCaUwAkh9ZaWVzV5A4BaF0+odfGUvP9mghNGOZlUKff6XesWFha1vo+Pj2+KkAlptegxMkJIvemr12/wlPqWI4Q0HCVwQki99bTUhpFIiNqe7OZxgI6a0juLiZC2ihI4IaTe+DwOK0ZUjMZWUxIXM2Dij1cQm5z77gIjpA2iBE4IkYmXvRG2T+4GQ5F0N7mRSIiNYx1gZ6yBzPwSTPgxEtcTX8opSkJaP7qJjRAiMy97Iwy0NcTV+Cyk5RVJjcQ22N4Q0wOvITrxJab8HIWdU53Rx1pX3iET0upQC5wQ0iB8HgcXKx2McjKBi5WO5LlvDaEi9nzYE+910EVBSTmmBV3DX9UM/EIIaRxK4ISQJqeipICffJwx2M4AJWVifBR8HX/EPJd3WIS0KpTACSFvhUCBj22TuuH9riYoFzMs+DUG+6KS5B0WIa0GJXBCyFujwOdh0zhHTO7dDowB/ofvYOf5J/IOi5BWgRI4IeSt4vE4rBllj9luVgCAL0/EYcuZB9XOJU4IqT9K4ISQt47jOCwZYgO/wZ0AAN+efYg1x+MoiRPSCJTACSHvzMce1lg10g4AsOtSPJYcuoNyMSVxQhqCEjgh5J3ycbXApnGO4HHAr9FPMf/ATZSUieUdFiEtDiVwQsg7N7a7KbZN6gZFPofQ2yn4aG80ikrL5R0WIS0KJXBCiFwM6WKEnVOdIVTkIex+Onx2XcWr4jJ5h0VIi0EJnBAiN+6d9LFnei+oCRQQFZ+F//wUheyCEnmHRUiLQAmcECJXPS21sW9mL2ipKOLW02x8sOMK0vKK5B0WIc0eJXBCiNw5mGri149coK8uwP0XeRj/QySevSyQd1iENGuUwAkhzUJHA3UcnO0CUy1lJGQWYPwPkXiS/kreYRHSbFECJ4Q0G+Y6qjg42wVWeqpIzinC+B2RiE3OlXdYhDRLlMAJIc2KkUgZv37kAlsjDWS8KsGEHyNxI+mlvMMipNmhBE4IaXZ01QTYP6s3uptrIbeoDJN/isLlRxnyDouQZoUSOCGkWRIpK2Lvhz3R11oXBSXl8A26hr9iX8g7LEKaDUrghJBmS0VJAT/5OGOgrQFKysSYHXwdR28lyzssQpoFSuCEkGZNqMhHwH+6wdvJGGVihk8P3MT+q0nyDosQuaMETghp9hT5PGwZ74T/9GoHxoClIXfw04Un8g6LELmiBE4IaRF4PA5feNvjI7f2AIAvQuPw9ZkHNKc4abMogRNCWgyO47DEywZ+gzsBAL45+xBfhMZREidtEiVwQkiLwnEcPvawxsoRtgCAny/GY2nIHZSLKYmTtoUSOCGkRfLtY4mNYx3A44AD157i0wM3UVImlndYhLwzlMAJIS3WOGczfD+pGxT5HI7fTsHs4OsoKi2Xd1iEvBOUwAkhLdrQLkb4caozBAo8nLuXBt/Aq3hVXCbvsAh56yiBE0JaPI9O+tgzvSfUBAq48iQL//kpCtkFJfIOi5C3ihI4IaRV6NVeB/tm9oKmiiJuPc3GhB+vIC2vSN5hEfLWUAInhLQaDqaa+HWWC/TUBbiXmocPdlzB8+xCeYdFyFtBCZwQ0qp0MlTHwY9cYKKpjPiMfIzbfhlP0l/JOyxCmhwlcEJIq2Ohq4rf57igvZ4qknOKMH5HJOJScuUdFiFNihI4IaRVMhIp47ePXGBrpIGMVyX4YEckbia9rNe2vr6+8Pb2rvL/8PBwcBxX48vDwwMAkJCQAI7jEBMTU+17QpoCJXBCSKulqybA/lm90a2dJnKLyvCfn6Jw+XFGg+tzdXVFSkpKldeOHTvAcRzmzp3bhNETUjtK4ISQVk2krIi9H/ZCH2sdFJSUwzfwGs7GvWhQXUpKSjA0NJR6vXz5En5+fvD398e4ceOaOHpCakYJnBDS6qkKFPCzTw8MtDVASZkYH+29jmO3khtdb3Z2Nry9veHm5oY1a9Y0QaSE1B8lcEJImyBU5CPgP90wyskYZWKG+Qdu4sDVpAbXJxaLMWnSJPD5fAQHB4PjuCaMlpC6Kcg7AEIIeVcU+Tx8Pd4JqgIF7ItKwpKQO3hVXIZpfSxxNT4LaXlF0FcXoj6zk/r7+yMyMhJXr16FhobG2w+ekDdQAieEtCk8Hocvve2hLlDAjvNP8EVoHLb+9VBq/PT8uynoIKq5Rf3rr79i06ZNCA0NRYcOHd5F2IRUQV3ohJA2h+M4LBlig5GORgBQZfKTwpJyxDzLwcm7KVW2jYmJwfTp07Fu3ToMHjz4ncRLSHWoBU4IaZPEDLiWUPtz4auOxaLja93pGRkZ8Pb2hru7OyZPnozU1FSp8nw+H3p6em8jXEKqoAROCGmTrsZnISWn9slOUnKKoP2qGIr/vA8NDUViYiISExNhZGRUpby5uTkSEhKaPlhCqkEJnBDSJtU2U5nusP9K/j/r800Y5WQCAPDx8YGPj0+ddVtYWIC9difcm+8JaQp0DZwQ0ibpqwubtBwh7xolcEJIm9TTUhtGIiFqe3pboMCDg6mozrrqM0a6u7t7rWUiIiLqPdZ6feoCpMdxJ60PdaETQtokPo/DihG2mBN8AxyA6jq4i/8Zte3Hqd2holTzr8vKMdLfdPToUcyePRtz586Fp6cnSkpKpNaXlJRg2LBhEAqF6NWrF3g8Xp31AEBISEiddZHWjxI4IaTN8rI3wvbJ3bDqWKzUDW1GIiEm9myHHRGPcfFRBnwDr2GXbw+oCar/lVk5Rvrr4uLi6hwjfebMmUhPT0d0dDSEwoqu+vrUo62tXa+6SOtGCZwQ0qZ52RthoK2h1EhsPS21wedx6GOtC99dV3E1PgtTf45C0PSe0BAq1llnfcZIDwgIwJ49exAWFgZTU9MG11PfukjrQ9fACSFtHp/HwcVKB6OcTOBipQM+r+LKeHdzLQTP6AUNoQJuJGVj8k9RyC4oqbWu+oyRfv78eSxYsADbtm2Dq6trg+upb12kdaIETgghtXA008T+Wb2hpaKI289yMGlnFDJfFaNczBD5OBN/xDxH5ONMlIsrrqJXjpH+xx9/VDtGelJSEsaOHYtZs2ZhxowZNe63rnpkqYu0TtSFTgghdbAzFuHALBf856coxKbkYvh3F1EuZkjLK5aUMRIJ4a74sNYx0gsLCzF69GjY2dlh69atNe6vPmOt17cu0npRC5wQQuqhk6E6DszqDZGyAlJyiqSSNwAkPojFev8F8F3gX+MY6TNmzEBWVhYOHjwIBYXq20/1HWu9PnWR1o1+6oQQUk+WuqpQ4vMBSE9+Ul6Qg7SQLyA064KbSl3wPDlFch0dqBgjPSgoCAcPHsSxY8dQVlZWZRx1kUiE/Pz8eo21vnHjxjrrUlZWbtqDJ80OJXBCCKmnq/FZSH9VXGV54eNolOemoTA3DTfWjofpWun15ubm4DgOpaWl8PLyqrbuwMBAcBxXr7HWAwIC6qzL19dX5uMjLQslcEIIqaeaxk9X6+IJtS6ekvebxzlgTHezBu2jPmOtx8fH16uuoKCgBsVAWga6Bk4IIfVU33HRVxz9G6uO/Y17qblvOSLSllELnBBC6qly/PTUnKJqh14FAB4HvCouR+ClBAReSoCjqQjje5hhhKNxvQaBIaS+qAVOCCH1VDl+OoAqk6Bw/7y+n9gNgb494GVnCAUeh1vPcrDs8F30/PIvLPwtBlFPMmlqUdIkqAVOCCEyqGn8dEORECtG2MLLvuLmMw8bfWS8KsbhG8/xa/RTPEp7hZAbzxFy4zksdVUxztkUY7uZQl+Dxi0nDUMJnBBCZFTb+Omv01UTYGa/9pjxniVuJGXjt2tPcex2MuIz8rHh5H1sPv0AHp30MN7ZDB42+lDkU6coqT9K4IQQ0gCV46fXB8dx6G6uhe7mWvi/EbYIvZ2CX6Of4nriS/wVl4a/4tKgpy7AmG6mGO9sivZ6am85etIaUAInhJB3SFWggPE9zDC+hxkepeXht+hnCLnxDOl5xfgh4jF+iHiMnhbaGN/DDEO7GNY6Dzlp2+ibQQghcmKtrw7/oZ3hN7gTzsal4bfopwi/n4arCVm4mpCFlUf/xghHY3zQwwyOpqIaZyQjbRNdcCGEEDlT5PPgZW+IXb49cHmJJ/wGd4K5jgpeFZdh/9UkeG+7BK+tF/DzxXhk5dc+namswsPDwXFcjS8PDw+4u7vXWiYiIqJe9QBAQkICOI5DTExMte9J/VELnBBCmhFDkRAfe1hjjpsVrsRn4rdrT/Hn3VTcf5GHNcdjsf7Pexhoa4DxPczQ11q3yo1zsnJ1dUVKSkqV5UePHsXs2bMxd+5ceHp6oqRE+g+HkpISDBs2DEKhEL169QKPx6uzHtK0KIETQkgzxONxcLXShauVLlYVluJoTMXjaHef5yL0TgpC76TAWCTEWGczjOtuCjNtlQbtR0lJCYaGhlLL4uLi4OfnB39/f4wbN67a7WbOnIn09HRER0dDKKx4FK4h9ZCGowROCCHNnEhZEVNcLDDFxQJ/J+fgt2tPcSQmGck5Rfj27EN8d+4h+ljpYnwPMwyyNYBQkd/gfWVnZ8Pb2xtubm5Ys2ZNtWUCAgKwZ88ehIWFwdTUtMH1kMahBE4IIS2InbEIq0aJsHRoZ5z6OxW/RT/FpUeZuPgoAxcfZUBTRRHeTiYY72wGW2ONausoF7Nqn2EXi8WYNGkS+Hw+goODq71p7vz581iwYAECAgLg6upabf31qYc0HiVwQghpgYSKfIxyMsEoJxM8zSrAweinOHj9GVJyihB0OQFBlxPQxaRiHPaRjsYQKVeMw37ybkqVUeSM/hlFLjz4G0RGRuLq1avQ0Kia/JOSkjB27FjMmjULM2bMqDE2f3//WushTYMSOCGEtHBm2ipYOKgTPh3QERcepuO36Kc4E/sCd57n4M7zHHxxPBbDuhjBQlcVX595UGUiltScIkxdthWZoZtxIjQUHTp0qLKPwsJCjB49GnZ2dti6dWuNsfz666/YtGkTQmuohzQdSuCEENJK8Hkc3Dvpw72TPjJfFePwzef4LfopHrx4hZCbz2vcrvjFE2T8+Q3MBn2IAQMHVVtmxowZyMrKwqlTp6CgUH3qiImJwfTp07Fu3ToMHjy4SY6J1IwSOCGEtEI6agLMeK89PuxriZin2fju3EOcu5depVx5QQ7SQr6A0KwLxO3fw59X4+BsoS1Zz+fzERQUhIMHD+LYsWMoKytDamqqVB0ikQj5+fnw9vaGu7s7Jk+eXKUMn8+Hnp7e2znYNooSOCGEtGIcx6FrOy2McjKpNoEXPo5GeW4aCnPT8GzbFIzYJr3e3NwcHMehtLQUXl5e1e4jMDAQHMchMTERiYmJMDIyqlLG3NwcCQkJTXFI5B+UwAkhpA3QV69+2lK1Lp5Q6+IpeT+mmwmWDOkMPXWBzPvw8fGps4yFhYXUfOhvvif1R0OpEkJIG9DTUhtGIiHqeqDr0I3n6LPuHPwO3kJscu47iY00DCVwQghpA/g8DitG2AJAlSTO/fP6sK8lurbTREm5GAevP8PQby9g4o9X8FfsC4jF1EpubqgLnRBC2ggveyNsn9ytynPghv88B+5lX3Ht+kbSS+y6GI8/76Yi8kkmIp9kwkJHBdP6WGJsd1OoCih1NAf0UyCEkDbEy94IA20Nqx2JrVK3dlroNkkLz7MLsScyAfujkpCQWYAVR//GptP3MbFnO0x1MYepVsPGXydNgxI4IYS0MXweBxcrnTrLmWgqY+mQzpjfvwNCbjzDrksJiM/Ix4/nn+Dni/HwsjPE9L4W6NZOi4ZLlQO6Bk4IIaRWqgIFTHGxwNmFbtjl64w+1jooFzOE3knBmO2R8A64jD9inqO0XNzofUVERMDb2xtKSko1ziv+5hzir89XLhKJAFQ8m94U85U3Z9QCJ4QQUi88Hof+Ngbob2OAe6m5CLyYgMMxz3HraTY+PRCDtSfuYaqrOSb1bAdNFaUG7cPFxQWBgYHw9PSEoqKiZHlt84qHhIRI5ivPy8tDx44dcffuXUyYMKFVz1dOLXBCCCEyszHUwPqxDri8pD/+O6AjdNUESM0twoaT99F77VksO3wHj9JeyVyvkpIStLS0YGhoKHm9fPmy1nnFtbW1JWUNDAwAABs2bEB6ejoOHz4MoVAomfdclnprs3LlSjg5Ocl8fDUJCgqCpqamTNtQAieEENJgumoCfDqgAy4t8cCmcY6wNdJAUakYv0QlYcCWCPgGXsWFh+kNHqylofOKHzhwACEhIW9tvvJFixbh7NmzMm/XlKgLnRBCSKMJFPgY290UY7qZ4MqTLOy6FI+/4l4g/H46wu+no6OBGqb3sYR3VxMIFflS274+P7mOigIqHzlvyLzily5dAgBs2rTprc5XrqamBjU1NZm3a0rUAieEENJkOK7iDvedU50R9j93+LpaQFWJjwcvXmFJyB24rD2LTafuIy234jn0k3dT0Hf9OUzceQWfHojB5F3RWHmdw8xFK6Cjo4M///wT2dnZ+O677wAAn332meSGs+HDh+Pzzz9HaWkpgIr5yseMGQMAEAgEsLCwgEgkwoQJE5CXlyeJcfHixTh79ixevHgBfX199O3bF9euXZM6jq5du+Ls2bNwdnaGiooKXF1dcf/+fcn66rrQd+3aBTs7OwgEAhgZGWHevHmSdVu2bEGXLl2gqqoKMzMzzJ07F69eyX6J4XWUwAkhhLwVFrqqWDnSDpH+nlg+rDNMNJXxsqAU34c9Qp/15zB+RyRmB9+QGlQGABLO7MGe7V8jJycHu3btwm+//Sa5tq2uro5NmzYBAPz8/LBz5058/fXXkvnKK2c8O378uOQVERGBdevWAaiYr3zLli1QV1dHcHAwbty4AWtrawwePBhZWVlScSxbtgybN29GdHQ0FBQUMH369BqPdfv27fj4448xa9Ys3LlzB0ePHoW1tbVkPY/Hw7fffou7d+9i9+7dOHfuHBYvXty4D5i1Ejk5OQwAy8nJaXAd+fn57MiRIyw/P78JIyOkeiUlJezIkSOspKRE3qFI0DlA3qbSsnJ24nYyGxNwiZl/drzal9mC3xh4Cgx8BdZuyCxWVi6uUk98fDwDwG7evMk2bNjAunfvziZNmsQsLCzY/PnzGQD27NkzSXk/Pz/Wq1cvdvPmTaasrMz4fD775ZdfJOtLSkqYsbEx27Bhg6RuAOyvv/6SlAkNDWUAWGFhIWOMsRUrVjBHR0fJemNjY7Zs2bJ6fxa//fYb09HRkbwPDAxkIpGo3tszxhhdAyeEEPJOKPB5GNLFCEO6GCH4SiKWH7lbpUzx83uAuAyCGuYnP3HiBLZv3w4AcHV1hVgshoKCAm7fvo1jx47h+PHjAICCggLJnOS6urpITU2Ft7c3unfvjosXL6JDhw5Sc5Y7OjoiLi5OKhYHBwfJ/yunSE1LS0O7du2kyqWlpSE5ORmenp6oSVhYGL766ivExsYiNzcXZWVlKCoqQn5+PlRVVev1+b1J5i708+fPY8SIETA2NgbHcThy5EiNZT/66CNwHIetW7fWWmdISAicnZ2hqakJVVVVODk5Ye/evbKGRgghpIVQF1bffixOeVjx79M7FfOTu9jByMhI8vrwww/h5uYGANi/fz+WLVuGgoICyXzl33//PQCgY8eOkm1iYmLw6tUrJCYm4uLFiwCAnj17StVbOdDL615/Dr1ynVhcdbAaZWXlWo81MTERQ4cOhb29PQ4dOoTr169j27aKidcrr983hMwJPD8/H46OjpIPqSZHjhxBVFQUjI2N66xTW1sby5YtQ2RkJG7fvo1p06Zh2rRpOHXqlKzhEUIIaQFqmp9c1Gs0OAUBtL0+gflnx7H1zAMwxsAYw6ZNm9C+fXts2rQJjDGMGjUKiYmJ0NDQkJRZsmQJACAnJ0eyrGfPnlBTUwNjDK9evYKSkhJ++eUXyfqSkhJoa2ujc+fOsLCwQFhYmEzHoq6uDgsLixofK4uOjkZZWRk2b96M3r17o2PHjkhOTpbtA6uGzF3oQ4YMwZAhQ2ot8/z5c8ybNw+nTp3CsGHD6qzT3d1d6v2nn36K3bt34+LFixg8eLCsIRJCCGnmelpqw1BDgNTcYqnlnIISNHqNQXZ4IDi+AoLKsuCskoF7cbGwtrZGUlISDhw4gB49eiA0NBSHDx+Wab+qqqqYM2cO/Pz8oK2tjXbt2mHDhg0oKCjAhx9+2ODjWblyJWbPng19fX0MGTIEeXl5uHTpEj755BNYWVmhrKwM3333HUaMGIFLly7hhx9+aPC+KjX5NXCxWIwpU6bAz88PdnZ2Mm/PGMO5c+dw//59rF+/vsZyxcXFKC7+9wefm1sx8XxpaWmDuyTKysok/zamW4OQ+qj8jjWn7xqdA+RdGt/dFN+GPa6yXNRnAjgeH9kXfkHmn99hzH4DzJszG1OnTsX8+fMxb948FBcXY8iQIfD398eaNWsk39fy8vI697tu3TpJrsrLy4OzszNOnToFLS2tBh+Lj48PioqK8PXXX2PRokXQ1dXF2LFjAQBOTk7YsmUL1q9fj6VLl6Jfv35Yu3Ytpk6d2uD9AQDHWAOHx0HFNYHDhw/D29tbsmzt2rUICwvDqVOnwHEcLCwssGDBAixYsKDWunJycmBiYoLi4mLw+XwEBATUesv+ypUrsWrVqirL9+3bBxUVmuKOEEKau+sZHPY85NdZbmqHcnTXrV+qKigowKRJk5CTkwMNDY3GhtisNWkL/Pr16/jmm29w48YNmUe2UVdXl9xocPbsWSxcuBDt27ev0r1eaenSpVi4cKHkfW5uLszMzDBo0KAG/9AKCwsRFhYGDw+POm9KIKSxSktLcebMGQwcOFDqZhl5onOAvEs68VnY8zC6znKD3uuFXpbadZYD/u2NbQuaNIFfuHChyi325eXl+N///oetW7ciISGhxm15PJ7koXcnJyfExcVh7dq1NSZwgUAAgUBQZbmiomKDfxlWdsEoKCg0m1+opPVrzHe2qdE5QN4lF2t9GImESM0pQnXtaw6AoUgIF2t98Hn1axS2pe9tk47ENmXKFNy+fRsxMTGSl7GxMfz8/GS+o5wxJnWNmxBCSOvC53FYMcIWQEWyfl3l+xUjbOudvNsamVvgr169wqNHjyTv4+PjERMTI7mbT0dHR6q8oqIiDA0N0alTJ8myqVOnwsTEBGvXrgVQcd3c2dkZVlZWKCkpwYkTJ7Bnzx7Jw/qEEEJaJy97I2yf3A2rjsVKDalqKBJgxQg7eNkbyTG65k3mBB4dHS0ZSB6A5Dq0j48PgoKC6lVHUlISeLx/G//5+fmYO3cunj17BmVlZdjY2CA4OBgffPCBrOERQghpYbzsjTDQ1hBX47OQkp2PJ3/HYN4H/SAUKMk7tGZN5gTu7u4u07yu1V33Dg8Pl3r/xRdf4IsvvpA1FEIIIa0En1cxi1lpqQZOPLtJ3eb1QLOREUIIIS0QJXBCCCGkBaIETgghhLRAlMAJIYSQFogSOCGEENICNflkJvJSeWd8Y4bRKygoQEFBgWSydULeptLSUsn3rbmMHkXnAJG3xp4XlTmgEdN8tBitJoHn5eUBAMzMzOQcCSGEEHnLy8uDSCSSdxhvVaNmI2tOxGIxkpOToa6uLvNEKpWeP38OW1tbxMbGwsTEpIkjJERa5QQ8T58+bTazJtE5QOStsecFYwx5eXkwNjaWGjCsNWo1LXAejwdTU9NG1VHZ9aKurt5sfqGS1k9DQ6PZfN/oHCDNRWPOi9be8q7Uuv88IYQQQlopSuCEEEJIC0QJ/DUaGhpwc3OjrkPyTggEAqxYsaLaee3lhc4BIm/N8bxorlrNTWyEEEJIW0ItcEIIIaQFogROCCGEtECUwAkhhJAWiBI4IYQQ0gK1+gQ+YcIEKCoqguM4qKio4Pvvv6+1/DfffAMVFRVwHAdFRUVMmjSpShk/Pz8IBAJwHAeBQIDPPvvsbYVPWpiAgABYWlpCKBSie/fuuHDhQo1lL168iD59+kBHRwfKysqwsbHB119/XaXcoUOHYGtrC4FAAFtbWxw+fLje8cjy/Q8ICICGhgZ4PJ7ku+3t7S1VRlNTExzHVXnp6+vXOybStshyTgBAcXExli1bBnNzcwgEAlhZWWHXrl1SZbZu3YpOnTpBWVkZZmZm+O9//4uioqK3eRjNE2vF5s+fzwCwqVOnsmPHjjEnJycGgF2+fLna8hEREQwAc3JyYseOHWNTp05lANiiRYskZXbs2MEAsEGDBrHQ0FA2aNAgBoD99NNP7+qwSDN14MABpqioyHbu3MliY2PZp59+ylRVVVliYmK15W/cuMH27dvH7t69y+Lj49nevXuZiooK27Fjh6TM5cuXGZ/PZ1999RWLi4tjX331FVNQUGBXrlypMx5Zv//79u1j8+bNY0eOHGEXLlxgs2fPZgDYf/7zH0mZR48esVu3bkleR44cYQDYhx9+KOOnRdoCWc8JxhgbOXIk69WrFztz5gyLj49nUVFR7NKlS5L1wcHBTCAQsF9++YXFx8ezU6dOMSMjI7ZgwYJ3cUjNSqtO4KqqqszW1lZqmZKSEuvdu3e15Xv27MmUlJSklnXu3JmpqalJ3puZmTFdXV2pMjo6Oqxdu3ZNFDVpqXr27Mlmz54ttczGxoYtWbKk3nWMHj2aTZ48WfJ+/PjxzMvLS6rM4MGD2YQJE+qsS9bvf3WMjIyYpaVljeu9vb0ZAPbixYt610naDlnPiT///JOJRCKWmZlZY50ff/wx69+/v9SyhQsXsr59+zY+4Bam1Xahv3r1Cvn5+Rg+fLjU8s6dOyMuLq7abe7du4fOnTtLLRsxYgRevXqFgoICAEBycjL69OkjVaZv3754/vx5E0ZPWpqSkhJcv34dgwYNklo+aNAgXL58uV513Lx5E5cvX4abm5tkWWRkZJU6Bw8eXGedDfn+v2n//v148eIF3nvvvRrL/Pnnn7CxsaEudFJFQ86Jo0ePwtnZGRs2bICJiQk6duyIRYsWobCwUFKmb9++uH79Oq5evQoAePLkCU6cOIFhw4a9vYNpplrNZCZvevDgAQCgffv2Usv19fURGxtb7TaFhYVVfhFVbv/gwQM4OTmhvLy8yixNJiYmKC8vb6rQSQuUkZGB8vJyGBgYSC03MDBAampqrduampoiPT0dZWVlWLlyJWbMmCFZl5qa2qA6G/L9r8Tn8yEWiwEA/fv3x+7du6stFxgYiOLiYixevLjW+kjb1JBz4smTJ7h48SKEQiEOHz6MjIwMzJ07F1lZWZLr4BMmTEB6ejr69u0LxhjKysowZ84cLFmy5K0fU3PTalvgld6cWpQxVut0o2+uq/xF9vq0dG9OUcdoMDvyD1m/bwBw4cIFREdH44cffsDWrVuxf//+RtfZmG3DwsLw+++/Y8qUKQgLC8Mnn3xSbbkNGzZAIBBg2rRp9YqFtE2yfAfFYjE4jsMvv/yCnj17YujQodiyZQuCgoIkrfDw8HB8+eWXCAgIwI0bNxASEoLjx49jzZo1b/1YmptW2wLv2LEjAODx48dSy9PT06GsrFztNsrKynjx4oXUsoSEBACAtbU1gIrWydOnT6XKJCcng8/nN0XYpIXS1dUFn8+v0rJIS0ur0gJ5k6WlJQCgS5cuePHiBVauXImJEycCAAwNDRtUZ0O+/5X69esHABgzZgySk5OxY8cOfPfdd1JlMjIycO/ePYwePbrWukjb1ZBzwsjICCYmJlLTgXbu3BmMMTx79gwdOnTA559/jilTpkh6qrp06YL8/HzMmjULy5Yta/VzgL+u1R6pmpoaVFVVERoaKrU8Li6uynXuSjY2NlWuDx4/fhxqampQUVEBABgbG1e5fnPp0qUq3eqkbVFSUkL37t1x5swZqeVnzpyBq6trvethjKG4uFjy3sXFpUqdp0+frrPOhnz/a4qnshfqdZXdlevXr693XaRtacg50adPHyQnJ+PVq1eSZQ8ePACPx4OpqSkAoKCgoEqS5vP5YBU3ZTfxUTRz8rl37t2ofIzG19eXHTt2jHXt2pUBYBcvXmSMMda7d2/Wvn17SfnKx8i6devGjh07xnx9fas8RvbDDz8wAMzLy4uFhoYyLy8veoyMMMb+fWTm559/ZrGxsWzBggVMVVWVJSQkMMYYW7JkCZsyZYqk/Pfff8+OHj3KHjx4wB48eMB27drFNDQ02LJlyyRlLl26xPh8Plu3bh2Li4tj69atk/kxsvp+/8eNG8eWL1/OTp8+zU6fPs2mTZvGALA+ffpUqVtDQ4OZmZk1+LMibYOs50ReXh4zNTVlY8eOZX///TeLiIhgHTp0YDNmzJCUWbFiBVNXV2f79+9nT548YadPn2ZWVlZs/Pjx7/z45K1VJ3DGGPvggw8Yn89nAJiysjL79ttvJeusrKyYSCSSKr9161amrKzMADAFBQU2ceLEKnUuXLiQKSkpMQBMSUmJ+fn5ve3DIC3Etm3bmLm5OVNSUmLdunVjERERknU+Pj7Mzc1N8v7bb79ldnZ2TEVFhWloaLCuXbuygIAAVl5eLlXnwYMHWadOnZiioiKzsbFhhw4dqnc8snz/x4wZwwQCAQMgKT9hwgRWWloqVefJkycZALZ27dp6x0HaLlnOCcYYi4uLYwMGDGDKysrM1NSULVy4kBUUFEjWl5aWspUrVzIrKysmFAqZmZkZmzt3Lnv58uU7OqLmg6YTJYQQQlqgVnsNnBBCCGnNKIETQgghLRAlcEIIIaQFogROCCGEtECUwAkhhJAWiBI4IYQQ0gJRAieEEEJaIErghBBCSAtECZyQWri7u2PBggXyDkPucch7/4SQqiiBkzbP19cXHMdVeT169Ejeob1zNSXqkJCQNjldIyHNWaudTpQQWXh5eSEwMFBqmZ6enpyiaXolJSVQUlJq8Pba2tpNGA0hpClQC5wQAAKBAIaGhlKv6uZ4Ly4uxvz586Gvrw+hUIi+ffvi2rVrkvXHjh2DpqamZArOmJgYcBwHPz8/SZmPPvpIMt93dfLz8zF16lSoqanByMgImzdvllpvYWGBrVu3Si1zcnLCypUrJe/d3d0xb948LFy4ELq6uhg4cCAA4OTJk+jbty80NTWho6OD4cOHS+YM9/X1RUREBL755htJL0RCQoKkvtdb5nV9Du7u7pg/fz4WL14MbW1tGBoaSsVXHbFYjK+++godOnSAUCiEgYEBpkyZUus2hLRllMAJkcHixYtx6NAh7N69Gzdu3IC1tTUGDx6MrKwsAEC/fv2Ql5eHmzdvAgAiIiKgq6uLiIgISR3h4eFwc3OrcR9+fn4ICwvD4cOHcfr0aYSHh+P69esyx7p7924oKCjg0qVL2LFjB4CKPw4WLlyIa9eu4ezZs+DxeBg9ejTEYjG++eYbuLi4YObMmUhJSUFKSgrMzMwa9DlU7l9VVRVRUVHYsGEDVq9eXWVu6NetXbsW+/btw48//oj79+8jJCQE7u7uMh83IW2GvKdDI0TefHx8GJ/PZ6qqqpLX2LFjGWOMubm5sU8//ZQxxtirV6+YoqIi++WXXyTblpSUMGNjY7ZhwwbJsm7durFNmzYxxhjz9vZmX375JVNSUmK5ubksJSWFAWBxcXHVxpKXl8eUlJTYgQMHJMsyMzOZsrKyJA5zc3P29ddfS23n6OjIVqxYIXnv5ubGnJyc6jz2tLQ0BoDduXOnyvG+TtbPwc3NjfXt21eqjh49erDPPvusxljee+89tnjx4jpjJoRUoBY4IQA8PDwQExMjeX377bdVyjx+/BilpaXo06ePZJmioiJ69uyJuLg4yTJ3d3eEh4eDMYYLFy5g1KhRsLe3x8WLFxEWFgYDAwPY2NhUG8fjx49RUlICFxcXyTJtbW106tRJ5mNydnautv5Jkyahffv20NDQgKWlJQAgKSmp3vXW93NwcHCQ2s7IyAhpaWk11jty5Ehs2rQJgwYNwg8//CDVmieEVEUJnBAAqqqqsLa2lryMjIyqlGGMAQA4jquy/PVl7u7uuHDhAm7dugUejwdbW1u4ubkhIiKizu7zyn3UhsfjVSlXWlpa7TG9acSIEcjMzMTOnTsRFRWFqKgoABU3udVXfT8HRUVFqfUcx0nuDajOokWLEBcXhwEDBuC7776DtbU14uPj6x0XIW0NJXBC6sna2hpKSkq4ePGiZFlpaSmio6PRuXNnybLK6+Bbt26Fm5sbOI6Dm5sbwsPD60zg1tbWUFRUxJUrVyTLXr58iQcPHkje6+npISUlRfI+Nze3XokuMzMTcXFxWL58OTw9PdG5c2e8fPlSqoySkhLKy8ub5HNoiI4dO2Lx4sW4ceMGCgoKEBsb26j6CGnN6DEyQupJVVUVc+bMgZ+fH7S1tdGuXTts2LABBQUF+PDDDyXlRCIRnJycEBwcjG+++QZARVIfN24cSktLa70xS01NDR9++CH8/Pygo6MDAwMDLFu2DDzev39r9+/fH0FBQRgxYgS0tLTw+eefV3vH/Ju0tLSgo6ODH3/8EUZGRkhKSsKSJUukylhYWCAqKgoJCQlQU1ODtra21L5l+RxksWHDBhgYGKBHjx7g8/n46aefoKWlBVdX1wbVR0hbQAmcEBmsW7cOYrEYU6ZMQV5eHpydnXHq1CloaWlJlfPw8MCNGzckyVpLSwu2trZITk6us5W6ceNGvHr1CiNHjoS6ujr+97//IScnR7J+6dKlePLkCYYPHw6RSIQ1a9bUqwXO4/Fw4MABzJ8/H/b29ujUqRO+/fZbqT8oFi1aBB8fH9ja2qKwsBDx8fGwsLBo8OdQX0VFRfjqq6+QlJQENTU19OnTB+fOnWtwfYS0BRyrz0U3QgghhDQrdA2cEEIIaYEogRNCCCEtECVwQgghpAWiBE4IIYS0QJTACSGEkBaIEjghhBDSAlECJ4QQQlogSuCEEEJIC0QJnBBCCGmBKIETQgghLRAlcEIIIaQFogROCCGEtED/D7hl8L5vit/mAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -222,14 +243,14 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|INFO|2023-12-20 08:04:36]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.3|INFO|2023-12-20 11:33:27]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -271,22 +292,22 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "New optimized step at iteration 1/10: 0.01793750114496096\n", - "New optimized step at iteration 2/10: 0.009205725351293752\n", - "New optimized step at iteration 3/10: 0.007968963636717416\n", - "New optimized step at iteration 4/10: 0.007300304878041382\n", - "New optimized step at iteration 5/10: 0.006149291001910284\n", - "New optimized step at iteration 6/10: 0.008468118348732902\n", - "New optimized step at iteration 7/10: 0.010900962182685027\n", - "New optimized step at iteration 8/10: 0.0096388986275741\n", - "New optimized step at iteration 9/10: 0.006651370934435026\n" + "New optimized step at iteration 1/10: 0.7062312186303615\n", + "New optimized step at iteration 2/10: 0.008532942926003376\n", + "New optimized step at iteration 3/10: 0.006606636973440978\n", + "New optimized step at iteration 4/10: 0.007800726979611531\n", + "New optimized step at iteration 5/10: 0.011122658550886365\n", + "New optimized step at iteration 6/10: 0.0067752987838349075\n", + "New optimized step at iteration 7/10: 0.00766267164940544\n", + "New optimized step at iteration 8/10: 0.0067358771941091475\n", + "New optimized step at iteration 9/10: 0.01048267830684162\n" ] } ], @@ -310,12 +331,12 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index e5a7eea793..3f6ab887d3 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -16,7 +16,7 @@ def visualize_matrix(matrix, title=""): - """Visualize hamiltonian in a heatmap form.""" + """Visualize absolute values of a matrix in a heatmap form.""" fig, ax = plt.subplots(figsize=(5, 5)) ax.set_title(title) try: @@ -29,7 +29,7 @@ def visualize_matrix(matrix, title=""): def visualize_drift(h0, h): """Visualize drift of the evolved hamiltonian w.r.t. h0.""" fig, ax = plt.subplots(figsize=(5, 5)) - ax.set_title(r"Drift: $|\hat{H}_0 - \hat{H}_{\ell}|$") + ax.set_title(r"Drift: $|\hat{H}_0 - \hat{H}_{1}|$") try: im = ax.imshow(np.absolute(h0 - h), cmap="inferno") except TypeError: @@ -68,15 +68,35 @@ def plot_histories(loss_histories: list, steps: list, labels: list = None): plt.title("Loss function histories") -def generate_Z_operators(n_qubits: int): - """Generate the full permutations of local_Z operators with n_qubits and their respective names. - +def generate_Z_operators(nqubits: int): + """Generate a dictionary containing 1) all possible products of Pauli Z operators for L = n_qubits and 2) their respective names. Return: Dictionary with the following keys - *"Z_operators"* - *"Z_words"* + + Example: + .. testcode:: + + from qibo.models.dbi.additional_double_bracket_functions import generate_Z_operators + from qibo.models.dbi.double_bracket import DoubleBracketIteration + from qibo.quantum_info import random_hermitian + from qibo.hamiltonians import Hamiltonian + import numpy as np + + nqubits = 4 + h0 = random_hermitian(2**nqubits) + dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) + generate_Z = generate_Z_operators(4) + Z_ops = generate_Z["Z_operators"] + Z_words = generate_Z["Z_operators"] + + 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) + print(norm_diff) """ - combination_strings = product("ZI", repeat=n_qubits) + combination_strings = product("ZI", repeat=nqubits) operator_map = {"Z": Z, "I": I} operators = [] operators_words = [] @@ -96,32 +116,39 @@ def generate_Z_operators(n_qubits: int): def iteration_from_list( - class_dbi: DoubleBracketIteration, + dbi_object: DoubleBracketIteration, d_list: list, step: float = None, + step_min: float = 1e-5, + step_max: float = 1, + max_evals: int = 100, compare_canonical: bool = True, ): """Perform 1 double-bracket iteration with an optimal diagonal operator. Args: - class_dbi (_DoubleBracketIteration): The object intended for double bracket iteration. + dbi_object (_DoubleBracketIteration): The object intended for double bracket iteration. d_list (list): List of diagonal operators (np.array) to run from. step (float): Fixed iteration duration. Defaults to ``None``, uses hyperopt. + 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. Returns: The index of the optimal diagonal operator and respective step duration. """ - h_before = deepcopy(class_dbi.h) - off_diagonal_norms = [] + h_before = deepcopy(dbi_object.h) + norms_off_diagonal_restriction = [] + optimal_steps = [] for d in d_list: - # fixed step + # prescribed step durations if step is not None: - class_dbi(step=step, d=d) - # hyperopt + dbi_object(step=step, d=d) + # compute step durations using hyperopt else: - step = class_dbi.hyperopt_step( + step = dbi_object.hyperopt_step( step_min=1e-5, step_max=1, space=hp.uniform, @@ -129,57 +156,40 @@ def iteration_from_list( max_evals=100, d=d, ) - off_diagonal_norms.append(class_dbi.off_diagonal_norm) - class_dbi.h = deepcopy(h_before) + optimal_steps.append(step) + norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) + dbi_object.h = deepcopy(h_before) # canonical if compare_canonical is True: - generator_type = class_dbi.mode - class_dbi.mode = DoubleBracketGeneratorType.canonical + generator_type = dbi_object.mode + dbi_object.mode = DoubleBracketGeneratorType.canonical if step is not None: - class_dbi(step=step) + dbi_object(step=step) else: - step = class_dbi.hyperopt_step( - step_min=1e-5, - step_max=1, + step = dbi_object.hyperopt_step( + step_min=step_min, + step_max=step_max, space=hp.uniform, optimizer=tpe, - max_evals=100, + max_evals=max_evals, ) - off_diagonal_norms.append(class_dbi.off_diagonal_norm) - class_dbi.h = deepcopy(h_before) - class_dbi.mode = generator_type + optimal_steps.append(step) + norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) + dbi_object.h = deepcopy(h_before) + dbi_object.mode = generator_type # find best d - idx_max_loss = off_diagonal_norms.index(min(off_diagonal_norms)) + idx_max_loss = norms_off_diagonal_restriction.index( + min(norms_off_diagonal_restriction) + ) + step_optimal = optimal_steps[idx_max_loss] # run with optimal d if idx_max_loss == len(d_list): # canonical - generator_type = class_dbi.mode - class_dbi.mode = DoubleBracketGeneratorType.canonical - if step is not None: - class_dbi(step=step) - else: - step = class_dbi.hyperopt_step( - step_min=1e-5, - step_max=1, - space=hp.uniform, - optimizer=tpe, - max_evals=100, - ) - class_dbi.mode = generator_type + generator_type = dbi_object.mode + dbi_object.mode = DoubleBracketGeneratorType.canonical + dbi_object(step=step) + dbi_object.mode = generator_type else: d_optimal = d_list[idx_max_loss] - # fixed step - if step is not None: - class_dbi(step=step, d=d_optimal) - # hyperopt - else: - step = class_dbi.hyperopt_step( - step_min=1e-5, - step_max=1, - space=hp.uniform, - optimizer=tpe, - max_evals=100, - d=d_optimal, - ) - + dbi_object(step=step, d=d_optimal) return idx_max_loss, step From 5222045f57ccdf70ca6c5d606a8d1cfe101d8e3e Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 20 Dec 2023 12:11:49 +0800 Subject: [PATCH 13/48] Added missed arguments changes --- src/qibo/models/dbi/additional_double_bracket_functions.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index 3f6ab887d3..a396dc215c 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -149,11 +149,11 @@ def iteration_from_list( # compute step durations using hyperopt else: step = dbi_object.hyperopt_step( - step_min=1e-5, - step_max=1, + step_min=step_min, + step_max=step_max, space=hp.uniform, optimizer=tpe, - max_evals=100, + max_evals=max_evals, d=d, ) optimal_steps.append(step) From 9913226472ede6767a8fa87dc5d3a949e85c2839 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 20 Dec 2023 17:34:04 +0800 Subject: [PATCH 14/48] Rename notebooks, added mixed strategy tests and fixed minor issue with visualize_matrix --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 519 ++++++++++++++++++ examples/dbi/Z_search.ipynb | 381 ------------- ...i.ipynb => dbi_tutorial_basic_intro.ipynb} | 0 .../additional_double_bracket_functions.py | 36 +- 4 files changed, 548 insertions(+), 388 deletions(-) create mode 100644 examples/dbi/DBI_strategy_Pauli-Z_products.ipynb delete mode 100644 examples/dbi/Z_search.ipynb rename examples/dbi/{dbi.ipynb => dbi_tutorial_basic_intro.ipynb} (100%) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb new file mode 100644 index 0000000000..32271f6f07 --- /dev/null +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -0,0 +1,519 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-Bracket Iteration Strategy: Pauli-Z products\n", + "\n", + "In this example, we demonstrate the usage of the DBI strategy: Pauli-Z products, where the diagonal operator is chosen as the optimal product of Pauli-Z operators." + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import copy, deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", + "from qibo.models.dbi.additional_double_bracket_functions import *\n", + "from qibo.symbols import I, X, Z" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The initial setup\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": 112, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.3|INFO|2023-12-20 17:31:22]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], + "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": "markdown", + "metadata": {}, + "source": [ + "## Local Z operators\n", + "Denoted as local Z operators, the diagonal operators used for this strategy are tensor products of pauli Z and identity." + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: 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 = generate_local_Z[\"Z_operators\"]\n", + "Z_names = generate_local_Z[\"Z_words\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Iteration from list" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 1/10: 0.226541694813849 with operator ZZZZI\n", + "New optimized step at iteration 2/10: 0.04365219052800224 with operator ZIIIZ\n", + "New optimized step at iteration 3/10: 0.0004223910173936202 with operator ZIIIZ\n", + "New optimized step at iteration 4/10: 0.0005286811447081021 with operator ZIIIZ\n", + "New optimized step at iteration 5/10: 0.005143071387459883 with operator ZIIIZ\n", + "New optimized step at iteration 6/10: 0.035695046259435294 with operator IIIZZ\n", + "New optimized step at iteration 7/10: 0.051138876252057375 with operator IZIIZ\n", + "New optimized step at iteration 8/10: 0.058915541216558114 with operator IIIZZ\n", + "New optimized step at iteration 9/10: 0.06227076215089642 with operator IIZII\n", + "New optimized step at iteration 10/10: 0.004415480749114426 with operator ZIIIZ\n" + ] + } + ], + "source": [ + "NSTEPS = 10\n", + "Z_optimal = []\n", + "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", + "steps = [0]\n", + "for _ in range(NSTEPS):\n", + " idx, step = select_best_dbr_generator_and_run(dbi, Z_ops, compare_canonical=False)\n", + " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", + " steps.append(steps[-1]+step)\n", + " if idx == len(Z_ops):\n", + " Z_optimal.append(\"canonical\")\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]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.3|INFO|2023-12-20 17:31:23]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], + "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": 117, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 1/10: 0.7146460310874032\n", + "New optimized step at iteration 2/10: 0.01295934582879973\n", + "New optimized step at iteration 3/10: 0.0073423008284427375\n", + "New optimized step at iteration 4/10: 0.005757100401123474\n", + "New optimized step at iteration 5/10: 0.00725004121094582\n", + "New optimized step at iteration 6/10: 0.00878215971833188\n", + "New optimized step at iteration 7/10: 0.008138545510328506\n", + "New optimized step at iteration 8/10: 0.008905425886364926\n", + "New optimized step at iteration 9/10: 0.0071714932971553135\n", + "New optimized step at iteration 10/10: 0.0050508011630583174\n" + ] + } + ], + "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", + " step = dbi_canonical.hyperopt_step(\n", + " step_min = 1e-5,\n", + " step_max = 1,\n", + " space = hp.uniform,\n", + " optimizer = tpe,\n", + " max_evals = 100,\n", + " )\n", + " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}\")\n", + " dbi_canonical(step=step)\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": 118, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 118, + "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(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": "markdown", + "metadata": {}, + "source": [ + "Here we see that variationally chosen diagonal operators are less likely to converge to a local minimum compared to the GWW flow. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mixed strategy\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": 119, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], + "source": [ + "dbi_mixed= DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "print(\"Initial off diagonal norm\", dbi_mixed.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 0.7146460310874032, 0.01295934582879973, 0.0073423008284427375, 0.005757100401123474, 0.00725004121094582, 0.00878215971833188, 0.008138545510328506, 0.008905425886364926, 0.0071714932971553135, 0.0050508011630583174]\n", + "[37.94733192202055, 28.819909345949704, 22.92044340981513, 21.188224428205743, 21.154011569814752, 21.152981183370528, 21.15289615375783, 21.15289397912285, 21.15289385280897, 21.152893836911957, 21.152893836305644]\n" + ] + } + ], + "source": [ + "print(steps_canonical)\n", + "print(off_diagonal_norm_history_canonical)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "After 2 steps, off diagonal norm: 22.92044340981513\n", + "By comparison, the Pauli-Z: 27.697127814319394\n" + ] + } + ], + "source": [ + "# Run the initial iterations using canonical iterations\n", + "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", + "steps_mixed = [0]\n", + "cannonical_NSTEPS = 2\n", + "for i in range(cannonical_NSTEPS):\n", + " step = steps_canonical[i+1]\n", + " dbi_mixed(step=step)\n", + " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", + " steps_mixed.append(step)\n", + " \n", + "print(\"After 2 steps, off diagonal norm:\", dbi_mixed.off_diagonal_norm)\n", + "print(\"By comparison, the Pauli-Z:\", off_diagonal_norm_history[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 1/8: 0.05941564262362324 with operator ZZIZZ\n", + "New optimized step at iteration 2/8: 0.03940145130227511 with operator ZIZIZ\n", + "New optimized step at iteration 3/8: 0.0011280629619659756 with operator canonical\n", + "New optimized step at iteration 4/8: 0.0006687287367940978 with operator canonical\n", + "New optimized step at iteration 5/8: 7.009154476669683e-05 with operator canonical\n", + "New optimized step at iteration 6/8: 0.0006524905648483872 with operator canonical\n", + "New optimized step at iteration 7/8: 0.0004846714536669654 with operator canonical\n", + "New optimized step at iteration 8/8: 0.00042762745962869885 with operator canonical\n" + ] + } + ], + "source": [ + "# Continue the remaining steps with Pauli-Z operators\n", + "Z_optimal_mixed = [\"Cannonical\" for _ in range(cannonical_NSTEPS)]\n", + "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", + "dbi_mixed.mode = DoubleBracketGeneratorType.single_commutator\n", + "for _ in range(remaining_NSTEPS):\n", + " idx, step = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True)\n", + " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", + " steps_mixed.append(step)\n", + " if idx == len(Z_ops):\n", + " Z_optimal_mixed.append(\"canonical\")\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[-1]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[37.94733192202055, 28.819909345949704, 22.92044340981513, 21.34720527797985, 21.054031744647673, 20.213777401246823, 19.785419985540294, 19.744094238325083, 19.37058316672788, 19.1198463086939, 18.91557430830763]\n", + "[0, 0.7146460310874032, 0.01295934582879973, 0.05941564262362324, 0.03940145130227511, 0.0011280629619659756, 0.0006687287367940978, 7.009154476669683e-05, 0.0006524905648483872, 0.0004846714536669654, 0.00042762745962869885]\n", + "['Cannonical', 'Cannonical', 'ZZIZZ', 'ZIZIZ', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical']\n" + ] + } + ], + "source": [ + "print(off_diagonal_norm_history_mixed)\n", + "print(steps_mixed)\n", + "print(Z_optimal_mixed)" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histories(off_diagonal_norm_history_mixed, steps_mixed, Z_optimal_mixed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the mixed strategy does not necessarily give a better result, this could also be a result of the unstability of hyperopt." + ] + } + ], + "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/Z_search.ipynb b/examples/dbi/Z_search.ipynb deleted file mode 100644 index e6abf2317f..0000000000 --- a/examples/dbi/Z_search.ipynb +++ /dev/null @@ -1,381 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Double-Bracket Iteration Strategy: Local Z search\n", - "\n", - "In this example, we demonstrate the usage of the DBI strategy: local_Z_search, where the diagonal operator is chosen as the optimal local Z operator for the system." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "from copy import deepcopy\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "from hyperopt import hp, tpe\n", - "\n", - "from qibo import hamiltonians, set_backend\n", - "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", - "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", - "from qibo.models.dbi.additional_double_bracket_functions import *\n", - "from qibo.symbols import I, X, Z\n", - "import warnings" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The initial setup\n", - "\n", - "As an example, we consider the Transverse Field Ising Model (TFIM):\n", - "$$ H_{\\rm TFIM} = - \\sum_{q=0}^{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": 20, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.3|INFO|2023-12-20 11:56:07]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "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 = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", - "\n", - "# initialize class\n", - "# Note: use deepcopy to prevent h being edited\n", - "dbi = DoubleBracketIteration(h,mode=DoubleBracketGeneratorType.single_commutator)\n", - "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n", - "visualize_matrix(h.matrix)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Local Z operators\n", - "Denoted as local Z operators, the diagonal operators used for this strategy are tensor products of pauli Z and identity." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 11:55:40]: 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 = generate_local_Z[\"Z_operators\"]\n", - "Z_names = generate_local_Z[\"Z_words\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n" - ] - } - ], - "source": [ - "# Verify the Z_ops are correct\n", - "# $\\Delta(A) =\\sum_{\\mu\\in\\{0,1\\}^{\\times L} Z_\\mu A Z_\\mu$\" we get $\\|\\Delta(A) - A.diag()\\| \\le eps\\|$.\n", - "dephasing_channel = (sum([Z_op @ h.matrix @ Z_op for Z_op in Z_ops]) + h.matrix)/2**nqubits\n", - "norm_diff = np.linalg.norm(dbi.diagonal_h_matrix - dephasing_channel)\n", - "print(norm_diff)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Iteration from list" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 0/10: 0.22461177968747748 with operator ZZZZI norm 31.966734538297906\n", - "New optimized step at iteration 1/10: 0.03845265033885956 with operator ZIIIZ norm 27.755939593307335\n", - "New optimized step at iteration 2/10: 0.027099927986183554 with operator ZIIIZ norm 26.044733973096722\n", - "New optimized step at iteration 3/10: 0.05949237161426739 with operator IIIZZ norm 23.92910659572215\n", - "New optimized step at iteration 4/10: 0.0004024883635361719 with operator canonical norm 23.670167587947244\n", - "New optimized step at iteration 5/10: 0.03839567611025839 with operator IZIIZ norm 21.759377111077235\n", - "New optimized step at iteration 6/10: 0.05508708960922482 with operator IZIIZ norm 20.5315164700773\n", - "New optimized step at iteration 7/10: 0.026984254777118407 with operator IIIZZ norm 18.615202254486412\n", - "New optimized step at iteration 8/10: 0.093631252308069 with operator ZIZZI norm 15.114330234612124\n", - "New optimized step at iteration 9/10: 0.004424997817894337 with operator canonical norm 13.533609007340472\n" - ] - } - ], - "source": [ - "NSTEPS = 10\n", - "Z_optimal = []\n", - "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", - "steps = [0]\n", - "for _ in range(NSTEPS):\n", - " idx, step = iteration_from_list(dbi, Z_ops, step_max=0.6)\n", - " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", - " steps.append(step)\n", - " if idx == len(Z_ops):\n", - " Z_optimal.append(\"canonical\")\n", - " else:\n", - " Z_optimal.append(Z_names[idx])\n", - " print(f\"New optimized step at iteration {_}/{NSTEPS}: {step} with operator {Z_optimal[-1]} norm {dbi.off_diagonal_norm}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_histories(off_diagonal_norm_history, steps, Z_optimal)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Compare with canonical" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.3|INFO|2023-12-20 11:33:27]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "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 = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", - "\n", - "# initialize class|\n", - "# Note: use deepcopy to prevent h being edited\n", - "dbi_canonical = DoubleBracketIteration(h,mode=DoubleBracketGeneratorType.canonical)\n", - "print(\"Initial off diagonal norm\", dbi_canonical.off_diagonal_norm)\n", - "visualize_matrix(h.matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 1/10: 0.7062312186303615\n", - "New optimized step at iteration 2/10: 0.008532942926003376\n", - "New optimized step at iteration 3/10: 0.006606636973440978\n", - "New optimized step at iteration 4/10: 0.007800726979611531\n", - "New optimized step at iteration 5/10: 0.011122658550886365\n", - "New optimized step at iteration 6/10: 0.0067752987838349075\n", - "New optimized step at iteration 7/10: 0.00766267164940544\n", - "New optimized step at iteration 8/10: 0.0067358771941091475\n", - "New optimized step at iteration 9/10: 0.01048267830684162\n" - ] - } - ], - "source": [ - "off_diagonal_norm_history = [dbi_canonical.off_diagonal_norm]\n", - "steps = [0]\n", - "for s in range(NSTEPS):\n", - " if s != 0:\n", - " step = dbi_canonical.hyperopt_step(\n", - " step_min = 1e-5,\n", - " step_max = 1,\n", - " space = hp.uniform,\n", - " optimizer = tpe,\n", - " max_evals = 100,\n", - " )\n", - " print(f\"New optimized step at iteration {s}/{NSTEPS}: {step}\")\n", - " dbi_canonical(step=step)\n", - " off_diagonal_norm_history.append(dbi_canonical.off_diagonal_norm)\n", - " steps.append(step)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_histories(off_diagonal_norm_history, steps)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we see that variationally chosen diagonal operators are less likely to converge to a local minimum compared to the GWW flow" - ] - } - ], - "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.ipynb b/examples/dbi/dbi_tutorial_basic_intro.ipynb similarity index 100% rename from examples/dbi/dbi.ipynb rename to examples/dbi/dbi_tutorial_basic_intro.ipynb diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index a396dc215c..3e4b40e795 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -1,4 +1,4 @@ -from copy import deepcopy +from copy import copy, deepcopy from itertools import product import matplotlib.pyplot as plt @@ -58,7 +58,7 @@ def plot_histories(loss_histories: list, steps: list, labels: list = None): plt.yticks(y_labels_rounded) if labels is not None: - labels_copy = labels + labels_copy = copy(labels) labels_copy.insert(0, "Initial") for i, label in enumerate(labels_copy): plt.text(x_axis[i], loss_histories[i], label) @@ -115,7 +115,7 @@ def generate_Z_operators(nqubits: int): return {"Z_operators": operators, "Z_words": operators_words} -def iteration_from_list( +def select_best_dbr_generator( dbi_object: DoubleBracketIteration, d_list: list, step: float = None, @@ -124,7 +124,7 @@ def iteration_from_list( max_evals: int = 100, compare_canonical: bool = True, ): - """Perform 1 double-bracket iteration with an optimal diagonal operator. + """Selects the best double bracket rotation generator from a list. Args: dbi_object (_DoubleBracketIteration): The object intended for double bracket iteration. @@ -182,14 +182,36 @@ def iteration_from_list( min(norms_off_diagonal_restriction) ) step_optimal = optimal_steps[idx_max_loss] + return idx_max_loss, step_optimal + + +def select_best_dbr_generator_and_run( + dbi_object: DoubleBracketIteration, + d_list: list, + step: float = None, + step_min: float = 1e-5, + step_max: float = 1, + max_evals: int = 100, + compare_canonical: bool = True, +): + """Run double bracket iteration with generator chosen from a list.""" + idx_max_loss, step_optimal = select_best_dbr_generator( + dbi_object, + d_list, + step=step, + step_min=step_min, + step_max=step_max, + max_evals=max_evals, + compare_canonical=compare_canonical, + ) # run with optimal d if idx_max_loss == len(d_list): # canonical generator_type = dbi_object.mode dbi_object.mode = DoubleBracketGeneratorType.canonical - dbi_object(step=step) + dbi_object(step=step_optimal) dbi_object.mode = generator_type else: d_optimal = d_list[idx_max_loss] - dbi_object(step=step, d=d_optimal) - return idx_max_loss, step + dbi_object(step=step_optimal, d=d_optimal) + return idx_max_loss, step_optimal From d75b3575a5d3994534f343011c62c2db94e59c81 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 5 Jan 2024 13:13:13 +0900 Subject: [PATCH 15/48] Resolved issue for functools.partial, reason for previous error unclear (could be order of args). --- src/qibo/models/dbi/double_bracket.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 082ca1f4ea..3729085b03 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -1,5 +1,6 @@ from copy import deepcopy from enum import Enum, auto +from functools import partial import hyperopt import numpy as np @@ -147,15 +148,13 @@ def hyperopt_step( optimizer = hyperopt.tpe space = space("step", step_min, step_max) - objective = lambda step: self.loss(step=step, d=d, look_ahead=look_ahead) best = hyperopt.fmin( - fn=objective, + 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 loss(self, step: float, d: np.array = None, look_ahead: int = 1): From 2085c3db1b816468ad2e34b0a2a136fd877b2988 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 5 Jan 2024 14:16:56 +0900 Subject: [PATCH 16/48] 1. Simplify generate_Z_operators function with added function str_to_op 2. Deleted plotting functions --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 238 +++++++++++------- .../additional_double_bracket_functions.py | 96 ++----- 2 files changed, 170 insertions(+), 164 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 32271f6f07..826a22270a 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 111, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -28,6 +28,65 @@ "from qibo.symbols import I, X, Z" ] }, + { + "cell_type": "code", + "execution_count": 2, + "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": {}, @@ -41,14 +100,15 @@ }, { "cell_type": "code", - "execution_count": 112, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|INFO|2023-12-20 17:31:22]: Using qibojit (numba) backend on /CPU:0\n" + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", + "[Qibo 0.2.4|INFO|2024-01-05 14:12:53]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -87,51 +147,51 @@ }, { "cell_type": "code", - "execution_count": 113, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.3|WARNING|2023-12-20 17:31:22]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: 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 = generate_local_Z[\"Z_operators\"]\n", - "Z_names = generate_local_Z[\"Z_words\"]" + "Z_ops = list(generate_local_Z.values())\n", + "Z_names = list(generate_local_Z.keys())" ] }, { @@ -143,23 +203,23 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "New optimized step at iteration 1/10: 0.226541694813849 with operator ZZZZI\n", - "New optimized step at iteration 2/10: 0.04365219052800224 with operator ZIIIZ\n", - "New optimized step at iteration 3/10: 0.0004223910173936202 with operator ZIIIZ\n", - "New optimized step at iteration 4/10: 0.0005286811447081021 with operator ZIIIZ\n", - "New optimized step at iteration 5/10: 0.005143071387459883 with operator ZIIIZ\n", - "New optimized step at iteration 6/10: 0.035695046259435294 with operator IIIZZ\n", - "New optimized step at iteration 7/10: 0.051138876252057375 with operator IZIIZ\n", - "New optimized step at iteration 8/10: 0.058915541216558114 with operator IIIZZ\n", - "New optimized step at iteration 9/10: 0.06227076215089642 with operator IIZII\n", - "New optimized step at iteration 10/10: 0.004415480749114426 with operator ZIIIZ\n" + "New optimized step at iteration 1/10: 0.2228337317596202 with operator ZZZZI\n", + "New optimized step at iteration 2/10: 0.035477924096777136 with operator IIIZZ\n", + "New optimized step at iteration 3/10: 0.035172652127034264 with operator ZIIIZ\n", + "New optimized step at iteration 4/10: 0.05284947697359669 with operator IIZIZ\n", + "New optimized step at iteration 5/10: 0.05945391423239668 with operator ZIIIZ\n", + "New optimized step at iteration 6/10: 0.06722463454874757 with operator IZIII\n", + "New optimized step at iteration 7/10: 0.0004656172832855188 with operator IIIZZ\n", + "New optimized step at iteration 8/10: 0.0004368451128360077 with operator IIIZZ\n", + "New optimized step at iteration 9/10: 0.0004206499567262245 with operator IIIZZ\n", + "New optimized step at iteration 10/10: 0.0017291128494125731 with operator IIIZZ\n" ] } ], @@ -181,12 +241,12 @@ }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -219,14 +279,14 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.3|INFO|2023-12-20 17:31:23]: Using qibojit (numba) backend on /CPU:0\n" + "[Qibo 0.2.4|INFO|2024-01-05 14:14:34]: Using qibojit (numba) backend on /CPU:0\n" ] }, { @@ -251,23 +311,23 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "New optimized step at iteration 1/10: 0.7146460310874032\n", - "New optimized step at iteration 2/10: 0.01295934582879973\n", - "New optimized step at iteration 3/10: 0.0073423008284427375\n", - "New optimized step at iteration 4/10: 0.005757100401123474\n", - "New optimized step at iteration 5/10: 0.00725004121094582\n", - "New optimized step at iteration 6/10: 0.00878215971833188\n", - "New optimized step at iteration 7/10: 0.008138545510328506\n", - "New optimized step at iteration 8/10: 0.008905425886364926\n", - "New optimized step at iteration 9/10: 0.0071714932971553135\n", - "New optimized step at iteration 10/10: 0.0050508011630583174\n" + "New optimized step at iteration 1/10: 0.7142480688060842\n", + "New optimized step at iteration 2/10: 0.010872949360825475\n", + "New optimized step at iteration 3/10: 0.006641176164949921\n", + "New optimized step at iteration 4/10: 0.008158790292294325\n", + "New optimized step at iteration 5/10: 0.01138407139374301\n", + "New optimized step at iteration 6/10: 0.00599341515517138\n", + "New optimized step at iteration 7/10: 0.00804371900698387\n", + "New optimized step at iteration 8/10: 0.01154541035249238\n", + "New optimized step at iteration 9/10: 0.0066184869859390386\n", + "New optimized step at iteration 10/10: 0.011473689491291406\n" ] } ], @@ -292,22 +352,22 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 118, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACJKUlEQVR4nOzdd3gUVdvA4d9ueocAIYSEEEqA0Duh9ypdaUq3IF0siL4KiBJA4aMK+qqEVzpSFem999A7CaEkhJZK+s73R8zKkkI2bVKe+7rmYnfmzJlnN0v2yZlTNIqiKAghhBBCFCJatQMQQgghhMhtkgAJIYQQotCRBEgIIYQQhY4kQEIIIYQodCQBEkIIIUShIwmQEEIIIQodSYCEEEIIUehIAiSEEEKIQkcSICGEEEIUOpIACaNduHCBoUOH4uHhgaWlJba2ttSpU4dZs2bx7NkztcPLs2rXrk3p0qVJTExMs0yTJk0oXrw4cXFxWb7e/v370Wg07N+/3+hzr1y5wpQpUwgICEhxbMiQIZQtWzbL8WUXjUbDlClTMlTu5c3BwYGWLVuydevWHI2vbNmyDBkyRP88ICAAjUaDr69vhs59Ne5Xt5frzk6vvq/pfSZatmxJtWrVsnS92NhYFi5cSNOmTSlatCjm5uaULl2aPn36cODAgSzVrYZXf+7ZrWXLlrRs2TLH6i8MTNUOQOQv//3vfxk5ciSVKlXi008/xcvLi/j4eE6fPs2SJUs4duwYGzduVDvMPGn48OGMGTOGHTt20Llz5xTHb9y4wdGjRxk/fjzm5uZZvl6dOnU4duwYXl5eRp975coVpk6dSsuWLVMkO1999RXjxo3LcnxqePPNN/n444/R6XTcuXOHb7/9lq5du/Lnn3/SpUuXXImhVKlSHDt2jPLly7+27MaNG4mNjU312NixYzl9+jQ9evTI5giTHDt2DFdXV/3z9D4TWfXkyRM6duzIhQsXGDZsGJ9++imOjo48ePCAzZs306ZNG86cOUPNmjWz9bo5aePGjdjb26sdhkiPIkQGHT16VDExMVE6duyoxMTEpDgeGxurbN68WYXIckdUVFSWzn/27JliaWmp9O7dO9XjEydOVADlwoULWbpOXFycEh8fn6U61q1bpwDKvn37slRPbgCUyZMnZ6jcqFGjDPbdunVLAZS2bdvmUHSK4u7urgwePDhb65w9e7YCKJMmTcrWetOT3meiRYsWStWqVTNdd6dOnRRTU1Nlz549qR4/efKkcvfu3UzXXxC1aNFCadGihdph5GuSAIkMe+ONNxRTU1MlMDAwQ+UTExOVmTNnKpUqVVLMzc2VEiVKKAMHDlTu3btnUC75l+fRo0cVb29vxdLSUnF3d1d+++03RVEU5a+//lJq166tWFlZKdWqVVO2bdtmcP7kyZMVQDl79qzSs2dPxc7OTrG3t1fefvttJSQkxKDs6tWrlXbt2inOzs6KpaWlUrlyZWXixIlKZGSkQbnBgwcrNjY2yoULF5R27doptra2SqNGjRRFSUr0pk2bpn9dxYsXV4YMGZLiWqnp37+/Ym5urjx58sRgf0JCguLi4qLUr19fURRFuXnzpjJkyBClQoUKipWVleLi4qK88cYbKZKjffv2KYDyv//9T5kwYYLi4uKiaDQa5erVq/pjL39hnTp1Sunbt6/i7u6uf5/79eunBAQE6MssXbpUAVJsS5cu1b837u7uBnFER0crn3/+uVK2bFnFzMxMcXFxUUaOHKk8f/7coJy7u7vSpUsXZdu2bUrt2rUVS0tLpVKlSsqvv/5qUC4kJET58MMPlSpVqig2NjZKiRIllFatWikHDx5M8Z5mJQFSFEUpUaKEUrFiRUVRFGXnzp1Kt27dlNKlSysWFhZK+fLllffff195/PixwTmpvQeK8u9n8dXX/HIC5O/vb/B+Gmvv3r2Kqamp0r59eyUxMTHdsgsXLlQ0Go3y6NEj/b4ffvhBAZSRI0fq9yUmJipFihRRJkyYoN/38vv6us9E8v/hkydPKk2bNlWsrKwUDw8PxcfH57Uxnj59WgGUDz74IEOvP6OfjeT3+fvvv1dmz56tlC1bVrGxsVEaNWqkHDt2LEW9mzdvVho1aqRYWVkptra2Stu2bZWjR48alEn++V66dEnp16+fYm9vrzg5OSlDhw5VQkNDDcqmlvg+f/5cmTBhguLh4aH/ndipUyfl6tWr+jJTpkxRGjRooBQtWlSxs7NTateurfzyyy+KTqczqEsSoKyTPkAiQxITE9m7dy9169bFzc0tQ+d8+OGHTJw4kXbt2rFlyxamTZvG9u3bady4MU+ePDEoGxwczNChQ3n33XfZvHkz1atXZ9iwYXzzzTdMmjSJzz77jPXr12Nra0uPHj14+PBhiuv17NmTChUq8McffzBlyhQ2bdpEhw4diI+P15e5efMmnTt35tdff2X79u2MHz+etWvX0rVr1xT1xcXF0a1bN1q3bs3mzZuZOnUqOp2O7t27M2PGDAYMGMDWrVuZMWMGu3btomXLlkRHR6f7ngwfPpy4uDiWL19usH/Hjh08fPiQ4cOHA/Dw4UOKFSvGjBkz2L59O4sWLcLU1JSGDRty/fr1FPVOmjSJwMBAlixZwp9//omTk1Oq1w8ICKBSpUrMnTuXHTt2MHPmTIKCgqhfv77+Z9KlSxemT58OwKJFizh27BjHjh1L8xaRoij06NGDH374gYEDB7J161YmTJjAsmXLaN26dYpbOOfPn+fjjz/mo48+YvPmzdSoUYPhw4dz8OBBfZnkvmSTJ09m69atLF26lHLlytGyZctM9WlKy/Pnz3n69CklSpQA4Pbt23h7e7N48WJ27tzJ119/zYkTJ2jatKnB50gtgYGB9O3bF1dXV1atWoVWm/6v8LZt26IoCnv27NHv2717N1ZWVuzatUu/7/Tp04SGhtK2bdtU68nIZyI4OJi3336bd955hy1bttCpUycmTZqU4rP+qp07dwJk+FaesZ+NRYsWsWvXLubOncuKFSuIioqic+fOhIWF6cusXLmS7t27Y29vz6pVq/j11195/vw5LVu25PDhwynq7N27N56enqxfv57PP/+clStX8tFHH6Ubd0REBE2bNuWnn35i6NCh/PnnnyxZsgRPT0+CgoL05QICAvjggw9Yu3YtGzZsoFevXowZM4Zp06Zl6P0RRlA7AxP5Q3BwsAIo/fr1y1D5q1evpvgrU1EU5cSJEwqgfPHFF/p9LVq0UADl9OnT+n1Pnz5VTExMFCsrK+XBgwf6/X5+fgqgzJ8/X78v+a+yjz76yOBaK1asUABl+fLlqcao0+mU+Ph45cCBAwqgnD9/Xn9s8ODBCqBvhUq2atUqBVDWr19vsP/UqVMKoPz444/pvi86nU7x8PBQatSoYbC/d+/eirW1tRIWFpbqeQkJCUpcXJxSsWJFg9eZ3MrTvHnzFOek1gKUWr2RkZGKjY2NMm/ePP3+9G53vNr6sX37dgVQZs2aZVBuzZo1CqD8/PPP+n3JLU8v386Ijo5WHB0d020BSEhIUOLj45U2bdooPXv2NDiGES1AI0eOVOLj45W4uDjl6tWrSqdOnRRAWbRoUYryyZ+Pu3fvKoDB7V01WoCio6OVunXrKlZWVsrZs2czfJ6rq6sybNgwRVGSWi9tbGz0t1uTfw7fffedYmZmZtAS+ur7+rpbYIBy4sQJg/1eXl5Khw4d0o1vxIgRCqBcu3Ytw6/pZWl9NpLf5+rVqysJCQn6/SdPnlQAZdWqVYqiJLV+ubi4KNWrVzdorYqIiFCcnJyUxo0b6/cl/3xf/ayPHDlSsbS0NGilefXn/s033yiAsmvXrgy/tsTERCU+Pl755ptvlGLFihnULy1AWSctQCJH7Nu3DyDFKIgGDRpQpUoVg79IIaljaN26dfXPHR0dcXJyolatWri4uOj3V6lSBYC7d++muObbb79t8LxPnz6YmprqYwG4c+cOAwYMwNnZGRMTE8zMzGjRogUAV69eTVFn7969DZ7/9ddfFClShK5du5KQkKDfatWqhbOz82tbJzQaDUOHDuXChQucOXMGgKdPn/Lnn3/Su3dvfafJhIQEpk+fjpeXF+bm5piammJubs7NmzczFGdaIiMjmThxIhUqVMDU1BRTU1NsbW2JiopKtd6M2Lt3L5DyZ/3WW29hY2OT4mddq1YtypQpo39uaWmJp6dnip/pkiVLqFOnDpaWlpiammJmZsaePXsyHSfAjz/+iJmZGebm5lSpUoWjR4/yzTffMHLkSABCQkIYMWIEbm5u+mu6u7sDqX8+ssvLn6WEhAQURUlRZsSIEZw5c4affvqJ2rVrZ7juNm3asHv3bgCOHj3KixcvmDBhAsWLF9e3Au3evRtvb29sbGwy/RqcnZ1p0KCBwb4aNWqk+n81q4z5bHTp0gUTExODmODf3yHXr1/n4cOHDBw40KBFzdbWlt69e3P8+HFevHhhUGe3bt0MnteoUYOYmBhCQkLSjHnbtm14enqm2cqWbO/evbRt2xYHBwf976ivv/6ap0+fplu/MJ4kQCJDihcvjrW1Nf7+/hkq//TpUyApsXmVi4uL/ngyR0fHFOXMzc1T7E8eHRUTE5OivLOzs8FzU1NTihUrpr9WZGQkzZo148SJE3z77bfs37+fU6dOsWHDBoAUt6+sra1TjOJ49OgRoaGhmJubY2ZmZrAFBwenuLWXmqFDh6LValm6dCkAK1asIC4uTn/7C2DChAl89dVX9OjRgz///JMTJ05w6tQpatasmeptttTe59QMGDCAhQsX8u6777Jjxw5OnjzJqVOnKFGixGtv36Xl6dOnmJqa6m8jJdNoNDg7O6f4WRcrVixFHRYWFgbXnzNnDh9++CENGzZk/fr1HD9+nFOnTtGxY8dMxwlJSfGpU6c4ffo0169f5+nTp3z11VcA6HQ62rdvz4YNG/jss8/Ys2cPJ0+e5Pjx40DKz0d2CQgISPFZenXY94IFC1i2bBmjR49m4MCBRtXftm1bAgMDuXnzJrt376Z27do4OTnRunVrdu/eTXR0NEePHn3tF/PrZOTnmprkZDijv1uM/Wy8GpeFhQXw78/zdb+rdDodz58/N6rO1Dx+/NhgVF1qTp48Sfv27YGkEbdHjhzh1KlTfPnll6+tXxhPhsGLDDExMaFNmzZs27aN+/fvv/Y/cvIviKCgoBRlHz58SPHixbM9xuDgYEqXLq1/npCQwNOnT/Wx7N27l4cPH7J//359qw9AaGhoqvVpNJoU+4oXL06xYsXYvn17qufY2dm9Nk5XV1fat2/PypUrmT17NkuXLqVChQo0b95cX2b58uUMGjRI3+8i2ZMnTyhSpEiGYn1VWFgYf/31F5MnT+bzzz/X74+Njc3S/E3FihUjISGBx48fGyRBiqIQHBxM/fr1ja5z+fLltGzZksWLFxvsj4iIyHScACVKlKBevXqpHrt06RLnz5/H19eXwYMH6/ffunUrRVlLS8tUh6dnJAF+lYuLC6dOnTLYV6lSJf3jQ4cO8fHHH9O0aVPmzJljdP1t2rQBklp5du3aRbt27fT7//Of/3Dw4EFiY2OznABlVocOHfjiiy/YtGkTHTt2fG357P5svPy76lUPHz5Eq9VStGjRTNX9shIlSnD//v10y6xevRozMzP++usvLC0t9fs3bdqU5euLlKQFSGTYpEmTUBSF9957L9WJ+uLj4/nzzz8BaN26NUCKDpCnTp3i6tWr+l/K2WnFihUGz9euXUtCQoJ+srDkJCH5r7VkP/30U4av8cYbb/D06VMSExOpV69eiu3lL670DB8+nOfPn/P111/j5+fH0KFDDZIYjUaTIs6tW7fy4MGDDMf6Ko1Gg6IoKer95ZdfUkzOmJG/aJMl/yxf/VmvX7+eqKioTP2sU3v9Fy5c4NixY0bXZcw1IWOfj7JlyxISEsKjR4/0++Li4tixY4fR1zU3N0/xOUpOpB88eMBbb71F8eLFWbduHWZmZkbXX6pUKby8vFi/fj1nzpzRJ0Dt2rXj8ePHzJkzB3t7+9cmqsZ8JoxRp04dOnXqxK+//qq/nfqq06dPExgYCGT/Z6NSpUqULl2alStXGtx6jIqKYv369Xh7e2NtbZ2pul/WqVMnbty4keZrhKTXZmpqanDLLjo6mt9//z3L1xcpSQuQyLDk0TEjR46kbt26fPjhh1StWpX4+HjOnTvHzz//TLVq1ejatSuVKlXi/fffZ8GCBWi1Wjp16kRAQABfffUVbm5urx0xkRkbNmzA1NSUdu3acfnyZb766itq1qxJnz59AGjcuDFFixZlxIgRTJ48GTMzM1asWMH58+czfI1+/fqxYsUKOnfuzLhx42jQoAFmZmbcv3+fffv20b17d3r27Pnaerp160bx4sX5/vvvMTExMWhxgKREy9fXl8qVK1OjRg3OnDnD999//9qWt/TY29vTvHlzvv/+e4oXL07ZsmU5cOAAv/76a4pWpeRZfX/++Wfs7OywtLTEw8Mj1dsc7dq1o0OHDkycOJHw8HCaNGnChQsXmDx5MrVr1zb6lg0kvf5p06YxefJkWrRowfXr1/nmm2/w8PAgISEhU6//dSpXrkz58uX5/PPPURQFR0dH/vzzT4PRUsn69u3L119/Tb9+/fj000+JiYlh/vz56c7ybay4uDh69erFo0ePmD17NgEBAanOwmxvb//ayS7btGnDggULsLKyokmTJgB4eHjg4eHBzp076datG6am6X8dGPOZMNb//vc/OnbsSKdOnRg2bBidOnWiaNGiBAUF8eeff7Jq1SrOnDlDmTJlsv2zodVqmTVrFm+//TZvvPEGH3zwAbGxsXz//feEhoYyY8aMLL8+gPHjx7NmzRq6d+/O559/ToMGDYiOjubAgQO88cYbtGrVii5dujBnzhwGDBjA+++/z9OnT/nhhx9SJHwim6jZA1vkT35+fsrgwYOVMmXKKObm5oqNjY1Su3Zt5euvvzaYCyd5HiBPT0/FzMxMKV68uPLOO++kOQ/Qq5LnjHkVr8znkjwy48yZM0rXrl0VW1tbxc7OTunfv7/B/CeKoujnGrK2tlZKlCihvPvuu8rZs2dTjMpJngcoNfHx8coPP/yg1KxZU7G0tFRsbW2VypUrKx988IFy8+bNDL2HiqIoH330kQIonTt3TnHs+fPnyvDhwxUnJyfF2tpaadq0qXLo0KEUIz+SR3qtW7cuRR2pjQK7f/++0rt3b/0cIx07dlQuXbqU6pwlc+fOVTw8PBQTE5MMzQM0ceJExd3dXTEzM1NKlSqlfPjhh2nOA/SqV19XbGys8sknnyilS5dWLC0tlTp16iibNm1K9dpkcR6gl125ckVp166dYmdnpxQtWlR56623lMDAwFSv8ffffyu1atVSrKyslHLlyikLFy7M1lFgyeVet2VkJNDmzZsVQGnXrp3B/vfeey/FqMpkqb3mtD4Taf0fTmu0XGqio6OV+fPnK97e3oq9vb1iamqquLi4KL169VK2bt2qL5fRz8bL8wBl5LVt2rRJadiwoWJpaanY2Ngobdq0UY4cOWJQJvnn++q8UMnzJPn7++v3pTUP0Lhx45QyZcooZmZmipOTk9KlSxeDEXC//fabUqlSJcXCwkIpV66c4uPjo/z6668p6pdRYFmnUZRUhhsIkY9MmTKFqVOn8vjx4xzpWySEEKLgkT5AQgghhCh0JAESQgghRKEjt8CEEEIIUehIC5AQQgghCh1JgIQQQghR6EgCJIQQQohCRyZCTIVOp+Phw4fY2dllaIkBIYQQQqhPURQiIiJwcXExWNw2NZIApeLhw4e4ubmpHYYQQgghMuHevXuvnTlfEqBUJK/Dc+/evRSrgQshhBAibwoPD8fNzS1DC1NLApSK5Nte9vb2kgAJIYQQ+UxGuq9IJ2ghhBBCFDqSAAkhhBCi0JEESAghhBCFjvQBEkIIUeAlJiYSHx+vdhgiG5ibm792iHtGSAIkhBCiwFIUheDgYEJDQ9UORWQTrVaLh4cH5ubmWapHEiAhhBAFVnLy4+TkhLW1tUxum88lT1QcFBREmTJlsvTzlARICCFEgZSYmKhPfooVK6Z2OCKblChRgocPH5KQkICZmVmm65FO0EIIIQqk5D4/1tbWKkcislPyra/ExMQs1SMJkBBCiAJNbnsVLNn185QESAghhBCFjiRAQgghRCEzZcoUatWqpX8+ZMgQevTooVo8apAESAghhMhjhgwZgkajQaPRYGZmRrly5fjkk0+IiorKkevNmzcPX1/fNI/7+vrq40ltGzp0aI7ElZMkAcplIcH3uXPphNphCCGEyOM6duxIUFAQd+7c4dtvv+XHH3/kk08+yZFrOTg4UKRIkTSP9+3bl6CgoBTbV199hbm5Oe+9916OxJWTJAHKRWe2/07xxdVI2DRa7VCEEELkcRYWFjg7O+Pm5saAAQN4++232bRpE8uXL6devXrY2dnh7OzMgAEDCAkJ0Z/n6+ubIpnZtGlTup2HX3cLzMrKCmdnZ4Pt+vXr+Pj4sGjRIho3bpzVl5vrZB6gXFS2ZnO0xxUqxN/kwvUb1KjkqXZIQghRqCiKQnR81oZPZ4aVmUmWRy9ZWVkRHx9PXFwc06ZNo1KlSoSEhPDRRx8xZMgQ/v7772yK9vXu3r3LW2+9xQcffMC7776ba9fNTpIA5aJipdy5b+mJa8wNzu/9gxqVvlA7JCGEKFSi4xPx+npHrl/3yjcdsDbP/FfuyZMnWblyJW3atGHYsGH6/eXKlWP+/Pk0aNCAyMhIbG1tsyPcdL148YKePXtStWpV5s6dm+PXyylyCyyXWVbtDEDxh/u4//yFytEIIYTIq/766y9sbW2xtLTE29ub5s2bs2DBAs6dO0f37t1xd3fHzs6Oli1bAhAYGJgt112xYgW2trb67dChQwbHhw8fzvPnz1m3bh2mpvm3HUXVyBcvXszixYsJCAgAoGrVqnz99dd06tQJSHuyo1mzZvHpp5+meszX1zfV3ujR0dFYWlpmT+BZULxONzgzl6baiyw8fJNJXWuqHZIQQhQaVmYmXPmmgyrXNVarVq1YvHgxZmZmuLi4YGZmRlRUFO3bt6d9+/YsX76cEiVKEBgYSIcOHYiLiwOSFgtVFMWgruRZsTOiW7duNGzYUP+8dOnS+sczZ85ky5YtHD16lOLFixv9mvISVRMgV1dXZsyYQYUKFQBYtmwZ3bt359y5c1StWpWgoCCD8tu2bWP48OH07t073Xrt7e25fv26wb68kPwAUKo2sZbFsYt5wu3Tu4hsXxVbi/ybQQshRH6i0WiydCsqN9nY2Oi/H5Ndu3aNJ0+eMGPGDNzc3AA4ffq0QZkSJUoQERFBVFQUNjY2APj5+WX4unZ2dtjZ2aXYv337dr788ktWrVpFzZr5/493VT8FXbt2NXj+3XffsXjxYo4fP07VqlVxdnY2OL5582ZatWpFuXLl0q1Xo9GkODfP0Goxr9wB/FbgnXiatafuMayph9pRCSGEyAfKlCmDubk5CxYsYMSIEVy6dIlp06YZlGnYsCHW1tZ88cUXjBkzhpMnT6Y7x09G3Lx5k/79+/Puu+/SrFkzgoODDY6bm5vj6OiYpWvktjzTBygxMZHVq1cTFRWFt7d3iuOPHj1i69atDB8+/LV1RUZG4u7ujqurK2+88Qbnzp1Lt3xsbCzh4eEGW07SeHYEoLX2LL8d8SdRp7zmDCGEECKpdcfX15d169bh5eXFjBkz+OGHHwzKODo6snz5cv7++2+qV6/OqlWrmDJlSpauu3LlSkJDQ/npp58oVapUiq1Xr15Zql8NGuXVG4W57OLFi3h7exMTE4OtrS0rV66kc+fOKcrNmjWLGTNm8PDhw3RvZx0/fpxbt25RvXp1wsPDmTdvHn///Tfnz5+nYsWKqZ4zZcoUpk6dmmJ/WFgY9vb2mX9xaYmNQJnpgUYXT6vY2Xw2oAudqpfK/usIIUQhFhMTg7+/Px4eHnmnG4TIsvR+ruHh4Tg4OGTo+1v1BCguLo7AwEBCQ0NZv349v/zyCwcOHMDLy8ugXOXKlWnXrh0LFiwwqn6dTkedOnVo3rw58+fPT7VMbGwssbGx+ufh4eG4ubnlXAIE8L/ucGc/0+Lf5rzrO/zxYf6bREoIIfIySYAKpuxKgFS/BWZubk6FChWoV68ePj4+1KxZk3nz5hmUOXToENevX8/UZEtarZb69etz8+bNNMtYWFhgb29vsOW4f26DtTXx4/Td5/jdC835awohhBACyAMJ0KsURTFojQH49ddfqVu3bqZ6nSuKgp+fH6VK5bFbTJ5JwzAbaK9hxwt+PeyvckBCCCFE4aFqAvTFF19w6NAhAgICuHjxIl9++SX79+/n7bff1pcJDw9n3bp1abb+DBo0iEmTJumfT506lR07dnDnzh38/PwYPnw4fn5+jBgxIsdfj1Ecy0GxipiQSDPtBf6+GMSD0Gi1oxJCCCEKBVUToEePHjFw4EAqVapEmzZtOHHiBNu3b6ddu3b6MqtXr0ZRFPr3759qHYGBgQbzBYWGhvL+++9TpUoV2rdvz4MHDzh48CANGjTI8ddjtH9agfo5XCFRp7DsaIC68QghhBCFhOqdoPMiYzpRZYn/IVj2BnEWRakctgAbS3OOTWojEyMKIUQ2kE7QBVOB6QRdqJVpBBYOmMc+p7PjAyJiElh3+p7aUQkhhBAFniRAajIxgwqtAfjA+RYAS48EyMSIQgghRA6TBEht/wyHrxp5jCLWZgQ+e8GuK49UDkoIIYQo2CQBUluFdoAGbcglRtSyAOA3GRIvhBAin/D19aVIkSLZVt/+/fvRaDSEhoZmW52pkQRIbTbFwC1phNoAx+uYmWg4GfCM8zIxohBCFGrBwcGMGTOGcuXKYWFhgZubG127dmXPnj1qh2agb9++3LhxQ+0wjCYJUF5QsT0A9oF76FrDBUAmRhRCiEIsICCAunXrsnfvXmbNmsXFixfZvn07rVq1YtSoUWqHZ8DKygonJye1wzCaJEB5wT/9gLizn+GNnAH4+2IQD2ViRCGEKJRGjhyJRqPh5MmTvPnmm3h6elK1alUmTJjA8ePHAZgzZw7Vq1fHxsYGNzc3Ro4cSWRkpL6O5FtTO3bsoEqVKtja2tKxY0eDufN0Oh3ffPMNrq6uWFhYUKtWLbZv364/HhAQgEajYcOGDbRq1Qpra2tq1qzJsWPHUlznZVu2bKFevXpYWlpSvHhxg9Xily9fTr169bCzs8PZ2ZkBAwYQEhKS3W/ha0kClBeUrAr2rpAQQ9XY83iXK0aCTmHZsQC1IxNCiIJFUSAuKvc3I6bce/bsGdu3b2fUqFHY2NikOJ6cbGi1WubPn8+lS5dYtmwZe/fu5bPPPjMo++LFC3744Qd+//13Dh48SGBgIJ988on++Lx585g9ezY//PADFy5coEOHDnTr1i3F+plffvkln3zyCX5+fnh6etK/f38SEhJSjX/r1q306tWLLl26cO7cOfbs2UO9evX0x+Pi4pg2bRrnz59n06ZN+Pv7M2TIkAy/P9lFZtzLCzSapFmhT/8KN3YwvOlEjt15yqoTgYxtXREbmRhRCCGyR/wLmO6S+9f94iGYp0xmUnPr1i0URaFy5crplhs/frz+sYeHB9OmTePDDz/kxx9/1O+Pj49nyZIllC9fHoDRo0fzzTff6I//8MMPTJw4kX79+gEwc+ZM9u3bx9y5c1m0aJG+3CeffEKXLl2ApCWnqlatyq1bt1KN8bvvvqNfv35MnTpVv+/ltTyHDRumf1yuXDnmz59PgwYNiIyMxNbWNt3XnJ2kBSiv+GdZDG7soHWlEngUtyE8JoE/ztxXNy4hhBC5KnmBBo1Gk265ffv20a5dO0qXLo2dnR2DBg3i6dOnREVF6ctYW1vrkx+AUqVK6W83hYeH8/DhQ5o0aWJQb5MmTbh69arBvho1ahjUAaR528rPz482bdqkGfe5c+fo3r077u7u2NnZ0bJlSyBpaavcJE0LeYVHczC1gvD7aB9fYViTsny1+TK/HfHnnUbumGjT/48ghBAiA8ysk1pj1LhuBlWsWBGNRsPVq1fp0aNHqmXu3r1L586dGTFiBNOmTcPR0ZHDhw8zfPhw4uPj/72smZnBeRqNhldXwHo10VIUJcW+l+tJPqbT6VKNzcrKKs3XFhUVRfv27Wnfvj3Lly+nRIkSBAYG0qFDB+Li4tI8LydIC1BeYWYF5VokPb6xnd51XXGwMuPu0xfsuSoTIwohRLbQaJJuReX29prWnJc5OjrSoUMHFi1aZNCakyw0NJTTp0+TkJDA7NmzadSoEZ6enjx8aFxiZ29vj4uLC4cPHzbYf/ToUapUqWJUXS+rUaNGmkP1r127xpMnT5gxYwbNmjWjcuXKqnSABkmA8pZ/hsNzcyfW5qYMaFgGgF9kSLwQQhQqP/74I4mJiTRo0ID169dz8+ZNrl69yvz58/H29qZ8+fIkJCSwYMEC7ty5w++//86SJUuMvs6nn37KzJkzWbNmDdevX+fzzz/Hz8+PcePGZTr2yZMns2rVKiZPnszVq1e5ePEis2bNAqBMmTKYm5vr496yZQvTpk3L9LWyQhKgvCS5H9C9kxD1lMHeZTHVajjp/4yL98PUjU0IIUSu8fDw4OzZs7Rq1YqPP/6YatWq0a5dO/bs2cPixYupVasWc+bMYebMmVSrVo0VK1bg4+Nj9HXGjh3Lxx9/zMcff0z16tXZvn07W7ZsoWLFipmOvWXLlqxbt44tW7ZQq1YtWrduzYkTJwAoUaIEvr6+rFu3Di8vL2bMmMEPP/yQ6WtlhUZ59WagIDw8HAcHB8LCwrC3t8/diy9uCo8uQs+foGY/Plrjx8ZzD+hRy4W5/WrnbixCCJGPxcTE4O/vj4eHB5aWlmqHI7JJej9XY76/pQUor3lpNBjA8KYeAPx1IYjgsBi1ohJCCCEKFEmA8prkBOjWHkiMp1ppBxp6OMrEiEIIIUQ2kgQoryldF6yLQWwYBCZNd57cCrTyRCAv4lKfeVMIIYQQGScJUF6jNfl3NNiNpPVY2lQpSdli1oRFx7NeJkYUQgghskwSoLwo+TbYzZ0AmGg1DG2S1Ar025EAdDrpty6EEBklY30Kluz6eUoClBeVbw1aU3hyA57eBuDNuq7YW5ri/ySKvdfUmTRKCCHyk+TZi1+8eKFyJCI7Jc8YbWJikqV6ZCmMvMjSAcp4Q8ChpFagYh9iY2HKgIbuLDlwm18O36GtV0m1oxRCiDzNxMSEIkWK6Gcatra2fu36WiJv0+l0PH78GGtra0xNs5bCSAKUV3l2TEqAbmyHRh8CMLixO78cusPxO8+49CCMaqUdVA5SCCHyNmdnZyDthTtF/qPVailTpkyWk1lJgPIqzw6w80sIOAKxEWBhRykHK7rUKMVmv4f8dtifOX1rqR2lEELkaRqNhlKlSuHk5GSwSKjIv8zNzdFqs96DRxKgvKpYBXAsB8/uwO194NUNSBoSv9nvIVvOP2Rip8qUtJfZTYUQ4nVMTEyy3GdEFCzSCTqv0miSboOBflZogBquRWhQNmlixP/JxIhCCCFEpkgClJfph8PvAJ1Ov3t4s6Qh8StkYkQhhBAiUyQBysvKNAZzO4h6DEHn9LvbVilJGUdrQl/Es/7sAxUDFEIIIfInSYDyMlNzKN8q6fFLt8FMtBqGNSkLwNLD/jIxohBCCGEkSYDyOn0/oO0Gu9+q54adpSl3nkSx77oM7xRCCCGMIQlQXlexHaCBoPMQHqTfbWNhyoAGZQD49bC/SsEJIYQQ+ZOqCdDixYupUaMG9vb22Nvb4+3tzbZt2/THhwwZgkajMdgaNWr02nrXr1+Pl5cXFhYWeHl5sXHjxpx8GTnL1glK10l6/M/aYMkGNy6LiVbD0dtPufwwTIXghBBCiPxJ1QTI1dWVGTNmcPr0aU6fPk3r1q3p3r07ly9f1pfp2LEjQUFB+u3vv/9Ot85jx47Rt29fBg4cyPnz5xk4cCB9+vThxIkTOf1yck4qw+EBXIpY0bl6KQB+OxyQy0EJIYQQ+ZdGyWPL5Do6OvL9998zfPhwhgwZQmhoKJs2bcrw+X379iU8PNygJaljx44ULVqUVatWZaiO8PBwHBwcCAsLw97e3tiXkP2CzsNPzcHMGj7zB7N/Jz/0uxdKj0VHMDPRcGRia5xkYkQhhBCFlDHf33mmD1BiYiKrV68mKioKb29v/f79+/fj5OSEp6cn77333mvXczl27Bjt27c32NehQweOHj2a5jmxsbGEh4cbbHmKcw2wKwXxL+DuYYNDtdyKUM+9KPGJCv87dlelAIUQQoj8RfUE6OLFi9ja2mJhYcGIESPYuHEjXl5eAHTq1IkVK1awd+9eZs+ezalTp2jdujWxsbFp1hccHEzJkoYrpZcsWZLg4OA0z/Hx8cHBwUG/ubm5Zc+Lyy4aDVT8J6l75TYYwLv6iRHvEh2XmJuRCSGEEPmS6glQpUqV8PPz4/jx43z44YcMHjyYK1euAEm3s7p06UK1atXo2rUr27Zt48aNG2zdujXdOl9dIVZRlHRXjZ00aRJhYWH67d69e1l/Ydnt5eHwr9y1bOfljJujFc9fxLPh3H0VghNCCCHyF9UTIHNzcypUqEC9evXw8fGhZs2azJs3L9WypUqVwt3dnZs3b6ZZn7Ozc4rWnpCQkBStQi+zsLDQj0RL3vKcci3AxAJCA+HxNYNDJloNQxsntQL9JhMjCiGEEK+legL0KkVR0rzF9fTpU+7du0epUqXSPN/b25tdu3YZ7Nu5cyeNGzfO1jhznbkNeDRLepzKbbA+9d2wszDl9uMoDtx4nMvBCSGEEPmLqgnQF198waFDhwgICODixYt8+eWX7N+/n7fffpvIyEg++eQTjh07RkBAAPv376dr164UL16cnj176usYNGgQkyZN0j8fN24cO3fuZObMmVy7do2ZM2eye/duxo8fr8IrzGZpDIcHsLUwpV+DpL5Lvxy+k5tRCSGEEPmOqgnQo0ePGDhwIJUqVaJNmzacOHGC7du3065dO0xMTLh48SLdu3fH09OTwYMH4+npybFjx7Czs9PXERgYSFDQvzMkN27cmNWrV7N06VJq1KiBr68va9asoWHDhmq8xOyV3BH63nF48SzF4eSJEY/cesrVoDw2kk0IIYTIQ/LcPEB5QZ6bB+hlP3pDyBXo/StUfzPF4VErz7L1QhBv1nXlh7dqqhCgEEIIoY58OQ+QyCD9cPjtqR5+t2lSZ+gtfg8JiYjJraiEEEKIfEUSoPwmuR/QzV2QmJDicO0yRalTpghxiTqWy8SIQgghRKokAcpvXOuDVVGICYX7J1Mt8m6zcgAsPxFITLxMjCiEEEK8ShKg/MbEFCq0S3qcymgwgPZeJXEtasWzqDg2nnuQi8EJIYQQ+YMkQPmRZ4ekf9NIgExNtAxpXBaAXw/7I/3chRBCCEOSAOVH5VuDxgQeX4XnAakW6VvfDVsLU26FRMrEiEIIIcQrJAHKj6wdoUyjpMc3dqZaxM7SjL71kyZG/PWwf25FJoQQQuQLkgDlV8m3wW6mfhsMYEjjsmg1cOjmE64HR+RSYEIIIUTeJwlQflXxnwTI/yDERqZaxM3Rmk7VktZN+1WWxxBCCCH0JAHKr0pUgiLukBgH/gfSLDbsn4kRN517yOOI1BeZFUIIIQobSYDyK40m3cVRk9V1L0rt5IkRj8vEiEIIIQRIApS/eSYvi7ED0hnqPvyfVqDlx+/KxIhCCCEEkgDlb+5NwcwGIoMh6HyaxTpWdaZ0ESueRsWx2U8mRhRCCCEkAcrPzCyhfKukx+ncBpOJEYUQQghDppk5ac+ePezZs4eQkBB0Op3Bsd9++y1bAhMZ5NkBrv2VNBy+5cQ0i/Vt4Mbc3Te48SiSQzef0NyzRC4GKYQQQuQtRrcATZ06lfbt27Nnzx6ePHnC8+fPDTaRyyr+0w/owRmIDEmzmL2lGX3rlwHgF5kYUQghRCFndAvQkiVL8PX1ZeDAgTkRjzCWnTOUqgVBfnBzJ9R+J82iQ5uUxfeoPwdvPObGowg8S9rlWphCCCFEXmJ0C1BcXByNGzfOiVhEZumHw29Pt5ibozUdqjoD8Ju0AgkhhCjEjE6A3n33XVauXJkTsYjMSl4W4/Y+SIhLt2jykPgN5x7wJFImRhRCCFE4GX0LLCYmhp9//pndu3dTo0YNzMzMDI7PmTMn24ITGVSqFtg4QVQI3D3y78iwVNR1L0pNtyKcvxfKiuOBjGtbMffiFEIIIfIIo1uALly4QK1atdBqtVy6dIlz587pNz8/vxwIUbyWVms4KWI6NBoN7/7TCvT78QCZGFEIIUShZHQL0L59+3IiDpFVnh3h3PKkfkAdfZKWykhDp2rOuDhY8jAshi1+D+lT3y0XAxVCCCHUl6WJEO/fv8+DBzKzcJ5QriWYmMNzf3h6K92ipiZahjQpC8jEiEIIIQonoxMgnU7HN998g4ODA+7u7pQpU4YiRYowbdq0FJMiilxkYQfuTZIev2Y0GEDf+mWwNjfh+qMIDt96ksPBCSGEEHmL0QnQl19+ycKFC5kxYwbnzp3j7NmzTJ8+nQULFvDVV1/lRIwiozKwOnwyBysz+tRLuvX1qwyJF0IIUchoFCPvf7i4uLBkyRK6detmsH/z5s2MHDmyQNwSCw8Px8HBgbCwMOzt7dUOJ+Oe3YH5tUFrCp/eBqsi6Ra/+zSKlj/sR1Fg10fNqSgTIwohhMjHjPn+NroF6NmzZ1SuXDnF/sqVK/Ps2TNjqxPZybEcFPcEXQLc3vva4u7FbGjvVRKA345IK5AQQojCw+gEqGbNmixcuDDF/oULF1KzZs1sCUpkQfKkiBm4DQbwbrNyAGw4+4CnMjGiEEKIQsLoYfCzZs2iS5cu7N69G29vbzQaDUePHuXevXv8/fffORGjMIZnRzi6IGldMF0iaE3SLV7PvSg1XB24cD+MFScCGdtGJkYUQghR8BndAtSiRQtu3LhBz549CQ0N5dmzZ/Tq1Yvr16/TrFmznIhRGMOtIVg6QPSzpBXiX0Oj0eiXx/jfsbvEJsjEiEIIIQq+TM0D5OLiwnfffcf69evZsGED3377LS4uLkbXs3jxYmrUqIG9vT329vZ4e3uzbds2AOLj45k4cSLVq1fHxsYGFxcXBg0axMOHD9Ot09fXF41Gk2KLiYnJzEvNf0zMoHybpMcZGA4P0Ll6KUo5WPIkMpYtfum/v0IIIURBkKFbYBcuXKBatWpotVouXLiQbtkaNWpk+OKurq7MmDGDChUqALBs2TK6d+/OuXPncHV15ezZs3z11VfUrFmT58+fM378eLp168bp06fTrdfe3p7r168b7LO0tMxwXPmeZ0e4vCGpH1Cbr19b3MxEy+DGZZmx7Rq/HvbnzbquaNKZSVoIIYTI7zI0DF6r1RIcHIyTkxNarRaNRpPq7MEajYbExKzdQnF0dOT7779n+PDhKY6dOnWKBg0acPfuXcqUKZPq+b6+vowfP57Q0NBMx5Bvh8Eni3oKP1QARQfjL0GR1y91EfYinkY+e4iOT2TFuw1pUqF4LgQqhBBCZJ9sHwbv7+9PiRIl9I/v3LmDv79/iu3OnTuZDjoxMZHVq1cTFRWFt7d3qmXCwsLQaDQUKVIk3boiIyNxd3fH1dWVN954g3PnzmU6rnzJphi4Nkh6fHNnhk5xsDajTz1XAH45lPmfoxBCCJEfZCgBcnd3198SuXv3LqVLl8bd3d1gK126NHfv3jU6gIsXL2Jra4uFhQUjRoxg48aNeHl5pSgXExPD559/zoABA9LN6ipXroyvry9btmxh1apVWFpa0qRJE27evJnmObGxsYSHhxts+V4GV4d/2dAmHmg0sO/6Y26FROZQYEIIIYT6jJ4J2sTEhKCgIJycnAz2P336FCcnJ6NvgcXFxREYGEhoaCjr16/nl19+4cCBAwZJUHx8PG+99RaBgYHs37/fqNtSOp2OOnXq0Lx5c+bPn59qmSlTpjB16tQU+/PtLTCAR5dhcWMwtYTP/MHcOkOnvfe/0+y68ogBDcswvWf1HA5SCCGEyD45OhO0oiipdpB9+vQpNjY2xlaHubk5FSpUoF69evj4+FCzZk3mzZunPx4fH0+fPn3w9/dn165dRickWq2W+vXrp9sCNGnSJMLCwvTbvXv3jH4deY6TFzi4QUIMBBzK8Gnv/jMkfsPZ+zyLisup6IQQQghVZXgixF69egFJHZ2HDBmChYWF/lhiYiIXLlygcePGWQ5IURRiY5NmJE5Ofm7evMm+ffsoVqxYpurz8/OjevW0WzMsLCwMXk+BoNEkzQp96pek4fDJM0S/RgMPR6qVtufSg3BWnrjL6NYyMaIQQoiCJ8MJkIODA5CUUNjZ2WFlZaU/Zm5uTqNGjXjvvfeMuvgXX3xBp06dcHNzIyIigtWrV7N//362b99OQkICb775JmfPnuWvv/4iMTGR4OBgIGmkmLm5OQCDBg2idOnS+Pj4ADB16lQaNWpExYoVCQ8PZ/78+fj5+bFo0SKjYisQKiYnQDtAUZKSotfQaDS827Qc49f4sezYXd5rXg4L0/RnkxZCCCHymwwnQEuXLgWgbNmyfPrpp1hbZ6xPSXoePXrEwIEDCQoKwsHBgRo1arB9+3batWtHQEAAW7ZsAaBWrVoG5+3bt4+WLVsCEBgYiFb775280NBQ3n//fYKDg3FwcKB27docPHiQBg0aZDnefMejGZhaQfgDeHQJnDPWp6dz9VLM2HaN4PAY/jofRO+6rjkcqBBCCJG7jO4E7e/vT0JCAhUrGt4auXnzJmZmZpQtWzY741NFvp8H6GUr+8GNbdD6K2j+SYZP+3H/LWZtv06VUvb8PbapTIwohBAiz8vRTtBDhgzh6NGjKfafOHGCIUOGGFudyGmZGA4PMKBBGazMTLgaFM6xO09zIDAhhBBCPUYnQOfOnaNJkyYp9jdq1Ag/P7/siElkp4r/dH6+fwqinmT4tCLW5rz5z62vXw/550RkQgghhGqMToA0Gg0REREp9oeFhWV5GQyRAxxK/9P3R4Gbu4w6dWiTsmg0sOdaCHcey8SIQgghCg6jE6BmzZrh4+NjkOwkJibi4+ND06ZNszU4kU08Oyb9e9O422DlStjSpnLShJe/HZFWICGEEAVHhkeBJZs1axbNmzenUqVKNGvWDIBDhw4RHh7O3r17sz1AkQ0qdoCD38OtPZAYDyZmGT51eNNy7L4awtpT9xnkXRbPknY5GKgQQgiRO4xuAfLy8uLChQv06dOHkJAQIiIiGDRoENeuXaNatWo5EaPIqtJ1wLo4xIZD4DGjTm1UzpE2lZ2IS9Tx8drzxCfqcihIIYQQIvcYPQy+MChQw+CTbfwQzq8E79HQ4TujTg0Jj6Hd/x0kLDqeCe08GdtGZocWQgiR92T7MPgLFy6g0+n0j9PbRB6VvBSGkcPhAZzsLfmme1UA5u+5yeWHYdkZmRBCCJHrMtQCpNVqCQ4OxsnJCa1Wi0ajIbXTNBpNgRgJViBbgGLCYFY50CXAmLNQrLxRpyuKwofLz7L9cjCVne3YMrop5qZG30EVQgghcowx398Z6gTt7+9PiRIl9I9FPmTpAO6Nwf9gUiuQ90ijTtdoNHzbsxonA55xLTiCBXtv8nH7SjkUrBBCCJGzMvQnvLu7OxqNhvj4eKZMmUJiYiLu7u6pbiIPy+Rw+GTFbS34tkdSR/cf99/m/L3QbApMCCGEyF1G3cMwMzNj48aNORWLyGnJs0IHHIGY8ExV0bl6KbrWdCFRp/DxuvPExOf/W55CCCEKH6M7cfTs2ZNNmzblQCgixxWvAI7lQRcPd/ZluppvulWlhJ0Ft0Ii+b9dN7IxQCGEECJ3GD0RYoUKFZg2bRpHjx6lbt262NjYGBwfO3ZstgUncoBnRzi+KKkfkFf3TFVR1MYcn57Vefd/p/n50B3aVy1JXXfHbA5UCCGEyDlGzwPk4eGRdmUaDXfu3MlyUGorkKPAkt05AP/rBjYl4OMboM38SK6P155n/dn7eBS34e+xzbAyN8nGQIUQQgjjZPsosJfJKLB8row3mNtB1GN4eA5c62a6qq+7enHk1hP8n0Qxa8c1Jnetmo2BCiGEEDnH6D//v/nmG168eJFif3R0NN988022BCVykKk5VGid9PjG9ixV5WBlxsw3awCw9EgAx+88zWp0QgghRK4wOgGaOnUqkZGRKfa/ePGCqVOnZktQIodlcTj8y1p4lqB/AzcAPv3jPFGxCVmuUwghhMhpRidAiqKg0WhS7D9//jyOjtIRNl+o0A7QQNB5CH+Y5eq+7OJF6SJW3HsWzfS/r2Y9PiGEECKHZTgBKlq0KI6Ojmg0Gjw9PXF0dNRvDg4OtGvXjj59+uRkrCK72JaA0v/0/bm5M+vVWZjy/VtJt8JWnAjk0M3HWa5TCCGEyEkZ7gQ9d+5cFEVh2LBhTJ06FQcHB/0xc3NzypYti7e3d44EKXKAZ0d4cDppOHzdIVmurnH54gz2dmfZsbt89scFdnzUHHtLs6zHKYQQQuQAo4fBHzhwgCZNmmBqavQAsnyjQA+DTxZ0AX5qBmbW8Jk/mFlmucoXcQl0nneIgKcveKuuK9+/VTMbAhVCCCEyxpjvb6P7ANnZ2XH16r/9PDZv3kyPHj344osviIuLMz5aoQ7n6mDnAvEvIOBwtlRpbW7K92/VRKOBdWfus/fao2ypVwghhMhuRidAH3zwATduJC1/cOfOHfr27Yu1tTXr1q3js88+y/YARQ7RaMCzfdLjLA6Hf1n9so4Mb5I0Webn6y8S+kKSYiGEEHmP0QnQjRs3qFWrFgDr1q2jRYsWrFy5El9fX9avX5/d8YmclDwc/sYOMO5OaLo+6VCJ8iVsCImIZcqWy9lWrxBCCJFdMjUMXqfTAbB79246d+4MgJubG0+ePMne6ETO8mgBppYQFgiPr2VbtZZmJvzwVk20Gtjk95Dtl4KzrW4hhBAiOxidANWrV49vv/2W33//nQMHDtClSxcgaYmMkiVLZnuAIgeZW0PZZkmPs/E2GEDtMkUZ0aI8AF9uvMjTyNhsrV8IIYTICqMToLlz53L27FlGjx7Nl19+SYUKFQD4448/aNy4cbYHKHKYZ4ekf29kfVboV41rW5HKznY8jYrjq82XMHLAoRBCCJFjjB4Gn5aYmBhMTEwwM8v/c78UimHwyUIDYW510Gjh09tgnb2zeV96EEaPRUdI0CnM71+bbjVdsrV+IYQQIlmODoMHCA0N5ZdffmHSpEk8e/YMgCtXrhASEpKZ6oSaipQBp6qg6ODWnmyvvlppB0a3Tmol/HrzJUIiYrL9GkIIIYSxjE6ALly4QMWKFZk5cyY//PADoaGhAGzcuJFJkyZld3wiN+TAcPiXjWpVgaou9oS+iOeLDXIrTAghhPqMToAmTJjA0KFDuXnzJpaW/84e3KlTJw4ePGhUXYsXL6ZGjRrY29tjb2+Pt7c327Zt0x9XFIUpU6bg4uKClZUVLVu25PLl1w+rXr9+PV5eXlhYWODl5cXGjRuNiqvQSR4Of2sXJGb/au5mJlpm96mJmYmG3VcfseHsg2y/hhBCCGEMoxOgU6dO8cEHH6TYX7p0aYKDjRvu7OrqyowZMzh9+jSnT5+mdevWdO/eXZ/kzJo1izlz5rBw4UJOnTqFs7Mz7dq1IyIiIs06jx07Rt++fRk4cCDnz59n4MCB9OnThxMnThj3QgsT1/pgVRRiwuD+yRy5RGVne8a39QRgyp+XCQqLzpHrCCGEEBlhdAJkaWlJeHh4iv3Xr1+nRIkSRtXVtWtXOnfujKenJ56ennz33XfY2tpy/PhxFEVh7ty5fPnll/Tq1Ytq1aqxbNkyXrx4wcqVK9Osc+7cubRr145JkyZRuXJlJk2aRJs2bZg7d66xL7Xw0JpAxZy9DQbwQfNy1HQrQkRMAhPXX5RbYUIIIVRjdALUvXt3vvnmG+Lj4wHQaDQEBgby+eef07t370wHkpiYyOrVq4mKisLb2xt/f3+Cg4Np3769voyFhQUtWrTg6NGjadZz7Ngxg3MAOnTokO45sbGxhIeHG2yFjj4Byv7h8MlMTbTMfqsmFqZaDt54zOpT93LsWkIIIUR6jE6AfvjhBx4/foyTkxPR0dG0aNGCChUqYGdnx3fffWd0ABcvXsTW1hYLCwtGjBjBxo0b8fLy0t9Oe3VyxZIlS6Z7qy04ONjoc3x8fHBwcNBvbm5uRr+OfK9CG9CYJM0I/Twg5y7jZMunHSoB8O1fV7j37EWOXUsIIYRIi9EJkL29PYcPH2b9+vXMmDGD0aNH8/fff3PgwAFsbGyMDqBSpUr4+flx/PhxPvzwQwYPHsyVK1f0xzUajUF5RVFS7HuVsedMmjSJsLAw/XbvXiFsmbAqCmW8kx7f2JmjlxraxIP6ZYsSFZfIxPUX0OnkVpgQQojcZWpM4YSEBCwtLfHz86N169a0bt06ywGYm5vrZ5OuV68ep06dYt68eUycOBFIatEpVaqUvnxISEi6S244OzunaO153TkWFhZYWFhk5WUUDJ4d4O7hpH5ADd/PscuYaDV8/2ZNOs07xNHbT1l+4i6DvMvm2PWEEEKIVxnVAmRqaoq7uzuJiYk5FQ+KohAbG4uHhwfOzs7s2rVLfywuLo4DBw6ku+SGt7e3wTkAO3fulGU6MiJ5WYyAQxAbmaOXKlvchs87VQbA5+9rBDyJytHrCSGEEC8z+hbYf/7zH4MZoLPiiy++4NChQwQEBHDx4kW+/PJL9u/fz9tvv41Go2H8+PFMnz6djRs3cunSJYYMGYK1tTUDBgzQ1zFo0CCDCRjHjRvHzp07mTlzJteuXWPmzJns3r2b8ePHZzneAq+4JxQtC4lxcGd/jl9uYCN3vMsVIzo+kU//OE+i3AoTQgiRS4y6BQYwf/58bt26hYuLC+7u7in6/Zw9ezbDdT169IiBAwcSFBSEg4MDNWrUYPv27bRr1w6Azz77jOjoaEaOHMnz589p2LAhO3fuxM7OTl9HYGAgWu2/eVzjxo1ZvXo1//nPf/jqq68oX748a9asoWHDhsa+1MJHo0maFPHEEri5A6q8kaOX02o1zHqzBh3nHuRUwHOWHvHn3WblcvSaQgghBGRiMdSpU6eme3zy5MlZCigvKFSLob7q1h5Y3gtsnWHCVdBmark4o6w6GcikDRcxN9Xy99hmVHCyzfFrCiGEKHiM+f7OttXgC5JCnQAlxMJMD4iPgvf3g0vtHL+koigMXnqKgzceU9OtCOtHeGNqkvOJlxBCiIIlx1eDFwWYqQWUb5X0OIeHwyfTaDTM7F0dO0tTzt8L5edDd3LlukIIIQovSYBESsmLo+bgshivKuVgxeSuVQGYu+sm14PTXu9NCCGEyCpJgERKyctiPDwLEY9y7bK965SmbRUn4hJ1TFjrR3yiLteuLYQQonCRBEikZFfy374/N3PnNhgk3Qqb3qs6RazNuPwwnEX7buXatYUQQhQukgCJ1CXfBruZc4ujpsbJzpJvulcDYOHeW1x6EJar1xdCCFE4ZGgeoAkTJmS4wjlz5mQ6GJGHeHaA/T5we1/SyDDT3FsqpGuNUmy/FMTfF4P5eO15toxpgoWpSa5dXwghRMGXoQTo3LlzGarsdYuUinzEuSbYloTIR3D3CJTP+rpvGaXRaJjWvRon7jzj+qMI5u2+yWcdK+fa9YUQQhR8GUqA9u3bl9NxiLxGq03qDH3ud7ixI1cTIIBithZ817MaI5afZcmB27Sv6kwttyK5GoMQQoiCS/oAibS9PBxehfkyO1YrRfdaLugU+HitHzHxObcIrxBCiMLF6LXAAE6dOsW6desIDAwkLi7O4NiGDRuyJTCRB5RrCSbm8DwAntyEEp65HsLUblU5dvsptx9HMXvndb7s4pXrMQghhCh4jG4BWr16NU2aNOHKlSts3LiR+Ph4rly5wt69e3FwcMiJGIVaLGyhbNOkx7k4KeLLilibM6N3dQB+OezPqYBnqsQhhBCiYDE6AZo+fTr/93//x19//YW5uTnz5s3j6tWr9OnThzJlyuREjEJN+uHwuTcf0KtaVy7JW3VdURT4ZN15XsQlqBaLEEKIgsHoBOj27dt06dIFAAsLC6KiotBoNHz00Uf8/PPP2R6gUJlnh6R/7x6BsAeqhfFVVy9KOVhy9+kLZm67plocQgghCgajEyBHR0ciIpLWaSpdujSXLl0CIDQ0lBcvXmRvdEJ9RcuCexNQdOC3QrUw7C3NmNm7BgDLjt3l6K0nqsUihBAi/zM6AWrWrBm7du0CoE+fPowbN4733nuP/v3706ZNm2wPUOQBdQYn/Xv2d9Cptz5Xc88SDGiYdJv10z8uEBkrt8KEEEJkjtEJ0MKFC+nXrx8AkyZN4pNPPuHRo0f06tWLX3/9NdsDFHmAVzewdICwQLizV9VQvuhcBdeiVjwIjea7rVdVjUUIIUT+pVEUFSZ4yePCw8NxcHAgLCwMe3t7tcPJG/7+DE7+BFW6Qd/fVQ3l2O2n9P/vcQCWDWtAC88SqsYjhBAibzDm+ztT8wDpdDpu3bpFSEgIulduiTRv3jwzVYq8ru7gpATo+t8QGQK2TqqF4l2+GEMal8X3aAAT/7jAjo+a42Blplo8Qggh8h+jE6Djx48zYMAA7t69y6uNRxqNhsREma23QCpZFVzrw/1TSZ2hm36kajgTO1bmwI3H+D+J4ps/rzC7T01V4xFCCJG/GN0HaMSIEdSrV49Lly7x7Nkznj9/rt+ePZNJ6go0fWfo/6myNMbLrMxN+OGtGmg0sP7sfXZdeaRqPEIIIfIXoxOgmzdvMn36dKpUqUKRIkVwcHAw2EQBVq0XmNvBszsQcEjtaKjr7sh7zcoBMGnDRZ5Hxb3mDCGEECKJ0QlQw4YNuXXrVk7EIvI6cxuo/mbS4zPL1I3lHxPaeVLByZYnkbF8veWy2uEIIYTIJ4zuAzRmzBg+/vhjgoODqV69OmZmhp1Pa9SokW3BiTyo7mA4sxSuboEXz8DaUdVwLM1MmP1WTXotPsqf5x/SqZoznauXUjUmIYQQeZ/Rw+C12pSNRhqNBkVRCkwnaBkG/xpLmkHwBejgA94j1Y4GgB92XGfhvls42piz86PmFLe1UDskIYQQuSxHh8H7+/tnOjBRQNQdDFs/hrPLoNGHoNGoHRFj21Rk99VHXAuO4D8bL7H4nTpo8kBcQggh8iaZCDEV0gL0GjFhMLsyxL+AYTuhTEO1IwLg8sMwui88QoJOYV6/WnSvVVrtkIQQQuQiY76/je4EDUkrwo8ZM4a2bdvSrl07xo4dy+3btzMVrMiHLB2gas+kx2fzRmdogKouDoxpXRGArzdf5lF4jMoRCSGEyKuMToB27NiBl5cXJ0+epEaNGlSrVo0TJ05QtWpV/SKpohBInhPo0oakFqE8YmSr8lQv7UBYdDyf/nGB2IT83ydNCCFE9jP6Fljt2rXp0KEDM2bMMNj/+eefs3PnTs6ePZutAapBboFlgKLAj43g8TXoMhvqv6t2RHo3HkXwxvzDxCXqqF2mCEveqUtJe0u1wxJCCJHDcvQW2NWrVxk+fHiK/cOGDePKlSvGVifyK43m31agM76qzwz9Ms+Sdvw6pB4OVmacCwyl64LDnAt8rnZYQggh8hCjE6ASJUrg5+eXYr+fnx9OTsYtkOnj40P9+vWxs7PDycmJHj16cP36dYMyGo0m1e37779Ps15fX99Uz4mJkT4h2apmPzAxh+CL8PCc2tEYaFaxBFtGN8GzpC0hEbH0/ek4a0/fUzssIYQQeYTRCdB7773H+++/z8yZMzl06BCHDx9mxowZfPDBB7z//vtG1XXgwAFGjRrF8ePH2bVrFwkJCbRv356oqCh9maCgIIPtt99+Q6PR0Lt373Trtre3T3GupaXcBslW1o7g1T3pcR7qDJ3MvZgNG0Y2oUPVksQl6vjsjwtM2XKZ+ESd2qEJIYRQmdF9gBRFYe7cucyePZuHDx8C4OLiwqeffsrYsWOzNPfK48ePcXJy4sCBAzRv3jzVMj169CAiIoI9e/akWY+vry/jx48nNDQ0U3FIHyAj+B+CZW+AuS18fB0sbNWOKAWdTmHhvlvM2XUDgEblHFk0oA7FZLJEIYQoUHK0D5BGo+Gjjz7i/v37hIWFERYWxv379xk3blyWJ54LC0saTeTomPryCo8ePWLr1q2p9kF6VWRkJO7u7ri6uvLGG29w7lzat2hiY2MJDw832EQGlW0KjuUhLhIub1A7mlRptRrGtqnIzwPrYmNuwvE7z+i28AiXH+ad0WtCCCFyV6bmAUpmZ2eHnZ1dtgSiKAoTJkygadOmVKtWLdUyy5Ytw87Ojl69eqVbV+XKlfH19WXLli2sWrUKS0tLmjRpws2bN1Mt7+PjY7CivZubW5ZfT6Gh0UCdQUmP88gCqWlpX9WZTaOa4FHchgeh0fRefJQt5x+qHZYQQggVZGoYfGotPRqNBktLSypUqMCQIUNo1aqVUYGMGjWKrVu3cvjwYVxdXVMtU7lyZdq1a8eCBQuMqlun01GnTh2aN2/O/PnzUxyPjY0lNjZW/zw8PBw3Nze5BZZRkSEwpwroEuDDo1CyqtoRpSssOp6xq85x4MZjAEa0KM+nHSphopWlM4QQIj/L0VtgHTt25M6dO9jY2NCqVStatmyJra0tt2/fpn79+gQFBdG2bVs2b96c4TrHjBnDli1b2LdvX5rJz6FDh7h+/Trvvmv8fDNarZb69eun2QJkYWGBvb29wSaMYOsElTonPc7jrUAADlZm/DakPiNalAdgyYHbDF92irDoeJUjE0IIkVuMToCePHnCxx9/zKFDh5g9ezZz5szh4MGDfPLJJ0RFRbFz507+85//MG3atNfWpSgKo0ePZsOGDezduxcPD480y/7666/UrVuXmjVrGhsyiqLg5+dHqVKljD5XZFDdf+YEurAa4qPVjSUDTLQaPu9Umfn9a2NppmX/9cf0WHSEm48i1A5NCCFELjA6AVq7di39+/dPsb9fv36sXbsWgP79+6eYzyc1o0aNYvny5axcuRI7OzuCg4MJDg4mOtrwCzQ8PJx169al2fozaNAgJk2apH8+depUduzYwZ07d/Dz82P48OH4+fkxYsQIY16qMEa51uBQJmlZjCtb1I4mw7rVdOGPEY0pXcQK/ydR9PzxKDsvB6sdlhBCiBxmdAJkaWnJ0aNHU+w/evSofp4dnU6HhcXrhxgvXryYsLAwWrZsSalSpfTbmjVrDMqtXr0aRVFSTbwAAgMDCQoK0j8PDQ3l/fffp0qVKrRv354HDx5w8OBBGjRoYMxLFcbQaqHOwKTHeXBOoPRUK+3AltFNaFTOkcjYBN7//Qzzdt9Ep8s7s1sLIYTIXkZ3gv7222+ZPn067733HvXr10ej0XDy5El++eUXvvjiC7788kv+7//+j7///jvfLo4q8wBlUtgDmFsNFB2MPg3FK6odkVHiE3V8t/UqvkcDAOhQtSSz+9TC1sJU3cCEEEJkiDHf30YnQAArVqxg4cKF+ttclSpVYsyYMQwYMACA6Oho/aiw/EgSoCxY2RdubIfGY6D9t2pHkylrT93jP5suEZeow7OkLf8dVA/3YjZqhyWEEOI1cjwBKugkAcqCa3/D6v5gXQwmXAXT/Dnb8tnA54z4/QwhEbE4WJmxcEBtmlUsoXZYQggh0pGjw+CFSFfF9mBXCl48hWtb1Y4m0+qUKcqfY5pSu0wRwqLjGfzbSX4+eBv5e0EIIQoGoxOgxMREfvjhBxo0aICzszOOjo4GmyjkTEyh9jtJj/NZZ+hXlbS3ZPX7jehTzxWdAtP/vsZHa/yIiU9UOzQhhBBZZHQCNHXqVObMmUOfPn0ICwtjwoQJ9OrVC61Wy5QpU3IgRJHv1B4IaODOfnjmr3Y0WWJhasLM3jWY2q0qJloNm/we8uaSozwIzftzHQkhhEib0QnQihUr+O9//8snn3yCqakp/fv355dffuHrr7/m+PHjORGjyG+KukP5f5ZCOfe7urFkA41Gw+DGZVk+vCGONuZcehBOtwWHOen/TO3QhBBCZJLRCVBwcDDVq1cHwNbWVr+C+xtvvMHWrfm3z4fIZnX+mRn63ApITFA3lmziXb4YW0Y3wauUPU+j4hjw3+P8fvyu9AsSQoh8yOgEyNXVVT/pYIUKFdi5cycAp06dytDkh6KQqNQZrItDZDDc3KF2NNnGtag16z9sTNeaLiToFL7adIkvNl4kNkH6BQkhRH5idALUs2dP9uzZA8C4ceP46quvqFixIoMGDWLYsGHZHqDIp0zNoVbSvFD5YYFUY1iZmzC/Xy0+71QZjQZWnbzHgP+eICQ8Ru3QhBBCZFCW5wE6fvw4R48epUKFCnTr1i274lKVzAOUTZ7cgoV1QaOF8ZfAobTaEWW7/ddDGLPqHBExCZS0t+CngfWo5VZE7bCEEKJQkokQs0gSoGy0tAvcPQwtv4CWE9WOJkf4P4nivf+d5lZIJOamWqb3rM6bdV3VDksIIQqdbE+AtmzZQqdOnTAzM2PLlvRX+i4IrUCSAGWjC2thw3vg4AbjzoPWRO2IckRETDwfrTnP7quPABjapCxfdq6CqYnMNSqEELkl2xMgrVZLcHAwTk5OaLVp/0LXaDQkJub/zqCSAGWj+BiYXQliQuHt9VCxrdoR5RidTmHenpvM23MTgMbli7FwQB0cbcxVjkwIIQqHbF8KQ6fT4eTkpH+c1lYQkh+RzcwsoWa/pMdnlqobSw7TajV81M6TJe/UxdrchKO3n9Jt4WGuPAxXOzQhhBCvkPZ5kfOS5wS6sR0iHqkbSy7oWM2ZjSObUMbRmvvPo+m9+Ch/XXiodlhCCCFeYpqRQvPnz89whWPHjs10MKKAKukFrvXh/inwWwHNJqgdUY6r5GzHltFNGLPqHIduPmH0ynNceRjOx+0rYaLVqB2eEEIUehnqA+Th4WHw/PHjx7x48YIiRYoAEBoairW1NU5OTty5cydHAs1N0gcoB5z9HbaMhqIeMOYspNOXrCBJSNQxa8d1fj6Y9P+iVaUSzOtfG3tLM5UjE0KIgifb+wD5+/vrt++++45atWpx9epVnj17xrNnz7h69Sp16tRh2rRp2fICRAFUrReY28Fzfwg4pHY0ucbURMsXnaswt28tLEy17Lv+mB4Lj3ArJFLt0IQQolAzeh6g8uXL88cff1C7dm2D/WfOnOHNN9/E3z9/r/4N0gKUY/76CE7/BtV6w5u/qR1Nrrt4P4wPfj/Nw7AY7CxMmduvFm2qlFQ7LCGEKDCyvQXoZUFBQcTHx6fYn5iYyKNHBb+Dq8iC5M7QV/+EqKfqxqKC6q4ObBnTlAZlHYmITeDd/51mwZ6bspiqEEKowOgEqE2bNrz33nucPn1a/4v79OnTfPDBB7RtW3DneBHZwKUWlKoJiXFwYbXa0aiiuK0Fy99tyMBG7igKzN51g5ErzhIVm6B2aEIIUagYnQD99ttvlC5dmgYNGmBpaYmFhQUNGzakVKlS/PLLLzkRoyhIkluBziyDQtryYW6qZVqPaszoVR0zEw3bLgXTe/FRAp++UDs0IYQoNDK9FtjNmze5evUqiqJQpUoVPD09szs21UgfoBwUE540M3T8Cxi2A8o0UjsiVZ25+4wPfj/Lk8hYHKzMWDSgDk0rFlc7LCGEyJdytA9QsooVK1KsWDE6duxYoJIfkcMs7aFqr6THZ5apG0seUNfdkb/GNKWmqwNh0fEMWXqSk/7P1A5LCCEKvCxNxtKpUycePHiQXbGIwqLuP7fBLm+E6FBVQ8kLnB0sWfOBNx2qliRBpzBq5VlCwmPUDksIIQq0LCVAMnpFZIprfShRBRKi4eI6taPJEyzNTJjTpxaeJW15HBHLqJVniU/UqR2WEEIUWIVjOl6Rt2g0/7YCFeLO0K+ysTBlyTt1sbMw5VTAc6b/fVXtkIQQosDKUALk6OjIkydPABg2bBgREREA/PTTT5QsKRO5iUyo0RdMLODRRXh4Vu1o8oxyJWyZ3acmAEuPBLDZT24xCyFETshQAhQXF0d4eDgAy5YtIyYmqX/CgAEDsLGxybnoRMFl7Qhe3ZIeS2doA+2rOjOyZXkAPl9/kWvB4SpHJIQQBU+GVoP39vamR48e1K1bF0VRGDt2LFZWVqmW/e23wrfEgcikOoOT+gBdWg8dpoOFrdoR5Rkft6/EhfthHL71hBG/n2HLmKaygKoQQmSjDLUALV++nM6dOxMZmbSAY1hYGM+fP091M4aPjw/169fHzs4OJycnevTowfXr1w3KDBkyBI1GY7A1avT6uWPWr1+Pl5cXFhYWeHl5sXHjRqNiE7mgbFNwLA9xkUlJkNAz0WqY3782pYtYEfD0BRPWnEenk75SQgiRXYyeCNHDw4PTp09TrFixLF+8Y8eO9OvXj/r165OQkMCXX37JxYsXuXLliv7W2pAhQ3j06BFLly7Vn2dubo6jo2Oa9R47doxmzZoxbdo0evbsycaNG/n66685fPgwDRs2fG1cMhFiLjoyD3Z9DaXrwnt71Y4mzzl/L5S3lhwjLlHHpx0qMapVBbVDEkKIPMuY7+8MJUCOjo7cuHGD4sWLM2zYMObNm4ednV22BZzs8ePHODk5ceDAAZo3bw4kJUChoaFs2rQpw/X07duX8PBwtm3bpt/XsWNHihYtyqpVq157viRAuSjyMcypArp4GHEEnKupHVGes/pkIJ9vuIhGA8uGNqC5Zwm1QxJCiDwp22eCTqsTdHYLCwsDSNG6s3//fpycnPD09OS9994jJCQk3XqOHTtG+/btDfZ16NCBo0ePZm/AIutsS0DlzkmPz0pn6NT0a1CGvvXcUBQYt/oc95/LmmFCCJFVeaYTtKIoTJgwgaZNm1Kt2r+tAJ06deKtt97C3d0df39/vvrqK1q3bs2ZM2ewsLBIta7g4OAUw/NLlixJcHBwquVjY2OJjY3VP09O9kQuqTMYrmyGC2ug3TdglvpnqzCb2r0qV4LCufggjA+Xn2XdCG8szUzUDksIIfItoztBazSabOsE/bLRo0dz4cKFFLeo+vbtS5cuXahWrRpdu3Zl27Zt3Lhxg61bt6Zbn0ajMXiuKEqKfcl8fHxwcHDQb25ubpl+HSITyrWCImUgJiwpERIpWJqZsPidOhS1NuPigzAmb76sdkhCCJGvZagFqGTJksyYMQNI6gT9+++/Z0sn6GRjxoxhy5YtHDx4EFdX13TLlipVCnd3d27evJlmGWdn5xStPSEhIWlO2jhp0iQmTJigfx4eHi5JUG7SaqH2INj3bdKcQDX7qR1RnuRa1Jr5/Wsz6LeTrDl9j9plitCvQRm1wxJCiHzJ6KUw/P39sy35URSF0aNHs2HDBvbu3YuHh8drz3n69Cn37t2jVKlSaZbx9vZm165dBvt27txJ48aNUy1vYWGBvb29wSZyWe23QaOFwKPw+PrryxdSzSqW4JP2lQD4evNlzt8LVTcgIYTIpzK1FtiBAwfo2rUrFSpUoGLFinTr1o1Dhw4ZXc+oUaNYvnw5K1euxM7OjuDgYIKDg4mOjgYgMjKSTz75hGPHjhEQEMD+/fvp2rUrxYsXp2fPnvp6Bg0axKRJk/TPx40bx86dO5k5cybXrl1j5syZ7N69m/Hjx2fm5YrcYO8CFTskPT77P3VjyeM+bFGetlVKEpeoY+SKszyLilM7JCGEyHeMToCWL19O27Ztsba2ZuzYsYwePRorKyvatGnDypUrjapr8eLFhIWF0bJlS0qVKqXf1qxZA4CJiQkXL16ke/fueHp6MnjwYDw9PTl27JjBMPzAwECCgoL0zxs3bszq1atZunQpNWrUwNfXlzVr1mRoDiChouQFUv1WQkJs+mULMa1Ww5y+NSlbzJoHodGMXXWORJkkUQghjGL0RIhVqlTh/fff56OPPjLYP2fOHP773/9y9Wr+X8Fa5gFSSWICzK0GEUHw5m9QrbfaEeVp14Mj6LHoCNHxiYxsWZ7POlZWOyQhhFBVts8D9LI7d+7QtWvXFPu7deuGv7+/sdUJ8S8TU6j9TtJjWSD1tSo52zGjd3UAftx/mx2XU5/mQQghREpGJ0Bubm7s2bMnxf49e/bIyCmRdbUHAhrwPwDP7qgdTZ7XvVZphjYpC8Ana89z53GkugEJIUQ+kaFh8C/7+OOPGTt2LH5+fjRu3BiNRsPhw4fx9fVl3rx5ORGjKEyKukP5VnB7L5z9HdpOVjuiPO+LzlW49CCMUwHPGbH8DBtHNsHGwuj/2kIIUagY3QcIYOPGjcyePVvf36dKlSp8+umndO/ePdsDVIP0AVLZlc2wdhDYloSPLoOJmdoR5Xkh4TF0WXCYxxGxvFGjFAv6105z4k8hhCiosn0x1MJGEiCVJcTB/3lB1GPouwKqvKF2RPnCqYBn9P/5OAk6ha/e8GJ409fPqyWEEAVJjnaCFiLHmZpDrQFJj2WB1AyrX9aRL7tUAWD631c56f9M5YiEECLvkgRI5E11/pkT6NZuCLuvbiz5yJDGZeley4VEncLIFWd5FB6jdkhCCJEnSQIk8qZi5aFsM1B0cG652tHkGxqNBp9e1alU0o4nkbGMXHGWuASd2mEJIUSeIwmQyLuSW4HO/g66RHVjyUeszU1ZMrAudhamnLn7nOl/5//JSYUQIrtJAiTyripdwaoohN+HWynnnhJp8yhuw5y+tQDwPRrAZr8H6gYkhBB5jNGThSiKwh9//MG+ffsICQlBpzNsXt+wYUO2BScKOTNLqNEPTixO6gzt2V7tiPKVdl4lGd2qAgv33WLi+gt4lrSjSikZ1SiEEJCJFqBx48YxcOBA/P39sbW1xcHBwWATIlslL5B6fRtEyFIPxvqonSfNKhYnJl7HiOVnCIuOVzskIYTIE4yeB8jR0ZHly5fTuXPnnIpJdTIPUB7zSzu4fxLafA3NPlY7mnzneVQcbyw4zIPQaNpWceLngfXQamWSRCFEwZOj8wA5ODhQrly5TAcnhNGSW4HO/g90MqLJWEVtzFnyTl3MTbXsvhrCj/tvqR2SEEKozugEaMqUKUydOpXo6OiciEeIlKr2BAt7eB4AAQfVjiZfqu7qwLfdqwEwe9cNDtx4rHJEQgihLqMToLfeeovnz5/j5ORE9erVqVOnjsEmRLYzt4HqbyY9PiMzQ2dWn/pu9G/ghqLAuNXnuPfshdohCSGEaoweBTZkyBDOnDnDO++8Q8mSJWXBRZE76g6B07/Btb8g6inYFFM7onxpSreqXHkYzvn7YXy44gx/jGiMpZmJ2mEJIUSuM7oTtI2NDTt27KBp06Y5FZPqpBN0HvVTCwjyg/bfQePRakeTbz0IjabrgsM8i4rjrbquzHqzhvwhI4QoEHK0E7Sbm5skBUId+s7Qy8C4vF28pHQRKxb0r41WA+vO3Gf1qXtqhySEELnO6ARo9uzZfPbZZwQEBORAOEKko9qbYGYNT25A4HG1o8nXmlQozicdKgEwefNl/O6FqhuQEELkMqMToHfeeYd9+/ZRvnx57OzscHR0NNiEyDGW9lCtV9LjM76qhlIQfNiiPO29ShKXqGPk8jM8jYxVOyQhhMg1RneCnjt3bg6EIUQG1RmStDr8lU3QaUbSWmEiUzQaDT/0qUmPhUe48ySKsavPsWxoA0xNZIlAIUTBZ1QCFB8fz/79+/nqq69kMkShDtd64OQFIVfgwjpo+L7aEeVr9pZmLBlYlx6LjnDk1lNm77rBxI6V1Q5LCCFynFF/6pmZmbFx48acikWI19NooI50hs5OniXtmNm7BgCL999m+yVZc00IUfAZ3dbds2dPNm3alAOhCJFBNfqAiQU8ugQPzqodTYHQtaYLw5t6APDJuvPcfhypckRCCJGzjO4DVKFCBaZNm8bRo0epW7cuNjY2BsfHjh2bbcEJkSprR/DqDhfXwllfcK2rdkQFwuedKnPxQRgn/Z8x4vczbBrVBBsLo39FCCFEvmD0RIgeHh5pV6bRcOfOnSwHpTaZCDEfCDgMvl3AzAY+uQ4WdmpHVCCERMTwxvzDhETE0qVGKRb2ry2TJAoh8g1jvr+N/vPO398/04EJkW3cm0CxCvD0Flxan7RUhsgyJztLFr9Th74/HWfrhSBquxXh3WYy4EEIUfBkabyroigY2YAkRPbQaKDOoKTHskBqtqrr7shXb3gB4LPtGsfvPFU5IiGEyH6ZSoD+97//Ub16daysrLCysqJGjRr8/vvv2R2bEOmrOQC0ZvDwLARfVDuaAmWQtzs9armQqFMYvfIswWExaockhBDZyugEaM6cOXz44Yd07tyZtWvXsmbNGjp27MiIESP4v//7v5yIUYjU2ZaAyl2SHksrULbSaDT49KpBZWc7nkTGMWrlWeISdGqHJYQQ2cboBGjBggUsXryYmTNn0q1bN7p3786sWbP48ccfmT9/vlF1+fj4UL9+fezs7HBycqJHjx5cv35dfzw+Pp6JEydSvXp1bGxscHFxYdCgQTx8+DDden19fdFoNCm2mBj5K7bASV4g9cJaiHuhbiwFjJW5CUveqYudpSln7j7nu61X1A5JCCGyjdEJUFBQEI0bN06xv3HjxgQFBRlV14EDBxg1ahTHjx9n165dJCQk0L59e6KiogB48eIFZ8+e5auvvuLs2bNs2LCBGzdu0K1bt9fWbW9vT1BQkMFmaWlpVHwiH/BoCUXcITYMrmxWO5oCp2xxG+b2rQXAsmN32XjuvroBCSFENsnUPEBr167liy++MNi/Zs0aKlasaFRd27dvN3i+dOlSnJycOHPmDM2bN8fBwYFdu3YZlFmwYAENGjQgMDCQMmXKpFm3RqPB2dnZqHhEPqTVQp2BsPfbpAVSa/VXO6ICp02VkoxtXYH5e28xacNFKpW0x8tFpocQQuRvRidAU6dOpW/fvhw8eJAmTZqg0Wg4fPgwe/bsYe3atVkKJiwsDCDdVeXDwsLQaDQUKVIk3boiIyNxd3cnMTGRWrVqMW3aNGrXrp1q2djYWGJj/10JOzw83PjghXpqvQP7fODecQi5Bk6yllV2G9fWE7/7YRy88ZgRy8/w5+imOFibqR2WEEJkmtG3wHr37s2JEycoXrw4mzZtYsOGDRQvXpyTJ0/Ss2fPTAeiKAoTJkygadOmVKtWLdUyMTExfP755wwYMCDdCY4qV66Mr68vW7ZsYdWqVVhaWtKkSRNu3ryZankfHx8cHBz0m5ubW6Zfh1CBfSnw7JD0+Oz/1I2lgDLRapjfrxauRa0IfPaCCWv90OlkCgwhRP5l9EzQOWXUqFFs3bqVw4cP4+rqmuJ4fHw8b731FoGBgezfv9+oGZp1Oh116tShefPmqXbUTq0FyM3NTWaCzk+ub4dVfcHKET6+BqYWakdUIF16EEbvxUeJTdAxoZ0nY9sYd9tbCCFykjEzQWdpIsTsMmbMGLZs2cK+ffvSTH769OmDv78/u3btMjop0Wq11K9fP80WIAsLC+zt7Q02kc9UaAt2LhD9DK7+qXY0BVa10g582yOphfb/dt9g//UQlSMSQojMyXACpNVqMTExSXczNTWuS5GiKIwePZoNGzawd+/eVNcZS05+bt68ye7duylWrJhR10i+jp+fH6VKlTL6XJFPmJhC7XeSHp+VOYFy0lv13BjQsAyKAuNW+3HvmUw/IITIfzKcsWzcuDHNY0ePHmXBggVGL4sxatQoVq5cyebNm7GzsyM4OBgABwcHrKysSEhI4M033+Ts2bP89ddfJCYm6ss4Ojpibm4OwKBBgyhdujQ+Pj5AUkftRo0aUbFiRcLDw5k/fz5+fn4sWrTIqPhEPlNnIBz8HvwPwrM74ChrWOWUyV29uPwwnPP3Qvng9zP8PrwBxWzltqMQIv/IUh+ga9euMWnSJP7880/efvttpk2blu7Q9BQXT2OV6aVLlzJkyBACAgLSXH1+3759tGzZEoCWLVtStmxZfH19Afjoo4/YsGEDwcHBODg4ULt2baZMmYK3t3eG4pLV4POx33vB7T3Q9CNoO0XtaAq0h6HRdF1wmKdRcZSws2D2WzVp7llC7bCEEIWYMd/fmUqAHj58yOTJk1m2bBkdOnTAx8cnzZFb+ZEkQPnYlc2wdhDYOMGEK2AiQ7Vz0vXgCMasOsuNR5EAvNvUg087VsLC1ETlyIQQhVGOdYIOCwtj4sSJVKhQgcuXL7Nnzx7+/PPPApX8iHzOsxPYlICoELix/fXlRZZUcrZjy+imDPJ2B+CXw/70XHSUWyERKkcmhBDpy3ACNGvWLMqVK8dff/3FqlWrOHr0KM2aNcvJ2IQwnqk51Ho76fHxxRAaqG48hYClmQnfdK/Gr4Pr4WhjzpWgcN5YcJgVJ+4a3S9QCCFyS4ZvgWm1WqysrGjbti0mJmk3b2/YsCHbglOL3ALL557ehgV1/n1e3BPKt0kaKl+2CZhZqRdbARcSHsPH685z6OYTANp5lWRm7xo42pirHJkQojDIkT5AQ4YMSbPT8suWLl2asSjzMEmACoDLG+H4Erh/EhTdv/tNLcG98b8JUYlKkIHPtcg4nU7htyP+zNp+nbhEHU52Fvxf31o0qVBc7dCEEAVcjneCLugkASpAokPB/wDc2g239kL4K6uZ25eGCv8kQx4twKqIGlEWSJcfhjF21TluP45Co4H3m5Xj4/aVMDfNE/OvCiEKIEmAskgSoAJKUeDx9aRh8rd2Q8ARSPx3CRQ0JuBaPykhKt8GXGqBVkYzZUV0XCLTtl5h5YmkvljVSzswt18typewVTkyIURBJAlQFkkCVEjEvYC7R/9NiJ7cMDxu5QjlW/+TELUGO2d14iwAdlwOZuL6C4S+iMfKzITJXb3oW98tQ7fVhRAioyQByiJJgAqp0EC4tScpIbpzAGLDDY+XrP7P7bI24NYoacSZyLBH4TFMWOvHkVtPAehUzRmfXtUpYi3voxAie0gClEWSAAkS4+H+6aSWodt74OE5w+NmNuDR/N+ESJbdyBCdTuG/h+7ww87rxCcqONtb8n99a+Fd3vg1/oQQ4lWSAGWRJEAihagncHvfPwnR3qSJFl9W1COpI3WFtlC2KVhIH5f0XLwfxrjV57jzJKmD9IgW5ZnQzhMzE+kgLYTIPEmAskgSIJEunQ4eXUy6XXZrD9w7DrqEf49rzcDd+5+h9m2gZDUZap+KF3EJfPPnFVafugdATVcH5vWrTdniNipHJoTIryQByiJJgIRRYsIh4NA/CdFuCL1reNzW+d+O1OVbg7WjOnHmUdsuBvH5houERcdjbW7ClG5Veauuq3SQFkIYTRKgLJIESGSaosCzO//MO7QnKTGKf/FSAQ2UrpN0q6x8GyhdF0xMVQs3rwgKi+ajNX4cv/MMgC41SjG9R3UcrGUxWyFExkkClEWSAIlskxALgcf+nYgx5LLhcUsHKNfy34TIobQqYeYFiTqFnw7eZs7OGyToFFwckjpINywnHaSFEBkjCVAWSQIkckz4w6RO1Ld2J3Wqjgk1PG7jBCbmSRMwak1Aa5o0QaPW1HCf1hQ02n8fa18qo3mpjPalMvr9qe0ztu6X92mBNG5XpXsbK/Vjtx5HsWDvTYLDYtFooGft0vSu64qpNp0O0mleJ53r58tbbPkxZiHSYGELJatma5WSAGWRJEAiV+gS4cHZfydifHDGcN0yIYQoyFwbwLu7srVKY76/pfOBEGrRmoBb/aSt5ecQ/TxpMkZdYlIipEv4Z0v8918l8ZX9aezTJby0/zX79PsTDa+XoRh0Sc9Tk+7fVmkce+WciNgEQiJiUHQKWo2G4nYW2FmaGraDpHmddK6fL//uy48xC5EOexdVLy8JkBB5hVXRpE3o2QHhodF8tNqPkwHPIBa61XTh257VsLeUDtJCiMyTWceEEHla6SJWrHq/ER+388REq2HL+Yd0nneI0wHP1A5NCJGPSQIkhMjzTLQaxrSpyLoR3pRxtOb+82j6/HSM/9t1g4RE6TclhDCeJEBCiHyjTpmibB3blF61S6NTYN6em/T9+Tj3nr14/clCCPESSYCEEPmKnaUZc/rWYl6/WthZmHLm7nM6zzvEZr8HaocmhMhHJAESQuRL3WuV5u9xzajrXpSI2ATGrfbjozV+RMTEqx2aECIfkARICJFvuTlas+b9RoxvWxGtBjaee0Dn+Yc4G/hc7dCEEHmcJEBCiHzN1ETL+LaerP3Am9JFrLj3LJq3lhxjwZ6bJOpk7hwhROokARJCFAj1yjqybXwzutdyIVGnMHvXDfr/fJwHodFqhyaEyIMkARJCFBj2lmbM61eb/+tbE1sLU04GPKPj3IP8deGh2qEJIfIYSYCEEAVOz9qu/D22GbXcihARk8Dolef4ZN15ImMT1A5NCJFHSAIkhCiQyhSzZt0Ib8a0roBWA3+cuU+X+YfwuxeqdmhCiDxAEiAhRIFlZqLl4/aVWP2+Ny4Oltx9+oI3Fx9l0b5b6KSDtBCFmiRAQogCr4GHI9vGNadLjVIk6BS+33Gd9/53mnCZM0iIQkvVBMjHx4f69etjZ2eHk5MTPXr04Pr16wZlFEVhypQpuLi4YGVlRcuWLbl8+fJr616/fj1eXl5YWFjg5eXFxo0bc+plCCHyAQdrMxb2r82s3jUwN9Wy51oIPRYd4fbjSLVDE0KoQNUE6MCBA4waNYrjx4+za9cuEhISaN++PVFRUfoys2bNYs6cOSxcuJBTp07h7OxMu3btiIiISLPeY8eO0bdvXwYOHMj58+cZOHAgffr04cSJE7nxsoQQeZRGo6FPfTf+GOFNKQdL7jyOosfCI+y5+kjt0IQQuUyjKEqeuRH++PFjnJycOHDgAM2bN0dRFFxcXBg/fjwTJ04EIDY2lpIlSzJz5kw++OCDVOvp27cv4eHhbNu2Tb+vY8eOFC1alFWrVr02jvDwcBwcHAgLC8Pe3j57XpwQIk95HBHLqBVnORnwDI0GJrT1ZFSrCmi1GrVDE0JkkjHf33mqD1BYWBgAjo6OAPj7+xMcHEz79u31ZSwsLGjRogVHjx5Ns55jx44ZnAPQoUOHNM+JjY0lPDzcYBNCFGwl7CxY/m5DBnm7oygwe9cNRq44K0PlhSgk8kwCpCgKEyZMoGnTplSrVg2A4OBgAEqWLGlQtmTJkvpjqQkODjbqHB8fHxwcHPSbm5tbVl6KECKfMDfV8k33aszsXR1zEy3bLwfT68cjBDyJev3JQoh8Lc8kQKNHj+bChQup3qLSaAybpBVFSbEvK+dMmjSJsLAw/Xbv3j0joxdC5Gd965dh9QeNcLKz4MajSLotPMyBG4/VDksIkYPyRAI0ZswYtmzZwr59+3B1ddXvd3Z2BkjRchMSEpKihedlzs7ORp1jYWGBvb29wSaEKFzqlCnKX2OaUqdMEcJjEhi69CRLDtwmD3WTFEJkI1UTIEVRGD16NBs2bGDv3r14eHgYHPfw8MDZ2Zldu3bp98XFxXHgwAEaN26cZr3e3t4G5wDs3Lkz3XOEEMLJ3pJV7zeiX303dArM2HaNMavO8SJO+gUJUdCYqnnxUaNGsXLlSjZv3oydnZ2+1cbBwQErKys0Gg3jx49n+vTpVKxYkYoVKzJ9+nSsra0ZMGCAvp5BgwZRunRpfHx8ABg3bhzNmzdn5syZdO/enc2bN7N7924OHz6syusUQuQfFqYm+PSqTrXSDkzZcpm/LgRxKySS/w6qh5ujtdrhCSGyiarD4NPqk7N06VKGDBkCJLUSTZ06lZ9++onnz5/TsGFDFi1apO8oDdCyZUvKli2Lr6+vft8ff/zBf/7zH+7cuUP58uX57rvv6NWrV4bikmHwQgiAUwHP+HD5WZ5ExlLE2oxFA+rQpEJxtcMSQqTBmO/vPDUPUF4hCZAQIllQWDQf/H6GC/fDMNFq+KJzFYY1KfvagRhCiNyXb+cBEkKIvKaUgxVrP/Cmdx1XEnUK0/66wsdrzxMTn6h2aEKILJAESAghXsPSzIQf3qrB5K5emGg1bDj3gLeWHONBaLTaoQkhMkkSICGEyACNRsPQJh4sH94QRxtzLj4Io9uCw5y481Tt0IQQmSAJkBBCGMG7fDG2jG5CVRd7nkbF8fYvJ/jfsQCZL0iIfEYSICGEMJJrUWv+GNGYbjVdSNApfL35MhPXXyA2QfoFCZFfSAIkhBCZYGVuwrx+tfiycxW0Glh7+j59fzrOo/AYtUMTQmSAJEBCCJFJGo2G95qXY9mwBjhYmeF3L5Q3FhzmzN1naocmhHgNSYCEECKLmlUswZ+jm1LZ2Y7HEbH0+/k4q04Gqh2WECIdkgAJIUQ2KFPMmvUfNqZzdWfiExUmbbjIlxsvEpegUzs0IUQqJAESQohsYmNhyqIBdfi0QyU0GlhxIpAB/z1OSIT0CxIir5EESAghspFGo2FUqwr8Nrg+dpamnL77nG4LjuB3L1Tt0IQQL5EESAghckCryk5sGd2UCk62BIfH0OenY6w7fU/tsIQQ/5AESAghcohHcRs2jmxMO6+SxCXo+PSPC0zZcpn4ROkXJITaJAESQogcZGdpxk/v1GV824oA+B4NYOCvJ3gaGatyZEIUbpIACSFEDtNqNYxv68nPA+tia2HK8TvP6LbwCJcehKkdmhCFliRAQgiRS9pXdWbTqMZ4FLfhQWg0by45yma/B2qHJUShJAmQEELkogpOdmwa1YRWlUoQE69j3Go/vtt6hQTpFyRErpIESAghcpmDlRm/DK7P6FYVAPjvIX+GLD3F86g4lSMTovCQBEgIIVRgotXwSYdK/Ph2HazNTTh86wndFh3malC42qEJUShIAiSEECrqXL0UG0Y2poyjNfeeRdPrx6P8fTFI7bCEKPAkARJCCJVVdrZny+gmNKtYnOj4REauOMus7ddI1ClqhyZEgSUJkBBC5AFFrM1ZOqQ+HzQvB8CP+28zfNkpwqLjVY5MiIJJEiAhhMgjTE20TOpchXn9amFppmX/9cf0WHSEm48i1A5NiAJHEiAhhMhjutcqzR8jGlO6iBX+T6LosegIWy8EERIew9PIWMKi44mKTSA2IVFukwmRSRpFUeR/zyvCw8NxcHAgLCwMe3t7tcMRQhRSz6LiGLXiLMfuPE23nEYDploNplpt0r8mGky0WsxMNJhoNZiZaDHRavTHXi5nqtX+829SWVMTbYq6TF/en1y3VoOJiQYzrfafayTtT1H+pXP013jpePJzk3+umVSn4fOXy2k0mlx690V+ZMz3t2kuxSSEEMJIjjbm/D68AbN2XGfliUCi41Nv8VEUiE9UiE9MVCHK3GWSImkyTPYMkqmXE7iXnhuUS5GIvfLcJI39+uP/7NdoUqk/lXNSSQZfTvb09RhcO+m4VoMkgNlIWoBSIS1AQoi8SlEUEnQKiTqF+ETdP/8aPk/Q6UjQKSQkKv/8+/Jz3b/7dS+fr0ulnpfOSVHPS88NjhleK/GfWF/dl2CwX2fwPPkckVLKhCopsbO1MMXe0hR7KzPsLc2w0z9ObZ8Z9lam2FmaYWNuUqCSKmkBEkKIAkqjSbrdZGYClmYmaoeTY15O9BJ0CokvJU/xrzx/NSE0TKb+TeySnyckJ3o6hcRXkq+ERIVE5Z9y+uu8cv4rcSWVT1l/muf9c1x/XipxpyU54Yx9Zf/jiFf3ZIyJVpOUGCUnSP8kR0n/vrwvKZmye/W4hSlabf5MoCQBEkIIkee8nOgVNoqioFMwTPBeSsQSFcMEMC5RR1RsIuHR8UTExhMenUB4dDzhMUmP9fti4v/Zn3Q8ub7QF/GEvsjcdAsaDdiam/6bLCW3OqWTNCUnW0WszShibZ7N717GSQIkhBBC5CEajQYTDZhocy77UxSFmHidYVL0SoIUkeq+fx/HJuhQFIiITSAiNsHoGKqVtuevMc1y4NVljKoJ0MGDB/n+++85c+YMQUFBbNy4kR49euiPp3VfctasWXz66aepHvP19WXo0KEp9kdHR2NpaZktcQshhBD5mUajwcrcBCtzE0raZ+67MTYhMSlJeilBCo+Jf2nfvy1Pqe2ztzTL5ldlHFUToKioKGrWrMnQoUPp3bt3iuNBQYbr4Wzbto3hw4enWvZl9vb2XL9+3WCfJD9CCCFE9rEwNcHC1oTithaZOl+nckd3VROgTp060alTpzSPOzs7GzzfvHkzrVq1oly5cunWq9FoUpwrhBBCiLxD7c7T+WYm6EePHrF161aGDx/+2rKRkZG4u7vj6urKG2+8wblz53IhQiGEEELkF/kmAVq2bBl2dnb06tUr3XKVK1fG19eXLVu2sGrVKiwtLWnSpAk3b95M85zY2FjCw8MNNiGEEEIUXPkmAfrtt994++23X9uXp1GjRrzzzjvUrFmTZs2asXbtWjw9PVmwYEGa5/j4+ODg4KDf3Nzcsjt8IYQQQuQh+SIBOnToENevX+fdd981+lytVkv9+vXTbQGaNGkSYWFh+u3evXtZCVcIIYQQeVy+mAfo119/pW7dutSsWdPocxVFwc/Pj+rVq6dZxsLCAguLzPViF0IIIUT+o2oCFBkZya1bt/TP/f398fPzw9HRkTJlygBJ63qsW7eO2bNnp1rHoEGDKF26ND4+PgBMnTqVRo0aUbFiRcLDw5k/fz5+fn4sWrQo51+QEEIIIfIFVROg06dP06pVK/3zCRMmADB48GB8fX0BWL16NYqi0L9//1TrCAwMRKv9905eaGgo77//PsHBwTg4OFC7dm0OHjxIgwYNcu6FCCGEECJfkdXgUyGrwQshhBD5jzHf3/miE7QQQgghRHaSBEgIIYQQhY4kQEIIIYQodCQBEkIIIUShIwmQEEIIIQqdfDERYm5LHhgna4IJIYQQ+Ufy93ZGBrhLApSKiIgIAFkTTAghhMiHIiIicHBwSLeMzAOUCp1Ox8OHD7Gzs0Oj0WRr3eHh4bi5uXHv3j2ZYygHyfucO+R9zh3yPuceea9zR069z4qiEBERgYuLi8EkyamRFqBUaLVaXF1dc/Qa9vb28p8rF8j7nDvkfc4d8j7nHnmvc0dOvM+va/lJJp2ghRBCCFHoSAIkhBBCiEJHEqBcZmFhweTJk7GwsFA7lAJN3ufcIe9z7pD3OffIe5078sL7LJ2ghRBCCFHoSAuQEEIIIQodSYCEEEIIUehIAiSEEEKIQkcSICGEEEIUOpIA5aIff/wRDw8PLC0tqVu3LocOHVI7pALHx8eH+vXrY2dnh5OTEz169OD69etqh1Wg+fj4oNFoGD9+vNqhFEgPHjzgnXfeoVixYlhbW1OrVi3OnDmjdlgFSkJCAv/5z3/w8PDAysqKcuXK8c0336DT6dQOLV87ePAgXbt2xcXFBY1Gw6ZNmwyOK4rClClTcHFxwcrKipYtW3L58uVci08SoFyyZs0axo8fz5dffsm5c+do1qwZnTp1IjAwUO3QCpQDBw4watQojh8/zq5du0hISKB9+/ZERUWpHVqBdOrUKX7++Wdq1KihdigF0vPnz2nSpAlmZmZs27aNK1euMHv2bIoUKaJ2aAXKzJkzWbJkCQsXLuTq1avMmjWL77//ngULFqgdWr4WFRVFzZo1WbhwYarHZ82axZw5c1i4cCGnTp3C2dmZdu3a6dfjzHGKyBUNGjRQRowYYbCvcuXKyueff65SRIVDSEiIAigHDhxQO5QCJyIiQqlYsaKya9cupUWLFsq4cePUDqnAmThxotK0aVO1wyjwunTpogwbNsxgX69evZR33nlHpYgKHkDZuHGj/rlOp1OcnZ2VGTNm6PfFxMQoDg4OypIlS3IlJmkBygVxcXGcOXOG9u3bG+xv3749R48eVSmqwiEsLAwAR0dHlSMpeEaNGkWXLl1o27at2qEUWFu2bKFevXq89dZbODk5Ubt2bf773/+qHVaB07RpU/bs2cONGzcAOH/+PIcPH6Zz584qR1Zw+fv7ExwcbPC9aGFhQYsWLXLte1EWQ80FT548ITExkZIlSxrsL1myJMHBwSpFVfApisKECRNo2rQp1apVUzucAmX16tWcPXuWU6dOqR1KgXbnzh0WL17MhAkT+OKLLzh58iRjx47FwsKCQYMGqR1egTFx4kTCwsKoXLkyJiYmJCYm8t1339G/f3+1Qyuwkr/7UvtevHv3bq7EIAlQLtJoNAbPFUVJsU9kn9GjR3PhwgUOHz6sdigFyr179xg3bhw7d+7E0tJS7XAKNJ1OR7169Zg+fToAtWvX5vLlyyxevFgSoGy0Zs0ali9fzsqVK6latSp+fn6MHz8eFxcXBg8erHZ4BZqa34uSAOWC4sWLY2JikqK1JyQkJEX2K7LHmDFj2LJlCwcPHsTV1VXtcAqUM2fOEBISQt26dfX7EhMTOXjwIAsXLiQ2NhYTExMVIyw4SpUqhZeXl8G+KlWqsH79epUiKpg+/fRTPv/8c/r16wdA9erVuXv3Lj4+PpIA5RBnZ2cgqSWoVKlS+v25+b0ofYBygbm5OXXr1mXXrl0G+3ft2kXjxo1ViqpgUhSF0aNHs2HDBvbu3YuHh4faIRU4bdq04eLFi/j5+em3evXq8fbbb+Pn5yfJTzZq0qRJimkcbty4gbu7u0oRFUwvXrxAqzX8OjQxMZFh8DnIw8MDZ2dng+/FuLg4Dhw4kGvfi9IClEsmTJjAwIEDqVevHt7e3vz8888EBgYyYsQItUMrUEaNGsXKlSvZvHkzdnZ2+lY3BwcHrKysVI6uYLCzs0vRp8rGxoZixYpJX6ts9tFHH9G4cWOmT59Onz59OHnyJD///DM///yz2qEVKF27duW7776jTJkyVK1alXPnzjFnzhyGDRumdmj5WmRkJLdu3dI/9/f3x8/PD0dHR8qUKcP48eOZPn06FStWpGLFikyfPh1ra2sGDBiQOwHmylgzoSiKoixatEhxd3dXzM3NlTp16sjQ7BwApLotXbpU7dAKNBkGn3P+/PNPpVq1aoqFhYVSuXJl5eeff1Y7pAInPDxcGTdunFKmTBnF0tJSKVeunPLll18qsbGxaoeWr+3bty/V38eDBw9WFCVpKPzkyZMVZ2dnxcLCQmnevLly8eLFXItPoyiKkjuplhBCCCFE3iB9gIQQQghR6EgCJIQQQohCRxIgIYQQQhQ6kgAJIYQQotCRBEgIIYQQhY4kQEIIIYQodCQBEkIIIUShIwmQEEL8o2zZssydO1ftMIQQuUASICGEKoYMGUKPHj0AaNmyJePHj8+1a/v6+lKkSJEU+0+dOsX777+fa3EIIdQja4EJIQqMuLg4zM3NM31+iRIlsjEaIUReJi1AQghVDRkyhAMHDjBv3jw0Gg0ajYaAgAAArly5QufOnbG1taVkyZIMHDiQJ0+e6M9t2bIlo0ePZsKECRQvXpx27doBMGfOHKpXr46NjQ1ubm6MHDmSyMhIAPbv38/QoUMJCwvTX2/KlClAyltggYGBdO/eHVtbW+zt7enTpw+PHj3SH58yZQq1atXi999/p2zZsjg4ONCvXz8iIiL0Zf744w+qV6+OlZUVxYoVo23btkRFReXQuymEyChJgIQQqpo3bx7e3t689957BAUFERQUhJubG0FBQbRo0YJatWpx+vRptm/fzqNHj+jTp4/B+cuWLcPU1JQjR47w008/AaDVapk/fz6XLl1i2bJl7N27l88++wyAxo0bM3fuXOzt7fXX++STT1LEpSgKPXr04NmzZxw4cIBdu3Zx+/Zt+vbta1Du9u3bbNq0ib/++ou//vqLAwcOMGPGDACCgoLo378/w4YN4+rVq+zfv59evXohSzAKoT65BSaEUJWDgwPm5uZYW1vj7Oys37948WLq1KnD9OnT9ft+++033NzcuHHjBp6engBUqFCBWbNmGdT5cn8iDw8Ppk2bxocffsiPP/6Iubk5Dg4OaDQag+u9avfu3Vy4cAF/f3/c3NwA+P3336latSqnTp2ifv36AOh0Onx9fbGzswNg4MCB7Nmzh+/+v337B0l1DeA4/vVILv0fHCoiqbASrYiGKLAhIxJagogIHJqChpbGloZTNNgiQdAYDQ392YIihKBB0Woph8DKoKCsCKIltTscrlxP557j4d7owPv7wLs8vo+P7zvIl+fVr1+5ubkhlUoxODhITU0NAC6X6z/cLRH5v2gHSET+SNFolGAwSFFRUfZobGwEvu26/K29vf3d3GAwSG9vL1VVVRQXF+Pz+bi/v/+tR0+xWIzq6ups/AA4HA7KysqIxWLZMZvNlo0fgIqKCm5vbwFoaWmhp6cHl8vF0NAQy8vLPD4+5n8TROTDKIBE5I+UyWQYGBjg+Pg45zg7O8PtdmfPKywszJl3eXmJ1+vF6XSyvr5ONBplcXERgNfX17zXf3t7w2Qy/XK8oKAg53WTyUQmkwHAbDazu7vL9vY2DoeDQCBAQ0MD5+fneX8OEfkYCiAR+XQWi4V0Op0z1tbWxsnJCTabjfr6+pzj++j5p0gkQiqVwu/309HRgd1u5/r6+pfrfc/hcJBIJLi6usqOnZ6e8vT0RFNTU97XZjKZ6OrqYmZmhqOjIywWC5ubm3nPF5GPoQASkU9ns9kIhUJcXFyQTCbJZDJMTEzw8PDAyMgI4XCYeDzOzs4OY2NjP42Xuro6UqkUgUCAeDzOysoKS0tL79Z7fn5mb2+PZDLJy8vLu/fxeDw0NzczOjrK4eEh4XAYn89Hd3f3Dx+7/UgoFGJ2dpZIJEIikWBjY4O7u7vfCigR+RgKIBH5dFNTU5jNZhwOB1arlUQiQWVlJQcHB6TTafr6+nA6nUxOTlJaWsqXL//+1dXa2srCwgLz8/M4nU5WV1eZm5vLOaezs5Px8XGGh4exWq3vfkQN33Zutra2KC8vx+124/F4qK2tZW1tLe/rKikpYX9/H6/Xi91uZ3p6Gr/fT39/f/43R0Q+hOlN/8cUERERg9EOkIiIiBiOAkhEREQMRwEkIiIihqMAEhEREcNRAImIiIjhKIBERETEcBRAIiIiYjgKIBERETEcBZCIiIgYjgJIREREDEcBJCIiIoajABIRERHD+Qt9j+lUth74lgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -346,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -364,15 +424,15 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 0.7146460310874032, 0.01295934582879973, 0.0073423008284427375, 0.005757100401123474, 0.00725004121094582, 0.00878215971833188, 0.008138545510328506, 0.008905425886364926, 0.0071714932971553135, 0.0050508011630583174]\n", - "[37.94733192202055, 28.819909345949704, 22.92044340981513, 21.188224428205743, 21.154011569814752, 21.152981183370528, 21.15289615375783, 21.15289397912285, 21.15289385280897, 21.152893836911957, 21.152893836305644]\n" + "[0, 0.7142480688060842, 0.010872949360825475, 0.006641176164949921, 0.008158790292294325, 0.01138407139374301, 0.00599341515517138, 0.00804371900698387, 0.01154541035249238, 0.0066184869859390386, 0.011473689491291406]\n", + "[37.94733192202055, 28.80143517496742, 21.948929896766895, 21.193262759184897, 21.15482325273987, 21.153158925755726, 21.15289717408808, 21.152893993520006, 21.152893840276587, 21.152893836578297, 21.152893836275403]\n" ] } ], @@ -383,15 +443,15 @@ }, { "cell_type": "code", - "execution_count": 121, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "After 2 steps, off diagonal norm: 22.92044340981513\n", - "By comparison, the Pauli-Z: 27.697127814319394\n" + "After 2 steps, off diagonal norm: 21.948929896766895\n", + "By comparison, the Pauli-Z: 27.84242666496467\n" ] } ], @@ -412,21 +472,21 @@ }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "New optimized step at iteration 1/8: 0.05941564262362324 with operator ZZIZZ\n", - "New optimized step at iteration 2/8: 0.03940145130227511 with operator ZIZIZ\n", - "New optimized step at iteration 3/8: 0.0011280629619659756 with operator canonical\n", - "New optimized step at iteration 4/8: 0.0006687287367940978 with operator canonical\n", - "New optimized step at iteration 5/8: 7.009154476669683e-05 with operator canonical\n", - "New optimized step at iteration 6/8: 0.0006524905648483872 with operator canonical\n", - "New optimized step at iteration 7/8: 0.0004846714536669654 with operator canonical\n", - "New optimized step at iteration 8/8: 0.00042762745962869885 with operator canonical\n" + "New optimized step at iteration 1/8: 0.07026121386850952 with operator ZIZIZ\n", + "New optimized step at iteration 2/8: 0.0005119598708917606 with operator canonical\n", + "New optimized step at iteration 3/8: 3.6209008485931554e-05 with operator canonical\n", + "New optimized step at iteration 4/8: 0.0003966788691854405 with operator canonical\n", + "New optimized step at iteration 5/8: 1.0758355699794022e-05 with operator canonical\n", + "New optimized step at iteration 6/8: 9.815194330571166e-05 with operator canonical\n", + "New optimized step at iteration 7/8: 0.0004348171691943361 with operator canonical\n", + "New optimized step at iteration 8/8: 0.00010412633106159863 with operator canonical\n" ] } ], @@ -448,16 +508,16 @@ }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[37.94733192202055, 28.819909345949704, 22.92044340981513, 21.34720527797985, 21.054031744647673, 20.213777401246823, 19.785419985540294, 19.744094238325083, 19.37058316672788, 19.1198463086939, 18.91557430830763]\n", - "[0, 0.7146460310874032, 0.01295934582879973, 0.05941564262362324, 0.03940145130227511, 0.0011280629619659756, 0.0006687287367940978, 7.009154476669683e-05, 0.0006524905648483872, 0.0004846714536669654, 0.00042762745962869885]\n", - "['Cannonical', 'Cannonical', 'ZZIZZ', 'ZIZIZ', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical']\n" + "[37.94733192202055, 28.80143517496742, 21.948929896766895, 19.67268067670322, 19.356984750279484, 19.33716439273286, 19.127002740180895, 19.1217782200388, 19.07449837528649, 18.87464451203365, 18.83120737196001]\n", + "[0, 0.7142480688060842, 0.010872949360825475, 0.07026121386850952, 0.0005119598708917606, 3.6209008485931554e-05, 0.0003966788691854405, 1.0758355699794022e-05, 9.815194330571166e-05, 0.0004348171691943361, 0.00010412633106159863]\n", + "['Cannonical', 'Cannonical', 'ZIZIZ', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical']\n" ] } ], @@ -469,12 +529,12 @@ }, { "cell_type": "code", - "execution_count": 126, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/additional_double_bracket_functions.py index 3e4b40e795..22b652342f 100644 --- a/src/qibo/models/dbi/additional_double_bracket_functions.py +++ b/src/qibo/models/dbi/additional_double_bracket_functions.py @@ -1,4 +1,4 @@ -from copy import copy, deepcopy +from copy import deepcopy from itertools import product import matplotlib.pyplot as plt @@ -6,74 +6,18 @@ import seaborn as sns from hyperopt import hp, tpe +from qibo import symbols from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, ) -from qibo.symbols import I, X, Z - - -def visualize_matrix(matrix, title=""): - """Visualize absolute values of a matrix in a heatmap form.""" - fig, ax = plt.subplots(figsize=(5, 5)) - ax.set_title(title) - try: - im = ax.imshow(np.absolute(matrix), cmap="inferno") - except TypeError: - im = ax.imshow(np.absolute(matrix.get()), cmap="inferno") - fig.colorbar(im, ax=ax) - - -def visualize_drift(h0, h): - """Visualize drift of the evolved hamiltonian w.r.t. h0.""" - fig, ax = plt.subplots(figsize=(5, 5)) - ax.set_title(r"Drift: $|\hat{H}_0 - \hat{H}_{1}|$") - try: - im = ax.imshow(np.absolute(h0 - h), cmap="inferno") - except TypeError: - im = ax.imshow(np.absolute((h0 - h).get()), cmap="inferno") - - fig.colorbar(im, ax=ax) - - -def plot_histories(loss_histories: list, steps: list, labels: list = None): - """Plot off-diagonal norm histories over a sequential evolution.""" - plt.figure(figsize=(5, 5 * 6 / 8)) - if len(steps) == 1: - # fixed_step - x_axis = [i * steps[0] for i in range(len(loss_histories))] - else: - x_axis = [sum(steps[:k]) for k in range(1, len(steps) + 1)] - plt.plot(x_axis, loss_histories, "-o") - - x_labels_rounded = [round(x, 2) for x in x_axis] - x_labels_rounded = [0] + x_labels_rounded[0:5] + [max(x_labels_rounded)] - x_labels_rounded.pop(3) - plt.xticks(x_labels_rounded) - - y_labels_rounded = [round(y, 1) for y in loss_histories] - y_labels_rounded = y_labels_rounded[0:5] + [min(y_labels_rounded)] - plt.yticks(y_labels_rounded) - - if labels is not None: - labels_copy = copy(labels) - labels_copy.insert(0, "Initial") - for i, label in enumerate(labels_copy): - plt.text(x_axis[i], loss_histories[i], label) - - plt.grid() - plt.xlabel(r"Flow duration $s$") - plt.title("Loss function histories") def generate_Z_operators(nqubits: int): """Generate a dictionary containing 1) all possible products of Pauli Z operators for L = n_qubits and 2) their respective names. - Return: Dictionary with the following keys - - - *"Z_operators"* - - *"Z_words"* + Return: Dictionary with operator names (str) as keys and operators (np.array) as values Example: .. testcode:: @@ -88,31 +32,33 @@ def generate_Z_operators(nqubits: int): h0 = random_hermitian(2**nqubits) dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) generate_Z = generate_Z_operators(4) - Z_ops = generate_Z["Z_operators"] - Z_words = generate_Z["Z_operators"] + Z_ops = list(generate_Z.values()) + Z_words = list(generate_Z.keys()) 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) print(norm_diff) """ + # list of tupples, e.g. ('Z','I','Z') combination_strings = product("ZI", repeat=nqubits) - operator_map = {"Z": Z, "I": I} - operators = [] - operators_words = [] + output_dict = {} - for op_string in combination_strings: - tensor_op = 1 + for op_string_tup in combination_strings: # except for the identity - if "Z" in op_string: - for qubit, char in enumerate(op_string): - if char in operator_map: - tensor_op *= operator_map[char](qubit) - op_string_cat = "".join(op_string) - operators_words.append(op_string_cat) - # append np.array operators - operators.append(SymbolicHamiltonian(tensor_op).dense.matrix) - return {"Z_operators": operators, "Z_words": operators_words} + if "Z" in op_string_tup: + op_name = "".join(op_string_tup) + tensor_op = str_to_op(op_name) + # append in output_dict + output_dict[op_name] = SymbolicHamiltonian(tensor_op).dense.matrix + return output_dict + + +def str_to_op(name: str): + tensor_op = 1 + for qubit, char in enumerate(name): + tensor_op *= getattr(symbols, char)(qubit) + return tensor_op def select_best_dbr_generator( From 3ecdd2e05e9310ccaa57350bf5693c6763546597 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 5 Jan 2024 14:26:19 +0900 Subject: [PATCH 17/48] 1. Renamed additional functions into utils.py 2. Added empty __init__.py --- examples/dbi/DBI_strategy_Pauli-Z_products.ipynb | 2 +- src/qibo/models/dbi/__init__.py | 0 .../dbi/{additional_double_bracket_functions.py => utils.py} | 0 3 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 src/qibo/models/dbi/__init__.py rename src/qibo/models/dbi/{additional_double_bracket_functions.py => utils.py} (100%) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 826a22270a..b86abf8598 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -24,7 +24,7 @@ "from qibo import hamiltonians, set_backend\n", "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", - "from qibo.models.dbi.additional_double_bracket_functions import *\n", + "from qibo.models.dbi.utils import *\n", "from qibo.symbols import I, X, Z" ] }, diff --git a/src/qibo/models/dbi/__init__.py b/src/qibo/models/dbi/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/qibo/models/dbi/additional_double_bracket_functions.py b/src/qibo/models/dbi/utils.py similarity index 100% rename from src/qibo/models/dbi/additional_double_bracket_functions.py rename to src/qibo/models/dbi/utils.py From 1b29ccd4a1283429c1e1c05a3792d6e5ac5440d4 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 5 Jan 2024 14:31:28 +0900 Subject: [PATCH 18/48] Remove redundant dependencies --- pyproject.toml | 1 - src/qibo/models/dbi/utils.py | 3 --- 2 files changed, 4 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index ff8207ad25..ef54114d8d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,7 +28,6 @@ cma = "^3.3.0" joblib = "^1.2.0" hyperopt = "^0.2.7" tabulate = "^0.9.0" -seaborn = "^0.13.0" [tool.poetry.group.dev] optional = true diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 22b652342f..99048e74b1 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -1,9 +1,6 @@ from copy import deepcopy from itertools import product -import matplotlib.pyplot as plt -import numpy as np -import seaborn as sns from hyperopt import hp, tpe from qibo import symbols From 7503a01434d9414a049d8dc13522606cbb8384fd Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 5 Jan 2024 15:26:18 +0900 Subject: [PATCH 19/48] Added descriptions in notebooks, clean outputs. --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 455 +++++++----------- examples/dbi/dbi_tutorial_basic_intro.ipynb | 353 ++------------ 2 files changed, 229 insertions(+), 579 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index b86abf8598..a9614d5a44 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -6,12 +6,29 @@ "source": [ "# Double-Bracket Iteration Strategy: Pauli-Z products\n", "\n", - "In this example, we demonstrate the usage of the DBI strategy: Pauli-Z products, where the diagonal operator is chosen as the optimal product of Pauli-Z operators." + "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": 1, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python -m pip install seaborn # plotting library\n", + "!python -m pip install hyperopt # required to optimize the DBF step" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -22,15 +39,20 @@ "import seaborn as sns\n", "\n", "from qibo import hamiltonians, set_backend\n", - "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *\n", - "from qibo.symbols import I, X, Z" + "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": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -91,7 +113,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## The initial setup\n", + "# 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", @@ -100,25 +122,9 @@ }, { "cell_type": "code", - "execution_count": 3, - "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.4|INFO|2024-01-05 14:12:53]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\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", @@ -141,53 +147,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Local Z operators\n", - "Denoted as local Z operators, the diagonal operators used for this strategy are tensor products of pauli Z and identity." + "### Generate local Pauli-Z operators" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-05 14:13:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -198,63 +165,34 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Iteration from list" + "## 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." ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 1/10: 0.2228337317596202 with operator ZZZZI\n", - "New optimized step at iteration 2/10: 0.035477924096777136 with operator IIIZZ\n", - "New optimized step at iteration 3/10: 0.035172652127034264 with operator ZIIIZ\n", - "New optimized step at iteration 4/10: 0.05284947697359669 with operator IIZIZ\n", - "New optimized step at iteration 5/10: 0.05945391423239668 with operator ZIIIZ\n", - "New optimized step at iteration 6/10: 0.06722463454874757 with operator IZIII\n", - "New optimized step at iteration 7/10: 0.0004656172832855188 with operator IIIZZ\n", - "New optimized step at iteration 8/10: 0.0004368451128360077 with operator IIIZZ\n", - "New optimized step at iteration 9/10: 0.0004206499567262245 with operator IIIZZ\n", - "New optimized step at iteration 10/10: 0.0017291128494125731 with operator IIIZZ\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "NSTEPS = 10\n", "Z_optimal = []\n", + "# add in initial values for plotting\n", "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", " idx, step = select_best_dbr_generator_and_run(dbi, Z_ops, compare_canonical=False)\n", " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", - " if idx == len(Z_ops):\n", - " Z_optimal.append(\"canonical\")\n", - " else:\n", - " Z_optimal.append(Z_names[idx])\n", + " Z_optimal.append(Z_names[idx])\n", " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}\")" ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plot_histories(off_diagonal_norm_history, steps, Z_optimal)" ] @@ -274,29 +212,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Compare with canonical" + "### 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": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.4|INFO|2024-01-05 14:14:34]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\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", @@ -311,31 +238,15 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 1/10: 0.7142480688060842\n", - "New optimized step at iteration 2/10: 0.010872949360825475\n", - "New optimized step at iteration 3/10: 0.006641176164949921\n", - "New optimized step at iteration 4/10: 0.008158790292294325\n", - "New optimized step at iteration 5/10: 0.01138407139374301\n", - "New optimized step at iteration 6/10: 0.00599341515517138\n", - "New optimized step at iteration 7/10: 0.00804371900698387\n", - "New optimized step at iteration 8/10: 0.01154541035249238\n", - "New optimized step at iteration 9/10: 0.0066184869859390386\n", - "New optimized step at iteration 10/10: 0.011473689491291406\n" - ] - } - ], + "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", @@ -352,30 +263,9 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.figure()\n", "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", @@ -392,50 +282,118 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Here we see that variationally chosen diagonal operators are less likely to converge to a local minimum compared to the GWW flow. " + "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\n", + "## Mixed strategy: optimal at each step" + ] + }, + { + "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_mixed = 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": [ + "NSTEPS = 10\n", + "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", + " idx, step = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True)\n", + " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", + " steps.append(steps[-1]+step)\n", + " if idx == len(Z_names):\n", + " Z_optimal_mixed.append('Canonical')\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]}\")" + ] + }, + { + "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" + ] + }, + { + "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": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ - "dbi_mixed= DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", - "print(\"Initial off diagonal norm\", dbi_mixed.off_diagonal_norm)" + "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": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0, 0.7142480688060842, 0.010872949360825475, 0.006641176164949921, 0.008158790292294325, 0.01138407139374301, 0.00599341515517138, 0.00804371900698387, 0.01154541035249238, 0.0066184869859390386, 0.011473689491291406]\n", - "[37.94733192202055, 28.80143517496742, 21.948929896766895, 21.193262759184897, 21.15482325273987, 21.153158925755726, 21.15289717408808, 21.152893993520006, 21.152893840276587, 21.152893836578297, 21.152893836275403]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(steps_canonical)\n", "print(off_diagonal_norm_history_canonical)" @@ -443,115 +401,70 @@ }, { "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "After 2 steps, off diagonal norm: 21.948929896766895\n", - "By comparison, the Pauli-Z: 27.84242666496467\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Run the initial iterations using canonical iterations\n", - "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", - "steps_mixed = [0]\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(step=step)\n", - " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", - " steps_mixed.append(step)\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.off_diagonal_norm)\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": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 1/8: 0.07026121386850952 with operator ZIZIZ\n", - "New optimized step at iteration 2/8: 0.0005119598708917606 with operator canonical\n", - "New optimized step at iteration 3/8: 3.6209008485931554e-05 with operator canonical\n", - "New optimized step at iteration 4/8: 0.0003966788691854405 with operator canonical\n", - "New optimized step at iteration 5/8: 1.0758355699794022e-05 with operator canonical\n", - "New optimized step at iteration 6/8: 9.815194330571166e-05 with operator canonical\n", - "New optimized step at iteration 7/8: 0.0004348171691943361 with operator canonical\n", - "New optimized step at iteration 8/8: 0.00010412633106159863 with operator canonical\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Continue the remaining steps with Pauli-Z operators\n", - "Z_optimal_mixed = [\"Cannonical\" for _ in range(cannonical_NSTEPS)]\n", + "Z_optimal_mixed_can = [\"Cannonical\" for _ in range(cannonical_NSTEPS)]\n", "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", - "dbi_mixed.mode = DoubleBracketGeneratorType.single_commutator\n", + "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n", "for _ in range(remaining_NSTEPS):\n", - " idx, step = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True)\n", - " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", - " steps_mixed.append(step)\n", + " idx, step = select_best_dbr_generator_and_run(dbi_mixed_can, Z_ops, compare_canonical=False)\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", + " Z_optimal_mixed_can.append(\"canonical\")\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[-1]}\")" + " Z_optimal_mixed_can.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": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[37.94733192202055, 28.80143517496742, 21.948929896766895, 19.67268067670322, 19.356984750279484, 19.33716439273286, 19.127002740180895, 19.1217782200388, 19.07449837528649, 18.87464451203365, 18.83120737196001]\n", - "[0, 0.7142480688060842, 0.010872949360825475, 0.07026121386850952, 0.0005119598708917606, 3.6209008485931554e-05, 0.0003966788691854405, 1.0758355699794022e-05, 9.815194330571166e-05, 0.0004348171691943361, 0.00010412633106159863]\n", - "['Cannonical', 'Cannonical', 'ZIZIZ', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical', 'canonical']\n" - ] - } - ], + "outputs": [], "source": [ - "print(off_diagonal_norm_history_mixed)\n", - "print(steps_mixed)\n", - "print(Z_optimal_mixed)" + "print(off_diagonal_norm_history_mixed_can)\n", + "print(steps_mixed_can)\n", + "print(Z_optimal_mixed_can)" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plot_histories(off_diagonal_norm_history_mixed, steps_mixed, Z_optimal_mixed)" + "plot_histories(off_diagonal_norm_history_mixed_can, steps_mixed_can, Z_optimal_mixed_can)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We see that the mixed strategy does not necessarily give a better result, this could also be a result of the unstability of hyperopt." + "We see that after two canonical steps, the diagonalization gets stuck at the same local minimum as the canonical trial. Hence, it may not be ideal to run the canonical generator at initial steps." ] } ], diff --git a/examples/dbi/dbi_tutorial_basic_intro.ipynb b/examples/dbi/dbi_tutorial_basic_intro.ipynb index 88a7e01062..ecb28bb4d7 100644 --- a/examples/dbi/dbi_tutorial_basic_intro.ipynb +++ b/examples/dbi/dbi_tutorial_basic_intro.ipynb @@ -16,41 +16,10 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "e1f362b8-eb73-456e-ae48-94c5f2a12649", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: seaborn in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (0.13.0)\n", - "Requirement already satisfied: numpy!=1.24.0,>=1.20 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from seaborn) (1.26.2)\n", - "Requirement already satisfied: pandas>=1.2 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from seaborn) (2.1.4)\n", - "Requirement already satisfied: matplotlib!=3.6.1,>=3.3 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from seaborn) (3.8.2)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (1.2.0)\n", - "Requirement already satisfied: cycler>=0.10 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (4.46.0)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (1.4.5)\n", - "Requirement already satisfied: packaging>=20.0 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (23.2)\n", - "Requirement already satisfied: pillow>=8 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (10.1.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (3.1.1)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from pandas>=1.2->seaborn) (2023.3.post1)\n", - "Requirement already satisfied: tzdata>=2022.1 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from pandas>=1.2->seaborn) (2023.3)\n", - "Requirement already satisfied: six>=1.5 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib!=3.6.1,>=3.3->seaborn) (1.16.0)\n", - "Requirement already satisfied: hyperopt in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (0.2.7)\n", - "Requirement already satisfied: numpy in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (1.26.2)\n", - "Requirement already satisfied: scipy in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (1.11.4)\n", - "Requirement already satisfied: six in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (1.16.0)\n", - "Requirement already satisfied: networkx>=2.2 in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (3.2.1)\n", - "Requirement already satisfied: future in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (0.18.3)\n", - "Requirement already satisfied: tqdm in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (4.66.1)\n", - "Requirement already satisfied: cloudpickle in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (3.0.0)\n", - "Requirement already satisfied: py4j in /Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages (from hyperopt) (0.10.9.7)\n" - ] - } - ], + "outputs": [], "source": [ "!python -m pip install seaborn # plotting library\n", "!python -m pip install hyperopt # required to optimize the DBF step" @@ -58,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "f270b1ea-ee6a-4eac-a0ff-3d7dae296cf0", "metadata": {}, "outputs": [], @@ -85,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "4aec7b46-19b9-4004-93c0-a90255e58fd9", "metadata": {}, "outputs": [], @@ -137,29 +106,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "2c4ed408-68ed-4054-825c-2a7df0979a4f", "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.3|INFO|2023-12-18 16:59:36]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# set the qibo backend (we suggest qibojit if N >= 20)\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -197,20 +147,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "26a487e9-366b-4203-b660-e3d4af2bcb68", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DoubleBracketGeneratorType.canonical\n", - "DoubleBracketGeneratorType.single_commutator\n", - "DoubleBracketGeneratorType.group_commutator\n" - ] - } - ], + "outputs": [], "source": [ "# we have a look inside the DoubleBracketGeneratorType class\n", "for generator in DoubleBracketGeneratorType:\n", @@ -219,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "da8dce89-27f6-403d-982a-58d531fade48", "metadata": {}, "outputs": [], @@ -240,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "055870ec-55f2-4b99-a622-e3aa4c7dd0e9", "metadata": {}, "outputs": [], @@ -258,18 +198,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "9e278c3d-9f34-4a40-b453-4e030c751ef5", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Backend: qibojit (numba)\n" - ] - } - ], + "outputs": [], "source": [ "# on which qibo backend am I running the algorithm?\n", "print(f\"Backend: {dbf.backend}\")" @@ -277,25 +209,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "5b8e142b-a0a2-41bd-a16a-265a420b7360", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial form of the target hamiltonian:\n", - "[[-5.-0.j -3.-0.j -3.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n", - " [-3.-0.j -1.-0.j -0.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n", - " [-3.-0.j -0.-0.j -1.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n", - " ...\n", - " [-0.-0.j -0.-0.j -0.-0.j ... -1.-0.j -0.-0.j -3.-0.j]\n", - " [-0.-0.j -0.-0.j -0.-0.j ... -0.-0.j -1.-0.j -3.-0.j]\n", - " [-0.-0.j -0.-0.j -0.-0.j ... -3.-0.j -3.-0.j -5.-0.j]]\n" - ] - } - ], + "outputs": [], "source": [ "# the initial target hamiltonian is a qibo hamiltonian\n", "# thus the matrix can be accessed typing h.matrix\n", @@ -304,21 +221,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "4f9d1d41-3df7-49cf-96ca-fa1019c00c33", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# let's visualize it in a more graphical way\n", "visualize_matrix(dbf.h0.matrix, r\"$H_0$\")" @@ -326,21 +232,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "7b864712-219c-44b6-8337-19ef0100e318", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# since we didn't perform yet any evolutionary step they are the same\n", "visualize_drift(dbf.h0.matrix, dbf.h.matrix)" @@ -356,21 +251,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "da3d3aaa-17e1-492e-bcd3-b510f44a5391", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# diagonal part of the H target\n", "visualize_matrix(dbf.diagonal_h_matrix)" @@ -388,18 +272,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "24d0dfa1-7039-4d7d-8aa3-5a937b9ab0b8", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HS norm of the off diagonal part of H: 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hilbert-Schmidt norm of the off-diagonal part\n", "# which we want to bring to be close to zero\n", @@ -420,21 +296,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "95f8d86f-07d4-498c-acb1-f6f6a4614c24", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6.708203932499369" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# define a quantum state\n", "# for example the ground state of a multi-qubit Z hamiltonian\n", @@ -457,19 +322,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "9a886261-8aa6-4df0-a31b-9c39847db124", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial value of the off-diagonal norm: 37.94733192202055\n", - "One step later off-diagonal norm: 34.179717587686405\n" - ] - } - ], + "outputs": [], "source": [ "# perform one evolution step\n", "\n", @@ -492,21 +348,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "cc74812d-7c2c-44e4-afc2-e235968801b4", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "visualize_drift(dbf.h0.matrix, dbf.h.matrix)" ] @@ -521,25 +366,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "aad79966-7a11-4a45-aba5-4a4bb8315c50", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0%| | 0/1000 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "visualize_matrix(dbf.h.matrix)" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "6bdaf7f9-7e49-4a16-8b29-ae1f9746cd9b", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "visualize_drift(dbf.h0.matrix, dbf.h.matrix)" ] @@ -611,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "59a6a485-a714-4e14-b27a-1df2930068ee", "metadata": {}, "outputs": [], @@ -634,21 +442,10 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "7e0b2f18-ca53-4f34-9fcf-0052dcc31dc5", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_histories(histories, labels)" ] @@ -663,37 +460,10 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "a6fd1e33-3620-4f3b-b705-a120f6da0027", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [00:00<00:00, 685.54trial/s, best loss: 28.7860881989508] \n", - "New optimized step at iteration 1/20: 0.004518769188329906\n", - "New optimized step at iteration 2/20: 0.009025775499129824\n", - "New optimized step at iteration 3/20: 0.006735227175805928\n", - "New optimized step at iteration 4/20: 0.008985994777717705\n", - "New optimized step at iteration 5/20: 0.006694566091224997\n", - "New optimized step at iteration 6/20: 0.007442596156470098\n", - "New optimized step at iteration 7/20: 0.008626256490322911\n", - "New optimized step at iteration 8/20: 0.00644190837439307\n", - "New optimized step at iteration 9/20: 0.009847781961679946\n", - "New optimized step at iteration 10/20: 0.003183204501257452\n", - "New optimized step at iteration 11/20: 0.007594562059229289\n", - "New optimized step at iteration 12/20: 0.006009602422684977\n", - "New optimized step at iteration 13/20: 0.011524210883291907\n", - "New optimized step at iteration 14/20: 0.0008441411991430689\n", - "New optimized step at iteration 15/20: 0.015716482154367724\n", - "New optimized step at iteration 16/20: 0.0019653861946552133\n", - "New optimized step at iteration 17/20: 0.002849630894901091\n", - "New optimized step at iteration 18/20: 0.006854467411576207\n", - "New optimized step at iteration 19/20: 0.0020424257684723878\n" - ] - } - ], + "outputs": [], "source": [ "# restart\n", "dbf_2 = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)\n", @@ -731,21 +501,10 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "0f0212bf-b642-4fea-9203-037876e0b266", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_histories(histories, labels)" ] @@ -760,42 +519,20 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "82b89092-07e5-4788-9ae0-8907df2428eb", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "visualize_matrix(dbf_1.h.matrix)" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "ac8ed320-04a8-42af-a980-48ab4f1fff7c", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "visualize_matrix(dbf_2.h.matrix)" ] From 540c7a7ab063dd5ea27e39834f8606c200f1f03f Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 5 Jan 2024 16:16:56 +0900 Subject: [PATCH 20/48] Modify descriptions and NSTEPS for better presentation --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 62 +++++++++---------- src/qibo/models/dbi/utils.py | 15 +++-- 2 files changed, 38 insertions(+), 39 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index a9614d5a44..7f9ebfb2c0 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -166,7 +166,9 @@ "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." + "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." ] }, { @@ -175,7 +177,7 @@ "metadata": {}, "outputs": [], "source": [ - "NSTEPS = 10\n", + "NSTEPS = 15\n", "Z_optimal = []\n", "# add in initial values for plotting\n", "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", @@ -185,7 +187,7 @@ " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", " Z_optimal.append(Z_names[idx])\n", - " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}\")" + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi.off_diagonal_norm}\")" ] }, { @@ -254,8 +256,8 @@ " optimizer = tpe,\n", " max_evals = 100,\n", " )\n", - " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}\")\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)" @@ -278,6 +280,16 @@ "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": {}, @@ -326,7 +338,6 @@ "metadata": {}, "outputs": [], "source": [ - "NSTEPS = 10\n", "Z_optimal_mixed = []\n", "# add in initial values for plotting\n", "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", @@ -335,11 +346,11 @@ " idx, step = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True)\n", " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", - " if idx == len(Z_names):\n", + " if idx == len(Z_ops):\n", " Z_optimal_mixed.append('Canonical')\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]}\")" + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal_mixed[-1]}, loss {dbi_mixed.off_diagonal_norm}\")" ] }, { @@ -367,7 +378,7 @@ "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" + "2. Tendency of canonical operator to get stuck at a near local minimum" ] }, { @@ -389,16 +400,6 @@ "print(\"Initial off diagonal norm\", dbi_mixed_can.off_diagonal_norm)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(steps_canonical)\n", - "print(off_diagonal_norm_history_canonical)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -446,25 +447,24 @@ "metadata": {}, "outputs": [], "source": [ - "print(off_diagonal_norm_history_mixed_can)\n", - "print(steps_mixed_can)\n", - "print(Z_optimal_mixed_can)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plot_histories(off_diagonal_norm_history_mixed_can, steps_mixed_can, Z_optimal_mixed_can)" + "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": [ - "We see that after two canonical steps, the diagonalization gets stuck at the same local minimum as the canonical trial. Hence, it may not be ideal to run the canonical generator at initial steps." + "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." ] } ], diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 99048e74b1..cb6597d06f 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -87,10 +87,7 @@ def select_best_dbr_generator( optimal_steps = [] for d in d_list: # prescribed step durations - if step is not None: - dbi_object(step=step, d=d) - # compute step durations using hyperopt - else: + if step is None: step = dbi_object.hyperopt_step( step_min=step_min, step_max=step_max, @@ -99,6 +96,7 @@ def select_best_dbr_generator( max_evals=max_evals, d=d, ) + dbi_object(step=step, d=d) optimal_steps.append(step) norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) dbi_object.h = deepcopy(h_before) @@ -106,9 +104,7 @@ def select_best_dbr_generator( if compare_canonical is True: generator_type = dbi_object.mode dbi_object.mode = DoubleBracketGeneratorType.canonical - if step is not None: - dbi_object(step=step) - else: + if step is None: step = dbi_object.hyperopt_step( step_min=step_min, step_max=step_max, @@ -116,11 +112,14 @@ def select_best_dbr_generator( optimizer=tpe, max_evals=max_evals, ) + dbi_object(step=step) optimal_steps.append(step) norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) + # print(f'canonical step {step}, loss {dbi_object.off_diagonal_norm}') dbi_object.h = deepcopy(h_before) dbi_object.mode = generator_type # find best d + # print(norms_off_diagonal_restriction) idx_max_loss = norms_off_diagonal_restriction.index( min(norms_off_diagonal_restriction) ) @@ -148,7 +147,7 @@ def select_best_dbr_generator_and_run( compare_canonical=compare_canonical, ) # run with optimal d - if idx_max_loss == len(d_list): + if idx_max_loss == len(d_list) and compare_canonical is True: # canonical generator_type = dbi_object.mode dbi_object.mode = DoubleBracketGeneratorType.canonical From a9539c90078c2aa00c6387cb2ebd884e2752e874 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 5 Jan 2024 17:04:01 +0900 Subject: [PATCH 21/48] Set hyperopt max_evals=200 (notebook 300) --- examples/dbi/DBI_strategy_Pauli-Z_products.ipynb | 7 ++++--- src/qibo/models/dbi/utils.py | 4 ++-- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 7f9ebfb2c0..7c94cba3a2 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -178,12 +178,13 @@ "outputs": [], "source": [ "NSTEPS = 15\n", + "max_evals = 300\n", "Z_optimal = []\n", "# add in initial values for plotting\n", "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", - " idx, step = select_best_dbr_generator_and_run(dbi, Z_ops, compare_canonical=False)\n", + " idx, step = select_best_dbr_generator_and_run(dbi, Z_ops, compare_canonical=False, max_evals=max_evals)\n", " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", " Z_optimal.append(Z_names[idx])\n", @@ -254,7 +255,7 @@ " step_max = 1,\n", " space = hp.uniform,\n", " optimizer = tpe,\n", - " max_evals = 100,\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", @@ -343,7 +344,7 @@ "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", - " idx, step = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True)\n", + " idx, step = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True, max_evals=max_evals)\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", diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index cb6597d06f..02e95bbe28 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -64,7 +64,7 @@ def select_best_dbr_generator( step: float = None, step_min: float = 1e-5, step_max: float = 1, - max_evals: int = 100, + max_evals: int = 200, compare_canonical: bool = True, ): """Selects the best double bracket rotation generator from a list. @@ -133,7 +133,7 @@ def select_best_dbr_generator_and_run( step: float = None, step_min: float = 1e-5, step_max: float = 1, - max_evals: int = 100, + max_evals: int = 200, compare_canonical: bool = True, ): """Run double bracket iteration with generator chosen from a list.""" From 604f14ecbfd65710d1af881417ea0bfad6e9d5a4 Mon Sep 17 00:00:00 2001 From: Edoardo-Pedicillo Date: Wed, 10 Jan 2024 17:24:08 +0400 Subject: [PATCH 22/48] use diagonal matrix with group commutator --- src/qibo/models/dbi/double_bracket.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 3729085b03..9e584c266a 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -74,7 +74,7 @@ def __call__( ) elif mode is DoubleBracketGeneratorType.group_commutator: if d is None: - raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") + d = self.diagonal_h_matrix operator = ( self.h.exp(-step) @ self.backend.calculate_matrix_exp(-step, d) From bdbc07300e72372982942b11e5f8c9badc4f2dc6 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 11 Jan 2024 09:52:36 +0800 Subject: [PATCH 23/48] Deleted code comments; fix example code snippet --- src/qibo/models/dbi/double_bracket.py | 2 +- src/qibo/models/dbi/utils.py | 12 +++++------- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 3729085b03..1a7e980e14 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -38,7 +38,7 @@ class DoubleBracketIteration: from qibo.hamiltonians import Hamiltonian nqubits = 4 - h0 = random_hermitian(2**nqubits) + h0 = random_hermitian(2**nqubits, seed=2) dbf = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) # diagonalized matrix diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 02e95bbe28..792b79f61b 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -1,5 +1,6 @@ from copy import deepcopy from itertools import product +from typing import Optional from hyperopt import hp, tpe @@ -35,7 +36,6 @@ def generate_Z_operators(nqubits: int): 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) - print(norm_diff) """ # list of tupples, e.g. ('Z','I','Z') combination_strings = product("ZI", repeat=nqubits) @@ -61,7 +61,7 @@ def str_to_op(name: str): def select_best_dbr_generator( dbi_object: DoubleBracketIteration, d_list: list, - step: float = None, + step: Optional[float] = None, step_min: float = 1e-5, step_max: float = 1, max_evals: int = 200, @@ -82,11 +82,11 @@ def select_best_dbr_generator( Returns: The index of the optimal diagonal operator and respective step duration. """ - h_before = deepcopy(dbi_object.h) norms_off_diagonal_restriction = [] optimal_steps = [] for d in d_list: # prescribed step durations + h_before = deepcopy(dbi_object.h) if step is None: step = dbi_object.hyperopt_step( step_min=step_min, @@ -99,7 +99,7 @@ def select_best_dbr_generator( dbi_object(step=step, d=d) optimal_steps.append(step) norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) - dbi_object.h = deepcopy(h_before) + dbi_object.h = h_before # canonical if compare_canonical is True: generator_type = dbi_object.mode @@ -115,11 +115,9 @@ def select_best_dbr_generator( dbi_object(step=step) optimal_steps.append(step) norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) - # print(f'canonical step {step}, loss {dbi_object.off_diagonal_norm}') dbi_object.h = deepcopy(h_before) dbi_object.mode = generator_type # find best d - # print(norms_off_diagonal_restriction) idx_max_loss = norms_off_diagonal_restriction.index( min(norms_off_diagonal_restriction) ) @@ -130,7 +128,7 @@ def select_best_dbr_generator( def select_best_dbr_generator_and_run( dbi_object: DoubleBracketIteration, d_list: list, - step: float = None, + step: Optional[float] = None, step_min: float = 1e-5, step_max: float = 1, max_evals: int = 200, From d985db4bab63f6fb41f92187099074dd69920351 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 11 Jan 2024 19:29:06 +0800 Subject: [PATCH 24/48] Added doc string to str_to_op (changed name to str_to_symbolic to be more descriptive) --- src/qibo/models/dbi/utils.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 792b79f61b..a700df0078 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -20,7 +20,7 @@ def generate_Z_operators(nqubits: int): Example: .. testcode:: - from qibo.models.dbi.additional_double_bracket_functions import generate_Z_operators + from qibo.models.dbi.utils import generate_Z_operators from qibo.models.dbi.double_bracket import DoubleBracketIteration from qibo.quantum_info import random_hermitian from qibo.hamiltonians import Hamiltonian @@ -45,13 +45,22 @@ def generate_Z_operators(nqubits: int): # except for the identity if "Z" in op_string_tup: op_name = "".join(op_string_tup) - tensor_op = str_to_op(op_name) + tensor_op = str_to_symbolic(op_name) # append in output_dict output_dict[op_name] = SymbolicHamiltonian(tensor_op).dense.matrix return output_dict -def str_to_op(name: str): +def str_to_symbolic(name: str): + """Converts string into symbolic hamiltonian + Example: + .. testcode:: + + from qibo.models.dbi.utils import str_to_op + op_name = "ZYXZI" + # returns 5-qubit symbolic hamiltonian + ZIXZI_op = str_to_op(op_name) + """ tensor_op = 1 for qubit, char in enumerate(name): tensor_op *= getattr(symbols, char)(qubit) From be96068516ee14684161e17b904a9492b2f0929d Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 15 Jan 2024 14:25:22 +0800 Subject: [PATCH 25/48] Added test file --- src/qibo/models/dbi/utils.py | 9 +++--- tests/test_models_dbi_utils.py | 54 ++++++++++++++++++++++++++++++++++ 2 files changed, 58 insertions(+), 5 deletions(-) create mode 100644 tests/test_models_dbi_utils.py diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index a700df0078..ebc352e284 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -6,7 +6,7 @@ from qibo import symbols from qibo.config import raise_error -from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian +from qibo.hamiltonians import SymbolicHamiltonian from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, @@ -29,9 +29,8 @@ def generate_Z_operators(nqubits: int): nqubits = 4 h0 = random_hermitian(2**nqubits) dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) - generate_Z = generate_Z_operators(4) + generate_Z = generate_Z_operators(nqubits) Z_ops = list(generate_Z.values()) - Z_words = list(generate_Z.keys()) delta_h0 = dbi.diagonal_h_matrix dephasing_channel = (sum([Z_op @ h0 @ Z_op for Z_op in Z_ops])+h0)/2**nqubits @@ -56,10 +55,10 @@ def str_to_symbolic(name: str): Example: .. testcode:: - from qibo.models.dbi.utils import str_to_op + from qibo.models.dbi.utils import str_to_symbolic op_name = "ZYXZI" # returns 5-qubit symbolic hamiltonian - ZIXZI_op = str_to_op(op_name) + ZIXZI_op = str_to_symbolic(op_name) """ tensor_op = 1 for qubit, char in enumerate(name): diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py new file mode 100644 index 0000000000..d7b55605ec --- /dev/null +++ b/tests/test_models_dbi_utils.py @@ -0,0 +1,54 @@ +""""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 = 15 +"""Number of steps for evolution.""" + + +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +def test_generate_Z_operators(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_and_run(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): + idx, step_optimize = select_best_dbr_generator_and_run( + dbi, Z_ops, step=step, compare_canonical=True + ) + if idx == len(Z_ops): + dbi(step=step_optimize, mode=DoubleBracketGeneratorType.canonical) + dbi.mode = DoubleBracketGeneratorType.single_commutator + else: + dbi(step=step_optimize, d=Z_ops[idx]) + + assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 02eb2b611d7d7c3bc25268806ee94acfe8a7979e Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 15 Jan 2024 14:56:35 +0800 Subject: [PATCH 26/48] Formatting --- src/qibo/models/dbi/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index ebc352e284..2c46ef8285 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -44,13 +44,13 @@ def generate_Z_operators(nqubits: int): # except for the identity if "Z" in op_string_tup: op_name = "".join(op_string_tup) - tensor_op = str_to_symbolic(op_name) + tensor_op = _str_to_symbolic(op_name) # append in output_dict output_dict[op_name] = SymbolicHamiltonian(tensor_op).dense.matrix return output_dict -def str_to_symbolic(name: str): +def _str_to_symbolic(name: str): """Converts string into symbolic hamiltonian Example: .. testcode:: From 8cc7e0dcc06a439172e06aec117ae926d3c10c49 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 15 Jan 2024 15:01:22 +0800 Subject: [PATCH 27/48] Rename symbol --- src/qibo/models/dbi/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 2c46ef8285..ebc352e284 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -44,13 +44,13 @@ def generate_Z_operators(nqubits: int): # except for the identity if "Z" in op_string_tup: op_name = "".join(op_string_tup) - tensor_op = _str_to_symbolic(op_name) + tensor_op = str_to_symbolic(op_name) # append in output_dict output_dict[op_name] = SymbolicHamiltonian(tensor_op).dense.matrix return output_dict -def _str_to_symbolic(name: str): +def str_to_symbolic(name: str): """Converts string into symbolic hamiltonian Example: .. testcode:: From 41bc42a2702626b01abc10f43f0eba5af4b71d14 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 17 Jan 2024 21:41:10 +0800 Subject: [PATCH 28/48] Fix error with Pauli-Z, added sign flip --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 56 +++++++---- src/qibo/models/dbi/utils.py | 97 ++++++++++++------- 2 files changed, 95 insertions(+), 58 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 7c94cba3a2..4ccf14c03d 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -178,16 +178,20 @@ "outputs": [], "source": [ "NSTEPS = 15\n", - "max_evals = 300\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", "for _ in range(NSTEPS):\n", - " idx, step = select_best_dbr_generator_and_run(dbi, Z_ops, compare_canonical=False, max_evals=max_evals)\n", + " idx, step, flip_sign = select_best_dbr_generator_and_run(dbi, Z_ops, 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", - " Z_optimal.append(Z_names[idx])\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}\")" ] }, @@ -316,21 +320,27 @@ "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_mixed = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", - "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + "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)" ] }, { @@ -344,11 +354,13 @@ "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", - " idx, step = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True, max_evals=max_evals)\n", + " idx, step, flip_sign = select_best_dbr_generator_and_run(dbi_mixed, Z_ops, compare_canonical=True, max_evals=max_evals)\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}\")" @@ -432,13 +444,15 @@ "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n", "for _ in range(remaining_NSTEPS):\n", - " idx, step = select_best_dbr_generator_and_run(dbi_mixed_can, Z_ops, compare_canonical=False)\n", + " idx, step, flip_sign = select_best_dbr_generator_and_run(dbi_mixed_can, Z_ops, compare_canonical=False)\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_can.append(\"canonical\")\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_can.append(Z_names[idx])\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]}\")" ] }, diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index ebc352e284..befe771bcd 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -2,11 +2,12 @@ from itertools import product from typing import Optional +import numpy as np from hyperopt import hp, tpe from qibo import symbols from qibo.config import raise_error -from qibo.hamiltonians import SymbolicHamiltonian +from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, @@ -67,13 +68,14 @@ def str_to_symbolic(name: str): def select_best_dbr_generator( - dbi_object: DoubleBracketIteration, + h: Hamiltonian, 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, ): """Selects the best double bracket rotation generator from a list. @@ -88,49 +90,58 @@ def select_best_dbr_generator( compare_canonical (bool): If `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. Returns: - The index of the optimal diagonal operator and respective step duration. + The index of the optimal diagonal operator, respective step duration, and evolution direction. """ - norms_off_diagonal_restriction = [] - optimal_steps = [] - for d in d_list: + norms_off_diagonal_restriction = [0 for i in range(len(d_list))] + optimal_steps = [0 for i in range(len(d_list))] + flip_list = [1 for i in range(len(d_list))] + for i, d in enumerate(d_list): # prescribed step durations - h_before = deepcopy(dbi_object.h) - if step is None: - step = dbi_object.hyperopt_step( - step_min=step_min, - step_max=step_max, - space=hp.uniform, - optimizer=tpe, - max_evals=max_evals, - d=d, - ) - dbi_object(step=step, d=d) - optimal_steps.append(step) - norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) - dbi_object.h = h_before + h_eval = deepcopy(h) + dbi_eval = DoubleBracketIteration(h_eval, mode=mode) + flip_list[i] = CS_angle_sgn(dbi_eval, d) + if flip_list[i] is not 0: + 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, + d=flip_list[i] * d, + ) + 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: - generator_type = dbi_object.mode - dbi_object.mode = DoubleBracketGeneratorType.canonical + flip_list.append(1) + h_eval = deepcopy(h) + dbi_eval = DoubleBracketIteration( + h_eval, mode=DoubleBracketGeneratorType.canonical + ) if step is None: - step = dbi_object.hyperopt_step( + step_best = dbi_eval.hyperopt_step( step_min=step_min, step_max=step_max, space=hp.uniform, optimizer=tpe, max_evals=max_evals, ) - dbi_object(step=step) - optimal_steps.append(step) - norms_off_diagonal_restriction.append(dbi_object.off_diagonal_norm) - dbi_object.h = deepcopy(h_before) - dbi_object.mode = generator_type + else: + step_best = step + dbi_eval(step=step_best) + optimal_steps.append(step_best) + norms_off_diagonal_restriction.append(dbi_eval.off_diagonal_norm) # find best d idx_max_loss = norms_off_diagonal_restriction.index( min(norms_off_diagonal_restriction) ) + flip = flip_list[idx_max_loss] step_optimal = optimal_steps[idx_max_loss] - return idx_max_loss, step_optimal + return idx_max_loss, step_optimal, flip def select_best_dbr_generator_and_run( @@ -143,23 +154,35 @@ def select_best_dbr_generator_and_run( compare_canonical: bool = True, ): """Run double bracket iteration with generator chosen from a list.""" - idx_max_loss, step_optimal = select_best_dbr_generator( - dbi_object, + idx_max_loss, step_optimal, flip_sign = select_best_dbr_generator( + dbi_object.h, d_list, step=step, step_min=step_min, step_max=step_max, max_evals=max_evals, compare_canonical=compare_canonical, + mode=dbi_object.mode, ) # run with optimal d if idx_max_loss == len(d_list) and compare_canonical is True: # canonical - generator_type = dbi_object.mode - dbi_object.mode = DoubleBracketGeneratorType.canonical - dbi_object(step=step_optimal) - dbi_object.mode = generator_type + dbi_object(step=step_optimal, mode=DoubleBracketGeneratorType.canonical) + else: - d_optimal = d_list[idx_max_loss] + d_optimal = flip_sign * d_list[idx_max_loss] dbi_object(step=step_optimal, d=d_optimal) - return idx_max_loss, step_optimal + return idx_max_loss, step_optimal, flip_sign + + +def CS_angle_sgn(dbi_object, d): + """Calculates the sign of Cauchy-Schwarz Angle $$_{HS}$$""" + norm = np.trace( + np.dot( + np.conjugate( + dbi_object.commutator(dbi_object.diagonal_h_matrix, dbi_object.h.matrix) + ).T, + dbi_object.commutator(d, dbi_object.h.matrix), + ) + ) + return np.sign(norm) From 563483043f76af33e4b1c576adb9f2d0c8e4dcea Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 17 Jan 2024 21:48:02 +0800 Subject: [PATCH 29/48] Fixed test codes according to previous change --- src/qibo/models/dbi/utils.py | 3 ++- tests/test_models_dbi_utils.py | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index befe771bcd..76f85a0940 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -80,7 +80,7 @@ def select_best_dbr_generator( """Selects the best double bracket rotation generator from a list. Args: - dbi_object (_DoubleBracketIteration): The object intended for double bracket iteration. + h (_Hamiltonian): The hamiltonian intended for double bracket iteration. d_list (list): List of diagonal operators (np.array) to run from. step (float): Fixed iteration duration. Defaults to ``None``, uses hyperopt. @@ -88,6 +88,7 @@ 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 index of the optimal diagonal operator, respective step duration, and evolution direction. diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index d7b55605ec..cb6dcd4bf2 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -42,13 +42,13 @@ def test_select_best_dbr_generator_and_run(backend, nqubits, step): initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - idx, step_optimize = select_best_dbr_generator_and_run( + idx, step_optimize, flip_sign = select_best_dbr_generator_and_run( dbi, Z_ops, step=step, compare_canonical=True ) if idx == len(Z_ops): dbi(step=step_optimize, mode=DoubleBracketGeneratorType.canonical) dbi.mode = DoubleBracketGeneratorType.single_commutator else: - dbi(step=step_optimize, d=Z_ops[idx]) + dbi(step=step_optimize, d=flip_sign * Z_ops[idx]) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 312df2f34a053fa9a3413d5c8c6d10948fd5c9d9 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 24 Jan 2024 09:28:00 +0800 Subject: [PATCH 30/48] Remove valueerror from test for single commutator --- src/qibo/models/dbi/double_bracket.py | 4 ++-- tests/test_models_dbi.py | 3 --- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index b3d40a4299..15ffdb007e 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -67,14 +67,14 @@ def __call__( ) elif mode is DoubleBracketGeneratorType.single_commutator: if d is None: - raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") + d = self.diagonal_h_matrix operator = self.backend.calculate_matrix_exp( 1.0j * step, self.commutator(d, self.h.matrix), ) elif mode is DoubleBracketGeneratorType.group_commutator: if d is None: - d = self.diagonal_h_matrix + raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") operator = ( self.h.exp(-step) @ self.backend.calculate_matrix_exp(-step, d) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index a3b22d1bbe..f1bcc82a2f 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -56,9 +56,6 @@ def test_double_bracket_iteration_single_commutator(backend, nqubits): ) initial_off_diagonal_norm = dbf.off_diagonal_norm - with pytest.raises(ValueError): - dbf(mode=DoubleBracketGeneratorType.single_commutator, step=0.01) - for _ in range(NSTEPS): dbf(step=0.01, d=d) From 59185dc39722bb5a335029d05771e6ee21cf427b Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 24 Jan 2024 09:45:08 +0800 Subject: [PATCH 31/48] Remove select_best_dbr_and_run --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 260 +++++++++++++++--- src/qibo/models/dbi/utils.py | 50 +--- 2 files changed, 234 insertions(+), 76 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 4ccf14c03d..1cf6a1cd86 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": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -122,9 +122,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 3, + "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.4|INFO|2024-01-24 09:40:57]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# set the qibo backend (we suggest qibojit if N >= 20)\n", "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", @@ -152,9 +168,47 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: 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", @@ -173,9 +227,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 1/15: 0.5802922474030862 with operator -IIIZZ, loss 33.11643018090643\n", + "New optimized step at iteration 2/15: 0.043359192379253356 with operator ZZZZI, loss 26.19914403314804\n", + "New optimized step at iteration 3/15: 0.09265860460897991 with operator -ZZIIZ, loss 22.98019174072421\n", + "New optimized step at iteration 4/15: 0.03358282350999491 with operator ZZZZI, loss 18.568952671100934\n", + "New optimized step at iteration 5/15: 0.04094014393728044 with operator -ZZIIZ, loss 17.26345497290312\n", + "New optimized step at iteration 6/15: 0.07482130385576535 with operator -ZIIIZ, loss 15.845257892068565\n", + "New optimized step at iteration 7/15: 0.03720439683578085 with operator ZZZZI, loss 14.548267871851474\n", + "New optimized step at iteration 8/15: 0.03641216105706838 with operator -ZZIIZ, loss 13.79425955612947\n", + "New optimized step at iteration 9/15: 0.0412368890795281 with operator -IIIZZ, loss 13.122192577713562\n", + "New optimized step at iteration 10/15: 0.07361535104393056 with operator IIZZI, loss 12.573384657978343\n", + "New optimized step at iteration 11/15: 0.026831336051354095 with operator ZZZZI, loss 11.558050437409028\n", + "New optimized step at iteration 12/15: 0.06748495147129051 with operator -IZIIZ, loss 10.107869461324858\n", + "New optimized step at iteration 13/15: 0.019704419401876765 with operator -ZZIIZ, loss 9.421737059033882\n", + "New optimized step at iteration 14/15: 0.054634826048662294 with operator -ZIIIZ, loss 8.946915095665906\n", + "New optimized step at iteration 15/15: 0.025109124757591778 with operator -IIIZZ, loss 8.623842763568359\n" + ] + } + ], "source": [ "NSTEPS = 15\n", "max_evals = 100\n", @@ -185,7 +261,7 @@ "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", - " idx, step, flip_sign = select_best_dbr_generator_and_run(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, 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", @@ -197,9 +273,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_histories(off_diagonal_norm_history, steps, Z_optimal)" ] @@ -228,9 +315,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.4|INFO|2024-01-24 09:43:29]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# set the qibo backend (we suggest qibojit if N >= 20)\n", "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", @@ -245,9 +347,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 1/15: 0.7141252558938868, loss 28.796954985844128\n", + "New optimized step at iteration 2/15: 0.013335314667006768, loss 23.150025325565377\n", + "New optimized step at iteration 3/15: 0.007151857665536799, loss 21.174565917599644\n", + "New optimized step at iteration 4/15: 0.008815389120800888, loss 21.15634538422303\n", + "New optimized step at iteration 5/15: 0.005580603223187713, loss 21.152930713031026\n", + "New optimized step at iteration 6/15: 0.006206159465007091, loss 21.1528964173955\n", + "New optimized step at iteration 7/15: 0.007774031676198437, loss 21.1528939848538\n", + "New optimized step at iteration 8/15: 0.010181202791294714, loss 21.15289383684111\n", + "New optimized step at iteration 9/15: 0.004841543017323015, loss 21.152893836287003\n", + "New optimized step at iteration 10/15: 0.008364467193678036, loss 21.15289383626384\n", + "New optimized step at iteration 11/15: 0.006360526619508675, loss 21.152893836260493\n", + "New optimized step at iteration 12/15: 0.009108166501832216, loss 21.15289383626047\n", + "New optimized step at iteration 13/15: 0.007303816352317934, loss 21.15289383626047\n", + "New optimized step at iteration 14/15: 0.03044774689153974, loss 21.15289383626047\n", + "New optimized step at iteration 15/15: 0.0028243313346074067, loss 21.15289383626047\n" + ] + } + ], "source": [ "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n", "steps_canonical = [0]\n", @@ -270,9 +394,30 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "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(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", @@ -287,9 +432,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[37.94733192202055, 33.11643018090643, 26.19914403314804, 22.98019174072421, 18.568952671100934, 17.26345497290312, 15.845257892068565, 14.548267871851474, 13.79425955612947, 13.122192577713562, 12.573384657978343, 11.558050437409028, 10.107869461324858, 9.421737059033882, 8.946915095665906, 8.623842763568359]\n", + "[37.94733192202055, 28.796954985844128, 23.150025325565377, 21.174565917599644, 21.15634538422303, 21.152930713031026, 21.1528964173955, 21.1528939848538, 21.15289383684111, 21.152893836287003, 21.15289383626384, 21.152893836260493, 21.15289383626047, 21.15289383626047, 21.15289383626047, 21.15289383626047]\n" + ] + } + ], "source": [ "print(off_diagonal_norm_history)\n", "print(off_diagonal_norm_history_canonical)" @@ -316,9 +470,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "dbi_mixed = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", "print(\"Initial off diagonal norm\", dbi_mixed.off_diagonal_norm)" @@ -326,9 +488,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "canonical norm 37.0169421025245 step 0.0028243313346074067\n" + ] + } + ], "source": [ "dbi_eval = deepcopy(dbi_mixed)\n", "dbi_eval.mode = DoubleBracketGeneratorType.canonical\n", @@ -345,16 +515,30 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New optimized step at iteration 1/15: 0.02673042815527681 with operator Canonical, loss 28.931545487398413\n", + "New optimized step at iteration 2/15: 0.012489323260897375 with operator Canonical, loss 22.642760635667926\n", + "New optimized step at iteration 3/15: 0.08262102611209304 with operator IZIZZ, loss 20.402863400714757\n", + "New optimized step at iteration 4/15: 0.005858370590980864 with operator Canonical, loss 17.704347807090855\n", + "New optimized step at iteration 5/15: 0.07801470544762314 with operator ZIZIZ, loss 16.35520150538464\n", + "New optimized step at iteration 6/15: 0.0024494184523774433 with operator Canonical, loss 15.028787315577059\n", + "New optimized step at iteration 7/15: 0.030895838247917303 with operator -ZIIIZ, loss 14.320569882373876\n" + ] + } + ], "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", - " idx, step, flip_sign = select_best_dbr_generator_and_run(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, compare_canonical=True, max_evals=max_evals)\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", @@ -444,7 +628,7 @@ "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n", "for _ in range(remaining_NSTEPS):\n", - " idx, step, flip_sign = select_best_dbr_generator_and_run(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, compare_canonical=False)\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 76f85a0940..100e82997d 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -68,7 +68,7 @@ def str_to_symbolic(name: str): def select_best_dbr_generator( - h: Hamiltonian, + dbi_object: DoubleBracketIteration, d_list: list, step: Optional[float] = None, step_min: float = 1e-5, @@ -77,10 +77,10 @@ def select_best_dbr_generator( compare_canonical: bool = True, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.single_commutator, ): - """Selects the best double bracket rotation generator from a list. + """Selects the best double bracket rotation generator from a list and runs the Args: - h (_Hamiltonian): The hamiltonian intended for double bracket iteration. + 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. @@ -91,15 +91,14 @@ def select_best_dbr_generator( mode (_DoubleBracketGeneratorType): DBI generator type used for the selection. Returns: - The index of the optimal diagonal operator, respective step duration, and evolution direction. + The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. """ norms_off_diagonal_restriction = [0 for i in range(len(d_list))] optimal_steps = [0 for i in range(len(d_list))] flip_list = [1 for i in range(len(d_list))] for i, d in enumerate(d_list): # prescribed step durations - h_eval = deepcopy(h) - dbi_eval = DoubleBracketIteration(h_eval, mode=mode) + dbi_eval = deepcopy(dbi_object) flip_list[i] = CS_angle_sgn(dbi_eval, d) if flip_list[i] is not 0: if step is None: @@ -119,10 +118,8 @@ def select_best_dbr_generator( # canonical if compare_canonical is True: flip_list.append(1) - h_eval = deepcopy(h) - dbi_eval = DoubleBracketIteration( - h_eval, mode=DoubleBracketGeneratorType.canonical - ) + dbi_eval = deepcopy(dbi_object) + dbi_eval.mode = DoubleBracketGeneratorType.canonical if step is None: step_best = dbi_eval.hyperopt_step( step_min=step_min, @@ -142,38 +139,15 @@ def select_best_dbr_generator( ) flip = flip_list[idx_max_loss] step_optimal = optimal_steps[idx_max_loss] - return idx_max_loss, step_optimal, flip - - -def select_best_dbr_generator_and_run( - 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, -): - """Run double bracket iteration with generator chosen from a list.""" - idx_max_loss, step_optimal, flip_sign = select_best_dbr_generator( - dbi_object.h, - d_list, - step=step, - step_min=step_min, - step_max=step_max, - max_evals=max_evals, - compare_canonical=compare_canonical, - mode=dbi_object.mode, - ) - # run with optimal d + dbi_eval = deepcopy(dbi_object) if idx_max_loss == len(d_list) and compare_canonical is True: # canonical - dbi_object(step=step_optimal, mode=DoubleBracketGeneratorType.canonical) + dbi_eval(step=step_optimal, mode=DoubleBracketGeneratorType.canonical) else: - d_optimal = flip_sign * d_list[idx_max_loss] - dbi_object(step=step_optimal, d=d_optimal) - return idx_max_loss, step_optimal, flip_sign + 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): From d01b48a548bae0e76e6cc1e5abc9c53aebff1233 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 24 Jan 2024 10:24:46 +0800 Subject: [PATCH 32/48] Update test file for utils.py --- tests/test_models_dbi_utils.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index cb6dcd4bf2..1c7f825c01 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -11,7 +11,7 @@ from qibo.models.dbi.utils import * from qibo.quantum_info import random_hermitian -NSTEPS = 15 +NSTEPS = 5 """Number of steps for evolution.""" @@ -31,7 +31,7 @@ def test_generate_Z_operators(nqubits): @pytest.mark.parametrize("nqubits", [3, 4, 5]) @pytest.mark.parametrize("step", [0.1, None]) -def test_select_best_dbr_generator_and_run(backend, nqubits, step): +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), @@ -42,13 +42,8 @@ def test_select_best_dbr_generator_and_run(backend, nqubits, step): initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - idx, step_optimize, flip_sign = select_best_dbr_generator_and_run( + dbi, idx, step_optimize, flip = select_best_dbr_generator( dbi, Z_ops, step=step, compare_canonical=True ) - if idx == len(Z_ops): - dbi(step=step_optimize, mode=DoubleBracketGeneratorType.canonical) - dbi.mode = DoubleBracketGeneratorType.single_commutator - else: - dbi(step=step_optimize, d=flip_sign * Z_ops[idx]) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 10eb087fdc72233bacfec4c4d1df976002778048 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 24 Jan 2024 10:48:45 +0800 Subject: [PATCH 33/48] Clear notebook outputs --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 254 +++--------------- 1 file changed, 35 insertions(+), 219 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 1cf6a1cd86..af214950bc 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": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -122,25 +122,9 @@ }, { "cell_type": "code", - "execution_count": 3, - "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.4|INFO|2024-01-24 09:40:57]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\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", @@ -168,47 +152,9 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.4|WARNING|2024-01-24 09:40:57]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -227,31 +173,9 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 1/15: 0.5802922474030862 with operator -IIIZZ, loss 33.11643018090643\n", - "New optimized step at iteration 2/15: 0.043359192379253356 with operator ZZZZI, loss 26.19914403314804\n", - "New optimized step at iteration 3/15: 0.09265860460897991 with operator -ZZIIZ, loss 22.98019174072421\n", - "New optimized step at iteration 4/15: 0.03358282350999491 with operator ZZZZI, loss 18.568952671100934\n", - "New optimized step at iteration 5/15: 0.04094014393728044 with operator -ZZIIZ, loss 17.26345497290312\n", - "New optimized step at iteration 6/15: 0.07482130385576535 with operator -ZIIIZ, loss 15.845257892068565\n", - "New optimized step at iteration 7/15: 0.03720439683578085 with operator ZZZZI, loss 14.548267871851474\n", - "New optimized step at iteration 8/15: 0.03641216105706838 with operator -ZZIIZ, loss 13.79425955612947\n", - "New optimized step at iteration 9/15: 0.0412368890795281 with operator -IIIZZ, loss 13.122192577713562\n", - "New optimized step at iteration 10/15: 0.07361535104393056 with operator IIZZI, loss 12.573384657978343\n", - "New optimized step at iteration 11/15: 0.026831336051354095 with operator ZZZZI, loss 11.558050437409028\n", - "New optimized step at iteration 12/15: 0.06748495147129051 with operator -IZIIZ, loss 10.107869461324858\n", - "New optimized step at iteration 13/15: 0.019704419401876765 with operator -ZZIIZ, loss 9.421737059033882\n", - "New optimized step at iteration 14/15: 0.054634826048662294 with operator -ZIIIZ, loss 8.946915095665906\n", - "New optimized step at iteration 15/15: 0.025109124757591778 with operator -IIIZZ, loss 8.623842763568359\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "NSTEPS = 15\n", "max_evals = 100\n", @@ -273,20 +197,9 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plot_histories(off_diagonal_norm_history, steps, Z_optimal)" ] @@ -315,24 +228,9 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.4|INFO|2024-01-24 09:43:29]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\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", @@ -347,31 +245,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 1/15: 0.7141252558938868, loss 28.796954985844128\n", - "New optimized step at iteration 2/15: 0.013335314667006768, loss 23.150025325565377\n", - "New optimized step at iteration 3/15: 0.007151857665536799, loss 21.174565917599644\n", - "New optimized step at iteration 4/15: 0.008815389120800888, loss 21.15634538422303\n", - "New optimized step at iteration 5/15: 0.005580603223187713, loss 21.152930713031026\n", - "New optimized step at iteration 6/15: 0.006206159465007091, loss 21.1528964173955\n", - "New optimized step at iteration 7/15: 0.007774031676198437, loss 21.1528939848538\n", - "New optimized step at iteration 8/15: 0.010181202791294714, loss 21.15289383684111\n", - "New optimized step at iteration 9/15: 0.004841543017323015, loss 21.152893836287003\n", - "New optimized step at iteration 10/15: 0.008364467193678036, loss 21.15289383626384\n", - "New optimized step at iteration 11/15: 0.006360526619508675, loss 21.152893836260493\n", - "New optimized step at iteration 12/15: 0.009108166501832216, loss 21.15289383626047\n", - "New optimized step at iteration 13/15: 0.007303816352317934, loss 21.15289383626047\n", - "New optimized step at iteration 14/15: 0.03044774689153974, loss 21.15289383626047\n", - "New optimized step at iteration 15/15: 0.0028243313346074067, loss 21.15289383626047\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n", "steps_canonical = [0]\n", @@ -394,30 +270,9 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAHFCAYAAAAHcXhbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB85UlEQVR4nO3dd1yV5f/H8ddhbxAFEUVEce+Zq9QcOTJNS8u+ptmwbJkNG9++af5ypbZs2bJSG5aaLcttORG34sYN4gQEZN6/P4gTCCoHzuEAvp+Px3kE932f6/4cOHHeXvd1XbfJMAwDERERkTLKwd4FiIiIiBSHwoyIiIiUaQozIiIiUqYpzIiIiEiZpjAjIiIiZZrCjIiIiJRpCjMiIiJSpinMiIiISJmmMCMiIiJlmsLMDW7Hjh088MADhIWF4ebmhpeXFy1atGDq1KmcP3/e3uWVWs2bN6dq1apkZmZe9ZgOHTpQqVIl0tLSin2+VatWYTKZWLVqlcXP3bNnD+PGjePIkSP59g0fPpwaNWoUuz5rMZlMjBs3rlDH5X74+vrSuXNnfv31V5vWV6NGDYYPH27+/siRI5hMJmbPnl2o515Z95WP3G1b05U/12u9Jzp37kyjRo2Kdb7U1FRmzpxJx44dqVChAi4uLlStWpVBgwaxevXqYrVtD1f+3q2tc+fOdO7c2Wbt3wic7F2A2M8nn3zCqFGjqFu3Ls8//zwNGjQgPT2dzZs389FHH7F+/XoWLlxo7zJLpQcffJAnn3ySP/74g969e+fbv3//ftatW8fo0aNxcXEp9vlatGjB+vXradCggcXP3bNnD+PHj6dz5875gsurr77K008/Xez67OGuu+7i2WefJSsri8OHD/N///d/9O3bl59//pk+ffqUSA1VqlRh/fr11KpV67rHLly4kNTU1AL3PfXUU2zevJn+/ftbucJs69evp1q1aubvr/WeKK6zZ8/Ss2dPduzYwYgRI3j++efx9/fn5MmT/PTTT3Tt2pXIyEiaNm1q1fPa0sKFC/Hx8bF3GXIthtyQ1q1bZzg6Oho9e/Y0Ll++nG9/amqq8dNPP9mhspKRlJRUrOefP3/ecHNzMwYOHFjg/rFjxxqAsWPHjmKdJy0tzUhPTy9WG/PnzzcAY+XKlcVqpyQAxmuvvVao4x5//PE82w4ePGgARrdu3WxUnWGEhoYaw4YNs2qb06dPNwDjpZdesmq713Kt90SnTp2Mhg0bFrntXr16GU5OTsby5csL3L9p0ybj6NGjRW6/POrUqZPRqVMne5dRpinM3KBuv/12w8nJyTh27Fihjs/MzDSmTJli1K1b13BxcTECAgKMoUOHGsePH89zXM4fwnXr1hnt2rUz3NzcjNDQUOPzzz83DMMwfvnlF6N58+aGu7u70ahRI+P333/P8/zXXnvNAIwtW7YYd955p+Ht7W34+PgY9913nxEXF5fn2G+//dbo3r27ERQUZLi5uRn16tUzxo4da1y6dCnPccOGDTM8PT2NHTt2GN27dze8vLyMtm3bGoaRHdomTJhgfl2VKlUyhg8fnu9cBbn33nsNFxcX4+zZs3m2Z2RkGMHBwUbr1q0NwzCMAwcOGMOHDzfCw8MNd3d3Izg42Lj99tvzBZ2VK1cagPHVV18ZY8aMMYKDgw2TyWRERUWZ9+X+8ImIiDAGDx5shIaGmn/O99xzj3HkyBHzMV988YUB5Ht88cUX5p9NaGhonjpSUlKMF1980ahRo4bh7OxsBAcHG6NGjTIuXLiQ57jQ0FCjT58+xu+//240b97ccHNzM+rWrWt89tlneY6Li4szHnvsMaN+/fqGp6enERAQYHTp0sVYs2ZNvp9pccKMYRhGQECAUbt2bcMwDOPPP/807rjjDqNq1aqGq6urUatWLeORRx4xzpw5k+c5Bf0MDOPf9+KVrzl3mImOjs7z87TUihUrDCcnJ6NHjx5GZmbmNY+dOXOmYTKZjNOnT5u3TZs2zQCMUaNGmbdlZmYafn5+xpgxY8zbcv9cr/eeyPl/eNOmTUbHjh0Nd3d3IywszJg0adJ1a9y8ebMBGCNHjizU6y/seyPn5/zmm28a06dPN2rUqGF4enoabdu2NdavX5+v3Z9++slo27at4e7ubnh5eRndunUz1q1bl+eYnN/vrl27jHvuucfw8fExAgMDjQceeMC4ePFinmMLCrEXLlwwxowZY4SFhZn/Jvbq1cuIiooyHzNu3DijTZs2RoUKFQxvb2+jefPmxqeffmpkZWXlaUthpvg0ZuYGlJmZyYoVK2jZsiUhISGFes5jjz3G2LFj6d69O4sXL2bChAksWbKE9u3bc/bs2TzHxsbG8sADD/DQQw/x008/0bhxY0aMGMHrr7/OSy+9xAsvvMCPP/6Il5cX/fv359SpU/nOd+eddxIeHs4PP/zAuHHjWLRoEbfddhvp6enmYw4cOEDv3r357LPPWLJkCaNHj+b777+nb9+++dpLS0vjjjvu4NZbb+Wnn35i/PjxZGVl0a9fPyZPnsyQIUP49ddfmTx5MkuXLqVz586kpKRc82fy4IMPkpaWxpw5c/Js/+OPPzh16hQPPvggAKdOnaJixYpMnjyZJUuW8P777+Pk5MRNN93Evn378rX70ksvcezYMT766CN+/vlnAgMDCzz/kSNHqFu3Lm+//TZ//PEHU6ZMISYmhtatW5t/J3369GHixIkAvP/++6xfv57169df9TKMYRj079+fadOmMXToUH799VfGjBnDl19+ya233prvMsn27dt59tlneeaZZ/jpp59o0qQJDz74IGvWrDEfkzP26rXXXuPXX3/liy++oGbNmnTu3LlIY4Cu5sKFC5w7d46AgAAADh06RLt27fjwww/5888/+d///sfGjRvp2LFjnveRvRw7dozBgwdTrVo1vvnmGxwcrv3nuFu3bhiGwfLly83bli1bhru7O0uXLjVv27x5MxcvXqRbt24FtlOY90RsbCz33Xcf//nPf1i8eDG9evXipZdeyvdev9Kff/4JUOjLZZa+N95//32WLl3K22+/zdy5c0lKSqJ3797Ex8ebj5k3bx79+vXDx8eHb775hs8++4wLFy7QuXNn/v7773xtDhw4kDp16vDjjz/y4osvMm/ePJ555plr1p2YmEjHjh35+OOPeeCBB/j555/56KOPqFOnDjExMebjjhw5wsiRI/n+++9ZsGABAwYM4Mknn2TChAmF+vmIBeydpqTkxcbGGoBxzz33FOr4qKiofP/6MwzD2LhxowEYL7/8snlbp06dDMDYvHmzedu5c+cMR0dHw93d3Th58qR5+7Zt2wzAePfdd83bcv619Mwzz+Q519y5cw3AmDNnToE1ZmVlGenp6cbq1asNwNi+fbt537BhwwzA3DuU45tvvjEA48cff8yzPSIiwgCMDz744Jo/l6ysLCMsLMxo0qRJnu0DBw40PDw8jPj4+AKfl5GRYaSlpRm1a9fO8zpzel9uueWWfM8pqGemoHYvXbpkeHp6Gu+88455+7UuKVzZK7FkyRIDMKZOnZrnuO+++84AjFmzZpm35fQI5b5kkJKSYvj7+1/zX+YZGRlGenq60bVrV+POO+/Msw8LemZGjRplpKenG2lpaUZUVJTRq1cvAzDef//9fMfnvD+OHj1qAHkuodqjZyYlJcVo2bKl4e7ubmzZsqXQz6tWrZoxYsQIwzCyexU9PT3NlzRzfg9vvPGG4ezsnKeH8sqf6/UuMwHGxo0b82xv0KCBcdttt12zvkcffdQAjL179xb6NeV2tfdGzs+5cePGRkZGhnn7pk2bDMD45ptvDMPI7pUKDg42GjdunKcXKTEx0QgMDDTat29v3pbz+73yvT5q1CjDzc0tT+/Jlb/3119/3QCMpUuXFvq1ZWZmGunp6cbrr79uVKxYMU/76pkpPvXMyHWtXLkSIN9o/jZt2lC/fv08/1KE7EGRLVu2NH/v7+9PYGAgzZo1Izg42Ly9fv36ABw9ejTfOe+777483w8aNAgnJydzLQCHDx9myJAhBAUF4ejoiLOzM506dQIgKioqX5sDBw7M8/0vv/yCn58fffv2JSMjw/xo1qwZQUFB1+01MJlMPPDAA+zYsYPIyEgAzp07x88//8zAgQPNAwYzMjKYOHEiDRo0wMXFBScnJ1xcXDhw4ECh6ryaS5cuMXbsWMLDw3FycsLJyQkvLy+SkpIKbLcwVqxYAeT/Xd999914enrm+103a9aM6tWrm793c3OjTp06+X6nH330ES1atMDNzQ0nJyecnZ1Zvnx5kesE+OCDD3B2dsbFxYX69euzbt06Xn/9dUaNGgVAXFwcjz76KCEhIeZzhoaGAgW/P6wl93spIyMDwzDyHfPoo48SGRnJxx9/TPPmzQvddteuXVm2bBkA69atIzk5mTFjxlCpUiVz78yyZcto164dnp6eRX4NQUFBtGnTJs+2Jk2aFPj/anFZ8t7o06cPjo6OeWqCf/+G7Nu3j1OnTjF06NA8PV1eXl4MHDiQDRs2kJycnKfNO+64I8/3TZo04fLly8TFxV215t9//506depctfcrx4oVK+jWrRu+vr7mv1H/+9//OHfu3DXbF8spzNyAKlWqhIeHB9HR0YU6/ty5c0B2SLlScHCweX8Of3//fMe5uLjk254zy+fy5cv5jg8KCsrzvZOTExUrVjSf69KlS9x8881s3LiR//u//2PVqlVERESwYMECgHyXiDw8PPLNRjh9+jQXL17ExcUFZ2fnPI/Y2Nh8l88K8sADD+Dg4MAXX3wBwNy5c0lLSzNfYgIYM2YMr776Kv379+fnn39m48aNRERE0LRp0wIvZRX0cy7IkCFDmDlzJg899BB//PEHmzZtIiIigoCAgOteIruac+fO4eTkZL5Uk8NkMhEUFJTvd12xYsV8bbi6uuY5/4wZM3jssce46aab+PHHH9mwYQMRERH07NmzyHVCdsCNiIhg8+bN7Nu3j3PnzvHqq68CkJWVRY8ePViwYAEvvPACy5cvZ9OmTWzYsAHI//6wliNHjuR7L105Ffm9997jyy+/5IknnmDo0KEWtd+tWzeOHTvGgQMHWLZsGc2bNycwMJBbb72VZcuWkZKSwrp16677IXs9hfm9FiQn2Bb2b4ul740r63J1dQX+/X1e729VVlYWFy5csKjNgpw5cybP7LCCbNq0iR49egDZM0fXrl1LREQEr7zyynXbF8tpavYNyNHRka5du/L7779z4sSJ6/5PmfM/e0xMTL5jT506RaVKlaxeY2xsLFWrVjV/n5GRwblz58y1rFixglOnTrFq1SpzbwzAxYsXC2zPZDLl21apUiUqVqzIkiVLCnyOt7f3deusVq0aPXr0YN68eUyfPp0vvviC8PBwbrnlFvMxc+bM4f777zePU8hx9uxZ/Pz8ClXrleLj4/nll1947bXXePHFF83bU1NTi7U+UMWKFcnIyODMmTN5Ao1hGMTGxtK6dWuL25wzZw6dO3fmww8/zLM9MTGxyHUCBAQE0KpVqwL37dq1i+3btzN79myGDRtm3n7w4MF8x7q5uRU4ZbowYfZKwcHBRERE5NlWt25d89d//fUXzz77LB07dmTGjBkWt9+1a1cgu/dl6dKldO/e3bz9v//9L2vWrCE1NbXYYaaobrvtNl5++WUWLVpEz549r3u8td8buf9WXenUqVM4ODhQoUKFIrWdW0BAACdOnLjmMd9++y3Ozs788ssvuLm5mbcvWrSo2OeX/NQzc4N66aWXMAyDhx9+uMBF3dLT0/n5558BuPXWWwHyDf6LiIggKirK/AfWmubOnZvn+++//56MjAzzwlI5H/g5/4rK8fHHHxf6HLfffjvnzp0jMzOTVq1a5Xvk/hC6lgcffJALFy7wv//9j23btvHAAw/kCSQmkylfnb/++isnT54sdK1XMplMGIaRr91PP/0030J+hfmXZo6c3+WVv+sff/yRpKSkIv2uC3r9O3bsYP369Ra3Zck5oXDvjxo1ahAXF8fp06fN29LS0vjjjz8sPq+Li0u+91FOKD558iR33303lSpVYv78+Tg7O1vcfpUqVWjQoAE//vgjkZGR5jDTvXt3zpw5w4wZM/Dx8blu6LTkPWGJFi1a0KtXLz777DPzJcsrbd68mWPHjgHWf2/UrVuXqlWrMm/evDyX95KSkvjxxx9p164dHh4eRWo7t169erF///6rvkbIfm1OTk55LoulpKTw9ddfF/v8kp96Zm5QObM8Ro0aRcuWLXnsscdo2LAh6enpbN26lVmzZtGoUSP69u1L3bp1eeSRR3jvvfdwcHCgV69eHDlyhFdffZWQkJDrjvwvigULFuDk5ET37t3ZvXs3r776Kk2bNmXQoEEAtG/fngoVKvDoo4/y2muv4ezszNy5c9m+fXuhz3HPPfcwd+5cevfuzdNPP02bNm1wdnbmxIkTrFy5kn79+nHnnXdet5077riDSpUq8eabb+Lo6JinJwCyQ9Ps2bOpV68eTZo0ITIykjfffPO6PWLX4uPjwy233MKbb75JpUqVqFGjBqtXr+azzz7L19uTs5rrrFmz8Pb2xs3NjbCwsAIvJXTv3p3bbruNsWPHkpCQQIcOHdixYwevvfYazZs3t/iyCGS//gkTJvDaa6/RqVMn9u3bx+uvv05YWBgZGRlFev3XU69ePWrVqsWLL76IYRj4+/vz888/55n1k2Pw4MH873//45577uH555/n8uXLvPvuu9dc3dlSaWlpDBgwgNOnTzN9+nSOHDlS4Oq7Pj4+110YsWvXrrz33nu4u7vToUMHAMLCwggLC+PPP//kjjvuwMnp2n/aLXlPWOqrr76iZ8+e9OrVixEjRtCrVy8qVKhATEwMP//8M9988w2RkZFUr17d6u8NBwcHpk6dyn333cftt9/OyJEjSU1N5c033+TixYtMnjy52K8PYPTo0Xz33Xf069ePF198kTZt2pCSksLq1au5/fbb6dKlC3369GHGjBkMGTKERx55hHPnzjFt2rR84U2sxJ6jj8X+tm3bZgwbNsyoXr264eLiYnh6ehrNmzc3/ve//+VZayVnnZk6deoYzs7ORqVKlYz//Oc/V11n5ko5a5JciSvWC8mZYRAZGWn07dvX8PLyMry9vY177703z/oahmGY17Lx8PAwAgICjIceesjYsmVLvtklOevMFCQ9Pd2YNm2a0bRpU8PNzc3w8vIy6tWrZ4wcOdI4cOBAoX6GhmEYzzzzjAEYvXv3zrfvwoULxoMPPmgEBgYaHh4eRseOHY2//vor3wyGnBlL8+fPz9dGQbOZTpw4YQwcONC8hkXPnj2NXbt2Fbgmxttvv22EhYUZjo6OhVpnZuzYsUZoaKjh7OxsVKlSxXjssceuus7Mla58XampqcZzzz1nVK1a1XBzczNatGhhLFq0qMBzU8x1ZnLbs2eP0b17d8Pb29uoUKGCcffddxvHjh0r8By//fab0axZM8Pd3d2oWbOmMXPmTKvOZso57nqPwsxo+emnnwzA6N69e57tDz/8cL7ZgTkKes1Xe09c7f/hq836KkhKSorx7rvvGu3atTN8fHwMJycnIzg42BgwYIDx66+/mo8r7Hsj9zozhXltixYtMm666SbDzc3N8PT0NLp27WqsXbs2zzE5v98r1x3KWYcnOjravO1q68w8/fTTRvXq1Q1nZ2cjMDDQ6NOnT56ZXJ9//rlRt25dw9XV1ahZs6YxadIk47PPPsvXvmYzFZ/JMAoYai9iJ+PGjWP8+PGcOXPGJmNxRESk/NGYGRERESnTFGZERESkTNNlJhERESnT1DMjIiIiZZrCjIiIiJRpCjMiIiJSppX7RfOysrI4deoU3t7ehVomXkREROzPMAwSExMJDg7Oc+PQgpT7MHPq1ClCQkLsXYaIiIgUwfHjx6+7Ynq5DzM590U5fvx4vrsmi4iISOmUkJBASEhIoW76W+7DTM6lJR8fH4UZERGRMqYwQ0Q0AFhERETKNIUZERERKdMUZkRERKRMK/djZkREpPzIysoiLS3N3mWIFTg7O+Po6GiVthRmRESkTEhLSyM6OpqsrCx7lyJW4ufnR1BQULHXgVOYERGRUs8wDGJiYnB0dCQkJOS6i6hJ6WYYBsnJycTFxQFQpUqVYrWnMCMiIqVeRkYGycnJBAcH4+HhYe9yxArc3d0BiIuLIzAwsFiXnBRtRUSk1MvMzATAxcXFzpWINeUE0/T09GK1ozAjIiJlhu6xV75Y6/epMCMiIiJlmsKMiIhIGTZu3DiaNWtm/n748OH079/fbvXYg8KMiIiIDQ0fPhyTyYTJZMLZ2ZmaNWvy3HPPkZSUZJPzvfPOO8yePfuq+2fPnm2up6DHAw88YJO6bElhphh27ogk4fQRe5chIiKlXM+ePYmJieHw4cP83//9Hx988AHPPfecTc7l6+uLn5/fVfcPHjyYmJiYfI9XX30VFxcXHn74YZvUZUsKM0W08cORNF5wK3sWTbN3KSIiUsq5uroSFBRESEgIQ4YM4b777mPRokXMmTOHVq1a4e3tTVBQEEOGDDGvvQLZvShXBpNFixZdc+Ds9S4zubu7ExQUlOexb98+Jk2axPvvv0/79u2L+3JLnNaZKSKPsDZw+lsqnFrFqYspBPu527skEZEbhmEYpKRn2uXc7s6OxZ6F4+7uTnp6OmlpaUyYMIG6desSFxfHM888w/Dhw/ntt9+sVO31HT16lLvvvpuRI0fy0EMPldh5rUlhpoga3dyfrA3PUdd0nP/77S/+O6SHvUsSEblhpKRn0uB/f9jl3Htevw0Pl6J/fG7atIl58+bRtWtXRowYYd5es2ZN3n33Xdq0acOlS5fw8vKyRrnXlJyczJ133knDhg15++23bX4+W9FlpiIyeVYkObAZAMm7l7AvNtG+BYmISKn1yy+/4OXlhZubG+3ateOWW27hvffeY+vWrfTr14/Q0FC8vb3p3LkzAMeOHbPKeefOnYuXl5f58ddff+XZ/+CDD3LhwgXmz5+Pk1PZ7d8ou5WXAl4Ne0HcFjo5bGfKkr18Pry1vUsSEbkhuDs7suf12+x2bkt16dKFDz/8EGdnZ4KDg3F2diYpKYkePXrQo0cP5syZQ0BAAMeOHeO2224z3xncwcEBwzDytGXJarl33HEHN910k/n7qlWrmr+eMmUKixcvZt26dVSqVMni11SaKMwUR+3usPINOjjs4om9p9hw+Bxta1a0d1UiIuWeyWQq1qWekubp6Ul4eHiebXv37uXs2bNMnjyZkJAQADZv3pznmICAABITE0lKSsLT0xOAbdu2Ffq83t7eeHt759u+ZMkSXnnlFb755huaNm1q4aspfXSZqTiCmoJnAF6my7Ry2Mek3/fmS9AiIiIFqV69Oi4uLrz33nscPnyYxYsXM2HChDzH3HTTTXh4ePDyyy9z8OBB5s2bd801ZArjwIED3HvvvTz00EPcfPPNxMbG5nmcP3++WO3bg8JMcTg4QHg3ALo772D78Yv8tjPWzkWJiEhZEBAQwOzZs5k/fz4NGjRg8uTJTJuWd7kPf39/5syZw2+//Ubjxo355ptvGDduXLHOO2/ePC5evMjHH39MlSpV8j0GDBhQrPbtwWSU866EhIQEfH19iY+Px8fHx/on2PUj/DCCc+5htLzwBjUqerB0TCecHZUTRUSs5fLly0RHRxMWFoabm5u9yxErudbv1ZLPb33iFlfNLmByoGJKNA094zlyLplvNllnFLqIiIhcn8JMcXn4Q7U2ALxa9yQA7yw7wKXUDHtWJSIicsNQmLGG2tnjZtpkRBJWyZNzSWnMWnPYzkWJiIjcGBRmrCG8OwAO0WsY2y0MgE//Okxc4mV7ViUiInJDUJixhqAm4FUZ0pO4zfswzUL8SE7L5J1lB+xdmYiISLmnMGMNuaZomw4u46Ve9QD4NuI4h85csmdlIiIi5Z7CjLXUzr7UxIGl3FSzIl3rBZKZZfDmkn32rUtERKScU5ixlppdwOQIZ/fBhaOM7VUPBxMs2R1L5NEL9q5ORESk3FKYsRZ3PwjJnqLNwaXUqezNXS2rATD59yjd5kBERMRGFGasKdelJoBnutfB1cmBiCMXWBYVZ8fCRERErm/27Nn4+flZrb1Vq1ZhMpm4ePGi1dosiMKMNf0zRZvoNZB+mSq+7ozomD1Ve8qSvWRkZtmxOBERsZfY2FiefPJJatasiaurKyEhIfTt25fly5fbu7Q8Bg8ezP79++1dhsUUZqwpqDF4BUF6MhxbB8CjnWrh5+HMwbhL/BB5ws4FiohISTty5AgtW7ZkxYoVTJ06lZ07d7JkyRK6dOnC448/bu/y8nB3dycwMNDeZVhMYcaaTCbzasA5l5p83Z15oks4AG8t209KWqa9qhMRETsYNWoUJpOJTZs2cdddd1GnTh0aNmzImDFj2LBhAwAzZsygcePGeHp6EhISwqhRo7h06d+lPXIu//zxxx/Ur18fLy8vevbsSUxMjPmYrKwsXn/9dapVq4arqyvNmjVjyZIl5v1HjhzBZDKxYMECunTpgoeHB02bNmX9+vX5zpPb4sWLadWqFW5ublSqVCnPXbXnzJlDq1at8Pb2JigoiCFDhhAXV/LDKhRmrC0877gZgKHtQqlWwZ3TCal8vjbaToWJiJQjhgFpSfZ5WDCh4/z58yxZsoTHH38cT0/PfPtzgoODgwPvvvsuu3bt4ssvv2TFihW88MILeY5NTk5m2rRpfP3116xZs4Zjx47x3HPPmfe/8847TJ8+nWnTprFjxw5uu+027rjjDg4cyLuA6yuvvMJzzz3Htm3bqFOnDvfeey8ZGQXfT/DXX39lwIAB9OnTh61bt7J8+XJatWpl3p+WlsaECRPYvn07ixYtIjo6muHDhxf652MtTiV+xvKu1j9TtM8dgPPR4B+Gq5Mjz/Woy+jvtvHRqkPc26Y6/p4u9q5URKTsSk+GicH2OffLp8AlfzApyMGDBzEMg3r16l3zuNGjR5u/DgsLY8KECTz22GN88MEH5u3p6el89NFH1KpVC4AnnniC119/3bx/2rRpjB07lnvuuQeAKVOmsHLlSt5++23ef/9983HPPfccffr0AWD8+PE0bNiQgwcPFljjG2+8wT333MP48ePN25o2bWr+esSIEeava9asybvvvkubNm24dOkSXl5e13zN1qSeGWtz84XqbbO/PrjMvPmOpsE0DPYhMTWD91boNgciIjeCnGU5TCbTNY9buXIl3bt3p2rVqnh7e3P//fdz7tw5kpKSzMd4eHiYgwxAlSpVzJd0EhISOHXqFB06dMjTbocOHYiKisqzrUmTJnnaAK56aWjbtm107dr1qnVv3bqVfv36ERoaire3N507dwbg2LFj13y91qaeGVuo3R2Ors2+1NTmYQAcHEy82KseQz/bxJwNR3mgfRjVK3rYuVARkTLK2SO7h8Re5y6k2rVrYzKZiIqKon///gUec/ToUXr37s2jjz7KhAkT8Pf35++//+bBBx8kPT3939M6O+d5nslkyreG2ZWhyTCMfNtyt5OzLyur4Nm27u7uV31tSUlJ9OjRgx49ejBnzhwCAgI4duwYt912G2lpaVd9ni2oZ8YWrpiinePm2gHcXLsS6ZkG0/7UbQ5ERIrMZMq+1GOPx3V6WXLz9/fntttu4/3338/Ty5Lj4sWLbN68mYyMDKZPn07btm2pU6cOp05ZFtR8fHwIDg7m77//zrN93bp11K9f36K2cmvSpMlVp4/v3buXs2fPMnnyZG6++Wbq1atnl8G/oDBjG5UbgncwZKTA0bxvrLE9s69JLt5+ip0n4u1RnYiIlKAPPviAzMxM2rRpw48//siBAweIiori3XffpV27dtSqVYuMjAzee+89Dh8+zNdff81HH31k8Xmef/55pkyZwnfffce+fft48cUX2bZtG08//XSRa3/ttdf45ptveO2114iKimLnzp1MnToVgOrVq+Pi4mKue/HixUyYMKHI5yoOhRlbyDNFe1meXY2q+tK/WfagtclLdJsDEZHyLiwsjC1bttClSxeeffZZGjVqRPfu3Vm+fDkffvghzZo1Y8aMGUyZMoVGjRoxd+5cJk2aZPF5nnrqKZ599lmeffZZGjduzJIlS1i8eDG1a9cucu2dO3dm/vz5LF68mGbNmnHrrbeyceNGAAICApg9ezbz58+nQYMGTJ48mWnTphX5XMVhMsr5p2lCQgK+vr7Ex8fj4+NTcifesxi+Hwr+teCpLXl2HT+fTNfpq0nLzOLLEW3oVCeg5OoSESmDLl++THR0NGFhYbi5udm7HLGSa/1eLfn8tmvPzIcffkiTJk3w8fHBx8eHdu3a8fvvv5v3Dx8+HJPJlOfRtm1bO1ZsgZqdwcEJzh+Cc4fy7Arx92Bou1AAJv++l6yscp0nRUREbMquYaZatWpMnjyZzZs3s3nzZm699Vb69evH7t27zcfkrHCY8/jtt9/sWLEF3Hygervsrw8uy7f7iS7heLs5ERWTwKJtJ0u4OBERkfLDrmGmb9++9O7dmzp16lCnTh3eeOMNvLy8zMs7A7i6uhIUFGR++Pv727FiC4XnvbVBbhU8XXisc/Z6AdP/3M/ldN3mQEREpChKzQDgzMxMvv32W5KSkmjXrp15+6pVqwgMDKROnTo8/PDDdpv2VSS1e2T/98hfkJ6Sb/eIDmEE+bhx8mIKX60/UrK1iYiIlBN2DzM7d+7Ey8sLV1dXHn30URYuXEiDBg0A6NWrF3PnzmXFihVMnz6diIgIbr31VlJTU6/aXmpqKgkJCXkedhNYH3yqQsZlOPJ3vt1uzo6M6V4HgPdXHiI+OT3fMSIi8q9yPmflhmOt36fdw0zdunXZtm0bGzZs4LHHHmPYsGHs2bMHgMGDB9OnTx8aNWpE3759+f3339m/fz+//vrrVdubNGkSvr6+5kdISEhJvZT8TKbs1YChwEtNAANbVqNOZS/iU9L5YNXBEixORKTscHR0BCjxlWXFtpKTk4H8qxtbqtRNze7WrRu1atXi448/LnB/7dq1eeihhxg7dmyB+1NTU/P03CQkJBASElLyU7NzRP0C390HFcLg6W0FHrI86jQPfrkZFycHVj7Xmap+V18+WkTkRmQYBseOHSM9PZ3g4GAcHOz+b3EpBsMwSE5OJi4uDj8/P/M9onKzZGp2qbs3k2EYV72MdO7cOY4fP17gi87h6uqKq6urrcqzXM1O4OAMF6Kzp2hXrJXvkFvrBdImzJ9N0eeZ8ed+pg9qWkBDIiI3LpPJRJUqVYiOjubo0aP2LkesxM/Pj6CgoGK3Y9cw8/LLL9OrVy9CQkJITEzk22+/ZdWqVSxZsoRLly4xbtw4Bg4cSJUqVThy5Agvv/wylSpV4s4777Rn2ZZx9YbQdtn3aTqwtMAwYzKZeKlXPe78YB0Ltp7goZvDqF/FDr1IIiKlmIuLC7Vr19alpnLC2dnZfPmwuOwaZk6fPs3QoUOJiYnB19eXJk2asGTJErp3705KSgo7d+7kq6++4uLFi1SpUoUuXbrw3Xff4e3tbc+yLRfe/Z8w8ye0fbTAQ5pXr0DvxkH8tjOWKUv2MvuBNiVcpIhI6efg4KAVgCWfUjdmxtrsdjuD3OL2wgc3gaMrjD0CLgXfPj76bBLdZ6wmI8tg3sM30b5WpZKtU0REpJQoM7czuGEE1AXfEMhMzV5z5irCKnlyb5vqgG5zICIiUlgKMyXBZLrmasC5PdW1Np4ujuw4Ec+vO2NKoDgREZGyTWGmpOSsBnxwKVzjyl6AtysP31ITgDf/2EdaRlZJVCciIlJmKcyUlLBbwNEFLhyBc9deHO/hm2tSycuVY+eTmbdRUxBFRESuRWGmpLh6/XsX7etcavJ0deLpbrUBeHfFQRIv6zYHIiIiV6MwU5JyLjUd+PO6h97TOoSalTw5n5TGrDWHbVyYiIhI2aUwU5Jy7tN0dC2kJV3zUGdHB56/rS4An/4VTVzCZVtXJyIiUiYpzJSkSnXArzpkpkH01ado5+jZKIjm1f1ISc/krWUHSqBAERGRskdhpiSZTNmrAUOhLjWZTCZe7l0fgO83H+dg3CVbViciIlImKcyUtJxLTdeZop2jdQ1/utWvTGaWwdQle21cnIiISNmjMFPScqZoXzwGZwt36Whsz7o4mODPPafZfOS8jQsUEREpWxRmSpqLJ4R2yP66EJeaAGpX9mZQqxAAJv2+l3J+Oy0RERGLKMzYQ+7VgAvpme51cHN2IPLoBf7cc9pGhYmIiJQ9CjP2YJ6ivQ5SCzeot7KPGw92DANg6pK9ZGTqNgciIiKgMGMfFcPBL/SfKdprCv20kZ1qUcHDmUNnkvh+8wkbFigiIlJ2KMzYg8lUpEtNPm7OPN4lHIDP10Zr7IyIiAgKM/aTc6npQOGmaOcY1DoEN2cHDsZdYtvxi7apTUREpAxRmLGXGjeDoyvEH4cz+wr9NB83Z3o2DAJgfqQuNYmIiCjM2IuLB9TomP11Iado57j7n2naP28/xeX0TGtXJiIiUqYozNhT7tWALdCuZkWq+rmTeDmDP3bH2qAwERGRskNhxp5yBgEfXQ+piYV+moODiYEtqwEwX7OaRETkBqcwY08Va0GFMMhKh8OrLXrq3f+EmbWHznLyYootqhMRESkTFGbsrQhTtAFC/D1oW9Mfw4AfNRBYRERuYAoz9lbEKdoAd7fMHgj8Q+QJsrK05oyIiNyYFGbsrUZHcHKDhJMQF2XRU3s1DsLL1Ylj55PZpLtpi4jIDUphxt6c3bPXnAGLLzV5uDjRp3EVQAOBRUTkxqUwUxrkvtRkoUGtswcC/7YzhkupGdasSkREpExQmCkNwrtl//fYericYNFTW1SvQM0AT1LSM/l1xykbFCciIlK6KcyUBhVrgX8tyMqAw6sseqrJZOIurTkjIiI3MIWZ0qKIqwEDDGxRDQcTbD56gcNnLlm5MBERkdLNqShPWr58OcuXLycuLo6srKw8+z7//HOrFHbDqd0dNn4EB5ZlT9E2mQr91Mo+btxSJ4BV+87wQ+QJXuhZz4aFioiIlC4W98yMHz+eHj16sHz5cs6ePcuFCxfyPKSIQjuCkzsknoLTuy1+es6aMwu2nCRTa86IiMgNxOKemY8++ojZs2czdOhQW9Rz43J2g7Bb4MAf2ZeaghpZ9PRuDQLx83AmNuEyfx04Q+e6gTYqVEREpHSxuGcmLS2N9u3b26IWKcYUbVcnR/o1DQZgvm5vICIiNxCLw8xDDz3EvHnzbFGLmKdob4DL8RY//e5W2Zealu4+zcXkNGtWJiIiUmpZfJnp8uXLzJo1i2XLltGkSROcnZ3z7J8xY4bVirvh+IdBxdpw7kD2FO0G/Sx6esNgH+oFebM3NpHF209xf7saNilTRESkNLG4Z2bHjh00a9YMBwcHdu3axdatW82Pbdu22aDEG4z5UtOfFj/VZDKZe2e05oyIiNwoLO6ZWblypS3qkBy1u8OGD+DgcounaAP0bxbM5N+j2HkynqiYBOpX8bFRoSIiIqVDsRbNO3HiBCdPnrRWLQIQ2gGcPSAxBk7vsvjpFb1c6VqvMqDeGRERuTFYHGaysrJ4/fXX8fX1JTQ0lOrVq+Pn58eECRPyLaAnReDkmj1FG4p0qQng7lbZtzdYtO0kaRn6nYiISPlmcZh55ZVXmDlzJpMnT2br1q1s2bKFiRMn8t577/Hqq6/aosYbj3nczLIiPb1TnQACvF05n5TGir1xVixMRESk9LE4zHz55Zd8+umnPPbYYzRp0oSmTZsyatQoPvnkE2bPnm2DEm9A4f+EmeMbIeWixU93cnRgQPOqAPwQedyKhYmIiJQ+FoeZ8+fPU69e/nv/1KtXj/Pnz1ulqBtehVCoVBeMTDhctAHXOZeaVu47Q1ziZWtWJyIiUqpYHGaaNm3KzJkz822fOXMmTZs2tUpRQrEvNYUHetMsxI/MLINFWzVIW0REyi+Lp2ZPnTqVPn36sGzZMtq1a4fJZGLdunUcP36c3377zRY13pjCu8H6mdn3acrKAgfLJ57d3aoa245fZP7mEzx8c01MFk7zFhERKQss/oTs1KkT+/fv58477+TixYucP3+eAQMGsG/fPm6++WZb1HhjCm0Pzp5w6TSc3lmkJvo2DcbVyYEDcZfYfsLy2yOIiIiUBRb3zAAEBwfzxhtvWLsWyc3JFWp2gn2/ZU/RrmL5JTwfN2d6Ngrip22nmL/5OM1C/Kxfp4iIiJ0Vqmdmx44d5jVkduzYcc2HJT788EOaNGmCj48PPj4+tGvXjt9//9283zAMxo0bR3BwMO7u7nTu3Jndu3dbdI4yLefGk0UcNwNwd8vs2xss3n6Ky+mZ1qhKRESkVClUz0yzZs2IjY0lMDCQZs2aYTKZMAwj33Emk4nMzMJ/YFarVo3JkycTHh4OZE/77tevH1u3bqVhw4ZMnTqVGTNmMHv2bOrUqcP//d//0b17d/bt24e3t3ehz1Nm5QwCPrEJUi6AewWLm2hfqyJV/dw5eTGFP3bH0q9ZVSsXKSIiYl8mo6BUcoWjR49SvXp1TCYTR48eveaxoaGhxSrI39+fN998kxEjRhAcHMzo0aMZO3YsAKmpqVSuXJkpU6YwcuTIQrWXkJCAr68v8fHx+PiUwfsUvX8TnNkLd30OjQYWqYkZS/fz7vIDdAyvxJyHbrJygSIiItZnyed3oS4zhYaGmmfCHD16lKpVqxIaGprnUbVq1esGnWvJzMzk22+/JSkpiXbt2hEdHU1sbCw9evQwH+Pq6kqnTp1Yt27dVdtJTU0lISEhz6NMK+YUbYC7W2avObP20FlOXkyxRlUiIiKlhsWzmbp06VLg4njx8fF06dLF4gJ27tyJl5cXrq6uPProoyxcuJAGDRoQGxsLQOXKlfMcX7lyZfO+gkyaNAlfX1/zIyQkxOKaSpWc1YBzpmgXQYi/B21r+mMY8GOkbj4pIiLli8VhxjCMAtcrOXfuHJ6enhYXULduXbZt28aGDRt47LHHGDZsGHv27DHvv/JcVzt/jpdeeon4+Hjz4/jxMr6cf/V24OIFSWcgdnuRm8kZCPxD5Amysq57ZVFERKTMKPTU7AEDBgDZ4WL48OG4urqa92VmZrJjxw7at29vcQEuLi7mAcCtWrUiIiKCd955xzxOJjY2lipVqpiPj4uLy9dbk5urq2ue2so8Jxeo2Rn2/pJ9qSm4eZGa6dU4iNcW7+bY+WQ2HTlP25oVrVuniIiInRS6Zybnso1hGHh7e+e5lBMUFMQjjzzCnDlzil2QYRikpqYSFhZGUFAQS5cuNe9LS0tj9erVRQpNZZp5ivafRW7Cw8WJPo2zQ+H8zbrUJCIi5Uehe2a++OILAGrUqMHzzz+Ph4dHsU/+8ssv06tXL0JCQkhMTOTbb79l1apVLFmyBJPJxOjRo5k4cSK1a9emdu3aTJw4EQ8PD4YMGVLsc5cpOYOAT26G5PPg4V+kZu5uVY3vNh/nt50xjO/XEC/XIq2ZKCIiUqpY/Gl2//33c/LkSWrXrp1n+4EDB3B2dqZGjRqFbuv06dMMHTqUmJgYfH19adKkCUuWLKF79+wP7xdeeIGUlBRGjRrFhQsXuOmmm/jzzz9vjDVmcvOtBoENIG4PHFoBje8qUjMtQytQs5Inh88m8duOGAa1LuODo0VERCjCAODhw4cXODV648aNDB8+3KK2PvvsM44cOUJqaipxcXEsW7bMHGQge3zOuHHjiImJ4fLly6xevZpGjRpZWnL5YL7UtPTax12DyWRi4D/TtOdHlvGB0SIiIv+wOMxs3bqVDh065Nvetm1btm3bZo2apCC1/1lv5+CyIk/RBhjYohoOJog4coHos0lWKk5ERMR+LA4zJpOJxMTEfNvj4+MtupWBWKh6W3DxhuSzELO1yM0E+bpxc+0AAH5Q74yIiJQDFoeZm2++mUmTJuUJLpmZmUyaNImOHTtatTjJxdEZanXO/roYqwEDDGqVPVbmx8iTZGrNGRERKeMsHgA8depUbrnlFurWrcvNN98MwF9//UVCQgIrVqyweoGSS3h3iPo5e4p257FFbqZbg0D8PJyJTbjMXwfO0LluoBWLFBERKVkW98w0aNCAHTt2MGjQIOLi4khMTOT+++9n7969N+7g3JKSMwj4ZCQknStyM65OjvRrGgzAfN3eQEREyrgiLTQSHBzMxIkTrV2LXI9vVajcCE7vyp6i3eTuIjd1d6sQvlx/lKW7T3MxOQ0/DxcrFioiIlJyChVmduzYQaNGjXBwcGDHjh3XPLZJkyZWKUyuIrxbdpiJWlysMNMw2Id6Qd7sjU1k8fZT3N+uhvVqFBERKUGFCjPNmjUjNjaWwMBAmjVrhslkwjDyDxw1mUya0WRrje+GtW9n36vp/GHwr1mkZkwmE3e3CmHCL3uYv/mEwoyIiJRZhQoz0dHRBAQEmL8WOwpqBLW6wqHlsG4m3D6jyE31bxbMpN+i2Hkynr2xCdQL8rFioSIiIiWjUAOAQ0NDMZlMpKenM27cODIzMwkNDS3wISWg4+js/26bC5fOFLmZil6udK2fPZNJN58UEZGyyqLZTM7OzixcuNBWtUhh1bgZgltAxmXY+FGxmrq7ZfaaM4u2niQ9s+grC4uIiNiLxVOz77zzThYtWmSDUqTQTKZ/e2ciPoHU/CsyF1bnugFU8nLlXFIaK/bGWac+ERGREmTx1Ozw8HAmTJjAunXraNmyJZ6ennn2P/XUU1YrTq6h3u3gXwvOH4LIL6H9E0VqxsnRgQEtqjJrzWHmbz7BbQ2DrFyoiIiIbZmMgqYlXUNYWNjVGzOZOHz4cLGLsqaEhAR8fX2Jj4/Hx6ecDXCNnA0/Pw3ewfD0dnAq2loxB04n0v2tNTg6mNjwUlcCvF2tW6eIiIiFLPn8trhnRrOZSpEm98DKiZB4CnbOh+b3FamZ2pW9aRbix7bjF1m09SQP31K06d4iIiL2YPGYmddff53k5OR821NSUnj99detUpQUkrMbtH0s++u170BW0Qfw3t2qGgDfbz5e4BpCIiIipZXFYWb8+PFcunQp3/bk5GTGjx9vlaLEAq1GgKsPnN0H+5cUuZm+TYNxdXLgQNwltp+It2KBIiIitmVxmDEMA5PJlG/79u3b8ff3t0pRYgE3X2j1QPbXa98pcjM+bs70bJQ9+Hf+5uPWqExERKREFDrMVKhQAX9/f0wmE3Xq1MHf39/88PX1pXv37gwaNMiWtcrVtB0Fji5wfAMc21DkZnLWnFm8/RSX03VbChERKRsKPQD47bffxjAMRowYwfjx4/H19TXvc3FxoUaNGrRr184mRcp1eAdB03tgy1fw99sw5NsiNdO+VkWq+rlz8mIKf+yOpV+zqtatU0RExAYKHWaGDRsGZE/N7tChA05OFk+EEltq/zRs+Rr2/w5xURBY3+ImHBxMDGxRlXdXHOSHyBMKMyIiUiZYPGbG29ubqKgo8/c//fQT/fv35+WXXyYtLc2qxYkFKoVD/duzv177bpGbueufS01/HzzLyYsp1qhMRETEpiwOMyNHjmT//v0AHD58mMGDB+Ph4cH8+fN54YUXrF6gWKDDM9n/3fk9xBftxpHVK3pwU5g/hgELInXzSRERKf0sDjP79++nWbNmAMyfP59OnToxb948Zs+ezY8//mjt+sQS1Vpm34QyKwPWf1DkZu5uld0788OWE1pzRkRESr0iTc3O+mdxtmXLltG7d28AQkJCOHv2rHWrE8t1eDr7v5GzIfl8kZro3TgITxdHjp5LZlN00doQEREpKRaHmVatWvF///d/fP3116xevZo+ffoA2bc5qFy5stULFAuFd4PKjSA9CSI+K1ITHi5O3N4kGID5utQkIiKlnMVh5u2332bLli088cQTvPLKK4SHhwPwww8/0L59e6sXKBYymf7tndn4EaQXbRBvzu0Nft0Rw6XUDGtVJyIiYnUW3zX7ai5fvoyjoyPOzs7WaM5qyvVds68mMwPebQ7xx6D3NGjzsMVNGIZB1+mrOXw2iakDmzCodYgNChURESmYJZ/fFvfMAFy8eJFPP/2Ul156ifPns8dU7Nmzh7i4uKI0J9bm6ATtn8j+et172eHGQiaTiYEts3tn5kfq9gYiIlJ6WRxmduzYQe3atZkyZQrTpk3j4sWLACxcuJCXXnrJ2vVJUTX/D7j7w8WjsGdRkZoY2KIaDiaIOHKB6LNJ1q1PRETESiwOM2PGjOGBBx7gwIEDuLm5mbf36tWLNWvWWLU4KQYXT7hpZPbXa9+GIlxNDPJ14+baAQD8oN4ZEREppSwOMxEREYwcOTLf9qpVqxIbG2uVosRK2jwCzh4QuxMOrShSEzkDgX+MPElmltacERGR0sfiMOPm5kZCQkK+7fv27SMgIMAqRYmVePhDi/uzv177dpGa6Fa/Mr7uzsQmXObvg1pHSERESh+Lw0y/fv14/fXXSU9PB7IHih47dowXX3yRgQMHWr1AKaZ2j4PJEaLXwMktFj/dzdmRfs3+WXNmsy41iYhI6WNxmJk2bRpnzpwhMDCQlJQUOnXqRHh4ON7e3rzxxhu2qFGKw686NL4r++u17xSpibv/ufnkn3tOE5+cbq3KRERErMLJ0if4+Pjw999/s2LFCrZs2UJWVhYtWrSgW7dutqhPrKHD07DjO4haDOcOQcVaFj29UVUf6gV5szc2kcXbTzK0XQ3b1CkiIlIEFoWZjIwM3Nzc2LZtG7feeiu33nqrreoSa6rcEGr3gAN/Zq870/dti55uMpm4u1UIE37Zw7srDtKtQWWq+LrbplYRERELWXSZycnJidDQUDIzM21Vj9hKh9HZ/902DxJPW/z0e9uEUC/ImzOJqYz8OpLL6XoPiIhI6WDxmJn//ve/eVb+lTIitD1Uaw2Zqdn3bLKQh4sTs4a2ws/DmR0n4nlpwU6sdCcMERGRYrH43kzNmzfn4MGDpKenExoaiqenZ579W7ZYPmPGlm7IezNdTdQv8N194OoLz+wCN8t/HusOnmXo55vIzDJ4uXc9HrnFsvE3IiIihWHJ57fFA4D79+9f1LrE3ur2hoq14dwBiJwNHZ6yuIn24ZX43+0NeG3xbib/vpc6lb3pXDfQ+rWKiIgUktXuml1aqWfmClu+gsVPgncVeHo7OLla3IRhGLz4406+23wcbzcnfnq8AzUDvGxQrIiI3KhsftdsKcOaDM4OMokxsOP7IjVhMpl4vX9DWoZWIPFyBg99tZmEy1p/RkRE7ENh5kbj5AptH8v+eu07kJVVpGZcnRz56D8tqeLrxuEzSYz+dpvu3SQiInahMHMjavlA9iDgcwdg329FbibA25VZQ1vh6uTAir1xTPtznxWLFBERKRyFmRuRmw+0HpH99dq3oRjDphpX82XqXU0A+HDVIX7adtIKBYqIiBSeXcPMpEmTaN26Nd7e3gQGBtK/f3/27cv7r/vhw4djMpnyPNq2bWunisuRmx4DR1c4EQFH1xWrqX7NqvJop+wp2i/8sIOdJ+KtUaGIiEihFGpq9pgxYwrd4IwZMwp97OrVq3n88cdp3bo1GRkZvPLKK/To0YM9e/bkWb+mZ8+efPHFF+bvXVxcCn0OuQrvytDs3uwp2mvfhhoditXc87fVZV9sAiv3neGRrzez+ImOBHhbPlNKRETEUoUKM1u3bi1UYyaTyaKTL1myJM/3X3zxBYGBgURGRnLLLbeYt7u6uhIUFGRR21II7Z+CyC+z79l0enf2PZyKyNHBxDv3Nqf/+2s5fCaJx+ZEMvfhm3B1crRiwSIiIvkVKsysXLnS1nUAEB+ffXnC398/z/ZVq1YRGBiIn58fnTp14o033iAwsOCF2lJTU0lNTTV/n5CQYLuCy7qKtaDBHbDnJ1j7Lgz4uFjN+bg588n9rej//lo2H73Aaz/tZtKAxhaHXBEREUuUmgHAhmEwZswYOnbsSKNGjczbe/Xqxdy5c1mxYgXTp08nIiKCW2+9NU9gyW3SpEn4+vqaHyEhISX1EsqmnBtQ7voBLh4vdnO1Arx4997mmEzwbcRxvt5wtNhtioiIXEuRVgCOiIhg/vz5HDt2jLS0tDz7FixYUKRCHn/8cX799Vf+/vtvqlWrdtXjYmJiCA0N5dtvv2XAgAH59hfUMxMSEqIVgK/ly74QvSZ7UHCvyVZp8uPVh5j0+14cHUx8/WAb2teqZJV2RUTkxmDTFYC//fZbOnTowJ49e1i4cCHp6ens2bOHFStW4OvrW6SCn3zySRYvXszKlSuvGWQAqlSpQmhoKAcOHChwv6urKz4+Pnkech05vTNbvoRk69wN/ZFbatK/WTCZWQaPz93C8fPJVmlXRETkShaHmYkTJ/LWW2/xyy+/4OLiwjvvvENUVBSDBg2ievXqFrVlGAZPPPEECxYsYMWKFYSFhV33OefOneP48eNUqVLF0tLlamrdCkFNID0ZNn1ilSZNJhOTBzahSTVfLiSn8/BXm0lKzbBK2yIiIrlZHGYOHTpEnz59gOxekKSkJEwmE8888wyzZs2yqK3HH3+cOXPmMG/ePLy9vYmNjSU2NpaUlBQALl26xHPPPcf69es5cuQIq1atom/fvlSqVIk777zT0tLlakwm6PB09tebPoY06/SiuDk78vHQllTycmVvbCLPzd9Olm55ICIiVmZxmPH39ycxMRGAqlWrsmvXLgAuXrxIcrJlH4Iffvgh8fHxdO7cmSpVqpgf3333HQCOjo7s3LmTfv36UadOHYYNG0adOnVYv3493t7elpYu19KgP/iFQvI52DrHas1W8XXn46EtcHF04Pddsby34qDV2hYREYFCTs3O7eabb2bp0qU0btyYQYMG8fTTT7NixQqWLl1K165dLWrremOP3d3d+eOPPywtUYrC0QnaPwm/PQfr34NWI7K3WUHLUH/+r38jXvhxB28t20/dIG96NtK6QSIiYh0Wz2Y6f/48ly9fJjg4mKysLKZNm8bff/9NeHg4r776KhUqVLBVrUViyWjoG156CrzVCJLPwoBPocndVm1+3OLdzF53BA8XRxaMak+9IP0+RESkYJZ8fhdpanZZojBjodVvwsr/g8qN4dG/ssfTWEl6ZhbDPt/EukPnCPF3Z/HjHangqVtTiIhIfjYPM1lZWRw8eJC4uDiysrLy7Mt9G4LSQGHGQsnns3tn0pPgvh+hdjerNn8hKY073v+b4+dTaF+rIl+OaIOzY6lZu1FEREoJSz6/LR4UsWHDBoYMGcLRo0fzjXkxmUxkZmZa2qSUJh7+0HIYbPgg+waUVg4zFTxd+OT+Vgz4YB3rDp3jjV+jGHdH0e8JJSIiYvE/iR999FFatWrFrl27OH/+PBcuXDA/zp+3zoJrYmftHgcHJzjyF5yItHrz9YJ8mDGoGQCz1x3h+4ji30ZBRERuXBaHmQMHDjBx4kTq16+Pn59fnvsgFXUFYCllfKtB438G/659yyan6NkoiGe61QHglUU7iTyqICwiIkVjcZi56aabOHhQa4WUezmL6EX9AmcLvnVEcT15azi9GgWRnmkw8ustxMSn2OQ8IiJSvlk8ZubJJ5/k2WefJTY2lsaNG+Ps7Jxnf5MmTaxWnNhRYH2o0xP2L4F178Id71n9FA4OJqbd3ZTos0nsjU3kka8imf9oO9ycHa1+LhERKb8sns3k4JC/M8dkMmEYRqkcAKzZTMVwdD180RMcXWD0TvC2zUJ3x88nc8fMv7mQnE6/ZsG8PbgZJitOCRcRkbLHprOZoqOji1yYlDGh7SDkJji+ETZ8CN3H2+Q0If4evH9fC4Z+tomftp2iQRUfRnaqZZNziYhI+aNF8+Ta9v4G394Lrj7wzC5ws90g76/WH+F/P+3GZILPh7emS91Am51LRERKN0s+v4u0WtmhQ4d48skn6datG927d+epp57i0KFDRSpWSrk6PSGgHqQmwOYvbHqqoW1DubdNCIYBT32zlUNnLtn0fCIiUj5YHGb++OMPGjRowKZNm2jSpAmNGjVi48aNNGzYkKVLl9qiRrEnBwdo/1T21xs+hIxUm53KZDIx/o5GtAqtQOLlDB7+cjPxKek2O5+IiJQPFl9mat68ObfddhuTJ0/Os/3FF1/kzz//ZMuWLVYtsLh0mckKMtLg3WaQcBL6TIfWD9n0dGcSU+k3829OxV+mc90APhvWGkcHDQgWEbmR2PQyU1RUFA8++GC+7SNGjGDPnj2WNidlgZMLtB2V/fVvL8Bf0+GKe3JZU4C3K7Pub4WrkwOr9p1h6h97bXYuEREp+ywOMwEBAWzbti3f9m3bthEYqAGb5VabR6DJYDAyYfnrMG8QJJ2z2ekaVfVl6l3ZaxZ9vPowP207abNziYhI2Wbx1OyHH36YRx55hMOHD9O+fXtMJhN///03U6ZM4dlnn7VFjVIaOLnAnR9DjY7w2/NwcCl8fDPc9TlUb2uTU/ZrVpW9sYl8uOoQry7aRcfwSlT0crXJuUREpOyyeMyMYRi8/fbbTJ8+nVOnTgEQHBzM888/z1NPPVXqFjvTmBkbiN0F84fBuYNgcoSu/8seJFzAgorFlZll0Pe9v9kTk8A9rUOYPFArTIuI3Ags+fwu1joziYmJAHh7exe1CZtTmLGR1ET4eTTs+iH7+9q3wZ0fgYe/1U+1+ch57vpoPSYTLBzVgWYhflY/h4iIlC42X2cmh7e3d6kOMmJDrt4w8FO4/W1wdIUDf8BHN8PxCKufqlUNfwa0qIphwGs/7SIrq1yv8ygiIhYq0tTsgi4lmUwm3NzcCA8PZ/jw4XTp0sVqRRaHemZKQMyO7MtO5w+DgxN0GwftngArXnKMS7xM12mrSUzNYMrAxgxuXd1qbYuISOlj056Znj17cvjwYTw9PenSpQudO3fGy8uLQ4cO0bp1a2JiYujWrRs//fRTkV+AlDFVmsAjq6HhnZCVAX/+F74dAikXrHaKQG83RnevA8CUJfu4mJxmtbZFRKRsszjMnD17lmeffZa//vqL6dOnM2PGDNasWcNzzz1HUlISf/75J//973+ZMGGCLeqV0srNB+76IntRPUcX2PcbfHQLnIi02inubxdKncpenE9KY8bS/VZrV0REyjaLLzP5+voSGRlJeHh4nu0HDx6kZcuWxMfHs3fvXlq3bm0eIGxPusxkB6e2ZV92unAEHJyh++vQ9jGrXHZad+gsQz7ZiIMJfn6yIw2DbXfjSxERsR+bXmZyc3Nj3bp1+bavW7cONzc3ALKysnB11XogN6zgZjByDdS/A7LS4Y+X4Lv/QMrFYjfdvlYlbm9ShSwDXvtpN+X8pu8iIlIIFi+a9+STT/Loo48SGRlJ69atMZlMbNq0iU8//ZSXX34ZyL4ZZfPmza1erJQhbr4w6CvY9An88TLs/QVid8Lds6Fqi2I1/Uqf+qzYG8fmoxdYuPUkA1pUs07NIiJSJhVpnZm5c+cyc+ZM9u3bB0DdunV58sknGTJkCAApKSnm2U32pstMpcDJLTB/OFw8mn3Z6bY3sm+PUIzLTh+uOsSUJXup5OXKyuc64e3mbL16RUTE7kps0byyQGGmlEi5CD89nt1DA9CgH9zxXnYPThGkZmTS6+2/OHw2iYc6hvHf2xtYr1YREbG7Els0T6TQ3P1g8BzoOTm7d2bPT/Bxp+zBwkXg6uTIa3c0BOCLdUfYf9r+g81FRMQ+LA4zmZmZTJs2jTZt2hAUFIS/v3+eh8hVmUzZs5pG/AG+1eFCNHzWPXtcTRE6CDvVCeC2hpXJzDI0GFhE5AZmcZgZP348M2bMYNCgQcTHxzNmzBgGDBiAg4MD48aNs0GJUu5UawkjV0Pd3pCZBr89Bz+MgMsJFjf13z4NcHVyYP3hc/y6M8YGxYqISGlncZiZO3cun3zyCc899xxOTk7ce++9fPrpp/zvf/9jw4YNtqhRyiMPf7hnHvR4I/sWCLsXwKzO2bdGsECIvwejOmevefTGr1EkpWbYoFgRESnNLA4zsbGxNG7cGAAvLy/i4+MBuP322/n111+tW52UbyYTtH8CHvgdfKrB+UPwaTfY/LlFl51GdqpJiL87MfGXmbnyoA0LFhGR0sjiMFOtWjViYrK788PDw/nzzz8BiIiI0EJ5UjQhbeDRv6D2bZCZCr88Az8+BKmFG9Tr5uzIa7dnDwb+9K/DHD5zyZbViohIKWNxmLnzzjtZvnw5AE8//TSvvvoqtWvX5v7772fEiBFWL1BuEB7+cO+32bc+MDnCrh+yLzvF7irU07vWD6RL3QDSMw3G/bxHg4FFRG4gxV5nZsOGDaxbt47w8HDuuOMOa9VlNVpnpgw6tgHmPwCJp8DJDXpNhRb3X3eRveizSdz21hrSMrOYNbQlPRoGlVDBIiJibVo0LxeFmTIq6RwsfAQOLsv+3s03u8fG5JAdakwOeR+YwGTiQkomF1IycHJ0oJq/Jw4OjvmOyftcU4Ht5NlvluvrEt0uIlLK1b8Dmg62apOWfH4X6t5MixcvplevXjg7O7N48eJrHlsae2ekDPKsCEPmw9q3YcX/weX4Qj2tAlDBATCAczasT0RE/lWpjl1PX6ieGQcHB2JjYwkMDMTB4erDbEwmE5mZmVYtsLjUM1MOJJ+HpLNgZGU/MP792vzA/PX6Q2d468+9ODuamHF3Eyp7O/+zz/jnkXWdtnKOy/VezvO/iVFy20VEyoKgptlriFmR1XtmsrKyCvxapER4+Gc/CqltiIHzoUqsPXiO/26vwCf3t7JhcSIiYm+6N5OUOyaTifF3NMTJwcTSPadZuS/O3iWJiIgNFapn5t133y10g0899VSRixGxlvBAb0Z0DGPWmsOMX7yb9s9UxNXJ0d5liYiIDRRqzExYWFie78+cOUNycjJ+fn4AXLx4EQ8PDwIDAzl8+LBNCi0qjZm5cSVeTqfr9NXEJaby/G11ebxLuL1LEhGRQrLk87tQl5mio6PNjzfeeINmzZoRFRXF+fPnOX/+PFFRUbRo0YIJEyZY5QWIWIO3mzMv964PwMwVBzl5McXOFYmIiC1YvM5MrVq1+OGHH2jevHme7ZGRkdx1111ER0dbtcDiUs/Mjc0wDAZ/vIFNR87Tp3EV3r+vhb1LEhGRQrB6z0xuMTExpKen59uemZnJ6dOnLW1OxKZMJhPj+zXEwQS/7oxh7cGz9i5JRESszOIw07VrVx5++GE2b95svv/N5s2bGTlyJN26dbOorUmTJtG6dWu8vb0JDAykf//+7Nu3L88xhmEwbtw4goODcXd3p3PnzuzevdvSsuUGVr+KD/e3qwHAa4t3k56p5QVERMoTi8PM559/TtWqVWnTpg1ubm64urpy0003UaVKFT799FOL2lq9ejWPP/44GzZsYOnSpWRkZNCjRw+SkpLMx0ydOpUZM2Ywc+ZMIiIiCAoKonv37iQmFu6OyiIAz3SvQ0VPFw7GXWL22iP2LkdERKyoyPdmOnDgAFFRURiGQf369alTp/hLGZ85c4bAwEBWr17NLbfcgmEYBAcHM3r0aMaOHQtAamoqlStXZsqUKYwcOfK6bWrMjOT4PuI4L/y4A08XR1Y+15lAHzd7lyQiIldh0zEzOWrXrk3FihXp2bOnVYIMQHx89v13/P2zV3uNjo4mNjaWHj16mI9xdXWlU6dOrFu3zirnlBvHXS2r0SzEj6S0TCb9vtfe5YiIiJUUawXgXr16cfLkSasUYhgGY8aMoWPHjjRq1AiA2NhYACpXrpzn2MqVK5v3XSk1NZWEhIQ8DxEABwcTr/driMkEC7eeZFP0eXuXJCIiVlCsMFPEK1QFeuKJJ9ixYwfffPNNvn0mkynfea/clmPSpEn4+vqaHyEhIVarUcq+JtX8uKd1dQD+99MuMjQYWESkzCsV92Z68sknWbx4MStXrqRatWrm7UFBQQD5emHi4uLy9dbkeOmll4iPjzc/jh8/brvCpUx64ba6+Hk4szc2kbkbj9m7HBERKaZChRl/f3/Ons1en2PEiBHmmUQff/zxVUNFYRiGwRNPPMGCBQtYsWJFvtsmhIWFERQUxNKlS83b0tLSWL16Ne3bty+wTVdXV3x8fPI8RHKr4OnCcz3qAjD9z32cvZRq54pERKQ4ChVm0tLSzGNPvvzySy5fvgzAkCFD8PT0LPLJH3/8cebMmcO8efPw9vYmNjaW2NhYUlKyl503mUyMHj2aiRMnsnDhQnbt2sXw4cPx8PBgyJAhRT6vyL1tqtMw2IeEyxm8uWTf9Z8gIiKlVqGmZnfv3p3Tp0/TsmVLvvzySwYPHoy7u3uBx37++eeFP/lVxr188cUXDB8+HMjuvRk/fjwff/wxFy5c4KabbuL99983DxK+Hk3NlquJPHqBgR9mz4pbOKo9zatXsHNFIiKSw5LP70KFmdOnT/PWW29x6NAhfvzxR3r27Imrq2uBxy5cuLBoVduIwoxcy3Pzt/ND5AkaV/Vl0eMdcHQoOGCLiEjJsnqYyS0sLIzNmzdTsWLFYhVZUhRm5FrOJKZy67RVJKZmMGlAY+5tU93eJYmICDZYNC/3AOAuXbrg4uJS/CpFSoEAb1ee6Z696OPUJXu5mJxm54pERMRSxRoALFIe3N8ulLqVvbmQnM60PzUYWESkrHEqzEHt2rWjf//+tGzZEsMweOqpp6wyAFikNHBydGB8v4bcM2sDczce457W1WlU1dfeZYmISCEVqmdmzpw59O7dm0uXLmEymYiPj+fChQsFPkTKorY1K3JH02AMI3tl4Kws661uLSIitqUBwCL/iI2/zK3TV5Gclsm0u5tyV8tq13+SiIjYhE3vmh0dHV1mgoyIJYJ83Xiqa20AJv8eRcLldDtXJCIihVGkezOtXr2avn37Eh4eTu3atbnjjjv466+/rF2bSIkb0SGMmgGenL2UxttLD9i7HBERKQSLw8ycOXPo1q0bHh4ePPXUUzzxxBO4u7vTtWtX5s2bZ4saRUqMi5MD4/o2BODL9UfYF5to54pEROR6LB4zU79+fR555BGeeeaZPNtnzJjBJ598QlRUlFULLC6NmZGiePTrSJbsjiXE350x3evQt0kwTo6l4ibzIiI3BJuuAOzq6sru3bsJDw/Ps/3gwYM0atSo1K1BozAjRXHyYgp3vr+WuMTsO2qHVfLkyVvDuaOpQo2ISEmw6QDgkJAQli9fnm/78uXLCQkJsbQ5kVKpqp87K57rzAs961LBw5nos0mM+X473Was5ofIE2RkZtm7RBER+YfFPTMffvgho0ePZsSIEbRv3x6TycTff//N7Nmzeeeddxg5cqStai0S9cxIcV1KzeDr9UeZteYQF5KzZziFVvTgiS7h3Nm8qnpqRERswKaXmSD7ztjTp083j4+pX78+zz//PP369StaxTakMCPWkpSawdcbjjJrzWHOJ2Xfw6m6vwdP3JodapwVakRErMbmYaYsUZgRa0tKzWDOP6Hm3D+hJsTfnSe71ObOFgo1IiLWoDCTi8KM2Epy2r+h5uylf0PN453DGdiymkKNiEgxKMzkojAjtpaclsHcDcf4eM0hc6ipVsGdx7uEM7BFNVycFGpERCylMJOLwoyUlJS0TOZuPMpHqw9z9lL2lO6qftmh5q6WCjUiIpZQmMlFYUZKWkpaJvM2HeOj1Yc4k/hvqBnVpRZ3twxRqBERKQSFmVwUZsReLqdnMm9jdqjJWXwv2NeNx7qEM6hVNVydHO1coYhI6WXTMGMYBj/88AMrV64kLi6OrKy8i4ctWLDA8optSGFG7O1yeibfbDrGh6v+DTVVfN0Y1bkWg1qHKNSIiBTApisAP/300wwdOpTo6Gi8vLzw9fXN8xCRvNycHXmgQxhrXujCuL4NqOzjSkz8ZV79aTedpq7iq/VHuJyeae8yRUTKLIt7Zvz9/ZkzZw69e/e2VU1WpZ4ZKW0up2fyXcRxPlx1iNiE7HuZVfZxZVTncAa3DsHNWT01IiI27Znx9fWlZs2aRS5O5Ebn5uzIsPY1WPV8Zyb0a0iQjxunE1J5bfFuOr25ki/WRqunRkTEAhb3zHz55ZcsWbKEzz//HHd3d1vVZTXqmZHSLjUjk+83n+CDlQeJic/uqQnycWNM9zoMbFkNRweTnSsUESl5Nh0AnJyczIABA1i7di01atTA2dk5z/4tW7ZYXrENKcxIWZGakcn8f0LNqX9CTe1AL8b2rEfX+oGYTAo1InLjsOTz28nSxocPH05kZCT/+c9/qFy5sv7AiliJq5Mj/2kbyl0tq/H1+qPMXHmQA3GXeOirzbSuUYEXe9WnZWgFe5cpIlLqWNwz4+npyR9//EHHjh1tVZNVqWdGyqr4lHQ+XHWIL9ZGk5qRvQTCbQ0r8/xt9QgP9LJzdSIitmXTAcAhISEKBSIlwNfdmRd71WPV850Z3CoEBxP8sfs0t729hpcW7OT0PzOhRERudBaHmenTp/PCCy9w5MgRG5QjIleq4uvOlLuasGT0LXSrX5nMLINvNh2j05srmfbHPhIup9u7RBERu7L4MlOFChVITk4mIyMDDw+PfAOAz58/b9UCi0uXmaS82RR9nsm/R7Hl2EUAKng488SttflP2+paTVhEyg2bzmb68ssvr7l/2LBhljRncwozUh4ZhsGfe04zZcleDp9JAqBaBXee61GXO5oG46Dp3CJSxtkszKSnp/PII4/w6quvlpmF8xRmpDzLyMxifuQJ3lq633zfpwZVfHixVz1uqRNg5+pERIrOpj0zfn5+bNmyRWFGpBRJScvk87XRfLTqEImpGQB0DK/E2J71aFxN90wTkbLHprOZ7rzzThYtWlTU2kTEBtxdHHm8SzirX+jCiA5hODua+PvgWfrO/Jsnv9nKsXPJ9i5RRMRmLO6ZeeONN5g2bRpdu3alZcuWeHp65tn/1FNPWbXA4lLPjNyIjp9PZsbS/SzadhLDAGdHE/fdFMoTt4ZTycvV3uWJiFyXTS8zhYWFXb0xk4nDhw9b0pzNKczIjWz3qXimLNnHmv1nAPB0cWRkp1o82DEMT1eLFwAXESkxNg0zZY3CjAisPXiWyb/vZefJeAAqebnydLfa3NM6BGdHi682i4jYXImFmZynlub7MynMiGTLyjL4dWcMb/6xj2Pns8fQhFXy5Pnb6tKrUVCp/v9YRG48Nh0ADPDVV1/RuHFj3N3dcXd3p0mTJnz99ddFKlZESoaDg4m+TYNZNqYT4+9oSEVPF6LPJjFq7hb6f7CODYfP2btEEZEisTjMzJgxg8cee4zevXvz/fff891339GzZ08effRR3nrrLVvUKCJW5OLkwLD2NVj9Qhee6lobDxdHth+/yD2zNjDs801sPXbB3iWKiFikSAOAx48fz/33359n+5dffsm4ceOIjo62aoHFpctMItcWl3iZd5cf4JtNx8nMyv5zcHPtSozuVpuWof52rk5EblQ2HTPj5ubGrl27CA8Pz7P9wIEDNG7cmMuXS9edfBVmRArnyNkk3l95kAVbT5pDTYfwijzdtQ5twhRqRKRk2XTMTHh4ON9//32+7d999x21a9e2tDkRKSVqVPLkzbubsvLZztzTOgQnBxNrD55j0MfruXfWBtYf0pgaESmdLO6Z+fHHHxk8eDDdunWjQ4cOmEwm/v77b5YvX87333/PnXfeaatai0Q9MyJFc/x8Mh+uPsT8zcdJz8z+M9EmzJ/RXWvTrlZFzX4SEZuy+dTsyMhI3nrrLaKiojAMgwYNGvDss8/SvHnzIhdtKwozIsVz8mIKH646yPcRJ0jLzAKgVWgFnu5Wm47hlRRqRMQmtGheLgozItYRE5/CR6sO8U3EcdIyskNN8+p+PN21Np3qBCjUiIhV2XydGWtZs2YNffv2JTg4GJPJlO8GlsOHD8dkMuV5tG3b1j7Fitzgqvi6M75fI/56oQsPdKiBq5MDW49dZPgXEfT/YB0r9p6mnP/bSERKqUKHGQcHBxwdHa/5cHKy7F4vSUlJNG3alJkzZ171mJ49exITE2N+/PbbbxadQ0Ssq7KPG6/1bchfY7vwUMcw3Jwd2H78IiNmb+aOmWtZukehRkRKVqHTx8KFC6+6b926dbz33nsW/wHr1asXvXr1uuYxrq6uBAUFWdSuiNheoLcb/729ASM71eLTvw7z1fqj7DwZz8NfbaZBFR+e6lqbHg0q4+Cgy08iYluFDjP9+vXLt23v3r289NJL/Pzzz9x3331MmDDBqsUBrFq1isDAQPz8/OjUqRNvvPEGgYGBVz0+NTWV1NRU8/cJCQlWr0lE/hXg7cpLvevzyC01+fTvaL5ad4Q9MQk8OieSekHePNW1Nj0bBinUiIjNFGnMzKlTp3j44Ydp0qQJGRkZbNu2jS+//JLq1atbtbhevXoxd+5cVqxYwfTp04mIiODWW2/NE1auNGnSJHx9fc2PkJAQq9YkIgWr6OXK2J71+HvsrTzRJRwvVyf2xiYyau4Wer6zhp+3nzIvxiciYk0WzWaKj49n4sSJvPfeezRr1owpU6Zw8803W6cQk4mFCxfSv3//qx4TExNDaGgo3377LQMGDCjwmIJ6ZkJCQjSbSaSEXUxO4/O1R/hibTSJlzMACA/04slbw7m9STCO6qkRkWuwyWymqVOnUrNmTX755Re++eYb1q1bZ7UgU1hVqlQhNDSUAwcOXPUYV1dXfHx88jxEpOT5ebgwpnsd/h57K6O71cbHzYmDcZd4+tttdH9rNQu3niDjn3VrRESKo9A9Mw4ODri7u9OtWzccHR2vetyCBQuKVkghembOnTtH1apVmTVrVr4bXV6N1pkRKR0SLqfz5dojfPp3NPEp6QCEVfLk8S7h9G8WjJOjXVeKEJFSxpLP70IPAL7//vutvijWpUuXOHjwoPn76Ohotm3bhr+/P/7+/owbN46BAwdSpUoVjhw5wssvv0ylSpVK3S0TROT6fNycebJrbYZ3qMFX64/y6V+HiT6bxHPztzNlyV461wmgS71AOtauhI+bs73LFZEyxK4rAK9atYouXbrk2z5s2DA+/PBD+vfvz9atW7l48SJVqlShS5cuTJgwwaJBveqZESmdklIz+HrDUT5Zc5hzSWnm7Y4OJlqGVqBL3UA61w2gXpC3VhcWuQHpdga5KMyIlG6pGZlERF9g1b44Vu6L49CZpDz7g3zc6Fw3gM51A+kQXhFv9dqI3BAUZnJRmBEpW46fT/4n2Jxh3aGzXE7/d5Cwk4OJ1jX86Vw3+5JU7UAv9dqIlFMKM7kozIiUXZfTM9kYfZ6Ve+NYvf8M0Wfz9tpU9XOnU90AutQNpH2tini6WnZLFREpvRRmclGYESk/jpxNMvfarD98znz3bgAXRwfahPmbL0nVCvBUr41IGaYwk4vCjEj5lJKWyYbD51j5z1ib4+dT8uwP8Xenc51AutQLoF3NSri7XH1JCREpfRRmclGYESn/DMPg8NkkVu07w6p9cWw8fJ60XAvyuTg50LZmRbr802sTVsnTjtWKSGEozOSiMCNy40lKzWD9oexem1X7znDyYt5emxoVPehcN5BOdQJoHeaPl8baiJQ6CjO5KMyI3NgMw+Bg3CVzsIk4cp70zH//7Dk6mGhazZd2tSrSvlYlWoZWwM1Zl6RE7E1hJheFGRHJ7VJqBmsPnmXVvjj+Png231gbF0cHmlf3M4ebZiF+uDjpVgsiJU1hJheFGRG5luPnk1l/+BwbDp1j3aFzxCZczrPf3dmRVjUq0K5WRdrVrEjjqr66j5RICVCYyUVhRkQKyzAMos8msf5wdrDZcOhcnlstAHi5OnFTmH92uKlVkfpBPjg4aAq4iLUpzOSiMCMiRWUYBvtPX2LdobOsP3SODYfPkXA5I88xfh7OtA2r+M9lqYqEa1ViEatQmMlFYUZErCUzyyAqJsEcbjZFnycpLTPPMZW8XM3Bpl3NioRW9FC4ESkChZlcFGZExFbSM7PYcSKeDYfPse7QWTYfuUBqrlWJAYJ93WhXq5I54AT7udupWpGyRWEmF4UZESkpqRmZbD120TzeZuvxC3mmgQOEVvTgpjB/moVUoEk1X+oGeeOsAcUi+SjM5KIwIyL2kpyWQeTRC6z7Z6bUzhMXybriL66rkwMNg31oGuJH02p+NA3xo4YuTYkozOSmMCMipUXC5XQios8TefQCO07Es/3ERRKvGFAM4OvuTJNqvjSt5keTar40C/Ej0MfNDhWL2I/CTC4KMyJSWmVlGRw5l8T2ExfZfjw73Ow+lZDnbuA5gnzcaBria+7BaVzNFx83ZztULVIyFGZyUZgRkbIkLSOL/acT2Xb8Ijv+CTkH4hLzXZ4CqBngSbN/em+ahvhRv4qPbsUg5YbCTC4KMyJS1iWlZrDrZDw7TsSz7UR2yLnyNgwAzo4m6gX50DTElybV/GgW4ketAC8ctaiflEEKM7kozIhIeXTuUqp53M324xfZcSI+32rFAJ4ujjSqmt1z0yq0Ap3rBupeU1ImKMzkojAjIjcCwzA4cSElT8DZeTKe5CsW9fP3dOHO5lUZ3DqEOpW97VStyPUpzOSiMCMiN6rMLINDZy6x7Xh2uFkWdZrTCanm/c1C/BjcOoS+TYPxcnWyY6Ui+SnM5KIwIyKSLSMzizUHzvBdxHGWR8WR8c+oYndnR/o0qcLg1iG0Cq2gNW6kVFCYyUVhRkQkvzOJqSzYcoLvNh/n8Jkk8/aaAZ4MahXCwBbVCPB2tWOFcqNTmMlFYUZE5OoMwyDy6AW+izjOLztiSEnPHmPj5GDi1nqBDG4dQqc6ATjplgtSwhRmclGYEREpnEupGfyy/RTfbT7O1mMXzdsDvV25q2U1BrUKoUYlT/sVKDcUhZlcFGZERCy3/3Qi30ccZ8HWk5zPNeX7pjB/BrcOoVejKri7aIE+sR2FmVwUZkREii4tI4tlUaf5LuI4aw6cIecTw9vViTuaBTO4dQiNq/pq0LBYncJMLgozIiLWcepiCj9EnuD7zcc5ceHfFYjrBXkzuHUIdzavip+Hix0rlPJEYSYXhRkREevKyjJYf/gc30UcZ8nuWPONMV0cHejRsDKDW4fQoVYlHHQbBSkGhZlcFGZERGznYnIaP207xXcRx9kTk2DeXtXPnUGtQrirVTWq+rnbsUIpqxRmclGYEREpGbtOxvNdxHEWbTtJ4uUMAEwm6FQngGe716VxNV87VyhlicJMLgozIiIl63J6Jr/viuG7iONsOHzevL1/s2Ceu60u1Sp42LE6KSsUZnJRmBERsZ8jZ5N4d/kBFmw9CYCLkwMPdKjBqM7h+Lo727k6Kc0UZnJRmBERsb9dJ+N549co1h8+B0AFD2ee6lqb+24KxcVJqwtLfgozuSjMiIiUDoZhsHJfHJN+28uBuEsA1Kjowdie9ejZKEhr1UgeCjO5KMyIiJQuGZlZfL/5BDOW7ufspVQAWoZW4OXe9WkZWsHO1UlpoTCTi8KMiEjpdCk1g1lrDvPJmsPmG1z2aVyFF3rWJbSi7gF1o1OYyUVhRkSkdDudcJkZf+7n+8jjGAY4O5oY2rYGT94aTgVPrSh8o1KYyUVhRkSkbNgbm8Ck3/ayev8ZALzdnHiiSzjD2tfAzVk3tbzRKMzkojAjIlK2/HXgDBN/20vUPysKV/Vz54WedenbJFi3SLiBKMzkojAjIlL2ZGYZLNx6kml/7CM24TIATar58nLv+rStWdHO1UlJUJjJRWFGRKTsSknL5PO10Xyw8iBJadmDhLvVr8yLveoRHuhl5+rElhRmclGYEREp+84kpvLO8v18s+k4mVkGjg4m7m0TwtNd6xDg7Wrv8sQGFGZyUZgRESk/DsZdYvLve1kWdRoATxdHHutciwc71sTdRYOEyxOFmVwUZkREyp8Nh88x8bcodpyIByDIx41ne9RhQItqOGqQcLlgyee3XW+IsWbNGvr27UtwcDAmk4lFixbl2W8YBuPGjSM4OBh3d3c6d+7M7t277VOsiIiUGm1rVmTRqA68c08zqvq5E5twmed/2EGfd//irwNn7F2elDC7hpmkpCSaNm3KzJkzC9w/depUZsyYwcyZM4mIiCAoKIju3buTmJhYwpWKiEhp4+Bgol+zqix/thMv966Hj5sTe2MTGfrZJu7/fJN5areUf6XmMpPJZGLhwoX0798fyO6VCQ4OZvTo0YwdOxaA1NRUKleuzJQpUxg5cmSh2tVlJhGRG8OFpDTeW3GQrzccIT0z+6MtrJIn7WtVpEN4JdrVrKgVhcsQSz6/nUqoJotFR0cTGxtLjx49zNtcXV3p1KkT69atu2qYSU1NJTU11fx9QoKSuYjIjaCCpwv/69uAYe1DmbpkH7/viiH6bBLRZ5OYu/EYJhM0qOJDh/BKtK9VkTZh/ni4lNqPQbFAqf0txsbGAlC5cuU82ytXrszRo0ev+rxJkyYxfvx4m9YmIiKlV2hFT96/rwXxKelsPHyOdYfOsfbgWQ7EXWL3qQR2n0pg1prDODuaaB5Sgfbh2T03zUL8cHa06+gLKaJSG2ZymEx5R6UbhpFvW24vvfQSY8aMMX+fkJBASEiIzeoTEZHSydfdmR4Ng+jRMAiAuITL5mCz7tA5Tl5MYdOR82w6cp63lx3Aw8WRNmH+dKhVifbhFakf5KPbJ5QRpTbMBAVlv/liY2OpUqWKeXtcXFy+3prcXF1dcXXVAkoiIpJXoI8b/ZtXpX/zqhiGwdFzyaw9dJZ1B8+x7tBZLiSns2rfGVbty54N5e/pQruaFbN7bmpVIrSixzX/MS32U2rDTFhYGEFBQSxdupTmzZsDkJaWxurVq5kyZYqdqxMRkbLMZDJRo5InNSp5ct9NoWRlGUTFJpiDzcbo85xPSuPXnTH8ujMGyL7hZc5g4va1KhLo42bnVyE57BpmLl26xMGDB83fR0dHs23bNvz9/alevTqjR49m4sSJ1K5dm9q1azNx4kQ8PDwYMmSIHasWEZHyxsHBRMNgXxoG+/LwLTVJz8xi+/GLrD14jrWHzrL12AVOXkxhfuQJ5keeAKB2oJc52NxUsyK+7s52fhU3LrtOzV61ahVdunTJt33YsGHMnj0bwzAYP348H3/8MRcuXOCmm27i/fffp1GjRoU+h6Zmi4hIcSWnZRBx5ALrDp5l7aGz7D6VQO5PTwcTNK7qS/t/wk2jYF9NAy8m3c4gF4UZERGxtgtJaWw4fM485ubw2aR8x1T2caV+FR/qBflQv4o39YJ8qBngqRlThaQwk4vCjIiI2FpMfArr/rkktfnIBY6dTy7wOBdHB8IDvahXxZsGuYJORS9NXLmSwkwuCjMiIlLSLqVmsC82kaiYBPbGJrA3JpG9sYlcSs0o8PgAb1fqBf0TcP7pxakV4IWL043bi6Mwk4vCjIiIlAZZWQYnL6YQFZNAVExidsiJTeTIuSQK+iR2djRRK8CL+lX+vUxVr4o3gd43xiwqhZlcFGZERKQ0S0rNYP/p7J6bqJjsXpyo2AQSLxfci1PJyyU72AR5Z4/JqeJNeKAXrk6OJVy5bSnM5KIwIyIiZY1hZPfi7P2nByfqn4Bz5GwSWQV8ajs5mAir5El1fw+qVXCnagV3qlXwoKqfO9UquOPv6VLmFvxTmMlFYUZERMqLlLTMf3px/gk4MdmXquJT0q/5PHdnR6pWcDeHm5ywU62CO9X83Knk5Vrqbt2gMJOLwoyIiJRnhmEQm3CZ/acvceJCMicvpHDiQgonL6Zw4kIycYmpBY7Jyc3FyeHfoHNF4Knq505lHzccSzjsWPL5XWpvZyAiIiLXZzKZqOLrThVf9wL3p2ZkEnPxsjnc5ISdExdTOHkhhZj4FNIysog+m0R0AevlQPZlrCp+blTz8/gn5OSEnuzenSBfN7uun6MwIyIiUo65Ojma70NVkPTMLGLjL+fpzcndu3PqYgoZWQbHz6dw/HxKgW38p211/q9/Y1u+jGtSmBEREbmBOTs6EOLvQYi/R4H7M7MM4hL/CTsX/gk7F1P+/f5iCtUqFPzckqIwIyIiIlfl6PDvZazWNfLvz8oyyChoilUJUpgRERGRInNwMOFi55lQN+46ySIiIlIuKMyIiIhImaYwIyIiImWawoyIiIiUaQozIiIiUqYpzIiIiEiZpjAjIiIiZZrCjIiIiJRpCjMiIiJSpinMiIiISJmmMCMiIiJlmsKMiIiIlGkKMyIiIlKmlfu7ZhtG9m3JExIS7FyJiIiIFFbO53bO5/i1lPswk5iYCEBISIidKxERERFLJSYm4uvre81jTEZhIk8ZlpWVxalTp/D29sZkMlm17YSEBEJCQjh+/Dg+Pj5Wbbs00ust3/R6yze93vKtPL5ewzBITEwkODgYB4drj4op9z0zDg4OVKtWzabn8PHxKTdvnsLQ6y3f9HrLN73e8q28vd7r9cjk0ABgERERKdMUZkRERKRMU5gpBldXV1577TVcXV3tXUqJ0Ost3/R6yze93vLtRnu9Vyr3A4BFRESkfFPPjIiIiJRpCjMiIiJSpinMiIiISJmmMCMiIiJlmsJMEX3wwQeEhYXh5uZGy5Yt+euvv+xdkk1MmjSJ1q1b4+3tTWBgIP3792ffvn32LqvETJo0CZPJxOjRo+1dis2cPHmS//znP1SsWBEPDw+aNWtGZGSkvcuymYyMDP773/8SFhaGu7s7NWvW5PXXXycrK8vepVnFmjVr6Nu3L8HBwZhMJhYtWpRnv2EYjBs3juDgYNzd3encuTO7d++2T7FWcK3Xm56eztixY2ncuDGenp4EBwdz//33c+rUKfsVXEzX+/3mNnLkSEwmE2+//XaJ1WcvCjNF8N133zF69GheeeUVtm7dys0330yvXr04duyYvUuzutWrV/P444+zYcMGli5dSkZGBj169CApKcnepdlcREQEs2bNokmTJvYuxWYuXLhAhw4dcHZ25vfff2fPnj1Mnz4dPz8/e5dmM1OmTOGjjz5i5syZREVFMXXqVN58803ee+89e5dmFUlJSTRt2pSZM2cWuH/q1KnMmDGDmTNnEhERQVBQEN27dzffx66sudbrTU5OZsuWLbz66qts2bKFBQsWsH//fu644w47VGod1/v95li0aBEbN24kODi4hCqzM0Ms1qZNG+PRRx/Ns61evXrGiy++aKeKSk5cXJwBGKtXr7Z3KTaVmJho1K5d21i6dKnRqVMn4+mnn7Z3STYxduxYo2PHjvYuo0T16dPHGDFiRJ5tAwYMMP7zn//YqSLbAYyFCxeav8/KyjKCgoKMyZMnm7ddvnzZ8PX1NT766CM7VGhdV77egmzatMkAjKNHj5ZMUTZ0tdd74sQJo2rVqsauXbuM0NBQ46233irx2kqaemYslJaWRmRkJD169MizvUePHqxbt85OVZWc+Ph4APz9/e1ciW09/vjj9OnTh27dutm7FJtavHgxrVq14u677yYwMJDmzZvzySef2Lssm+rYsSPLly9n//79AGzfvp2///6b3r1727ky24uOjiY2NjbP3y9XV1c6dep0Q/z9guy/YSaTqdz2PmZlZTF06FCef/55GjZsaO9ySky5v9GktZ09e5bMzEwqV66cZ3vlypWJjY21U1UlwzAMxowZQ8eOHWnUqJG9y7GZb7/9li1bthAREWHvUmzu8OHDfPjhh4wZM4aXX36ZTZs28dRTT+Hq6sr9999v7/JsYuzYscTHx1OvXj0cHR3JzMzkjTfe4N5777V3aTaX8zeqoL9fR48etUdJJery5cu8+OKLDBkypFzdjDG3KVOm4OTkxFNPPWXvUkqUwkwRmUymPN8bhpFvW3nzxBNPsGPHDv7++297l2Izx48f5+mnn+bPP//Ezc3N3uXYXFZWFq1atWLixIkANG/enN27d/Phhx+W2zDz3XffMWfOHObNm0fDhg3Ztm0bo0ePJjg4mGHDhtm7vBJxI/79Sk9P55577iErK4sPPvjA3uXYRGRkJO+88w5btmwp97/PK+kyk4UqVaqEo6Njvl6YuLi4fP/aKU+efPJJFi9ezMqVK6lWrZq9y7GZyMhI4uLiaNmyJU5OTjg5ObF69WreffddnJycyMzMtHeJVlWlShUaNGiQZ1v9+vXL5WD2HM8//zwvvvgi99xzD40bN2bo0KE888wzTJo0yd6l2VxQUBDADff3Kz09nUGDBhEdHc3SpUvLba/MX3/9RVxcHNWrVzf//Tp69CjPPvssNWrUsHd5NqUwYyEXFxdatmzJ0qVL82xfunQp7du3t1NVtmMYBk888QQLFixgxYoVhIWF2bskm+ratSs7d+5k27Zt5kerVq2477772LZtG46OjvYu0ao6dOiQb6r9/v37CQ0NtVNFtpecnIyDQ94/fY6OjuVmava1hIWFERQUlOfvV1paGqtXry6Xf7/g3yBz4MABli1bRsWKFe1dks0MHTqUHTt25Pn7FRwczPPPP88ff/xh7/JsSpeZimDMmDEMHTqUVq1a0a5dO2bNmsWxY8d49NFH7V2a1T3++OPMmzePn376CW9vb/O/6Hx9fXF3d7dzddbn7e2dbzyQp6cnFStWLJfjhJ555hnat2/PxIkTGTRoEJs2bWLWrFnMmjXL3qXZTN++fXnjjTeoXr06DRs2ZOvWrcyYMYMRI0bYuzSruHTpEgcPHjR/Hx0dzbZt2/D396d69eqMHj2aiRMnUrt2bWrXrs3EiRPx8PBgyJAhdqy66K71eoODg7nrrrvYsmULv/zyC5mZmea/Yf7+/ri4uNir7CK73u/3yrDm7OxMUFAQdevWLelSS5Z9J1OVXe+//74RGhpquLi4GC1atCi3U5WBAh9ffPGFvUsrMeV5arZhGMbPP/9sNGrUyHB1dTXq1atnzJo1y94l2VRCQoLx9NNPG9WrVzfc3NyMmjVrGq+88oqRmppq79KsYuXKlQX+Pzts2DDDMLKnZ7/22mtGUFCQ4erqatxyyy3Gzp077Vt0MVzr9UZHR1/1b9jKlSvtXXqRXO/3e6UbZWq2yTAMo4Ryk4iIiIjVacyMiIiIlGkKMyIiIlKmKcyIiIhImaYwIyIiImWawoyIiIiUaQozIiIiUqYpzIiIiEiZpjAjIuVOjRo1ePvtt+1dhoiUEIUZESmW4cOH079/fwA6d+7M6NGjS+zcs2fPxs/PL9/2iIgIHnnkkRKrQ0TsS/dmEpFSJy0trVj3zQkICLBiNSJS2qlnRkSsYvjw4axevZp33nkHk8mEyWTiyJEjAOzZs4fevXvj5eVF5cqVGTp0KGfPnjU/t3PnzjzxxBOMGTOGSpUq0b17dwBmzJhB48aN8fT0JCQkhFGjRnHp0iUAVq1axQMPPEB8fLz5fOPGjQPyX2Y6duwY/fr1w8vLCx8fHwYNGsTp06fN+8eNG0ezZs34+uuvqVGjBr6+vtxzzz0kJiaaj/nhhx9o3Lgx7u7uVKxYkW7dupGUlGSjn6aIWEJhRkSs4p133qFdu3Y8/PDDxMTEEBMTQ0hICDExMXTq1IlmzZqxefNmlixZwunTpxk0aFCe53/55Zc4OTmxdu1aPv74YwAcHBx499132bVrF19++SUrVqzghRdeAKB9+/a8/fbb+Pj4mM/33HPP5avLMAz69+/P+fPnWb16NUuXLuXQoUMMHjw4z3GHDh1i0aJF/PLLL/zyyy+sXr2ayZMnAxATE8O9997LiBEjiIqKYtWqVQwYMADd2k6kdNBlJhGxCl9fX1xcXPDw8CAoKMi8/cMPP6RFixZMnDjRvO3zzz8nJCSE/fv3U6dOHQDCw8OZOnVqnjZzj78JCwtjwoQJPPbYY3zwwQe4uLjg6+uLyWTKc74rLVu2jB07dhAdHU1ISAgAX3/9NQ0bNiQiIoLWrVsDkJWVxezZs/H29gZg6NChLF++nDfeeIOYmBgyMjIYMGAAoaGhADRu3LgYPy0RsSb1zIiITUVGRrJy5Uq8vLzMj3r16gHZvSE5WrVqle+5K1eupHv37lStWhVvb2/uv/9+zp07Z9HlnaioKEJCQsxBBqBBgwb4+fkRFRVl3lajRg1zkAGoUqUKcXFxADRt2pSuXbvSuHFj7r77bj755BMuXLhQ+B+CiNiUwoyI2FRWVhZ9+/Zl27ZteR4HDhzglltuMR/n6emZ53lHjx6ld+/eNGrUiB9//JHIyEjef/99ANLT0wt9fsMwMJlM193u7OycZ7/JZCIrKwsAR0dHli5dyu+//06DBg147733qFu3LtHR0YWuQ0RsR2FGRKzGxcWFzMzMPNtatGjB7t27qVGjBuHh4XkeVwaY3DZv3kxGRgbTp0+nbdu21KlTh1OnTl33fFdq0KABx44d4/jx4+Zte/bsIT4+nvr16xf6tZlMJjp06MD48ePZunUrLi4uLFy4sNDPFxHbUZgREaupUaMGGzdu5MiRI5w9e5asrCwef/xxzp8/z7333sumTZs4fPgwf/75JyNGjLhmEKlVqxYZGRm89957HD58mK+//pqPPvoo3/kuXbrE8uXLOXv2LMnJyfna6datG02aNOG+++5jy5YtbNq0ifvvv59OnToVeGmrIBs3bmTixIls3ryZY8eOsWDBAs6cOWNRGBIR21GYERGree6553B0dKRBgwYEBARw7NgxgoODWbt2LZmZmdx22200atSIp59+Gl9fXxwcrv4nqFmzZsyYMYMpU6bQqFEj5s6dy6RJk/Ic0759ex599FEGDx5MQEBAvgHEkN2jsmjRIipUqMAtt9xCt27dqFmzJt99912hX5ePjw9r1qyhd+/e1KlTh//+979Mnz6dXr16Ff6HIyI2YzI0t1BERETKMPXMiIiISJmmMCMiIiJlmsKMiIiIlGkKMyIiIlKmKcyIiIhImaYwIyIiImWawoyIiIiUaQozIiIiUqYpzIiIiEiZpjAjIiIiZZrCjIiIiJRpCjMiIiJSpv0/Lwv8zN1rrLsAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.figure()\n", "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n", @@ -432,18 +287,9 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[37.94733192202055, 33.11643018090643, 26.19914403314804, 22.98019174072421, 18.568952671100934, 17.26345497290312, 15.845257892068565, 14.548267871851474, 13.79425955612947, 13.122192577713562, 12.573384657978343, 11.558050437409028, 10.107869461324858, 9.421737059033882, 8.946915095665906, 8.623842763568359]\n", - "[37.94733192202055, 28.796954985844128, 23.150025325565377, 21.174565917599644, 21.15634538422303, 21.152930713031026, 21.1528964173955, 21.1528939848538, 21.15289383684111, 21.152893836287003, 21.15289383626384, 21.152893836260493, 21.15289383626047, 21.15289383626047, 21.15289383626047, 21.15289383626047]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(off_diagonal_norm_history)\n", "print(off_diagonal_norm_history_canonical)" @@ -470,17 +316,9 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "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)" @@ -488,17 +326,9 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "canonical norm 37.0169421025245 step 0.0028243313346074067\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "dbi_eval = deepcopy(dbi_mixed)\n", "dbi_eval.mode = DoubleBracketGeneratorType.canonical\n", @@ -515,23 +345,9 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New optimized step at iteration 1/15: 0.02673042815527681 with operator Canonical, loss 28.931545487398413\n", - "New optimized step at iteration 2/15: 0.012489323260897375 with operator Canonical, loss 22.642760635667926\n", - "New optimized step at iteration 3/15: 0.08262102611209304 with operator IZIZZ, loss 20.402863400714757\n", - "New optimized step at iteration 4/15: 0.005858370590980864 with operator Canonical, loss 17.704347807090855\n", - "New optimized step at iteration 5/15: 0.07801470544762314 with operator ZIZIZ, loss 16.35520150538464\n", - "New optimized step at iteration 6/15: 0.0024494184523774433 with operator Canonical, loss 15.028787315577059\n", - "New optimized step at iteration 7/15: 0.030895838247917303 with operator -ZIIIZ, loss 14.320569882373876\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "Z_optimal_mixed = []\n", "# add in initial values for plotting\n", From 33a19a52f0e3df65febcecb1a156573c365683be Mon Sep 17 00:00:00 2001 From: Andrea Date: Wed, 24 Jan 2024 10:12:16 +0400 Subject: [PATCH 34/48] test: Fix coverage --- src/qibo/models/dbi/double_bracket.py | 3 +- tests/test_models_dbi.py | 45 ++++++++++++++------------- 2 files changed, 25 insertions(+), 23 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 15ffdb007e..d410d19cd1 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -5,7 +5,6 @@ import hyperopt import numpy as np -from qibo.config import raise_error from qibo.hamiltonians import Hamiltonian @@ -74,7 +73,7 @@ def __call__( ) elif mode is DoubleBracketGeneratorType.group_commutator: if d is None: - raise_error(ValueError, f"Cannot use group_commutator with matrix {d}") + d = self.diagonal_h_matrix operator = ( self.h.exp(-step) @ self.backend.calculate_matrix_exp(-step, d) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index f1bcc82a2f..a7e8a5bc4b 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -16,63 +16,66 @@ @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) + # test first iteration with default d + 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 + + # test first iteration with default d + dbi(mode=DoubleBracketGeneratorType.single_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_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 ) @@ -80,12 +83,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, @@ -94,12 +97,12 @@ 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 From 7d9ecaf29f795d6b9b0c2b48e8f82c4151d3ef18 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 25 Jan 2024 09:52:17 +0800 Subject: [PATCH 35/48] Solve missing line 70 in test_models_dbi.py, added line dbi call with d=None --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 45 ++++++++++++++++--- src/qibo/models/dbi/utils.py | 2 +- tests/test_models_dbi.py | 1 + 3 files changed, 42 insertions(+), 6 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index af214950bc..0f76a36245 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": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -122,16 +122,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "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" + ] + } + ], "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", + "nqubits = 2\n", "h = 3\n", "\n", "# define the hamiltonian\n", @@ -143,6 +158,26 @@ "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" ] }, + { + "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" + ] + } + ], + "source": [ + "print(H_TFIM.matrix)" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 100e82997d..9a56d1d798 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -100,7 +100,7 @@ def select_best_dbr_generator( # prescribed step durations dbi_eval = deepcopy(dbi_object) flip_list[i] = CS_angle_sgn(dbi_eval, d) - if flip_list[i] is not 0: + if flip_list[i] != 0: if step is None: step_best = dbi_eval.hyperopt_step( step_min=step_min, diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index f1bcc82a2f..90c0c1804b 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -58,6 +58,7 @@ def test_double_bracket_iteration_single_commutator(backend, nqubits): for _ in range(NSTEPS): dbf(step=0.01, d=d) + dbf(step=0.01) assert initial_off_diagonal_norm > dbf.off_diagonal_norm From 23844abea59307ce3ecd98d327885161414e82f2 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 29 Jan 2024 18:16:50 +0800 Subject: [PATCH 36/48] Fix doc string error: off_diagonal_norm: latex missing \Tr --- src/qibo/models/dbi/double_bracket.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 15ffdb007e..f8c931aeba 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -102,7 +102,7 @@ def off_diag_h(self): @property def off_diagonal_norm(self): - r"""Hilbert Schmidt norm of off-diagonal part of H matrix: \sqrt{A^\dag A}""" + r"""Hilbert Schmidt norm of off-diagonal part of H matrix: \Tr(\sqrt{A^\dag A})""" off_diag_h_dag = self.backend.cast( np.matrix(self.backend.to_numpy(self.off_diag_h)).getH() ) From 26502433c4c131e7daed8f7d7d3cad8af3f01789 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 29 Jan 2024 23:26:10 +0800 Subject: [PATCH 37/48] Fixed error with select_best_dbr_generator: initial off-norm list must not be 0 --- src/qibo/models/dbi/utils.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 9a56d1d798..5969637b62 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -93,9 +93,11 @@ def select_best_dbr_generator( Returns: The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. """ - norms_off_diagonal_restriction = [0 for i in range(len(d_list))] - optimal_steps = [0 for i in range(len(d_list))] - flip_list = [1 for i in range(len(d_list))] + norms_off_diagonal_restriction = [ + dbi_object.off_diagonal_norm for _ in range(len(d_list)) + ] + optimal_steps = [0 for _ in range(len(d_list))] + flip_list = [1 for _ in range(len(d_list))] for i, d in enumerate(d_list): # prescribed step durations dbi_eval = deepcopy(dbi_object) @@ -103,12 +105,12 @@ def select_best_dbr_generator( 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, - d=flip_list[i] * d, ) else: step_best = step From 0d15274d02a5ea9a8ff8b48528ed2e861bac9f5a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 2 Feb 2024 10:45:18 +0000 Subject: [PATCH 38/48] [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 4f148b81919f419e8ba72c0f46421fe2dfef9f54 Mon Sep 17 00:00:00 2001 From: Marek Gluza Date: Mon, 5 Feb 2024 09:22:38 +0100 Subject: [PATCH 39/48] Lower case PEP 8 convention Update src/qibo/models/dbi/utils.py Co-authored-by: Andrea Pasquale --- src/qibo/models/dbi/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 5969637b62..0adcb4be1f 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -152,7 +152,7 @@ def select_best_dbr_generator( return dbi_eval, idx_max_loss, step_optimal, flip -def CS_angle_sgn(dbi_object, d): +def cs_angle_sgn(dbi_object, d): """Calculates the sign of Cauchy-Schwarz Angle $$_{HS}$$""" norm = np.trace( np.dot( From 2fb84d4b6c2ea6d8c253906e87847f8a500f94df Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 13 Feb 2024 08:13:28 +0800 Subject: [PATCH 40/48] Update name change in commit 4f148b81919f419e8ba72c0f46421fe2dfef9f54 to fix lint error --- src/qibo/models/dbi/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 0adcb4be1f..6dd4b5de51 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -101,7 +101,7 @@ def select_best_dbr_generator( for i, d in enumerate(d_list): # prescribed step durations dbi_eval = deepcopy(dbi_object) - flip_list[i] = 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.hyperopt_step( From 138e133ec46fca8b17fa4398ab7bf16f9286f0bb Mon Sep 17 00:00:00 2001 From: Matteo Robbiati <62071516+MatteoRobbiati@users.noreply.github.com> Date: Tue, 13 Feb 2024 10:06:38 +0100 Subject: [PATCH 41/48] Apply suggestions from code review --- src/qibo/models/dbi/utils.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 6dd4b5de51..461e660b78 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -37,7 +37,7 @@ def generate_Z_operators(nqubits: int): 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) """ - # list of tupples, e.g. ('Z','I','Z') + # list of tuples, e.g. ('Z','I','Z') combination_strings = product("ZI", repeat=nqubits) output_dict = {} @@ -52,7 +52,7 @@ def generate_Z_operators(nqubits: int): def str_to_symbolic(name: str): - """Converts string into symbolic hamiltonian + """Convert string into symbolic hamiltonian. Example: .. testcode:: @@ -80,15 +80,15 @@ 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. + 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. - 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. + 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. Returns: The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. @@ -153,7 +153,7 @@ def select_best_dbr_generator( def cs_angle_sgn(dbi_object, d): - """Calculates the sign of Cauchy-Schwarz Angle $$_{HS}$$""" + """Calculates the sign of Cauchy-Schwarz Angle :math:`\\langle W(Z), W({\\rm canonical}) \\rangle_{\\rm HS}`.""" norm = np.trace( np.dot( np.conjugate( From 056830fff9eedef0da2003a638ce4dbd30b6e3b8 Mon Sep 17 00:00:00 2001 From: Matteo Robbiati <62071516+MatteoRobbiati@users.noreply.github.com> Date: Tue, 13 Feb 2024 10:07:18 +0100 Subject: [PATCH 42/48] Update tests/test_models_dbi_utils.py --- tests/test_models_dbi_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index 89e2ce9b0d..cd9f74e9de 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -17,7 +17,7 @@ @pytest.mark.parametrize("nqubits", [3, 4, 5]) -def test_generate_Z_operators(nqubits): +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) From d994b4ab62a1d753b992acf0eb90b68cbf8d5323 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 19 Feb 2024 13:22:41 +0100 Subject: [PATCH 43/48] argmin + renamed variable --- src/qibo/models/dbi/utils.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 461e660b78..4ae62b8322 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -41,10 +41,10 @@ def generate_Z_operators(nqubits: int): combination_strings = product("ZI", repeat=nqubits) output_dict = {} - for op_string_tup in combination_strings: + for zi_string_combination in combination_strings: # except for the identity - if "Z" in op_string_tup: - op_name = "".join(op_string_tup) + if "Z" in zi_string_combination: + op_name = "".join(zi_string_combination) tensor_op = str_to_symbolic(op_name) # append in output_dict output_dict[op_name] = SymbolicHamiltonian(tensor_op).dense.matrix @@ -136,9 +136,7 @@ def select_best_dbr_generator( optimal_steps.append(step_best) norms_off_diagonal_restriction.append(dbi_eval.off_diagonal_norm) # find best d - idx_max_loss = norms_off_diagonal_restriction.index( - min(norms_off_diagonal_restriction) - ) + 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) From d2d678c488fac2a96734a89c7c27a2c3ff1634fe Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 19 Feb 2024 13:25:36 +0100 Subject: [PATCH 44/48] complete sentence in docstrings --- src/qibo/models/dbi/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 4ae62b8322..285c268590 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -77,7 +77,7 @@ def select_best_dbr_generator( compare_canonical: bool = True, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.single_commutator, ): - """Selects the best double bracket rotation generator from a list and runs the + """Selects the best double bracket rotation generator from a list and execute the rotation. Args: dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. From d1d242ed95d04ab3c440242a5abea6a650a2f0a0 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 19 Feb 2024 14:11:39 +0100 Subject: [PATCH 45/48] rm mode since not used --- src/qibo/models/dbi/utils.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 285c268590..688648329b 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -75,7 +75,6 @@ def select_best_dbr_generator( step_max: float = 1, max_evals: int = 200, compare_canonical: bool = True, - mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.single_commutator, ): """Selects the best double bracket rotation generator from a list and execute the rotation. @@ -88,7 +87,6 @@ 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. @@ -96,12 +94,11 @@ def select_best_dbr_generator( norms_off_diagonal_restriction = [ dbi_object.off_diagonal_norm for _ in range(len(d_list)) ] - optimal_steps = [0 for _ in range(len(d_list))] - flip_list = [1 for _ in range(len(d_list))] + optimal_steps, flip_list = [], [] for i, d in enumerate(d_list): # prescribed step durations dbi_eval = deepcopy(dbi_object) - flip_list[i] = cs_angle_sgn(dbi_eval, d) + flip_list.append(cs_angle_sgn(dbi_eval, d)) if flip_list[i] != 0: if step is None: step_best = dbi_eval.hyperopt_step( @@ -115,7 +112,7 @@ def select_best_dbr_generator( else: step_best = step dbi_eval(step=step_best, d=flip_list[i] * d) - optimal_steps[i] = step_best + optimal_steps.append(step_best) norms_off_diagonal_restriction[i] = dbi_eval.off_diagonal_norm # canonical if compare_canonical is True: From 677d2d5dfd1f8e955af5241eb9442ec341ac237c Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 19 Feb 2024 14:11:56 +0100 Subject: [PATCH 46/48] lightening tests --- tests/test_models_dbi_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index cd9f74e9de..cd7f9e4627 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -16,7 +16,7 @@ """Number of steps for evolution.""" -@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("nqubits", [2, 3]) def test_generate_Z_operators(backend, nqubits): h0 = random_hermitian(2**nqubits) dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0)) @@ -30,7 +30,7 @@ def test_generate_Z_operators(backend, nqubits): assert norm_diff < 1e-3 -@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("nqubits", [2, 3]) @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) From 18f70c3cd9818e6ae17c55f57cf0e83544d627e1 Mon Sep 17 00:00:00 2001 From: Matteo Robbiati <62071516+MatteoRobbiati@users.noreply.github.com> Date: Mon, 19 Feb 2024 13:14:16 +0000 Subject: [PATCH 47/48] Update src/qibo/models/dbi/double_bracket.py --- src/qibo/models/dbi/double_bracket.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index f9248bc469..512df0069c 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -101,7 +101,7 @@ def off_diag_h(self): @property def off_diagonal_norm(self): - r"""Hilbert Schmidt norm of off-diagonal part of H matrix: \Tr(\sqrt{A^\dag A})""" + r"""Hilbert Schmidt norm of off-diagonal part of H matrix, namely :math:`\\text{Tr}(\\sqrt{A^{\\dagger} A})`.""" off_diag_h_dag = self.backend.cast( np.matrix(self.backend.to_numpy(self.off_diag_h)).getH() ) From 0ff852b39edae28728e0681f24a0560f9a18f005 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 19 Feb 2024 14:19:28 +0100 Subject: [PATCH 48/48] rm unused imports --- src/qibo/models/dbi/utils.py | 3 +-- tests/test_models_dbi_utils.py | 1 - 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 688648329b..27a92e8cb6 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -6,8 +6,7 @@ from hyperopt import hp, tpe from qibo import symbols -from qibo.config import raise_error -from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian +from qibo.hamiltonians import SymbolicHamiltonian from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index cd7f9e4627..a05266e1de 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -3,7 +3,6 @@ import numpy as np import pytest -from qibo import set_backend from qibo.hamiltonians import Hamiltonian from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType,