From b4d515c68b358c00d5c22705f4f5eb8dfd2629e8 Mon Sep 17 00:00:00 2001 From: James Nelson Date: Mon, 19 Jan 2026 10:26:33 +0000 Subject: [PATCH 01/10] init --- examples/gate_based.ipynb | 130 ++++++++++++++++++++++++++++++++++++++ qse/__init__.py | 1 + qse/gate_based.py | 41 ++++++++++++ qse/qbits.py | 41 +++++++++++- 4 files changed, 212 insertions(+), 1 deletion(-) create mode 100644 examples/gate_based.ipynb create mode 100644 qse/gate_based.py diff --git a/examples/gate_based.ipynb b/examples/gate_based.ipynb new file mode 100644 index 00000000..2fbb43ca --- /dev/null +++ b/examples/gate_based.ipynb @@ -0,0 +1,130 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qse\n", + "import numpy as np\n", + "\n", + "from qiskit.quantum_info import SparsePauliOp" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "positions = np.array([\n", + " [0., 0., 0.],\n", + " [0., 1., 0.],\n", + " [1., 0., 0.],\n", + " ])\n", + "\n", + "qbits = qse.Qbits(positions=positions)\n", + "qbits.draw(show_labels=True, radius=\"nearest\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def distance_func(distance, tolerance=0.01):\n", + " \"\"\"\n", + " Simple distance function that only includes nearest neighbours.\n", + " \n", + " This function returns a coefficient of 1.0 if the input distance is approximately 1.0\n", + " (within a specified tolerance), otherwise it returns 0.0.\n", + " \"\"\"\n", + " if np.abs(distance-1) < tolerance:\n", + " return 1.\n", + " return 0." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SparsePauliOp(['ZZI', 'ZIZ'],\n", + " coeffs=[1.+0.j, 1.+0.j])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# simple ZZ coupling\n", + "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", + "\n", + "SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SparsePauliOp(['XXI', 'XIX', 'YYI', 'YIY', 'ZZI', 'ZIZ'],\n", + " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# heisenberg model\n", + "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"X\") + qbits.compute_interaction_hamiltonian(distance_func, \"Y\") + qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", + "\n", + "SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qse_testbed", + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/qse/__init__.py b/qse/__init__.py index 00c108ae..7a452fe2 100644 --- a/qse/__init__.py +++ b/qse/__init__.py @@ -25,5 +25,6 @@ from qse.qbits import Qbits from qse.signal import Signal from qse.visualise import draw +from qse.gate_based import InteractionTerm from qse import calc, lattices, magnetic, utils, visualise # isort: skip diff --git a/qse/gate_based.py b/qse/gate_based.py new file mode 100644 index 00000000..6cfb0c88 --- /dev/null +++ b/qse/gate_based.py @@ -0,0 +1,41 @@ +class InteractionTerm: + """ + Represents an interaction term in a quantum system. + + This class encapsulates an interaction between two qubits, including the type of interaction, + the qubits involved, the coefficient, and the total number of qubits in the system. + + Parameters + ---------- + interaction: str + The type of interaction (e.g., "X", "Y", "Z"). + qubits: tuple + A tuple of two integers representing the indices of the interacting qubits. + coef: float + The coefficient associated with the interaction term. + nqubits: int + The total number of qubits in the system. + """ + def __init__(self, interaction, qubits, coef, nqubits): + self.interaction = interaction + self.qubits = qubits + self.coef = coef + self.nqubits = nqubits + + def to_str(self): + """ + Generates a string representation of the interaction term. + + The string is constructed as a tensor product of identity (I) and interaction operators, + where the interaction operator is placed at the positions specified by `qubits`. + + Returns + ------- + str + A string of length `nqubits`, with "I" at all positions except for the qubits in `qubits`, + which are replaced by the `interaction` operator. + """ + op = ["I"] * self.nqubits + for qi in self.qubits: + op[qi] = self.interaction + return "".join(op) diff --git a/qse/qbits.py b/qse/qbits.py index 7ff6d08d..f1e564c0 100644 --- a/qse/qbits.py +++ b/qse/qbits.py @@ -13,7 +13,7 @@ from qse.qbit import Qbit from qse.visualise import draw as _draw - +from qse.gate_based import InteractionTerm class Qbits: """ @@ -1283,6 +1283,45 @@ def to_pulser(self): return Register.from_coordinates(self.positions[:, :2], prefix="q") + def compute_interaction_hamiltonian( + self, + distance_func, + interaction, + tol = 1e-8, + ): + """ + Compute the interaction Hamiltonian the system of qubits. + + This function constructs a list of interaction terms between pairs of qubits, + based on their distances and a specified interaction type. Only terms with + coefficients above a given tolerance are included. + + Parameters + ---------- + distance_func : callable + A function that takes a distance (float) and returns the interaction coefficient (float). + interaction : str + The type of interaction (e.g., "X", "Y", "Z") for the Hamiltonian terms. + tol : float, optional + Tolerance threshold for including interaction terms. Terms with absolute coefficients + less than `tol` are discarded. Default is 1e-8. + + Returns + ------- + list of InteractionTerm + A list of `InteractionTerm` objects, each representing a non-negligible interaction + between a pair of qubits. + """ + ops = [] + + for i in range(self.nqbits-1): + for j in range(i+1, self.nqbits): + coef = distance_func(self.get_distance(i, j)) + if np.abs(coef) > tol: + ops.append(InteractionTerm(interaction, (i,j), coef, self.nqbits)) + + return ops + def _norm_vector(v): normv = np.linalg.norm(v) From 352853640fbf599fc0fc60eb18776a1bb8f3e0aa Mon Sep 17 00:00:00 2001 From: James Nelson Date: Mon, 19 Jan 2026 14:11:09 +0000 Subject: [PATCH 02/10] prettify --- examples/gate_based.ipynb | 186 +++++++++++++++++++++++++++++++++++++- 1 file changed, 185 insertions(+), 1 deletion(-) diff --git a/examples/gate_based.ipynb b/examples/gate_based.ipynb index 2fbb43ca..1e539973 100644 --- a/examples/gate_based.ipynb +++ b/examples/gate_based.ipynb @@ -1,5 +1,14 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gate based workflow\n", + "\n", + "This notebook shows an example of how a gate based computation (in this case using `qiskit`) could be integrated into `qse`." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -9,7 +18,18 @@ "import qse\n", "import numpy as np\n", "\n", - "from qiskit.quantum_info import SparsePauliOp" + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit.circuit.library import efficient_su2\n", + "from scipy.optimize import minimize\n", + "from qiskit.primitives import StatevectorEstimator, StatevectorSampler\n", + "from qiskit.circuit import QuantumCircuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Create qbits object" ] }, { @@ -39,6 +59,13 @@ "qbits.draw(show_labels=True, radius=\"nearest\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Step 2: Define a distance function to create an interaction Hamiltonian that's based on the geometry of the qubits." + ] + }, { "cell_type": "code", "execution_count": 3, @@ -104,6 +131,163 @@ "\n", "SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])" ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# simple ZZ coupling\n", + "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", + "\n", + "hamiltonian = SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Run in qiskit" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "ansatz = efficient_su2(qbits.nqbits, reps=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_expectation(params):\n", + " \"\"\"Compute the expectation value of a quantum operator using a statevector simulator.\"\"\"\n", + " estimator = StatevectorEstimator()\n", + "\n", + " pub = (ansatz, hamiltonian, params)\n", + " job = estimator.run([pub])\n", + "\n", + " return job.result()[0].data.evs\n", + "\n", + "def run_sampler(params, shots=1000):\n", + " \"\"\"Sample a circuit using a statevector simulator.\"\"\"\n", + " sampler = StatevectorSampler()\n", + "\n", + " circuit = QuantumCircuit(ansatz.num_qubits)\n", + " circuit.append(ansatz, range(ansatz.num_qubits))\n", + " circuit.measure_all()\n", + "\n", + " pub = (circuit, params)\n", + " job = sampler.run([pub], shots=shots)\n", + "\n", + " return job.result()[0].data.meas.get_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "x0 = 2 * np.pi * np.random.rand(ansatz.num_parameters)\n", + "\n", + "cost_hist = []\n", + "opt_result = minimize(\n", + " compute_expectation, x0, method=\"BFGS\", \n", + " callback=lambda intermediate_result: cost_hist.append(intermediate_result.fun)\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 0\n", + " fun: -1.9999999998514726\n", + " x: [ 3.142e+00 4.256e-05 1.335e+00 2.738e+00 2.870e+00\n", + " 3.142e+00 2.291e-07 4.623e-05 1.335e+00 2.106e+00\n", + " 2.334e+00 5.895e+00]\n", + " nit: 13\n", + " jac: [ 9.686e-07 -7.451e-07 7.361e-06 2.980e-08 -2.980e-08\n", + " -3.844e-06 2.086e-07 6.318e-06 -7.302e-06 -5.960e-08\n", + " 2.980e-08 2.980e-08]\n", + " hess_inv: [[ 4.814e-01 -6.394e-03 ... 8.469e-07 1.000e-05]\n", + " [-6.394e-03 7.359e+00 ... -6.725e-06 -4.386e-05]\n", + " ...\n", + " [ 8.469e-07 -6.725e-06 ... 1.000e+00 7.261e-10]\n", + " [ 1.000e-05 -4.386e-05 ... 7.261e-10 1.000e+00]]\n", + " nfev: 195\n", + " njev: 15" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "opt_result" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'011': 1000}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples = run_sampler(opt_result.x, shots=1000)\n", + "samples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Visualize results in qse" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qbits.draw(colouring=list(samples.keys())[0])" + ] } ], "metadata": { From 164843d6df1562441ae59d46320a8c21106b327d Mon Sep 17 00:00:00 2001 From: James Nelson Date: Mon, 19 Jan 2026 14:17:17 +0000 Subject: [PATCH 03/10] nicer --- examples/gate_based.ipynb | 134 +++++++++++++------------------------- 1 file changed, 47 insertions(+), 87 deletions(-) diff --git a/examples/gate_based.ipynb b/examples/gate_based.ipynb index 1e539973..be245d7b 100644 --- a/examples/gate_based.ipynb +++ b/examples/gate_based.ipynb @@ -88,81 +88,49 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "SparsePauliOp(['ZZI', 'ZIZ'],\n", - " coeffs=[1.+0.j, 1.+0.j])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# simple ZZ coupling\n", - "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", - "\n", - "SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "SparsePauliOp(['XXI', 'XIX', 'YYI', 'YIY', 'ZZI', 'ZIZ'],\n", - " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# heisenberg model\n", - "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"X\") + qbits.compute_interaction_hamiltonian(distance_func, \"Y\") + qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", - "\n", - "SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, "outputs": [], "source": [ "# simple ZZ coupling\n", "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", "\n", - "hamiltonian = SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])" + "# We can easily do something more complicated like a Heisenberg model:\n", + "# coupling = \n", + "# qbits.compute_interaction_hamiltonian(distance_func, \"X\") + \n", + "# qbits.compute_interaction_hamiltonian(distance_func, \"Y\") + \n", + "# qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Step 3: Run in qiskit" + "## Step 3: Run in qiskit\n", + "Here we use a simple VQE workflow." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SparsePauliOp(['ZZI', 'ZIZ'],\n", + " coeffs=[1.+0.j, 1.+0.j])\n" + ] + } + ], "source": [ + "hamiltonian = SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])\n", + "print(hamiltonian)\n", "ansatz = efficient_su2(qbits.nqbits, reps=1)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -191,22 +159,7 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "x0 = 2 * np.pi * np.random.rand(ansatz.num_parameters)\n", - "\n", - "cost_hist = []\n", - "opt_result = minimize(\n", - " compute_expectation, x0, method=\"BFGS\", \n", - " callback=lambda intermediate_result: cost_hist.append(intermediate_result.fun)\n", - " )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -215,35 +168,42 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 0\n", - " fun: -1.9999999998514726\n", - " x: [ 3.142e+00 4.256e-05 1.335e+00 2.738e+00 2.870e+00\n", - " 3.142e+00 2.291e-07 4.623e-05 1.335e+00 2.106e+00\n", - " 2.334e+00 5.895e+00]\n", - " nit: 13\n", - " jac: [ 9.686e-07 -7.451e-07 7.361e-06 2.980e-08 -2.980e-08\n", - " -3.844e-06 2.086e-07 6.318e-06 -7.302e-06 -5.960e-08\n", - " 2.980e-08 2.980e-08]\n", - " hess_inv: [[ 4.814e-01 -6.394e-03 ... 8.469e-07 1.000e-05]\n", - " [-6.394e-03 7.359e+00 ... -6.725e-06 -4.386e-05]\n", + " fun: -1.999999999997647\n", + " x: [ 3.142e+00 3.142e+00 3.142e+00 1.755e-01 5.679e+00\n", + " 2.727e-01 6.283e+00 3.142e+00 6.283e+00 5.128e+00\n", + " 5.355e+00 5.985e+00]\n", + " nit: 15\n", + " jac: [-1.416e-06 8.047e-07 -2.086e-07 -2.980e-08 0.000e+00\n", + " -2.980e-08 7.004e-07 -9.239e-07 6.706e-07 -2.980e-08\n", + " -2.980e-08 -1.490e-08]\n", + " hess_inv: [[ 4.856e-01 1.268e-02 ... 8.292e-05 -6.318e-05]\n", + " [ 1.268e-02 9.476e-01 ... -6.280e-06 -8.822e-06]\n", " ...\n", - " [ 8.469e-07 -6.725e-06 ... 1.000e+00 7.261e-10]\n", - " [ 1.000e-05 -4.386e-05 ... 7.261e-10 1.000e+00]]\n", - " nfev: 195\n", - " njev: 15" + " [ 8.292e-05 -6.280e-06 ... 1.000e+00 6.191e-07]\n", + " [-6.318e-05 -8.822e-06 ... 6.191e-07 1.000e+00]]\n", + " nfev: 247\n", + " njev: 19" ] }, - "execution_count": 10, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "x0 = 2 * np.pi * np.random.rand(ansatz.num_parameters)\n", + "\n", + "cost_hist = []\n", + "opt_result = minimize(\n", + " compute_expectation, x0, method=\"BFGS\", \n", + " callback=lambda intermediate_result: cost_hist.append(intermediate_result.fun)\n", + " )\n", "opt_result" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -252,7 +212,7 @@ "{'011': 1000}" ] }, - "execution_count": 11, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -271,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": {}, "outputs": [ { From a80e640915854b1eaac38f183f669c1948c65f72 Mon Sep 17 00:00:00 2001 From: James Nelson Date: Mon, 19 Jan 2026 14:27:59 +0000 Subject: [PATCH 04/10] more interesting geometry --- examples/gate_based.ipynb | 43 ++++++++++++++++++++------------------- 1 file changed, 22 insertions(+), 21 deletions(-) diff --git a/examples/gate_based.ipynb b/examples/gate_based.ipynb index be245d7b..9a872661 100644 --- a/examples/gate_based.ipynb +++ b/examples/gate_based.ipynb @@ -39,7 +39,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -49,10 +49,15 @@ } ], "source": [ + "h = np.sqrt(1 - 0.5*0.5)\n", + "\n", "positions = np.array([\n", " [0., 0., 0.],\n", - " [0., 1., 0.],\n", " [1., 0., 0.],\n", + " [2., 0., 0.],\n", + " [0.5, h, 0.],\n", + " [1.5, h, 0.],\n", + " [2.5, h, 0.],\n", " ])\n", "\n", "qbits = qse.Qbits(positions=positions)\n", @@ -117,8 +122,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "SparsePauliOp(['ZZI', 'ZIZ'],\n", - " coeffs=[1.+0.j, 1.+0.j])\n" + "SparsePauliOp(['ZZIIII', 'ZIIZII', 'IZZIII', 'IZIZII', 'IZIIZI', 'IIZIZI', 'IIZIIZ', 'IIIZZI', 'IIIIZZ'],\n", + " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n" ] } ], @@ -168,21 +173,17 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 0\n", - " fun: -1.999999999997647\n", - " x: [ 3.142e+00 3.142e+00 3.142e+00 1.755e-01 5.679e+00\n", - " 2.727e-01 6.283e+00 3.142e+00 6.283e+00 5.128e+00\n", - " 5.355e+00 5.985e+00]\n", - " nit: 15\n", - " jac: [-1.416e-06 8.047e-07 -2.086e-07 -2.980e-08 0.000e+00\n", - " -2.980e-08 7.004e-07 -9.239e-07 6.706e-07 -2.980e-08\n", - " -2.980e-08 -1.490e-08]\n", - " hess_inv: [[ 4.856e-01 1.268e-02 ... 8.292e-05 -6.318e-05]\n", - " [ 1.268e-02 9.476e-01 ... -6.280e-06 -8.822e-06]\n", + " fun: -4.999999999949555\n", + " x: [ 1.239e-06 2.015e-07 ... 1.955e+00 4.587e+00]\n", + " nit: 22\n", + " jac: [ 2.503e-06 6.557e-07 ... 0.000e+00 1.192e-07]\n", + " hess_inv: [[ 5.229e-01 1.887e-02 ... -2.939e-04 -6.162e-05]\n", + " [ 1.887e-02 1.047e+00 ... -4.146e-04 -1.414e-04]\n", " ...\n", - " [ 8.292e-05 -6.280e-06 ... 1.000e+00 6.191e-07]\n", - " [-6.318e-05 -8.822e-06 ... 6.191e-07 1.000e+00]]\n", - " nfev: 247\n", - " njev: 19" + " [-2.939e-04 -4.146e-04 ... 1.000e+00 6.489e-07]\n", + " [-6.162e-05 -1.414e-04 ... 6.489e-07 1.000e+00]]\n", + " nfev: 600\n", + " njev: 24" ] }, "execution_count": 7, @@ -209,7 +210,7 @@ { "data": { "text/plain": [ - "{'011': 1000}" + "{'010101': 1000}" ] }, "execution_count": 8, @@ -236,7 +237,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -246,7 +247,7 @@ } ], "source": [ - "qbits.draw(colouring=list(samples.keys())[0])" + "qbits.draw(colouring=list(samples.keys())[0], radius=\"nearest\")" ] } ], From d4f5238de4dcf21e996abcc4eaff83fb79e475a1 Mon Sep 17 00:00:00 2001 From: James Nelson Date: Wed, 28 Jan 2026 20:14:21 +0000 Subject: [PATCH 05/10] 2nd structure --- examples/gate_based.ipynb | 359 ++++++++++++++++++++++++++++++++++---- qse/__init__.py | 3 +- qse/gate_based.py | 47 +++-- qse/qbits.py | 4 +- 4 files changed, 361 insertions(+), 52 deletions(-) diff --git a/examples/gate_based.ipynb b/examples/gate_based.ipynb index 9a872661..8f5345ed 100644 --- a/examples/gate_based.ipynb +++ b/examples/gate_based.ipynb @@ -11,12 +11,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "import qse\n", "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "\n", "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit.circuit.library import efficient_su2\n", @@ -34,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -64,6 +65,80 @@ "qbits.draw(show_labels=True, radius=\"nearest\")" ] }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist([i for i in qbits.get_all_distances().flatten() if i > 0.01])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "h = np.sqrt(1 - 0.5*0.5)\n", + "\n", + "positions = np.array([\n", + " [0., 0., 0.],\n", + " [-h, -0.5, 0.],\n", + " [-h, 0.5, 0.],\n", + " [1., 0., 0.],\n", + " [1+h, -0.5, 0.],\n", + " [1+h, 0.5, 0.],\n", + " ])\n", + "\n", + "qbits = qse.Qbits(positions=positions)\n", + "qbits.draw(show_labels=True, radius=\"nearest\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist([i for i in qbits.get_all_distances().flatten() if i > 0.01])\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -73,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -91,13 +166,30 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[1.00 Z0 Z1,\n", + " 1.00 Z0 Z2,\n", + " 1.00 Z0 Z3,\n", + " 1.00 Z1 Z2,\n", + " 1.00 Z3 Z4,\n", + " 1.00 Z3 Z5,\n", + " 1.00 Z4 Z5]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# simple ZZ coupling\n", "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", - "\n", + "coupling\n", "# We can easily do something more complicated like a Heisenberg model:\n", "# coupling = \n", "# qbits.compute_interaction_hamiltonian(distance_func, \"X\") + \n", @@ -105,6 +197,60 @@ "# qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n" ] }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.00 X0, 1.00 X1, 1.00 X2, 1.00 X3, 1.00 X4, 1.00 X5]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ext_field = [qse.Operator(\"X\", i, 1.0, qbits.nqbits) for i in range(qbits.nqbits)]\n", + "ext_field" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.00 Z0 Z1,\n", + " 1.00 Z0 Z2,\n", + " 1.00 Z0 Z3,\n", + " 1.00 Z1 Z2,\n", + " 1.00 Z3 Z4,\n", + " 1.00 Z3 Z5,\n", + " 1.00 Z4 Z5,\n", + " 1.00 X0,\n", + " 1.00 X1,\n", + " 1.00 X2,\n", + " 1.00 X3,\n", + " 1.00 X4,\n", + " 1.00 X5]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hamiltonian = coupling + ext_field\n", + "hamiltonian" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -115,27 +261,28 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "SparsePauliOp(['ZZIIII', 'ZIIZII', 'IZZIII', 'IZIZII', 'IZIIZI', 'IIZIZI', 'IIZIIZ', 'IIIZZI', 'IIIIZZ'],\n", - " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n" + "SparsePauliOp(['ZZIIII', 'ZIZIII', 'ZIIZII', 'IZZIII', 'IIIZZI', 'IIIZIZ', 'IIIIZZ', 'XIIIII', 'IXIIII', 'IIXIII', 'IIIXII', 'IIIIXI', 'IIIIIX'],\n", + " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", + " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n" ] } ], "source": [ - "hamiltonian = SparsePauliOp([i.to_str() for i in coupling], [i.coef for i in coupling])\n", - "print(hamiltonian)\n", + "hamiltonian_qiskit = SparsePauliOp([i.to_str() for i in hamiltonian], [i.coef for i in hamiltonian])\n", + "print(hamiltonian_qiskit)\n", "ansatz = efficient_su2(qbits.nqbits, reps=1)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -143,7 +290,7 @@ " \"\"\"Compute the expectation value of a quantum operator using a statevector simulator.\"\"\"\n", " estimator = StatevectorEstimator()\n", "\n", - " pub = (ansatz, hamiltonian, params)\n", + " pub = (ansatz, hamiltonian_qiskit, params)\n", " job = estimator.run([pub])\n", "\n", " return job.result()[0].data.evs\n", @@ -164,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -173,20 +320,20 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 0\n", - " fun: -4.999999999949555\n", - " x: [ 1.239e-06 2.015e-07 ... 1.955e+00 4.587e+00]\n", - " nit: 22\n", - " jac: [ 2.503e-06 6.557e-07 ... 0.000e+00 1.192e-07]\n", - " hess_inv: [[ 5.229e-01 1.887e-02 ... -2.939e-04 -6.162e-05]\n", - " [ 1.887e-02 1.047e+00 ... -4.146e-04 -1.414e-04]\n", + " fun: -6.839109873659719\n", + " x: [ 2.817e+00 1.829e-01 ... 2.883e+00 7.040e+00]\n", + " nit: 130\n", + " jac: [-6.557e-07 1.311e-06 ... 3.278e-06 5.245e-06]\n", + " hess_inv: [[ 4.449e-01 8.411e-02 ... -9.078e-03 -4.828e-02]\n", + " [ 8.411e-02 4.946e-01 ... -5.601e-02 2.424e-01]\n", " ...\n", - " [-2.939e-04 -4.146e-04 ... 1.000e+00 6.489e-07]\n", - " [-6.162e-05 -1.414e-04 ... 6.489e-07 1.000e+00]]\n", - " nfev: 600\n", - " njev: 24" + " [-9.078e-03 -5.601e-02 ... 7.439e+01 -2.515e+01]\n", + " [-4.828e-02 2.424e-01 ... -2.515e+01 3.082e+02]]\n", + " nfev: 3600\n", + " njev: 144" ] }, - "execution_count": 7, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -204,16 +351,67 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'010101': 1000}" + "{'101001': 49,\n", + " '100011': 124,\n", + " '110011': 79,\n", + " '101010': 76,\n", + " '110001': 66,\n", + " '010101': 10,\n", + " '111111': 4,\n", + " '110010': 72,\n", + " '010011': 25,\n", + " '100101': 13,\n", + " '100110': 8,\n", + " '100010': 80,\n", + " '010010': 17,\n", + " '101011': 88,\n", + " '100001': 72,\n", + " '101100': 4,\n", + " '010001': 17,\n", + " '001010': 3,\n", + " '111010': 10,\n", + " '111001': 10,\n", + " '111101': 6,\n", + " '110000': 12,\n", + " '000011': 10,\n", + " '111011': 15,\n", + " '110111': 10,\n", + " '001001': 7,\n", + " '100111': 3,\n", + " '111110': 1,\n", + " '110110': 4,\n", + " '101110': 6,\n", + " '001011': 8,\n", + " '110101': 16,\n", + " '100000': 11,\n", + " '010000': 4,\n", + " '101101': 15,\n", + " '011010': 2,\n", + " '000001': 1,\n", + " '101000': 8,\n", + " '011000': 1,\n", + " '000010': 5,\n", + " '101111': 6,\n", + " '011001': 2,\n", + " '100100': 4,\n", + " '010110': 1,\n", + " '011011': 3,\n", + " '110100': 4,\n", + " '000101': 2,\n", + " '001000': 1,\n", + " '001101': 1,\n", + " '001111': 1,\n", + " '111000': 2,\n", + " '000000': 1}" ] }, - "execution_count": 8, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -223,6 +421,34 @@ "samples" ] }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'100011': 124,\n", + " '110011': 79,\n", + " '101010': 76,\n", + " '110001': 66,\n", + " '110010': 72,\n", + " '100010': 80,\n", + " '101011': 88,\n", + " '100001': 72}" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples_top = {i:j for i,j in samples.items() if j > 50}\n", + "samples_top" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -232,12 +458,82 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAD0CAYAAACGoBLMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQfpJREFUeJzt3Qd4VGW6B/B3kkwakBASWoBQAhKkhBqaNFlRYCkurFiwsILgoq5ruQv38eqq18vqZdVFcbFhhUWBRRfEtVGlg/QaCBI6pBBCejLnPv+XnNwBUybJTGYm8/8991yYyQk7npyc857ve7/3tRiGYQgRERERlcuv/C8TEREREYMmIiIiIgdxpImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIjIAQGO7OTLbDabnDlzRurVqycWi8XdH4eIiIgcgDKUmZmZEh0dLX5+zhkjYtBUAQRMLVq0cMrBJiIiopp18uRJad68uVP+LQZNFcAIk3nQw8LCqnSQk/adlfnPfC1XTqRLYF6BhNoMsYoIxq1Qjr1ARLL9LJIfZJW6LSPkd/89XNp0alql/y0iIiJPtC/prDwz/2s5cSVd8gILxBZqyPU3Q79siwTlW6Vl3Qj5798Nl05tqn4vvHz5sg56mPdxZ7CwjUrFBz08PFwyMjKqFDQd23NG5kxfKrbkdAkrMqSOIRIiIkHFCWU2EckTkRwRybKIXPa3iF9MhDw2d5zEdomu8g+WiIjIU+w5dkamz1kqybZ0KQozxKgjZd4MLVki/pctEuMXIXMfGyddYqPdcv8uDRPBXSgjNUvmPbVcA6aIQkMiDZGGIhIlV/80N/M1vo79sP+8p5fr9xMREXmz1IwseWrecg2YCiMMMSKl3Jshvo79sP/T85br93sKBk0utHnlQck8nqYjTPVFJKJ4iyxlM7+G/bB/ZlKqbPn6kCs/HhERkcut3HxQjmem6QhTZW6G2D8pM1W+3uI590IGTS5SVGiTdUt2S1BegU7JYUYVW3hxYGSeN+bf8b65D/YPyiuUtUt2679DRETkjQqLbLJk3W7JCyq4OiVXiZsh9s8LKpQla3frv+MJGDS5yMGtyZJ6NEWTvjFtGywioQiI7M4Xc9NAqfjr2A/7h9gMSU28KIe2JbvqIxIREbnU1oPJcjQ15WrSdxVuhrYQQxJTL8q2Q55xL2TQ5CIXTl4SS4FNFwYEFf/8zQ3nQ11MwxX/aZ4f5ob9A/GPFNj03yEiIvJGJy9ckgKLTapzMywQm/47noAlB1wkL6dAl1BaiiNTc/Mv3qx2B998z34/fJ/FMCQ3GwUJiIiIvE9OXoFWE6jOzdCwGJKd6xn3QgZNLhIUYr36wy5eSWluRcWb+eMvsHvPfj98n2GxSHAozigiIiLvExJk1XipOjdDi2GR0GDPuBcyaHKRRi3qi2H10/MApSdy7TbzR+9ffH5kX/d17J+PHax++u8QERF5oxaN6ovV8Lt6U6vizdAqfvrveAIGTS7SISFGIttGyZWdpyWnyNCff7bdOVJgd57ga1l250t28ev6bSIkrleMqz4iERGRS/WKayHRIXUkIyv32pucIzfDHBG/HIu0i2woveI8417IRHAX8Q/wk4Hj4yUvyKqVvjPl6pYhIpeKt3S7v+N9cx+cM1n+InlhF2Tjpg1SWFjoqo9JRETkEufPn5d/LFwgDYpSxV9vbFKpmyEqgwflBcj4QfES4O8Z4QpHmlyoz4gO8v0nO+Ty4fPiX6ipcFJY3DIl2K5yvDkSmVl8zqCVikT5S90WhbJq1Sr56aef5JZbbpEOHTqIxaKzw0RERB4pOztbVq9eLTt27BDDMKRthJ8k54fImcxsKQy4ei905GaIVipt6kXK8N5x4inYe86De89lW1Llu+++k8xMnEEirVq1kltvvVWaNGlStZ82ERGRixQVFcn27dtlzZo1kpuL6Ef0YR8P/SfTcqrUe+6tx8ZL59imHtN7jkFTDRx0BE7oJZeZlKYVwlG40lpcjgD/D/lxOX4WyQsKkHptImXa7NES2/nqSZKfny8bNmyQjRs36jQdRpq6d+8uQ4YMkTp1cNYRERG519GjR+Wbb76RlJQUfd24cWO57bbb9GHfvmkvesklZaZphXAUrjSQ22Qpvh/mX81hwpQcRphmTxtd5YAJGDS5gbMOOprvopfc2sW7JDUxRfKzcvUksQZaRQL9JbJdQxk0Pl56D4+T8MhfBkOXLl2S77//Xvbv36+vg4KCZPDgwdKrVy/x90cWHRERUc1KTU2Vb7/9Vo4cOaKvQ0ND9aEeD/d+fr/MQ0LzXfSSW7x2lySmpkhWfq5GTIFWqwSKvyZ9I4cJU3KR4dUbGGDQ5AbOPujoJbd3Y5J88PYCsRWIjL59pES3itJVckger8iJEyfk3//+t5w7d05fR0VF6ZRd27Ztq/3ZiIiIHJGbmyvr1q2TLVu2iM1m0wApISFBBg0aJMHBSFQqH3rJbdybJG9/sADNL+T20SOlVXSUrpJzVtK3K4ImJoLXMARGN/aJkQarr74eNK6LBAZq0xSHtGzZUqZMmSI7d+7UJHEMhS5YsEDatWsnw4YN0yCKiIjIFWw2m+zatUvvP1lZWA4n+tCOh/fK3H8QGPW5MUZWN7j6etygyt0L3YVBkxdCRN+jRw/p2LFjSaSfmJgox44dq1SkT0RE5Kjk5GSd6Th79qy+joyM1GAJD+2+gkGTF0NghNElzB1jThmB0+bNm2XPnj1y8803S7du3UqdUyYiInIUprewknu/XU4tHs7xkO5rObVed0edO3euZuMjYOjdu7ds3brVoe9btGiRrjwbO3as1DYYEr377rvlnnvu0b+jRsaKFSvknXfekZ9//tndH4+IiLxQQUGBlg948803SwKm7t27y6OPPip9+/b1uYDJ60aaPvvsM3niiSdk3rx5GjC9/vrrOjR4+PBhadSoUZnfh8DhqaeekgEDBkhthnnl1q1by7Zt2/RERzXWjz76SG688Uatk1G/vmf07iEiIs+FgpQIkjC6hGRqM5/2tttu8/k6gV4VNL366quaBD1p0iR9jeDpq6++kvnz58uMGTPKLLaFEZjnn39e1q9fr0v3azNE/n369JHOnTtrRVZUEz9w4IAuB+3Xr5/079/fK5LtiIio5p05c0bzlk6ePKmvsfoMaSDsSOFlQROKPKIk+8yZM0veQ77Or371K9m0aVOZ3/fCCy/oKNSDDz6oQVNF8vLydDOZUba3QeHLX//611rHCb8AGG1D0jhW3eGYIahiSxYiIoIrV67IDz/8oCvjwGq1yk033aTTcPg7eVnQhKX1GDVClVF7eH3o0KFSv+fHH3+U999/v+QkcMSsWbN0VKq2wPG577779BghWRwjbcuWLdMpPAy1NmvWzN0fkYiI3ASdJrACGw/VGJwAPFTj4dpZtY1qE68JmioL/druvfdeeffddytVOwIjWcibsh9patGihXgzjChhaBXLQjEqhxG3U6dOyXvvvSddu3bVlXb16tVz98ckIqIazFtC2gZan6Snp+t70dHR+jDt7fc8V/KaoAmBD/J1kNxsD69La2CLmkWYkho1atQ1RbkgICBAk8djY2N/8X1YSomtNsJ/N5LhEShhGHb37t06CoecJ7yPXCjsQ0REtdeFCxc0WEpKStLXdevWlaFDh0p8fDzTNirgNXdIJC+joCNu9mbZAARBeP3II4/8Yv+4uDjZu3fvNe8988wzOgL1t7/9zacjaYwq4Rj27NlT851Onz6txxFJ40j4a9++PX9xiIhqmZycHF0gtH37dh1pMhcO4aG5tg4W+GzQBJg2u//++/Vmj6JaKDmAMu7majrk7iBHB3lJqOPUqVOna77fXHJ//fu+qnnz5pogj2KYaAaMIVqUdUDZAgzRllfGgYiIvAMGGBAooRQNAidzYAEPyREREe7+eF7Fq4KmCRMmyMWLF+XZZ5/VhrWYZsJIiZkcjhLvrIBd+XwnDMki5wmJ8xs3bpTjx49rOQeM7KFbNbpWExGR98EUHO6TuHcCHoZR37BNmzbu/mheyauCJsBUXGnTcYAoujwffvihiz6V98P0p9l6BQXNDh48qE8m+/btk8GDB+voni9WfyUi8kZpaWm6Yhr5uxASEqIPwXgY5uCCDwVN5FoYqr3jjjt0tAmJgki0x1MKamTh6aS05HkiIvIMqDOIFdLoQ4oyPZhNQL0+PPwicKLqYdBEpUJe00MPPaTJ4atWrdKh3U8//VRuuOEGnQdHd2siIvIMSOzGimgs6kGhSsBDLh52GzZs6O6PV2swaKIyYQgX03IdO3aUtWvXakFM1PU4evSorrgYOHAgV1wQEbkZWp5gRgAtUKBBgwYaLKE2Hzs/OBeDJqoQhnSxmg4BFKbsEDQhYRxPNciDQkI+58iJiGoWii9j5bNZXge5qYMGDdLV5ay55xoMmqhSBUbR/DgxMVGDp9TUVFm+fLkmjCOoiomJ4dEkInKxgoICfXDdsGGD/h2wiAcPsShUSa7DoIkqDUO+WK66detWnbY7e/asfPDBB1r/Cv2K0BWbiIicn7eEDg5Y4ZyRkaHv4WEVD61Nmzbl4a4BDJqoSlB+AN2vu3TpooniSBhHeQI0Bu7fv79u7IxNROQceDhF3hLqEQKa6d5yyy2ac8q8pZrDoImqpU6dOtrfz8x3OnHihI4+7dy5k7/QRETVhK4XWBGHayogV4kPpu7DoImcAkPDaHFjP3S8dOlSncLD0DG6ZxMRkWNQY2nLli2ybt06rb0ETIFwPwZN5DQYIsZQMWo5bdq0SduyYCnsu+++qyvs0EWbSYpEROXnLZmLbVDV23wo5WIbz8CgiZwOuUyo4YRAyVwOu2vXLh2Fwvu9e/fmclgiouugiDBan6Csi5n+gIdNXEuZt+QZGDSRyyBR8Te/+Y2W8DcLryGIQtI4qopjRIoXAiLydTk5OZoLinQGjDSh7h0LCHsmBk3kci1atJDJkyeXlPjHkPOiRYu0bAGq1qLrNhGRr7HZbCWtqhA4Qfv27XURDVtVeSYGTVQjMKKEIeYOHTqUNJNMSkqSefPmsZkkEfkcNEXHCPyFCxf0NfrDsSm652PQRDUqKChIC2B2795dV9mhrhOGpJH3NGTIEOnRowdbshBRrZWenq7XvoMHD+rr4OBgvfahbAvbUXk+Bk3kFmgoOWHCBB1twioRPG2tXLlSW7LgaQtTd0REtUV+fr6OsmNlMcoJYPQdgdLgwYMlNDTU3R+PHMSgidwKwdHUqVNlx44dsnr1ag2ePvnkE4mLi9N5fQRXRETeConde/bs0UUwV65c0fdat26tJQSYz+l9GDSR22FIGivsULhtzZo1sm3bNp22Q60SrCAZMGCATusREXmTU6dOad7S6dOn9XVERISuHEayN1cOeycGTeQxQkJCZPjw4ZrXhCk7TN2hizdW3aFWSXx8PC80ROTxLl++rCuFMcIEgYGB+vCHh0C0QSHvxZ8eeRwMWU+cOFGOHDmihd5QouDLL7/UESgMaaOEARGRpykoKCjphoC/A1YN33zzzVKvXj13fzxyAgZN5JEwdI0h7NjY2JL+SyiOOX/+fOncubOuwEPxTCIiT8hbwmo4rIq7dOmSvte8eXN9yGvWrJm7Px45EYMm8mhmR29MzaEAHDp9ozwBcp7wfr9+/bRtCxGRO5w7d07TCX7++Wd9jRElLGJBjibzlmofP/Eyc+fOlVatWmltC/QwQ42fsqBRLOaRkXyHDaMT5e1PnguNfkePHi1TpkzR6TkMfSNpHOfD/v379UmPiKimZGVlyYoVK+Sdd97RgAkPeOit+cgjj+hoOAOm2smrRpo+++wzeeKJJ7SKNAKm119/XWv6HD58uNSlm7ip3nXXXToagSDr5Zdf1pULuMlyyNQ7RUdHy6RJk/RniKHwjIwMWbJkicTExOhQOLqBExG5CmosIb8S95e8vDx9r2PHjvpQXr9+fR74Ws5ieNEjOgIlLE1/8803S/r2YNTh0UcflRkzZjh0smPECd9/3333ObwKIjw8XG/OzsqhQZGzWbNm6d9nzpypKyuo8jDahNV12AoLC/U9VBpH0iW6gxMRORPKoGBxSkpKir5u0qSJPqy1bNmSB9oD74WuuH8HeNPBRQFEHFj7+j6I7rFawRHZ2dl6oy2vYCKeHMynB/Ogk2dCLhOq6Xbr1k0Lx+3bt0+bX2IUatCgQZKQkCD+/v7u/phE5OUQJCFYQtAEqOCNhzNce9j6xLcEeNNJi5Gixo0bX/M+XiMp2BF/+tOfdHoHgVZZEPU+//zz1f68VHPwJDFu3DgdhUQhubNnz+oFDkE2pm/btWvHHwcRVVpubq6sXbtWc2Exs4EACTMeyF1Cygf5Hq8JmqrrL3/5iyxatEjnocs72TGShbwp+5Em1gXyDshrmjx5shbDRGG51NRUWbhwobRt21Zz2dBFnIioIgiQsFIXK3YxQwF4+MJ1JCoqigfQh3lN0IQTFVMt58+fv+Z9vMa8cnlmz56tQROmcLp06VLuvmjXwZYd3gtPghgyv/HGG7W20+bNm+Xo0aNaXRwjUZi2Q+VxIqLSYCUcRqzNew3uPRixxsMXkdcETUgQQ3sNjCCMHTu25GkAr7HEsyyvvPKKvPTSS1pHAx2lyTcg8EWtFCSGY6oO1cVRJBNtDZCLgPeZi0BEJhSlxIrcAwcOlFxDkDOJhy3mRpLXBU2AabP7779fgx8k+aLkAGplYAk6YEUcSgmY2fgoMfDss8/qFA1qO6EImVnzBxvVfpGRkVp24tixYxo4X7x4Ub766ivZvn27Pj2i2zgR+S4sMkLbEywowipc1FfCQ9WQIUO4Cpe8O2iaMGGC3vQQCCEAQk8fDKOayeHJycnXjB78/e9/11+I8ePHX/PvPPfcc/LnP/+5xj8/uQ/asUydOlWDJeS1Yej9448/lg4dOuiIFEpREJHvQLUddBdA2kZmZqa+h4drlBC4fsERkVcGTYCpuLKm43AztGeWtScCDLFj5Quq9eJcQQCFflGYuuvbt69Wj2fNLKLa7/Tp0/rAferUKX2NopRI8o6Li2Mlb6pdQRNRdaHGyogRIzRHDlN2x48f1+H5Xbt2aTkKLBZgCwSi2gcjSlgRh991s9YbHpbw0IQ2KEQV4VlCPgtD8Pfee6+24UGyeHp6unzxxRfaIgFD9OhSTkTeD7lKWEm7fv16TdkANAEfOnSoNtglchSDJvJpGFHCkDyWE5sXVQzdv//++zrihJEnXlSJvDdvyf6hCLBYiA9FVFUMmojwixAQIDfddJM+fZrD9yhPgJwnDt8TeR8s9jCn3wErpjn9TtXFoInIDkaVxowZo2UtzERRBFHoaYdVdlhtx3wnIs+FCt6rV6/WNkoYacICkH79+ulDERd6UHUxaCIqBYbwf/e732kTYBS8Q+G7xYsXc0kykYdCb1KzpAh6xgFLipCzMWgiKgNGlFCeoH379rJhwwbZuHGjlrF4++23WfyOyIPYF681F3kgbwl1l4iciUETUQUwpI/qwOhph0J4+/fv16F//IledmyzQOQeaMpttkkC9JVkmyRyJQZNRA5CATxUl0eQhHwnVKXH0y0CKDb0JKo5eXl5JQ250YMUnSDYkJtqAoMmokpq2bKlTJkyRXbu3KlJ4ikpKbJgwQJp166dBk/od0dEzocACStb8XuHvqOAciH4vYuKiuIhJ5dj0ERUBXiyRUXxjh07ytq1a2Xr1q2SmJiouRVoJo1pu+DgYB5bIidBb1GM8J49e1Zf4+EEwRIeVohqCoMmompAYIQLNwIo5FYgcMKUAWo8IbcCeVD2TaSJqHIyMjJ0BStyCCEoKEgfSvBwgnICRDWJQRORE2Bq4O6779agCXlOSFBdsWKFLoHGKh5M6RGR4woKCnTVKja0QYHu3bvrw0idOnV4KMktGDQRORGmCtq0aaP961AvBsniH374odx4441aHBPJ5ERUNhSkxKgSRpcuX76s7+GhAyO6TZs25aEjt2LQRORkmDLo06eP1nhCZWJUEz9w4IAui0Zl4v79+7MyMVEpzpw5o3lLJ0+e1Nfh4eEybNgwVuInj8GgichFMIXw61//WluyYMoOhTGxTBqr7tADC0EVW7IQiVy5ckV++OEHXRkHVqtV25707dtX/07kKRg0EblYkyZN5L777tPmv2ZLlmXLlukUHvKd0LKFyBchV2nLli36MJGfn6/v4WECDxVhYWHu/nhEv8CgiagGYEQJeU033HCDbNq0SdavX6/NgN977z3p2rWrJreiWXB5igptcnBrslw4eUnycgokKMQqjVrUlw4JMeIfwBV6VPMKi2yy9WCynLxwSXLyCiQkyCotGtWXhA4xEuDvV27eEqarseI0LS1N34uOjtaHiBYtWtTgfwFR5TBoIqpBAQEBMmDAAImPj9fpCJQmwJQEcp7wPnKhsI+9jNQs2bzyoKxbsltSj6aIpcAmYiASEzGsfhLZNkoGjo+XPiM6SHgkVxWR66VmZMnKzQdlybrdcjQ1RQosNvOUFKvhJ20jo2T8wHgZ0aeDRIZfe05euHBBp6uTkpL0dd26dWXo0KH6O8HpavJ0DJqI3ABTD7fffntJS5bTp09rEIWkcSS+okkwbiDH9pyReU8tl8zjaRKUVyARNkOsxTcn3KQKkA+y87QsO3BBvv9kh0ybPUpiu0TzZ0ous+fYGXlq3nI5npkmeUEFYosw5PqTcueV03Jg2QX55PsdMnvaKOkSGy05OTm6ohTT0hhpMhdM4GEBtZeIvAGDJiI3at68uTz44IM64oRmwOnp6fLZZ59J69atpUNMD/n0v1aJLTldIosMqWOIhKC4HyqSo6UEenCJSE6RIVk5+XL58HmZM32pPDZ3HAMnclnANH3OUkm2pUtRpCEGBpFKOSmLcgzJycqXw5fPy+/nLJXpQ+Pk5KGdGjhBXFycluBo0KABf1LkVRg0EbkZRpQwNdGhQwfNdULOU+KB4/Lt7OMSni4SaRNBdSdkPAUXb+b9Kbd4CzZE/AsNSU9Ol3lPL5dnFk7kVB05fUoOI0wImAoxulTBSWkEixT6G/JzSprM+nyjjGgt0jK6kdZbQi0zIm/kddmjc+fOlVatWmn7it69e2vPr/IsXrxYn2qwP1ZlrFy5ssY+K1FlBAYGam7H9OnTJSS3iQRmiIQXB0wRxVtkKZv5NewXVmRIZlKqbPn6EA8+ORVymDAlVxRmVOqkNOqLXA4Uqduik0ydOpUBE3k1rwqaMG3xxBNPyHPPPae5H3g6x1MLEgtLs3HjRrnrrrt0+gO1ccaOHavbvn37avyzEzkqrF64ZB0PkLo2kbrFD/PYwosDI/N+Zf493G4fTOEF5RXK2iW7dbUdkbNWySHpGzlMOiVXmZOyroitnkW2n8gQG3KeiHxpeu7+++/XIGTgwIFS01599VWZMmWKTJo0SV/PmzdPvvrqK5k/f77MmDHjF/v/7W9/0yWsTz/9tL5+8cUXtU7Om2++qd9L5IlQVgCr5DADElI88xGKgKj4HoS/o01pEVYqFX8PEsKRLYL9Q2yGpB65KHs3JsmNfWLc/F9DtcHm/SckMTVFbPWrdlLaQgxJTL0o2w4lS9+Ordz8X0NUg0ETOk6j8Bh6ASF4QRBVE8X5UPhsx44dMnPmzJL30D0enwU5IKXB+xiZsoeRqS+++KLM/528vDzdTGbvI6KagjpMKCtgLc6vNVNGzPsURp+sxfckKf7T/Dr2txoi+Vm58sHbC6TBav7cqPoOp4lk56PERRVPykC8ZdN6Tn078idCPjQ9h4ADy6MffvhhnS5DftHw4cNlyZIl2pXaVVJSUqSoqEgaN258zft4jaaopcH7ldkfZs2apf2OzI2F1qimoXAllm5bin9Bzc2/eLMWP+1Y7d6z389SvNlc9+tIPgYzvYZ5YlXxpDQshmTn8qQkH1w917BhQx3BwYbcog8++EDuvfdeLVI2ceJE+f3vf6/d3r0RRrLsR6cw0sTAiWoSKn3rTaZ4MZK5FRVv9g/z5nv2++F7rYFWGX37MBk0rgt/eFRtS9bskV3//FaKpECMqpyUeAgwLBIazD5y5MMlB86ePas5QthQqGzEiBGyd+9ebRfxyiuvyB//+EenfdCoqCj93zh//vw17+M1enuVBu9XZn9AkTUWWiN3QmsUI8BP0Ikrz66sADbzlmOmj2Rf93Xsrx28Av0lulWUrsgjqq5W0VFixVmH2YQqnpRW8dMWK0Q+NT2HKbilS5dq93bkNWFJ/+OPPy5nzpyRjz76SAv0ff755/LCCy849YPi4t+jRw+tmmyy2Wz6Gp2wS4P37fcHBHhl7U/kCcKa+UthWJFkGf9//8GfWSKSibxCuy2z+H1zP+Td5vhZJLJdQ4nrxSRwcg70kkNrFL9sy9WTrDInZbaIkSXSKMAqXVpfmy5BVOtHmpo2barBCpbyo0YSmo1eb8iQIVK/vvOfKDBthsTznj17SkJCgrz++uuSlZVVspoOneSRlI68JPjDH/4ggwYNkr/+9a8ycuRIWbRokWzfvl3eeecdp382ourKzMzUIH/37t0S2lLkyjmRrIKr96CA6/Jr7esI4t6Uad6rLCJ5QQEycnw8m/iS06D5LnrJoTUKKn2jcKXjJ6VIQJZI47qZMu/vb+ninS5durDPHPlG0PTaa6/Jb3/7Wy0WWRYETMePHxdnmzBhgly8eFGeffZZTeZGwIa+XWayd3Jysq6oM/Xr108WLlwozzzzjPznf/6n5lkhkb1Tp05O/2xEVVVYWKgrPVEN3FxM0e/XHWVrygXJPJoiAYVXi9sUFo8klVYRHPemS8jB87dIvTaR0nt4HH8g5FRovotecmiNgkrfjp6UAZkWaVU3XLrGGHLlSoZeg9F/DuVg0EaIyJtYDHROpDIhERyr6FBqAU1WnVU+wRwNQ+I58058E371Dh06JN9++61cunSppBcdbiYYMUWzXvSSQ++5sPJ6zxWPMCFg8ouJkMfeGi+xnZu6+z+PanvvubCye8/hpLRkifhftkiMX4S89dh46dCyoWzZskXWrVun10DAiBOq4Dvr2kreJd/F90JX3L/Ze47IDbAg4ZtvvikZka1Xr55OW6DVD3rRQWyXaG2+i15yqUlpciWvQEJtxjUN5fOLc5gwJYcRpmmzRzNgIpfpEhstcx8bJ0/PWy5JqWmSd6VAbKGGXH9S+uVYJCgvQNrUi5TZ00ZL59irQXz//v21kwOmoXft2qWNqg8ePCg33XST5pparVxdR56NQRNRDcrOzpbVq1droVaMNGFFKKaRcdMo7SkLgROa76KX3NrFu7RSuBTYMEQsBoIrq58mfSOHCVNy4ZF49CdybeC08JmJ8vWWQ7J47S45mpqihStRhwllBbBKrl1kQxk/Ml6G946TyPBrz0mUphkzZoz06tVL0ytOnjypvxNodXXLLbdo42rzwYHI0zBoIqoBKMyKRQhr1qyR3FwkfIiW5sBNoqJFEwiEhk3sIUPv7CaHtiVrxfDc7AIJDrVqeQKskvMP8Ko2kuTlEAhNHNZD7hzaTVujoNI3CleiDhPKCvSKi9Hk8fJER0frIh70AsWqa0xRYzU2VmVjirq80jBE7sKgicjFjh49qlNxqGoPWLiAmwKq6VcGAqOOfVtJR1bMIA+BwAi95KraGgUjSpiSbt++vWzYsEGbrJ84cUJXOHfv3l1XYtepw9FT8hwMmohcJDU1VZO8jxw5oq9DQ0Pl5ptvlm7dul2zypPI12FqGgESfjcw6rR//36dwsYoFMrGoMQMprKJ3I1BE5GTYfoNK4SwUgg1zRAg4aKPi395pTqIfB2mqsePH1+S74TSMnjwQACFZuve2p6Lag8GTUROggAJK4JWrVqlRVcBF/lhw4ZpGyAicgzymqZMmaK/T1hph1Fb1Nzj7xO5G4MmIidAHob5ZAyRkZF8MiaqBozQIq8JCybMkdvExEQ5duwYR27JbRg0EVUDiqahnyFyMADNnpmDQeQ8mNLGaC16j5o5gps3b9YaT8wRpJrGoImoipVszdU+aIMCuKhztQ+Ra2D0Fj1P7VejrlixoqQlS2VXoxJVBYMmokpAQUqzrgxK9APryhDVnLZt20rr1q1L6p6huv5HH33kcN0zoupg0ETkoDNnzpRUMAb0NMK0ASsYE9UslB/o3bu31ngyK+wfOHBADh8+XG6FfaLqYtBEVIErV66U9MoC9Mdirywi90Pts5EjR0rPnj31gebnn3+W9evX6+/q9b0ciZyBQRNRGZCrxK7sRJ4PVfbvu+8+OXTokCaLoyXLsmXLSvKdmjVr5u6PSLUEgyaiUvKWMMyPi296enpJnyxcfFu0aMHjReSBMKKEqXLUctq0aZOOOJ06dUree+89iY+Pl6FDh0q9evXc/THJyzFoIrJz4cIFXZmTlJRU0pEdw/xdunThMD+RFwgICJABAwZI165ddVp99+7duh08eFDf79Onj+5DVBU8c4hEJCcnRxNKsSIHI01INO3bt6/mLqH2EhF5F4wqjR07tiTf6fTp0xpE/fTTT7rKLi4ujg9CVGkMmkh8vfWJuXQZgRNgiB8X1YiICHd/PCKqpubNm8uDDz4oe/fu1VIhmHL//PPPtWwB+tkhH4rIUQyayGdhCg5PoBcvXtTXjRo10rwlXEyJqHblO2GKHaNLP/74oxalPX78uLz99tslRWmxEo+oIgyayOekpaVpkjeSvSEkJEQvmrh4ot8VEdVOqN1ktl5B+yPkOWGkGQVrBw8erFN5mJonKguDJvIZeXl5uqIGfauKior06bNXr156sUTgRES+AVPvd9xxh9Z1wmgzqorjTwRQGG2OjY1190ckD8WgiWo9JHaj2B2SQLOysvQ9XBSRz9CwYUN3fzwichP0q3vooYc0OXzVqlXaz+7TTz+VG264Qav9o98dkT0/b5pSueeeeyQsLEx7CyGxD5Way9v/0Ucflfbt2+soQkxMjDz22GPalZ58B1qevPvuu/Kvf/1LA6YGDRpo00+cSwyYiAhT8piWw/0CrVnw+siRI/LWW2/pNH5ubi4PEnnfSBNucmfPntV56IKCApk0aZI+ISxcuLDMPmHYZs+erY0cT5w4IdOmTdP3lixZUuOfn2oWmulipQxWzJi5DIMGDdKLInMWiOh6eLjG1BwCKNRqO3r0qBbJ3LNnj+ZBoe4Tcx7JK4ImJOthvhkl8XFCwxtvvCEjRozQoAjVmq/XqVMnWbp0aclrTMe89NJLMnHiRG2PweJmtRMCaqyM2bBhg/4dkPSJix4KVRIRlScqKkof0hMTEzV4Sk1NleXLl5fkO2HWgnyXVwRNiPYxJWcGTIAqzYj60Rvs9ttvd+jfwdQcpvfKC5iQLIzNfsSCvCNvCV3OMRJpTsHi4oaLXNOmTd398YjIy6AdS5s2bWTr1q2ydu1anen44IMPpGPHjlrHLTw83N0fkdzAK4Kmc+fOaQ0dewh8kJ+CrzkCCX4vvviiTumVZ9asWfL8889X6/NSzcLFDCORycnJ+hqBMS5quLixwzkRVZXZGQA1npAojoTx/fv3a7mS/v3762a1WnmAfYhbE8FnzJihN7XyNnStri6MFo0cOVJzm/785z+Xu+/MmTN1pMLckEhMngmJ3UjwfueddzRgQiCNvKVHHnlEp2cZMBGRM9SpU0dGjRqlD90tW7bUFA+MPr355pta4wkj3eQb3DrS9OSTT8oDDzxQ7j4YHm3SpIk2UrWHkxYr5PC18mRmZuoUDfoQLVu2rMKnAvQZY68xz4YaS5iWXbduXclUKoIkTNlyyJyIXAVT/ffff7/m2WJlHR6skTuLKTzcZ0rLr6Xaxa1BE5Z8O7LsG8Ojly5dkh07dmjVZsBQKfqGYTVUeSNMqMWDIAgjEsHBwU79/FSz8DRnJmciYDYvYkzOJKKaghFszFog5wn5tmjLYpY2wQq7oUOHctFJLeYVOU1ooIob45QpU2TevHm6KgpTMHfeeWdJZI8O1jhZP/74Y0lISNCACcXJsrOztVgZXptJ3QjUuOzcu6A/HIKlY8eOlQyX4+eNixSn4YiopmHWYuDAgXoNMsuboIguFqTgfTzQc5V27eMVQRMsWLBAAyXcKLFqbty4cTJnzpySryOQQnIegiRAwh6mcKBt27bX/Fto1IhKsOT5cnJyNHcAw98YacLPvk+fPnpR4jQqEbkbFp785je/0ZZMWJCCWoAIojAzgpkOVBfng13t4TVBE1bKlVXIEhAE2SfjoZ8Yk/O8F6ZecdFZvXq1Bk6A6u5YFcfWBkTkaVq0aCGTJ0+W3bt3a8um9PR0WbRokeblIni6fgU4eSevCZrId2AkEE9sZvI/plNx0WETTSLyZBhRwnQdUkrM5uBJSUmaVsLm4LUDgybyGHgyQ3FKrEwBJO4PGTJEi5qyfQEReQukDmA1b/fu3fWahtI5SDFA3hNmQXhN814Mmsjt8vPz9akMK1FQTgBPa7io4OISGhrq7o9HRFTltJIJEyboaBMWsmD0/Ouvvy5pyYKpO/IuDJrIbZBzhmaYSJq8cuWKvte6dWu9mHD+n4hqCwRHU6dOLcnTxGrgTz75ROLi4jRPE8EVeQcGTeQWp06d0rwllIqAiIgILRGBZG+uNCGi2gYpBshrQiHeNWvWaAN6TNuh9hxWBA8YMIArgr0AgyaqUaiVhZUlGGGCwMBAvVjgosGaJkRU24WEhMjw4cM1BQEPjpi627Bhg666Q0md+Ph4Pjh6MAZNVCNQR8usnou/A1aZ3HzzzdrihojIl2BV8MSJE+XIkSPakgVdDr788ksdgUKKAkoYkOdh0EQuz1vCajisIEErHGjevLleFJo1a8ajT0Q+C6kISElAORWsrkMhXxTHnD9/vnTu3FlX4KF4JnkOBk3kMufOndPh5xMnTuhrjCgh6RFz+sxbIiIqvhEHBEi/fv2kS5cu2ld1586dWp4AOU/9+/fXr1XUbJ5qBoMmcrqsrCxdIYJWNhhpMi8I+OVHDhMREf1S3bp1ZfTo0SX5TmgEjKRxBFF44ESjYD5wuheDJnIa1FjCfDx+yfPy8vS9jh076hBz/fr1eaSJiByARvSTJk2S/fv3a2pDRkaGLFmyRGJiYjS1oWnTpjyObsKgiZwCy2aRzJiSkqKvmzRpor/cLVu25BEmIqokjCghlQE5T1hdhy05OVneeecdrTSORTR16tThca1hDJqoWhAkIVhC0ASo4I1ls1gZx9YnRETVg1wmdEfo1q2bFgLet2+fpj5gFGrQoEGSkJAg/v7+PMw1hEETVUlubq6u9MCKD5vNpgFS7969ZeDAgdozjoiInCc8PFzGjRunBTKR73T27Fl9YEWVcRQGbteuHfOdagCDJqoUBEhISsQKj+zsbH0Pv6z4pY2KiuLRJCJyIeQ1TZ48WYtholBwamqq/OMf/5C2bdvqdRj1n8h1GDSRw37++Wd9wjl//ry+RpB066236i8rERHVDIzsY7oOq+nWrVsnmzdvlqNHj2p1cYxEYdoOlcfJ+Rg0UYVQlBIrOA4cOKCvMf2GX0r8cnIunYjIPYKCgrQUARLDcY0+fPiwbNmyRdtUIVEc7zO31LkYNFGZ8vPzte0J2p8UFhbqfHmPHj1kyJAhmvBNRETuFxkZKXfeeaccO3ZMvvnmG7l48aJ89dVXsn37dp0NaN26tbs/Yq3BoIl+AQUpUY0WKzUyMzP1vVatWmkJgcaNG/OIERF5ILRjmTp1qgZLqJeHVIqPP/5YOnTooCNSERER7v6IXo9BE13j9OnTmrd06tQpfY2ilEgujIuL48oMIiIPh5QJrGRG7zoETgig0P8TjYH79u0rAwYMYGeGamDQRAojSlgRt2vXrpLaIPjlwi8Z2qAQEZH3QArFiBEjNKUCU3bHjx/XdAtc49GlAX3u2JKl8ng39HHIVcLKi/Xr12sOE8THx2uBSjTYJSIi74WUinvvvVeTxFHXKT09Xb744gtteYWUi+bNm7v7I3oVP/ESaWlpcs8990hYWJhOGT344INy5coVh3N0hg8frlE1Tha6ekzQQfutt97SWh8ImJo1a6bHdezYsQyYiIhqCdz7kGLx+9//Xh+I0TgdqRjvv/++LFu2rCR3lWrRSBMCJlRAxbLKgoICbWb40EMPycKFCyv83tdff53DkHaQHGgO15qdtTlcS0RUuyHV4qabbtLZBDMdA+UJkPPEdIxaFDThB4rkZAwn9uzZU9974403dL529uzZ2hG6LDgp/vrXv2oynK93hkYF79WrV2vZfYw0IWGwX79++kuEJw8iIqr9kHoxZswYvZ+aC38QRKGnHVbZYbUd8528OGhCnSBMyZkBE2BkBEW7UMjr9ttvLzNIuPvuu2Xu3LnSpEkTh/638vLydDNdvnxZvF1RUVHJElT0jAMuQSUi8m1Iyfjd736nTYAxi4NCxosXL2aJGW8Pms6dOyeNGjX6xTBjgwYN9Gtl+eMf/6gjKYioHTVr1ix5/vnnpbawL3ZmJgUi+Q91l4iIyLdhRAnlCdq3by8bNmyQjRs3asust99+WyuKo5hxnTp13P0xPYZbg6YZM2bIyy+/XOHUXFX861//0uFGNJetjJkzZ8oTTzxxzUhTixYtxNugiSNWSqA2B6APEcvqExFRaZCigQAJPe1Q2Hj//v2ayoE/2TbLQ4KmJ598Uh544IFy92nTpo1OrV24cOEXS+Wxoq6saTcETBhlwbSevXHjxmnCG6aqyurlg81bYWrRbOBos9l0CpMNHImIyBG4Z44fP17vG8h3wmwOZisQQN3KBu3uDZoaNmyoW0VQYBFzrfihoVCXGRQhKEDl07JGsSZPnnzNexiCfO2112TUqFFS2+BYIOkdxyUrK0vfa9u2rZ7kUVFR7v54RETkRVq2bClTpkzR2RrcV1JSUmTBggXSrl07va+g350v8oqcJiQtIw8HP8B58+ZpyYFHHnlEGxSaK+dQcwL1J9BnJyEhQUegShuFiomJqXXNC5OTk/WJACUZACczTmqc3ERERFWBmQoMVHTs2FHWrl0rW7dulcTERJ3FwYDFwIEDJTg42KcOrlcETYAIF4ESAiP8IDHNNmfOnJKvI5BCxVOsmPMVGRkZOveMlQ+AaUXMPSNoRDkBIiKi6kJghAfxHj16aK4sAiesat+9e7fmyiIPCvdlX+A1QRNWypVXyBKrwVB7qDwVfd1bIEDEKgdsyO0CrHLAyctVDkRE5ApRUVFaxgdBE/KcsOBoxYoVWtIGs0GY0qvtvCZoqi0Ki2yyef8JOZwmUmgTWbJmj7SKjpKEDjES4O9XYdCHlQyop2HWj8JJiicAXy/cSURENaNdu3a6SAsFp7GoCsniH374oU7joYbi9QuwSlNUaJP9m09I2mERW6HImiV7JLpVlHRIiBH/AM8dtbIYtWX4xUUQnISHh+tUGPreVVVqRpas3HxQlqzbLYmpKZKdnyuGRSTIahWr+EvbyCgZPzBeRvTpIJHhv6yJcebMGc1bOnnypL7GZ0Ll1htvvJGVW4mIyC2ysrK00wSqiSOcQA1F1Efs379/qZ0mMlKzZPPKg7JuyW5JTUyR/OxcsRgi1iCriNVfIttGycDx8dJnRAcJj6zjEfdvewyaauCg7zl2Rp6at1yOZ6ZJXlCB2EIMMaw4+vp/IgUiftkWCcqzSut6DWT2tFHSJfZqgjuaEqOhLlbGgdVq1bYnWFGIvxMREbnbueLSBCiMabZqwYN9p06dSh7sj+05I/OeWi6Zx9MkKK9AQmyGWI3i+6BFb4WS7WeRvCCr1GvdQKbNHiWxXcpuk1YRBk1uUN2DjoBp+pylkmxLl6IwQwwEziHI2sbSBNQKQHElEckRsWSJ+F+2SIxfhMyZPlayLyZrzaX8/PySkgkY+nRWxExEROQshmFoQWqzJQugODRSSHJTLTJn+lKxJadLWJEhdYwyb4WSZRG57G8Rv5gIeWzuuCoHTgya3KA6Bx1Tcnf996dyOPe8FEYYIpjmrYelCMWbeabkFm+ZInJJxD/VIlFZFhnWwiYhAaJlFZBk542VyYmIyLcUFBTo6roff/xR/16YI3JudbAEncuTBoWGo7dCSQ+wSHBcY3lm4cQqTdW5ImhiIrgLIYcJU3JFkcUBU0TxmRJaypmS/f8/jaJCQ1JzDDmbGyR/vOc2iY+PZ94SERF5BavVqjWcunbtquklqxftkaJzuRJWWKlboRQVGZKalCpbvj4kwyZeLWztbp6bol4LVskh6Rs5TDolV694C0edevn/M8f8e7jdPnVEiuqKpFujpFPnLgyYiIjI64SFhcnoUWMkMKOh1CnSW1vlboWGSFBeoaxdsltX23kCBk0usvVgshxNTRFbaPHEbXBxWG2eNeF2W3GgVBJ2489QkWNpqbLtULKrPiIREZFLHdyaLFdOZkrd625xjtwKcetEsnhq4kU5tM0z7oUMmlzk5IVLUmCxiViLM93MyVvzjMEZhClW+zPJ3LB/IFYS2PTfISIi8kYXTl4SS4GtOrdCkQKb/juegDlNLpKTVyBaAMtSHJqam3/xZrU7+uZ79vtZRAyLIdm5WIRJRETkffJyCgQ3w2rcClEbSXKzPeNeyKDJRUKCrFdrTyBystltRcWb+fMvsHvPfj+cZIZFQoNZi4mIiLxTUIj16iBA1W+FYlgsEhzqGfdCBk0u0qJRfbEaflfPhDy7tZTYzJ+9f/EZkn3d17F/Pnbz03+HiIjIGzVqUV8Mq191boUiVj/9dzwBc5pcBL3k0BoFlb61Wpe5ljKruAhFht2WWfy+ecbkiPjlWKRdZEPpFRfjqo9IRETkUh0SYrQ1Cip9V+FWKDl+Fols11DiennGvZBBk4ug+S56yaE1Cip969lgniGXzMpddn83z5jMq5XBg/ICZPyg+Aqb+BIREXkq/wA/7SWH1iio9F2JW6HunxcUIIPGx3tME1/P+BS1FJrvopccWqOUnBnYUkvZzK+hIvhli7SpFynDe8e5+z+BiIioWvqM6KC95NAapRK3Qt2/XptI6T3cc+6FDJpcKDK8jjbfRS+5gHSLWHBGXBSRlOI/L177Gl/Hfth/9rTR+v1ERETeLDyyjjbfRS85tEZJtZR7K9SvYz/sP2326Cq1UHEVi4EOe+TS3jVo2vv0vOWSlJmmFcK14CUy4LC8Dkc//2oOE6bkMMKEgKlzbFP+VIiIqNY4tueMzHt6uWQmpUlQXoGE2ozrb4Waw4QpOYwwIWCK7Vz1eyEb9roBgqX69evLyZMnq9XwLy0jS77bfkSWbdgrSWmpWrhSLAbWUuoqudgGUTK2fye5pecN0oAjTEREVAtlpGXJ9u+OyIZleyUtKVULV1rEEAOhk9VPGsRGSf+xnaTnLTdIeIPqjTAhaEKj+0uXLunghzNwpKkCSUlJEhsb65SDTURERDULgx7Nmzd3yr/FOk0VaNCggf6ZnJzstEjVV5lRf3VH7XwdjyOPpafhOclj6ann5IEDByQ6Otpp/y6Dpgr4+V3NlUfAxBu9c+A48ljyOHoSnpM8jp6G56RzNGvWrOQ+7gxcPUdERETkAAZNRERERA5g0FSBoKAgee655/RPqh4eS+fgcXQeHkseR0/Dc9KzjyNXzxERERE5gCNNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNpXjppZekX79+Ehoaqn3nHIG+x88++6w0bdpUQkJC5Fe/+pUkJiaKL0tLS5N77rlHi7ThOD744INy5cqVcr9n8ODBYrFYrtmmTZsmvmbu3LnSqlUrCQ4Olt69e8vWrVvL3X/x4sUSFxen+3fu3FlWrlxZY5+1Nh3LDz/88BfnH77P161bt05GjRqllZVxTL744osKv2fNmjXSvXt3Xb3Utm1bPba+rrLHEcfw+vMR27lz58SXzZo1S3r16iX16tWTRo0aydixY+Xw4cMVfp8zrpMMmkqRn58vv/3tb+Xhhx92+EC+8sorMmfOHJk3b55s2bJF6tSpI7feeqvk5uaKr0LAtH//fvnuu+9kxYoVesF46KGHKvy+KVOmyNmzZ0s2HFtf8tlnn8kTTzyhy2V/+ukniY+P13PpwoULpe6/ceNGueuuuzQo3blzp15AsO3bt098XWWPJSDItz//Tpw4Ib4uKytLjx0CUEccP35cRo4cKUOGDJFdu3bJ448/LpMnT5ZvvvlGfFllj6MJAYH9OYlAwZetXbtWpk+fLps3b9b7S0FBgQwbNkyPb1mcdp00qEwffPCBER4eXuERstlsRpMmTYz//d//LXnv0qVLRlBQkPGPf/zDJ4/wgQMHDJxe27ZtK3nv66+/NiwWi3H69Okyv2/QoEHGH/7wB8OXJSQkGNOnTy95XVRUZERHRxuzZs0qdf877rjDGDly5DXv9e7d25g6darh6yp7LB39nfdl+L1etmxZufv8x3/8h9GxY8dr3pswYYJx6623uvjT1a7juHr1at0vPT29xj6XN7pw4YIep7Vr15a5j7OukxxpcgI8VWG4FFNyJvSqw1TApk2bxBfhvxtTcj179ix5D8cHPYAwEleeBQsWSFRUlHTq1Elmzpwp2dnZ4kujnDt27LjmXMIxw+uyziW8b78/YDTFV8+96hxLwBRyy5YttdnnmDFjdLSUKofnpHN17dpVUz9uueUW2bBhA0/H62RkZOifDRo0EFefk2zY6wTm/HLjxo2veR+vfXXuGf/d1w8hBwQE6Eld3jG5++679YaFOf89e/bIn/70Jx2a/uc//ym+ICUlRYqKiko9lw4dOlTq9+B48txzzrFs3769zJ8/X7p06aIX4tmzZ2t+IwKn5s2bV+Mn61vKOifReT4nJ0fzPqliCJSQ8oGHz7y8PHnvvfc07xMPnsgXIxGbzabTv/3799cH7cqek5W9R/tM0DRjxgx5+eWXy93n4MGDmiRG1T+OVWWf84REPVw0hg4dKseOHZPY2Fj+aMil+vbtq5sJAVOHDh3k7bfflhdffJFHn2oUgnhs9ucjroWvvfaafPLJJ/xpiGhuE/KSfvzxxxo5Hj4TND355JPywAMPlLtPmzZtqvRvN2nSRP88f/683uRNeI1hVV88jjgm1yfbFhYW6oo683g5AlOccPToUZ8ImjAt6e/vr+eOPbwu67jh/crs7yuqciyvZ7VapVu3bnr+kePKOieRZM9RpupJSEiosQDB0z3yyCMli4wqGgl21nXSZ3KaGjZsqKNI5W2BgYFV+rdbt26tB/6HH34oeQ/D0BhCtX9q9aXjiP/uS5cuaU6JadWqVTqUagZCjsDKG7APRmszHLsePXpccy7hmOF1WecS3rffH7CipLadezVxLK+H6b29e/f6zPnnLDwnXQfXRF8/Hw3D0IBp2bJlel/BPbjGzskqp6vXYidOnDB27txpPP/880bdunX179gyMzNL9mnfvr3xz3/+s+T1X/7yF6N+/frGl19+aezZs8cYM2aM0bp1ayMnJ8fwVbfddpvRrVs3Y8uWLcaPP/5otGvXzrjrrrtKvn7q1Ck9jvg6HD161HjhhReM7du3G8ePH9dj2aZNG2PgwIGGL1m0aJGuvPzwww91FeJDDz2k59a5c+f06/fee68xY8aMkv03bNhgBAQEGLNnzzYOHjxoPPfcc4bVajX27t1r+LrKHkv8zn/zzTfGsWPHjB07dhh33nmnERwcbOzfv9/wZbj2mddB3DZeffVV/TuulYBjiGNpSkpKMkJDQ42nn35az8m5c+ca/v7+xr///W/Dl1X2OL722mvGF198YSQmJurvM1YW+/n5Gd9//73hyx5++GFd5bpmzRrj7NmzJVt2dnbJPq66TjJoKsX999+vJ/T1G5Z/lhw4EV2ebF924L/+67+Mxo0b60V66NChxuHDhw1flpqaqkESAs+wsDBj0qRJ1wSeCIzsj2tycrIGSA0aNNBj2LZtW73oZmRkGL7mjTfeMGJiYozAwEBdNr958+ZryjLgHLX3+eefGzfccIPuj6XeX331lRs+tfcfy8cff7xkX/wujxgxwvjpp58MX2cufb9+M48d/sSxvP57unbtqscSDz/210tfVdnj+PLLLxuxsbEauOO6OHjwYGPVqlWGr5NSjuH192RXXSctxR+AiIiIiMrhMzlNRERERNXBoImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIfMrFixelSZMm8j//8z8l723cuFECAwPlhx9+cOtnIyLPxoa9RORzVq5cKWPHjtVgqX379tK1a1cZM2aMvPrqq+7+aETkwRg0EZFPmj59unz//ffSs2dP2bt3r2zbtk2CgoLc/bGIyIMxaCIin5STkyOdOnWSkydPyo4dO6Rz587u/khE5OGY00REPunYsWNy5swZsdls8vPPP7v74xCRF+BIExH5nPz8fElISNBcJuQ0vf766zpF16hRI3d/NCLyYAyaiMjnPP3007JkyRLZvXu31K1bVwYNGiTh4eGyYsUKd380IvJgnJ4jIp+yZs0aHVn65JNPJCwsTPz8/PTv69evl7///e/u/nhE5ME40kRERETkAI40ERERETmAQRMRERGRAxg0ERERETmAQRMRERGRAxg0ERERETmAQRMRERGRAxg0ERERETmAQRMRERGRAxg0ERERETmAQRMRERGRAxg0EREREUnF/g8RFT7XnWC41gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -247,7 +543,8 @@ } ], "source": [ - "qbits.draw(colouring=list(samples.keys())[0], radius=\"nearest\")" + "for s in samples_top.keys():\n", + " qbits.draw(colouring=s, radius=\"nearest\")" ] } ], diff --git a/qse/__init__.py b/qse/__init__.py index 7a452fe2..2199a50d 100644 --- a/qse/__init__.py +++ b/qse/__init__.py @@ -11,6 +11,7 @@ "draw", "lattices", "magnetic", + "Operator", "Qbit", "Qbits", "Signal", @@ -25,6 +26,6 @@ from qse.qbits import Qbits from qse.signal import Signal from qse.visualise import draw -from qse.gate_based import InteractionTerm +from qse.gate_based import Operator from qse import calc, lattices, magnetic, utils, visualise # isort: skip diff --git a/qse/gate_based.py b/qse/gate_based.py index 6cfb0c88..842a52e5 100644 --- a/qse/gate_based.py +++ b/qse/gate_based.py @@ -1,41 +1,52 @@ -class InteractionTerm: +class Operator: """ - Represents an interaction term in a quantum system. - - This class encapsulates an interaction between two qubits, including the type of interaction, - the qubits involved, the coefficient, and the total number of qubits in the system. + Represents an operator in a quantum system. Parameters ---------- - interaction: str - The type of interaction (e.g., "X", "Y", "Z"). - qubits: tuple - A tuple of two integers representing the indices of the interacting qubits. + operator: str | list[str] + The type of qubit operator. + Currently only "X", "Y", "Z" are supported. + If a list, must be equal in length to the size of + the qubits tuple. + qubits: int | list[int] + A single integer or list of integers representing the qubits + the operator acts on. coef: float - The coefficient associated with the interaction term. + The coefficient associated with the term. nqubits: int The total number of qubits in the system. """ - def __init__(self, interaction, qubits, coef, nqubits): - self.interaction = interaction + def __init__(self, operator, qubits, coef, nqubits): + if isinstance(qubits, int): + qubits = [qubits] + if isinstance(operator, str): + operator = [operator] * len(qubits) + + assert len(qubits) == len(operator) + + self.operator = operator self.qubits = qubits self.coef = coef self.nqubits = nqubits def to_str(self): """ - Generates a string representation of the interaction term. + Generates a string representation of the operator. - The string is constructed as a tensor product of identity (I) and interaction operators, - where the interaction operator is placed at the positions specified by `qubits`. + The string is constructed as a tensor product of identity (I) and operator, + where the operator is placed at the positions specified by `qubits`. Returns ------- str A string of length `nqubits`, with "I" at all positions except for the qubits in `qubits`, - which are replaced by the `interaction` operator. + which are replaced by the operator. """ op = ["I"] * self.nqubits - for qi in self.qubits: - op[qi] = self.interaction + for qi, op_str in zip(self.qubits, self.operator): + op[qi] = op_str return "".join(op) + + def __repr__(self): + return f"{self.coef:.2f} " + " ".join([f"{op}{q}" for op, q in zip(self.operator, self.qubits)]) diff --git a/qse/qbits.py b/qse/qbits.py index f1e564c0..3474fc7b 100644 --- a/qse/qbits.py +++ b/qse/qbits.py @@ -13,7 +13,7 @@ from qse.qbit import Qbit from qse.visualise import draw as _draw -from qse.gate_based import InteractionTerm +from qse.gate_based import Operator class Qbits: """ @@ -1318,7 +1318,7 @@ def compute_interaction_hamiltonian( for j in range(i+1, self.nqbits): coef = distance_func(self.get_distance(i, j)) if np.abs(coef) > tol: - ops.append(InteractionTerm(interaction, (i,j), coef, self.nqbits)) + ops.append(Operator(interaction, (i,j), coef, self.nqbits)) return ops From b12a21906293e5d54f485b148ac9949433b9a0c1 Mon Sep 17 00:00:00 2001 From: James Nelson Date: Fri, 6 Feb 2026 16:24:57 +0000 Subject: [PATCH 06/10] update --- examples/gate_based.ipynb | 238 ++++++++++++++++++-------------- examples/qutip-dqpt.ipynb | 281 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 418 insertions(+), 101 deletions(-) create mode 100644 examples/qutip-dqpt.ipynb diff --git a/examples/gate_based.ipynb b/examples/gate_based.ipynb index 8f5345ed..ab7b8a94 100644 --- a/examples/gate_based.ipynb +++ b/examples/gate_based.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -67,12 +67,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIlNJREFUeJzt3QuQFdWdP/DfAArGAtSADCiKqPjkoagsRlcpjMhSLrq7+CgT0FWzZemWFsEEUvEVtwrURJMslJqUiFmjgLsKW4El8QWsAeICUlE3oYDwXHmIKyAYwYX7r9P/mskMzqBjZuTMnc+n6mRu9z3ddnfOvffL6dPdFaVSqRQAABlrdbA3AADg0wgsAED2BBYAIHsCCwCQPYEFAMiewAIAZE9gAQCyJ7AAANlrE2Vg37598c4770T79u2joqLiYG8OAPAZpHvXfvDBB9GtW7do1apV+QeWFFa6d+9+sDcDAPgc1q9fH8cee2z5B5bUs1K1wx06dDjYmwMAfAY7duwoOhyqfsfLPrBUnQZKYUVgAYDm5bMM5zDoFgDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9toc7A1oDnqMnRXNzZoJww72JgBAo9HDAgBkT2ABALInsAAA2RNYAIDsCSwAQPkFlvnz58fll18e3bp1i4qKipgxY0at99O8uspDDz1U7zrvvffeT9Q/9dRTP98eAQBlp8GBZdeuXdG3b9+YNGlSne9v3LixVpk8eXIRQP72b//2gOs944wzai332muvNXTTAIAy1eD7sAwdOrQo9amsrKw1PXPmzBg0aFD07NnzwBvSps0nlgUAaPIxLJs3b45Zs2bFjTfe+Kl1V6xYUZxmSsHmuuuui3Xr1tVbd/fu3bFjx45aBQAoX00aWJ566qlo3759/M3f/M0B6w0YMCCmTJkSc+bMiUcffTRWr14dF154YXzwwQd11h8/fnx07NixunTv3r2J9gAAKPvAksavpN6Sdu3aHbBeOsU0YsSI6NOnTwwZMiRmz54d27Zti+nTp9dZf9y4cbF9+/bqsn79+ibaAwCgrJ8l9J//+Z+xfPnymDZtWoOXPeKII6JXr16xcuXKOt9v27ZtUQCAlqHJelieeOKJ6N+/f3FFUUPt3LkzVq1aFV27dm2SbQMAyjywpDCxbNmyoiRpvEl6XXOQbBoE+9xzz8VNN91U5zoGDx4cEydOrJ4eM2ZMzJs3L9asWRMLFiyIK6+8Mlq3bh3XXnvt59srAKBlnxJavHhxcZlyldGjRxd/R40aVQycTaZOnRqlUqnewJF6T7Zu3Vo9vWHDhqLue++9F507d44LLrggFi1aVLwGAKgopWTRzKUenXS1UBqA26FDh0Zff4+xs6K5WTNh2MHeBABotN9vzxICALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAFB+gWX+/Plx+eWXR7du3aKioiJmzJhR6/3rr7++mF+zXHbZZZ+63kmTJkWPHj2iXbt2MWDAgHj99dcbumkAQJlqcGDZtWtX9O3btwgY9UkBZePGjdXl2WefPeA6p02bFqNHj4577rknli5dWqx/yJAhsWXLloZuHgBQhto0dIGhQ4cW5UDatm0blZWVn3mdDz/8cNx8881xww03FNOPPfZYzJo1KyZPnhxjx45t6CYCAGWmScawzJ07N44++ug45ZRT4pZbbon33nuv3rp79uyJJUuWxCWXXPKnjWrVqpheuHBhncvs3r07duzYUasAAOWr0QNLOh30s5/9LF5++eV44IEHYt68eUWPzN69e+usv3Xr1uK9Ll261Jqfpjdt2lTnMuPHj4+OHTtWl+7duzf2bgAAzfmU0Ke55pprql/37t07+vTpEyeeeGLR6zJ48OBG+W+MGzeuGPNSJfWwCC0AUL6a/LLmnj17RqdOnWLlypV1vp/ea926dWzevLnW/DRd3ziYNEamQ4cOtQoAUL6aPLBs2LChGMPStWvXOt8/9NBDo3///sUppCr79u0rpgcOHNjUmwcAlGNg2blzZyxbtqwoyerVq4vX69atK9678847Y9GiRbFmzZoidAwfPjxOOumk4jLlKunU0MSJE6un0+mdn/70p/HUU0/F7373u2Kgbrp8uuqqIQCgZWvwGJbFixfHoEGDqqerxpKMGjUqHn300fjtb39bBI9t27YVN5e79NJL4/777y9O41RZtWpVMdi2ytVXXx3vvvtu3H333cVA2379+sWcOXM+MRAXAGiZKkqlUimauTToNl0ttH379iYZz9Jj7KxobtZMGHawNwEAGu3327OEAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgCUX2CZP39+XH755dGtW7eoqKiIGTNmVL/38ccfx7e//e3o3bt3HH744UWdkSNHxjvvvHPAdd57773FumqWU0899fPtEQBQdhocWHbt2hV9+/aNSZMmfeK9Dz/8MJYuXRp33XVX8ff555+P5cuXx1//9V9/6nrPOOOM2LhxY3V57bXXGrppAECZatPQBYYOHVqUunTs2DFefPHFWvMmTpwY5513Xqxbty6OO+64+jekTZuorKxs6OYAAC1Ak49h2b59e3GK54gjjjhgvRUrVhSnkHr27BnXXXddEXDqs3v37tixY0etAgCUryYNLB999FExpuXaa6+NDh061FtvwIABMWXKlJgzZ048+uijsXr16rjwwgvjgw8+qLP++PHji96cqtK9e/cm3AsAoGwDSxqAe9VVV0WpVCpCyIGkU0wjRoyIPn36xJAhQ2L27Nmxbdu2mD59ep31x40bV/TcVJX169c30V4AAM1yDEtDwsratWvjlVdeOWDvSl3S6aNevXrFypUr63y/bdu2RQEAWoZWTRVW0piUl156Kb785S83eB07d+6MVatWRdeuXRt78wCAlhBYUphYtmxZUZI03iS9ToNkU1j5u7/7u1i8eHH8/Oc/j71798amTZuKsmfPnup1DB48uLh6qMqYMWNi3rx5sWbNmliwYEFceeWV0bp162LsCwBAg08JpTAyaNCg6unRo0cXf0eNGlXcAO7f//3fi+l+/frVWu7VV1+Niy++uHidek+2bt1a/d6GDRuKcPLee+9F586d44ILLohFixYVrwEAGhxYUuhIA2nrc6D3qqSelJqmTp3q/wkAoF6eJQQAZE9gAQCyJ7AAANkTWACA7AksAED2BBYAIHsCCwCQPYEFAMiewAIAZE9gAQCyJ7AAANkTWACA7AksAED2BBYAIHsCCwCQPYEFAMiewAIAZE9gAQCyJ7AAANkTWACA7AksAED2BBYAIHsCCwCQPYEFAMiewAIAZE9gAQCyJ7AAANkTWACA7AksAED2BBYAIHsCCwCQPYEFAMiewAIAZE9gAQCyJ7AAANkTWACA7AksAED2BBYAoPwCy/z58+Pyyy+Pbt26RUVFRcyYMaPW+6VSKe6+++7o2rVrHHbYYXHJJZfEihUrPnW9kyZNih49ekS7du1iwIAB8frrrzd00wCAMtXgwLJr167o27dvETDq8uCDD8aPf/zjeOyxx+I3v/lNHH744TFkyJD46KOP6l3ntGnTYvTo0XHPPffE0qVLi/WnZbZs2dLQzQMAylBFKXWJfN6FKyrihRdeiCuuuKKYTqtKPS/f/OY3Y8yYMcW87du3R5cuXWLKlClxzTXX1Lme1KNy7rnnxsSJE4vpffv2Rffu3eMf//EfY+zYsZ+6HTt27IiOHTsW/60OHTpEY+sxdlY0N2smDDvYmwAAjfb73ahjWFavXh2bNm0qTgNVSRuSAsnChQvrXGbPnj2xZMmSWsu0atWqmK5vmd27dxc7WbMAAOWrUQNLCitJ6lGpKU1Xvbe/rVu3xt69exu0zPjx44sgVFVSbwwAUL6a5VVC48aNK7qPqsr69esP9iYBAM0lsFRWVhZ/N2/eXGt+mq56b3+dOnWK1q1bN2iZtm3bFue6ahYAoHw1amA54YQTipDx8ssvV89L40vS1UIDBw6sc5lDDz00+vfvX2uZNOg2Tde3DADQsrRp6AI7d+6MlStX1hpou2zZsjjqqKPiuOOOizvuuCP+6Z/+KU4++eQiwNx1113FlUNVVxIlgwcPjiuvvDJuu+22Yjpd0jxq1Kg455xz4rzzzosf/vCHxeXTN9xwQ2PtJwDQkgLL4sWLY9CgQdXTKWwkKXCkS5e/9a1vFWHjG9/4Rmzbti0uuOCCmDNnTnFDuCqrVq0qBttWufrqq+Pdd98tbjiXBtr269evWGb/gbgAQMv0Z92HJRfuw/JJ7sMCQO4O2n1YAACagsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgJYXWHr06BEVFRWfKLfeemud9adMmfKJuu3atWvszQIAmrE2jb3C//qv/4q9e/dWT7/11lvx1a9+NUaMGFHvMh06dIjly5dXT6fQAgDQZIGlc+fOtaYnTJgQJ554Ylx00UX1LpMCSmVlZWNvCgBQJpp0DMuePXvi6aefjr//+78/YK/Jzp074/jjj4/u3bvH8OHD4+23327KzQIAmpkmDSwzZsyIbdu2xfXXX19vnVNOOSUmT54cM2fOLMLNvn374vzzz48NGzbUu8zu3btjx44dtQoAUL6aNLA88cQTMXTo0OjWrVu9dQYOHBgjR46Mfv36FaeNnn/++eK00uOPP17vMuPHj4+OHTtWl9QzAwCUryYLLGvXro2XXnopbrrppgYtd8ghh8RZZ50VK1eurLfOuHHjYvv27dVl/fr1jbDFAECLCyxPPvlkHH300TFs2LAGLZeuMHrzzTeja9eu9dZp27ZtcWVRzQIAlK8mCSxpHEoKLKNGjYo2bWpfiJRO/6Qekirf+9734le/+lX84Q9/iKVLl8bXvva1onemoT0zAED5avTLmpN0KmjdunXF1UH7S/NbtfpTTnr//ffj5ptvjk2bNsWRRx4Z/fv3jwULFsTpp5/eFJsGADRDFaVSqRTNXLpKKA2+TeNZmuL0UI+xs6K5WTOhYafiACDn32/PEgIAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDIXpuDvQHAF6vH2FnN7pCvmTDsYG8CcJDpYQEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsA0PICy7333hsVFRW1yqmnnnrAZZ577rmiTrt27aJ3794xe/bsxt4sAKAZa5IeljPOOCM2btxYXV577bV66y5YsCCuvfbauPHGG+ONN96IK664oihvvfVWU2waANAMNUlgadOmTVRWVlaXTp061Vv3Rz/6UVx22WVx5513xmmnnRb3339/nH322TFx4sSm2DQAoBlqksCyYsWK6NatW/Ts2TOuu+66WLduXb11Fy5cGJdcckmteUOGDCnmAwAkbRr7MAwYMCCmTJkSp5xySnE66L777osLL7ywOMXTvn37T9TftGlTdOnSpda8NJ3m12f37t1FqbJjx45G3gsAoKwDy9ChQ6tf9+nTpwgwxx9/fEyfPr0Yp9IYxo8fXwQhAKBlaPLLmo844ojo1atXrFy5ss730xiXzZs315qXptP8+owbNy62b99eXdavX9/o2w0AtKDAsnPnzli1alV07dq1zvcHDhwYL7/8cq15L774YjG/Pm3bto0OHTrUKgBA+Wr0wDJmzJiYN29erFmzprhk+corr4zWrVsXly4nI0eOLHpIqtx+++0xZ86c+MEPfhC///3vi/u4LF68OG677bbG3jQAoJlq9DEsGzZsKMLJe++9F507d44LLrggFi1aVLxO0hVDrVr9KSedf/758cwzz8R3v/vd+M53vhMnn3xyzJgxI84888zG3jQAoJlq9MAyderUA74/d+7cT8wbMWJEUQAA6uJZQgBA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACALS8pzUD8P/1GDur2R2KNROGHexNgDrpYQEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACAGRPYAEAsiewAADZE1gAgOwJLABA9gQWACB7AgsAkD2BBQDInsACALS8wDJ+/Pg499xzo3379nH00UfHFVdcEcuXLz/gMlOmTImKiopapV27do29aQBAM9XogWXevHlx6623xqJFi+LFF1+Mjz/+OC699NLYtWvXAZfr0KFDbNy4sbqsXbu2sTcNAGim2jT2CufMmfOJ3pPU07JkyZL4y7/8y3qXS70qlZWVjb05AEAZaPIxLNu3by/+HnXUUQest3Pnzjj++OOje/fuMXz48Hj77bfrrbt79+7YsWNHrQIAlK8mDSz79u2LO+64I77yla/EmWeeWW+9U045JSZPnhwzZ86Mp59+ulju/PPPjw0bNtQ7TqZjx47VJYUcAKB8NWlgSWNZ3nrrrZg6deoB6w0cODBGjhwZ/fr1i4suuiief/756Ny5czz++ON11h83blzRc1NV1q9f30R7AACU5RiWKrfddlv84he/iPnz58exxx7boGUPOeSQOOuss2LlypV1vt+2bduiAAAtQ6P3sJRKpSKsvPDCC/HKK6/ECSec0OB17N27N958883o2rVrY28eANAMtWmK00DPPPNMMR4l3Ytl06ZNxfw01uSwww4rXqfTP8ccc0wxFiX53ve+F3/xF38RJ510Umzbti0eeuih4rLmm266qbE3DwBohho9sDz66KPF34svvrjW/CeffDKuv/764vW6deuiVas/de68//77cfPNNxfh5sgjj4z+/fvHggUL4vTTT2/szQMAmqE2TXFK6NPMnTu31vQjjzxSFACAuniWEACQPYEFAMiewAIAtNz7sAAAdesxdlazOzRrJgw7qP99PSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgAgewILAJA9gQUAyJ7AAgBkT2ABALInsAAA2RNYAIDsCSwAQPYEFgCg5QaWSZMmRY8ePaJdu3YxYMCAeP311w9Y/7nnnotTTz21qN+7d++YPXt2U20aANDMNElgmTZtWowePTruueeeWLp0afTt2zeGDBkSW7ZsqbP+ggUL4tprr40bb7wx3njjjbjiiiuK8tZbbzXF5gEAzUyTBJaHH344br755rjhhhvi9NNPj8ceeyy+9KUvxeTJk+us/6Mf/Sguu+yyuPPOO+O0006L+++/P84+++yYOHFiU2weANDMtGnsFe7ZsyeWLFkS48aNq57XqlWruOSSS2LhwoV1LpPmpx6ZmlKPzIwZM+qsv3v37qJU2b59e/F3x44d0RT27f4wmpumOhY0f9qzY30gvjt8Dr/ItlG1zlKp9MUHlq1bt8bevXujS5cutean6d///vd1LrNp06Y666f5dRk/fnzcd999n5jfvXv3P2vby0nHHx7sLYDGoz1/cRxrDkbb+OCDD6Jjx45fbGD5IqTem5o9Mvv27Yv//d//jS9/+ctRUVHR6OkvBaH169dHhw4dGnXdzZVj4nhoIz4zvkN8rzaG1LOSwkq3bt0+tW6jB5ZOnTpF69atY/PmzbXmp+nKyso6l0nzG1K/bdu2RanpiCOOiKaUworA4phoIz43vkd8r/qtaVyf1rPSZINuDz300Ojfv3+8/PLLtXpA0vTAgQPrXCbNr1k/efHFF+utDwC0LE1ySiidrhk1alScc845cd5558UPf/jD2LVrV3HVUDJy5Mg45phjirEoye233x4XXXRR/OAHP4hhw4bF1KlTY/HixfGTn/ykKTYPAGhmmiSwXH311fHuu+/G3XffXQyc7devX8yZM6d6YO26deuKK4eqnH/++fHMM8/Ed7/73fjOd74TJ598cnGF0JlnnhkHWzr1lO4ns/8pqJbMMXE8tBGfGd8hvle/aBWlz3ItEQDAQeRZQgBA9gQWACB7AgsAkD2BBQDIXosKLPPnz4/LL7+8uKNeuiNufc8qqmnu3LnFgxjTlTEnnXRSTJky5RN1Jk2aFD169Ih27drFgAED4vXXX49yPSbPP/98fPWrX43OnTsXN9JL98r55S9/WavOvffeW6yrZjn11FOjHI9Hah/772sq+z9WoiW1keuvv77OY3LGGWeURRtJt2M499xzo3379nH00UcXT5Zfvnz5py733HPPFfuY2kDv3r1j9uzZtd5P1z+kKyu7du0ahx12WPH8tRUrVkQ5Ho+f/vSnceGFF8aRRx5ZlLSv+38m6mpH6SG5zcHnOSbpt2X//U1tpRzaSGNpUYEl3Qumb9++xY/HZ7F69erivjCDBg2KZcuWxR133BE33XRTrR/oadOmFfedSZc+L126tFh/enDjli1bohyPSfrxSoElfdmmh1ymY5N+zN54441a9dKP08aNG6vLa6+9FuV4PKqkL6Oa+5u+pFpqG0lPX695LNJjLY466qgYMWJEWbSRefPmxa233hqLFi0qbnD58ccfx6WXXlocp/osWLAgrr322rjxxhuLz0r6AUvlrbfeqq7z4IMPxo9//OPi6fa/+c1v4vDDDy/ayUcffRTldjxS0E/H49VXXy0efpsef5KW+Z//+Z9a9VJAqdlGnn322WgOPs8xSdI/Amvu79q1a2u9/2AzbSONptRCpV1/4YUXDljnW9/6VumMM86oNe/qq68uDRkypHr6vPPOK916663V03v37i1169atNH78+FI5HpO6nH766aX77ruvevqee+4p9e3bt9TcfZbj8eqrrxb13n///XrrtPQ2kupXVFSU1qxZU3ZtJNmyZUtxXObNm1dvnauuuqo0bNiwWvMGDBhQ+od/+Ifi9b59+0qVlZWlhx56qPr9bdu2ldq2bVt69tlnS+V2PPb3f//3f6X27duXnnrqqep5o0aNKg0fPrxUDj7LMXnyySdLHTt2rPf9fWXURj6vFtXD0lAp+acut5pSmk3zkz179hS9DDXrpBvipemqOuUuPXYhPbgq/Qu6ptRNmU4h9OzZM6677rriZoHlLN0cMXXTpt6nX//619XztZGIJ554ovhMHH/88WXZRrZv31783f8z0JDvktSbm04j1qyTnq+STh82t++Sz3I89vfhhx8WvRD7L5N6YlJv5SmnnBK33HJLvPfee9EcfdZjsnPnzuJzknqchg8fHm+//Xb1e6vLqI18XgLLAaTGUXV33ippOj2t+I9//GNs3bo19u7dW2ed/ccwlKvvf//7xYfsqquuqp6XPkDpfGy6u/Gjjz5afNDS+eoUbMpNCimpe/bf/u3fipK+aC6++OLi1E/S0tvIO++8E//xH/9RnEqtqVzaSArs6VTxV77ylQPembu+75KqNlD1t7m3k896PPb37W9/uwivNX+M0+mgn/3sZ8Vz5h544IHiNMvQoUOLz1Nz8lmPSQplkydPjpkzZ8bTTz9dLJfuAr9hw4ayaiPZ3ZqfliE9TuG+++4rPmA1x2ykL5Uqffr0KX6c0r8apk+fXpzDLyfpSyaVKukLZtWqVfHII4/Ev/zLv0RL99RTTxVPUk/jNWoqlzaSximkcSjNZfxNjsdjwoQJxfPjUm9KzUGm11xzTfXrNEg5tZMTTzyxqDd48OAot2OSLmCo+cDf9F1y2mmnxeOPPx7333//F7Cl+dPDcgCVlZWxefPmWvPSdBoYlUZod+rUKVq3bl1nnbRsOUtfMOlfzekHZv+u7v2lH6xevXrFypUroyVID/ys2teW3EbSkJf0L8avf/3rxVPcy62N3HbbbfGLX/yiGDh67LHHfq7vkqo2UPW3ObeThhyPmj20KbD86le/KgLJgaRTh+nzVK5tZH+HHHJInHXWWdX7W1kGbeTPJbAcQEq7qTuypjTiuyoFpy/h/v3716qTuvHSdM2kXG7SSP305O30N11F9WnSKaPU65BOn7QE6Yqyqn1tqW0kSV346cv2s/SYNKc2koJY+iF64YUX4pVXXokTTjjhz/4uSetIPzo166RTz+lKkNzbyec5HlVXvKSeg3Ra8JxzzvnU+unUSBrDUq5tZH/p1Nebb75Zvb8nNOM20mhKLcgHH3xQeuONN4qSdv3hhx8uXq9du7Z4f+zYsaWvf/3r1fX/8Ic/lL70pS+V7rzzztLvfve70qRJk0qtW7cuzZkzp7rO1KlTi1HaU6ZMKf33f/936Rvf+EbpiCOOKG3atKlUjsfk5z//ealNmzbFsdi4cWN1SaPVq3zzm98szZ07t7R69erSr3/969Ill1xS6tSpUzFSvtyOxyOPPFKaMWNGacWKFaU333yzdPvtt5datWpVeumll1psG6nyta99rbgSpi7NuY3ccsstxdUcaftrfgY+/PDD6jrpeKTjUiXtY/rcfP/73y++S9JVUoccckjRZqpMmDChaBczZ84s/fa3vy2ukDnhhBNKf/zjH0vldjzSvh566KGlf/3Xf621TGprSfo7ZsyY0sKFC4s2kj5PZ599dunkk08uffTRR6XcfZ5jkq60/OUvf1latWpVacmSJaVrrrmm1K5du9Lbb7/d7NtIY2lRgaXqEtT9S7p8Lkl/L7rook8s069fv+LD1bNnz+LSs/398z//c+m4444r6qRLWBctWlQq12OSXh+oftWl3127di2OxzHHHFNMr1y5slSOx+OBBx4onXjiicUXy1FHHVW6+OKLS6+88kqLbiNJCrCHHXZY6Sc/+Umd62zObaSuY5FKze+GdDxqfiaS6dOnl3r16lXsc7pdwqxZsz5x2epdd91V6tKlSxFwBw8eXFq+fHmpHI/H8ccfX+cyKcgl6Yf90ksvLXXu3LkIdqn+zTff3GxC/uc5JnfccUf1d0RqA3/1V39VWrp0aVm0kcZSkf7nYPfyAAAciDEsAED2BBYAIHsCCwCQPYEFAMiewAIAZE9gAQCyJ7AAANkTWACA7AksAED2BBYAIHsCCwCQPYEFAIjc/T+GJvLS1hlBtgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -83,12 +83,14 @@ ], "source": [ "plt.hist([i for i in qbits.get_all_distances().flatten() if i > 0.01])\n", + "plt.title(\"Qubit distance histogram\")\n", + "plt.xlabel(\"Distance\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -120,12 +122,12 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -136,6 +138,8 @@ ], "source": [ "plt.hist([i for i in qbits.get_all_distances().flatten() if i > 0.01])\n", + "plt.title(\"Qubit distance histogram\")\n", + "plt.xlabel(\"Distance\")\n", "plt.show()" ] }, @@ -148,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -166,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -181,7 +185,7 @@ " 1.00 Z4 Z5]" ] }, - "execution_count": 33, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -199,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -208,7 +212,7 @@ "[1.00 X0, 1.00 X1, 1.00 X2, 1.00 X3, 1.00 X4, 1.00 X5]" ] }, - "execution_count": 34, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -220,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -241,7 +245,7 @@ " 1.00 X5]" ] }, - "execution_count": 35, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -261,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -282,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -311,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -320,20 +324,20 @@ " message: Optimization terminated successfully.\n", " success: True\n", " status: 0\n", - " fun: -6.839109873659719\n", - " x: [ 2.817e+00 1.829e-01 ... 2.883e+00 7.040e+00]\n", - " nit: 130\n", - " jac: [-6.557e-07 1.311e-06 ... 3.278e-06 5.245e-06]\n", - " hess_inv: [[ 4.449e-01 8.411e-02 ... -9.078e-03 -4.828e-02]\n", - " [ 8.411e-02 4.946e-01 ... -5.601e-02 2.424e-01]\n", + " fun: -6.839108621944124\n", + " x: [ 6.608e+00 1.829e-01 ... 3.206e+00 2.269e+00]\n", + " nit: 136\n", + " jac: [ 7.749e-07 -4.172e-07 ... 5.364e-07 -5.960e-08]\n", + " hess_inv: [[ 4.487e-01 -7.747e-02 ... 1.160e-02 1.365e-01]\n", + " [-7.747e-02 4.820e-01 ... -8.475e-02 -4.285e-01]\n", " ...\n", - " [-9.078e-03 -5.601e-02 ... 7.439e+01 -2.515e+01]\n", - " [-4.828e-02 2.424e-01 ... -2.515e+01 3.082e+02]]\n", - " nfev: 3600\n", - " njev: 144" + " [ 1.160e-02 -8.475e-02 ... 1.789e+02 4.709e+02]\n", + " [ 1.365e-01 -4.285e-01 ... 4.709e+02 1.455e+03]]\n", + " nfev: 3800\n", + " njev: 152" ] }, - "execution_count": 38, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -351,67 +355,88 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "{'101001': 49,\n", - " '100011': 124,\n", - " '110011': 79,\n", - " '101010': 76,\n", - " '110001': 66,\n", - " '010101': 10,\n", - " '111111': 4,\n", - " '110010': 72,\n", - " '010011': 25,\n", - " '100101': 13,\n", - " '100110': 8,\n", - " '100010': 80,\n", - " '010010': 17,\n", - " '101011': 88,\n", - " '100001': 72,\n", - " '101100': 4,\n", - " '010001': 17,\n", - " '001010': 3,\n", - " '111010': 10,\n", - " '111001': 10,\n", - " '111101': 6,\n", - " '110000': 12,\n", - " '000011': 10,\n", - " '111011': 15,\n", - " '110111': 10,\n", - " '001001': 7,\n", - " '100111': 3,\n", - " '111110': 1,\n", - " '110110': 4,\n", - " '101110': 6,\n", - " '001011': 8,\n", - " '110101': 16,\n", - " '100000': 11,\n", - " '010000': 4,\n", - " '101101': 15,\n", - " '011010': 2,\n", - " '000001': 1,\n", - " '101000': 8,\n", - " '011000': 1,\n", - " '000010': 5,\n", - " '101111': 6,\n", - " '011001': 2,\n", - " '100100': 4,\n", - " '010110': 1,\n", - " '011011': 3,\n", - " '110100': 4,\n", - " '000101': 2,\n", - " '001000': 1,\n", - " '001101': 1,\n", - " '001111': 1,\n", - " '111000': 2,\n", - " '000000': 1}" + "
" ] }, - "execution_count": 39, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cost_hist)\n", + "plt.ylabel(\"Energy\")\n", + "plt.xlabel(\"Iterations\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'011101': 86,\n", + " '001101': 59,\n", + " '010110': 65,\n", + " '101010': 6,\n", + " '010101': 73,\n", + " '010100': 81,\n", + " '011110': 67,\n", + " '101101': 14,\n", + " '011100': 99,\n", + " '111100': 4,\n", + " '101110': 21,\n", + " '011011': 8,\n", + " '001110': 72,\n", + " '101100': 27,\n", + " '001100': 81,\n", + " '000110': 14,\n", + " '000100': 10,\n", + " '110011': 1,\n", + " '111010': 2,\n", + " '001010': 17,\n", + " '011111': 17,\n", + " '001111': 16,\n", + " '010111': 9,\n", + " '110110': 5,\n", + " '111101': 10,\n", + " '011000': 11,\n", + " '100101': 3,\n", + " '001000': 7,\n", + " '010010': 19,\n", + " '101000': 3,\n", + " '001011': 3,\n", + " '010011': 3,\n", + " '101001': 2,\n", + " '011010': 20,\n", + " '001001': 8,\n", + " '101111': 7,\n", + " '000101': 12,\n", + " '011001': 5,\n", + " '110100': 5,\n", + " '010000': 5,\n", + " '000111': 4,\n", + " '000010': 4,\n", + " '111110': 6,\n", + " '100001': 1,\n", + " '010001': 2,\n", + " '000011': 1,\n", + " '100110': 2,\n", + " '111111': 1,\n", + " '100011': 1,\n", + " '000001': 1}" + ] + }, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -423,23 +448,24 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'100011': 124,\n", - " '110011': 79,\n", - " '101010': 76,\n", - " '110001': 66,\n", - " '110010': 72,\n", - " '100010': 80,\n", - " '101011': 88,\n", - " '100001': 72}" + "{'011101': 86,\n", + " '001101': 59,\n", + " '010110': 65,\n", + " '010101': 73,\n", + " '010100': 81,\n", + " '011110': 67,\n", + " '011100': 99,\n", + " '001110': 72,\n", + " '001100': 81}" ] }, - "execution_count": 40, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -458,12 +484,22 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -473,7 +509,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -483,7 +519,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -493,7 +529,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAD0CAYAAACGoBLMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQKpJREFUeJzt3Qd4VHXWP/AzSYYUIAESWoBQApJICTU0abKiwCK4sGLBwgqii7qu5V14H1cX/fuy+rLqorjYsMKi4qIL4tqo0kF6DQQIHVIIIT2Z+3++h9y8A6ZMkplM+36e5z4wkxscb27uPff3O79zLIZhGEJEREREFQqo+MtERERExKCJiIiIyEEcaSIiIiJyAIMmIiIiIgcwaCIiIiJyAIMmIiIiIgcwaCIiIiJyQJAjO/kzm80mp0+flvr164vFYnH3xyEiIiIHoAxlVlaWREdHS0CAc8aIGDRVAgFTq1atnHKwiYiIqHadOHFCWrZs6ZR/i0FTJTDCZB708PDwah3kPcln5Jn538jxyxmSX6dQbGGGiFVEMHCFeuyFIgE5FgkusErreg3l//1uhHRu17xa/y0iIiJPtKeW74WXLl3SQQ/zPu4MFrZRqfygR0RESGZmZrWCpl1HTsu0OV9Iii1DisMNMeqKSKiIBJdklNlEJF9EckUs2SKBlywSE9BQ5j42TrrGRlf7B0tEROQpdrnhXljT+3dZmAjuQmmZ2fLUvKV6khQ1NMSIFJHGIhJV8mfjq1/j69gP+z89b6l+PxERkTdL86F7IYMmF1q+cb8czUrXqFoaiEjDki2yjM38WgPR/ZOz0uSbTQdc+fGIiIhcbrkP3QsZNLlIUbFNFq/ZKfnBhVeGIeuXbBFXTobSE8f8e8T/7YP984OLZPHqnfrvEBEReaMiH7sXMmhykc37U+RwWuqVRDfM24aISJiImCdNhN1Wv+T9sJL9QkVsoYYkpV2QLQdSXPURiYiIXGqzj90LGTS5yInzF6XQYruyMiC45AQwN5wQ9UQkvORP8wQxN+xfBwsJbPrvEBEReaMTPnYvZMkBF8nNL9QVlLqUMsBuCyzZrHZH33zPfj+LiGExJCev0FUfkYiIyKVyfexeyKDJRUKDrXqO6Nlis9uKSzbz519o9579fgbqQVgkLARnFBERkfcJ9bF7IYMmF2nVpIFYjYArJwJqT+TZbebPPrDkBMm55uvYvwC7Bei/Q0RE5NX3wgLfuBcyaHKRxPgYaR8ZJdsvn5LiXOPKCZBjd5IU2p0o+Fq23QmDP7NF2jVoKL3jYlz1EYmIiFyqd1wriQ6tK5nZeVff4xy5F+aKBORapENkY4+5FzIR3EWCAgNk/KAECc63anVTySrZMkXkYsmWYff3TLt9UA01WyQ8/7xsWL9OioqKXPUxiYiIXOLcuXPyz4ULpFFxmt7TpIr3Qtw7g/ODZPzgBL2negKONLnQyL7x8vEP2+TgpXNSFKipcCKIf3JLVgaYpePNoUicKBevlI+PkkBpVa9IVqxYIT///LPcdNNNEh8fLxaLzg4TERF5pJycHFm5cqVs27ZNDMOQ9g0DJKUgVE5n5UhRUNXuhe3qR8qIPnHiKdh7zoN7z1ly0uT777+XrCycQSJt2rSRm2++WZo1a1a9nzYREZGLFBcXy9atW2XVqlWSl4foR/RhHw/9J9Jzq3UvfPOx8dIltrnH9J5j0FQLBx2BE/rnJGela1VUFOsySjo767hRwZV5WwxDIqqe/dCtpSdJQUGBrFu3TtavX6/TdBhp6tGjhwwdOlTq1sVZR0RE5F6HDx+Wb7/9VlJTU/V106ZN5ZZbbtGHfWfcC6uDQZMbOOugo+Eg+ud8vnqHJKWlSnZBnp4ldaxWqSOBmuiGeVsMQ0ZG/DIYunjxovzwww+yd+9efR0cHCxDhgyR3r17S2AgsuiIiIhqV1pamnz33Xdy6NAhfR0WFqYP9Xi4DwgIcPq9sCoYNLmBsw86+ues350sb72/QAptIrfdOkraREfpygBHEt2OHz8u//nPf+Ts2bP6OioqSqfs2rdvX+PPRkRE5Ii8vDxZs2aNbNq0SWw2mwZIiYmJMnjwYAkJQaKSa++F7gqamAhey3Ay9L0+RlY2uvJ63OCuUqdOHYe/v3Xr1jJlyhTZvn27JoljKHTBggXSoUMHGT58uAZRRERErmCz2WTHjh16/8nOxnI40Yd2PLxX5f5T03uhuzBo8kKI6Hv27CmdOnUqjfSTkpLkyJEjVYr0iYiIHJWSkqIzHWfOnNHXkZGRGizhod1fMGjyYgiMMLqEuWPMKSNw2rhxo+zatUtuvPFG6d69e5lzykRERI7C9BZWcu+1y6nFwzke0v0tp9br7qhz587VbHwEDH369JHNmzc79H2LFi3SlWdjx44VX4Mh0bvuukvuvvtu/TtqZCxbtkzefvttOXbsmLs/HhEReaHCwkItH/DGG2+UBkw9evSQRx99VPr16+d3AZPXjTR9+umn8sQTT8i8efM0YHrttdd0aPDgwYPSpEmTcr8PgcNTTz0lAwcOFF+GeeW2bdvKli1b9ERHNdYPP/xQrr/+eq2T0aCBZ/TuISIiz4WClAiSMLqEZGozn/aWW27x+zqBXhU0vfLKK5oEPWnSJH2N4Onrr7+W+fPny/Tp08sttoURmJkzZ8ratWt16b4vQ+Tft29f6dKli1ZkRTXxffv26XLQ/v37y4ABA7wi2Y6IiGrf6dOnNW/pxIkT+hqrz5AGwo4UXhY0ocgjSrLPmDGj9D3k6/zqV7+SDRs2lPt9zz//vI5CPfDAAxo0VSY/P183kxllexsUvvz1r3+tdZzwC4DRNiSNY9UdjhmCKrZkISIiuHz5svz444+6Mg6sVqvccMMNOg2Hv5OXBU1YWo9RI1QZtYfXBw4cKPN7fvrpJ3nvvfdKTwJHzJo1S0elfAWOz7333qvHCMniGGlbsmSJTuFhqLVFixbu/ohEROQm6DSBFdh4qMbgBOChGg/Xzqpt5Eu8JmiqKvRru+eee+Sdd96pUu0IjGQhb8p+pKlVq1bizTCihKFVLAvFqBxG3E6ePCnvvvuudOvWTVfa1a9f390fk4iIajFvCWkbaH2SkZGh70VHR+vDtLff81zJa4ImBD7I10Fysz28LquBLWoWYUpq9OjRVxXlgqCgIE0ej42N/cX3YSklNl+E/28kwyNQwjDszp07dRQOOU94H7lQ2IeIiHzX+fPnNVhKTk7W1/Xq1ZNhw4ZJQkIC0zYq4TV3SCQvo6AjbvZm2QAEQXj9yCOP/GL/uLg42b1791XvPfPMMzoC9fe//92vI2mMKuEY9urVS/OdTp06pccRSeNI+OvYsSN/cYiIfExubq4uENq6dauONJkLh/DQ7KuDBX4bNAGmze677z692aOoFkoOoIy7uZoOuTvI0UFeEuo4de7c+arvN5fcX/u+v2rZsqUmyKMYJpoBY4gWZR1QtgBDtBWVcSAiIu+AAQYESihFg8DJHFjAQ3LDhg3d/fG8ilcFTRMmTJALFy7Is88+qw1rMc2EkRIzORwl3lkBu+r5ThiSRc4TEufXr18vR48e1XIOGNlDt2p0rSYiIu+DKTjcJ3HvBDwMo75hu3bt3P3RvJJXBU2AqbiypuMAUXRFPvjgAxd9Ku+H6U+z9QoKmu3fv1+fTPbs2SNDhgzR0T1/rP5KROSN0tPTdcU08nchNDRUH4LxMMzBBT8Kmsi1MFR7++2362gTEgWRaI+nFNTIwtNJWcnzRETkGVBnECuk0YcUZXowm4B6fXj4ReBENcOgicqEvKYHH3xQk8NXrFihQ7uffPKJXHfddToPju7WRETkGZDYjRXRWNSDQpWAh1w87DZu3NjdH89nMGiicmEIF9NynTp1ktWrV2tBTNT1OHz4sK64GDRoEFdcEBG5GVqeYEYALVCgUaNGGiyhNh87PzgXgyaqFIZ0sZoOARSm7BA0IWEcTzXIg0JCPufIiYhqF4ovY+WzWV4HuamDBw/W1eWsuecaDJqoSgVG0fw4KSlJg6e0tDRZunSpJowjqIqJieHRJCJyscLCQn1wXbdunf4dsIgHD7EoVEmuw6CJqgxDvliuunnzZp22O3PmjLz//vta/wr9itAVm4iInJ+3hA4OWOGcmZmp7+FhFQ+tzZs35+GuBQyaqFpQfgDdr7t27aqJ4kgYR3kCNAYeMGCAbuyMTUTkHHg4Rd4S6hECmunedNNNmnPKvKXaw6CJaqRu3bra38/Mdzp+/LiOPm3fvp2/0ERENYSuF1gRh2sqIFeJD6buw6CJnAJDw2hxYz90/MUXX+gUHoaO0T2biIgcgxpLmzZtkjVr1mjtJWAKhPsxaCKnwRAxhopRy2nDhg3algVLYd955x1dYYcu2kxSJCKqOG/JXGyDqt7mQykX23gGBk3kdMhlQg0nBErmctgdO3boKBTe79OnD5fDEhFdA0WE0foEZV3M9Ac8bOJayrwlz8CgiVwGiYq/+c1vtIS/WXgNQRSSxlFVHCNSvBAQkb/Lzc3VXFCkM2CkCXXvWEDYMzFoIpdr1aqVTJ48ubTEP4acFy1apGULULUWXbeJiPyNzWYrbVWFwAk6duyoi2jYqsozMWiiWoERJQwxx8fHlzaTTE5Olnnz5rGZJBH5HTRFxwj8+fPn9TX6w7Epuudj0ES1Kjg4WAtg9ujRQ1fZoa4ThqSR9zR06FDp2bMnW7IQkc/KyMjQa9/+/fv1dUhIiF77ULaF7ag8H4Mmcgs0lJwwYYKONmGVCJ62li9fri1Z8LSFqTsiIl9RUFCgo+xYWYxyAhh9R6A0ZMgQCQsLc/fHIwcxaCK3QnA0depU2bZtm6xcuVKDp48//lji4uJ0Xh/BFRGRt0Ji965du3QRzOXLl/W9tm3bagkB5nN6HwZN5HYYksYKOxRuW7VqlWzZskWn7VCrBCtIBg4cqNN6RETe5OTJk5q3dOrUKX3dsGFDXTmMZG+uHPZODJrIY4SGhsqIESM0rwlTdpi6QxdvrLpDrZKEhAReaIjI4126dElXCmOECerUqaMPf3gIRBsU8l786ZHHwZD1xIkT5dChQ1roDSUKvvrqKx2BwpA2ShgQEXmawsLC0m4I+Dtg1fCNN94o9evXd/fHIydg0EQeCUPXGMKOjY0t7b+E4pjz58+XLl266Ao8FM8kIvKEvCWshsOquIsXL+p7LVu21Ie8Fi1auPvjkRMxaCKPZnb0xtQcCsCh0zfKEyDnCe/3799f27YQEbnD2bNnNZ3g2LFj+hojSljEghxN5i35ngDxMnPnzpU2bdpobQv0MEONn/KgUSzmkZF8hw2jExXtT54LjX5vvfVWmTJlik7PYegbSeM4H/bu3atPekREtSU7O1uWLVsmb7/9tgZMeMBDb81HHnlER8MZMPkmrxpp+vTTT+WJJ57QKtIImF577TWt6XPw4MEyl27ipnrnnXfqaASCrJdeeklXLuAmyyFT7xQdHS2TJk3SnyGGwjMzM2Xx4sUSExOjQ+HoBk5E5CqosYT8Stxf8vPz9b1OnTrpQ3mDBg144H2cxfCiR3QESlia/sYbb5T27cGow6OPPirTp0936GTHiBO+/95773V4FURERITenJ2VQ4MiZ7NmzdK/z5gxQ1dWUNVhtAmr67AVFRXpe6g0jqRLdAcnInImlEHB4pTU1FR93axZM31Ya926NQ+0B94LXXH/DvKmg4sCiDiw9vV9EN1jtYIjcnJy9EZbUcFEPDmYTw/mQSfPhFwmVNPt3r27Fo7bs2ePNr/EKNTgwYMlMTFRAgMD3f0xicjLIUhCsISgCVDBGw9nuPaw9Yl/CfKmkxYjRU2bNr3qfbxGUrAj/vSnP+n0DgKt8iDqnTlzZo0/L9UePEmMGzdORyFRSO7MmTN6gUOQjenbDh068MdBRFWWl5cnq1ev1lxYzGwgQMKMB3KXkPJB/sdrgqaa+utf/yqLFi3SeeiKTnaMZCFvyn6kiXWBvAPymiZPnqzFMFFYLi0tTRYuXCjt27fXXDZ0ESciqgwCJKzUxYpdzFAAHr5wHYmKiuIB9GNeEzThRMVUy7lz5656H68xr1yR2bNna9CEKZyuXbtWuC/adbBlh/fCkyCGzK+//nqt7bRx40Y5fPiwVhfHSBSm7VB5nIioLFgJhxFr816Dew9GrPHwReQ1QRMSxNBeAyMIY8eOLX0awGss8SzPyy+/LC+++KLW0UBHafIPCHxRKwWJ4ZiqQ3VxFMlEWwPkIuB95iIQkQlFKbEid9++faXXEORM4mGLuZHkdUETYNrsvvvu0+AHSb4oOYBaGViCDlgRh1ICZjY+Sgw8++yzOkWD2k4oQmbW/MFGvi8yMlLLThw5ckQD5wsXLsjXX38tW7du1adHdBsnIv+FRUZoe4IFRViFi/pKeKgaOnQoV+GSdwdNEyZM0JseAiEEQOjpg2FUMzk8JSXlqtGDf/zjH/oLMX78+Kv+neeee07+8pe/1PrnJ/dBO5apU6dqsIS8Ngy9f/TRRxIfH68jUihFQUT+A9V20F0AaRtZWVn6Hh6uUULg2gVHRF4ZNAGm4sqbjsPN0J5Z1p4IMMSOlS+o1otzBQEU+kVh6q5fv35aPZ41s4h836lTp/SB++TJk/oaRSmR5B0XF8dK3uRbQRNRTaHGysiRIzVHDlN2R48e1eH5HTt2aDkKLBZgCwQi34MRJayIw++6WesND0t4aEIbFKLK8Cwhv4Uh+HvuuUfb8CBZPCMjQ7788kttkYAhenQpJyLvh1wlrKRdu3atpmwAmoAPGzZMG+wSOYpBE/k1jChhSB7Lic2LKobu33vvPR1xwsgTL6pE3pu3ZP9QBFgsxIciqi4GTUT4RQgKkhtuuEGfPs3he5QnQM4Th++JvA8We5jT74AV05x+p5pi0ERkB6NKY8aM0bIWZqIogij0tMMqO6y2Y74TkedCBe+VK1dqGyWMNGEBSP/+/fWhiAs9qKYYNBGVAUP4v/vd77QJMAreofDd559/ziXJRB4KvUnNkiLoGQcsKULOxqCJqBwYUUJ5go4dO8q6detk/fr1WsbirbfeYvE7Ig9iX7zWXOSBvCXUXSJyJgZNRJXAkD6qA6OnHQrh7d27V4f+8Sd62bHNApF7oCm32SYJ0FeSbZLIlRg0ETkIBfBQXR5BEvKdUJUeT7cIoNjQk6j25OfnlzbkRg9SdIJgQ26qDQyaiKqodevWMmXKFNm+fbsmiaempsqCBQukQ4cOGjyh3x0ROR8CJKxsxe8d+o4CyoXg9y4qKoqHnFyOQRNRNeDJFhXFO3XqJKtXr5bNmzdLUlKS5lagmTSm7UJCQnhsiZwEvUUxwnvmzBl9jYcTBEt4WCGqLQyaiGoAgREu3AigkFuBwAlTBqjxhNwK5EHZN5EmoqrJzMzUFazIIYTg4GB9KMHDCcoJENUmBk1EToCpgbvuukuDJuQ5IUF12bJlugQaq3gwpUdEjissLNRVq9jQBgV69OihDyN169bloSS3YNBE5ESYKmjXrp32r0O9GCSLf/DBB3L99ddrcUwkkxNR+VCQEqNKGF26dOmSvoeHDozoNm/enIeO3IpBE5GTYcqgb9++WuMJlYlRTXzfvn26LBqViQcMGMDKxERlOH36tOYtnThxQl9HRETI8OHDWYmfPAaDJiIXwRTCr3/9a23Jgik7FMbEMmmsukMPLARVbMlCJHL58mX58ccfdWUcWK1WbXvSr18//TuRp2DQRORizZo1k3vvvVeb/5otWZYsWaJTeMh3QssWIn+EXKVNmzbpw0RBQYG+h4cJPFSEh4e7++MR/QKDJqJagBEl5DVdd911smHDBlm7dq02A3733XelW7dumtyKZsEVKSq2yeb9KXLi/EXJzS+U0GCrtGrSQBLjYyQokCv0qPYVF9lk/+YUOX/iouTnFkpwqFWatGog8YkxEhgUUGHeEqarseI0PT1d34uOjtaHiFatWtXi/wFR1TBoIqpFQUFBMnDgQElISNDpCJQmwJQEcp7wPnKhsI+9tMxsWb5xvyxes1MOp6VKocUmBgIxTGMYAdI+MkrGD0qQkX3jJTKCq4rI9TLTsmXj8v2yZvFOSTucKpZCm5gnpWENkMj2UTJofIL0HRkvEZFXn5Pnz5/X6erk5GR9Xa9ePRk2bJj+TnC6mjwdgyYiN8DUw2233VbakuXUqVMaRCFpHImvaBKMG8iuI6flqXlL5WhWuuQHF4qtoSFiLYmYcJMqFNl++ZTsW3JePv5hm8x+aLR0jY3mz5Rc5siu0zLvqaWSdTRdgvMLpaHNuPaUlMvbT8mSfeflh4+3yUOzR0ts12jJzc3VFaWYlsZIk7lgAg8LqL1E5A0YNBG5UcuWLeWBBx7QESc0A87IyJBPP/1U2rZtKzHxPeXPn6yQFFuGFEcaYuCBPRTV/VCSHD0l0IRLpDjXkNzsAjl46ZxMm/OFzH1sHAMnclnANGfaF2JLyZDIYkPqGmWekpJbbEh2boFcOnhO5vz+Cxk2LU4OnNiugRPExcVpCY5GjRrxJ0VehUETkZthRAlTE/Hx8ZrrhJynfUlHZfZ3RyUjQsSGVnYo74SUp5CSzbxD5V3ZjBCRokBDUjIy5Ol5S2XhMxM5VUdOn5LDCBMCpoZFRmWnpIQYIoFFhqQeS5fPZq2XtiNFols30XpLqGVG5I28Lnt07ty50qZNG21f0adPH+35VZHPP/9cn2qwP1ZlLF++vNY+K1FV1KlTR3M7pk2bJnmhzSSzjogtoiRgaliyRZaxmV9rIFIcbkhyVpp8s+kADz45FXKYMCUXXmxU5ZSUBoZInUsirep1lqlTpzJgIq/mVUETpi2eeOIJee655zT3A0/neGpBYmFZ1q9fL3feeadOf6A2ztixY3Xbs2dPrX92IkfVD4+Qo9lBYquHLNmSx3lsZgBl3rHMv0f83z6YwssPLpLFq3fqajsiZ62SQ9I3cpgwJVeFU/LKKWyzyPGtmWLwlCR/m5677777NAgZNGiQ1LZXXnlFpkyZIpMmTdLX8+bNk6+//lrmz58v06dP/8X+f//733UJ69NPP62vX3jhBa2T88Ybb+j3EnkilBXAKjkDd6HQkrmPMFTLLLkL4e/oU1qM5XMl34TsW6SLhIrYQg05lHZB1u9Olr7Xx7j5/4Z8wd6NxyUtKVUa2IzqnJISajMkLemCHNiSIp36tXHz/w1RLQZN6DiNwmPoBYTgBUFUbRTnQ+Gzbdu2yYwZM0rfQ/d4fBbkgJQF72Nkyh5Gpr788sty/zv5+fm6mczeR0S1BXWYUFZA7z7Bdkkj5p0Kj+7WkruSlPxpfj0YS75Fsgvy5K33F8hK5tmSE6QfFCnIQYmLap2SUkfftGk9p079+CMhP5qeQ8CB5dEPP/ywTpchv2jEiBGyePFi7UrtKqmpqVJcXCxNmza96n28RlPUsuD9quwPs2bN0n5H5sZCa1TbULgSS7d1DXeA3RZYsllLHnesdu/Z74fvs+g9isgpbEUiFqOGp6RhSF6O6+4RRB67eq5x48Y6goMNuUXvv/++3HPPPVqkbOLEifL73/9eu717I4xk2Y9OYaSJgRPVJlT6xk1GIyeb3VZcstk/zpvv2e2H761jtcpttw6XcYO78odHNbZq8S75147vRIoLxWZU+ZTUU9mwWCQkjH3kyI9LDpw5c0ZzhLChUNnIkSNl9+7d2i7i5Zdflj/+8Y9O+6BRUVH63zh37txV7+M1enuVBe9XZX9AkTUWWiN3QmuUICNABK248u3WcGMz7zlmAknONV/H/gWYDgmUNtFRuiKPqKai20SJWAOlUAqre0qKWAO0xQqRX03PYQruiy++0O7tyGvCkv7HH39cTp8+LR9++KEW6Pvss8/k+eefd+oHxcW/Z8+eWjXZZLPZ9DU6YZcF79vvDwjwytufyBO0CA+U8KJiMbLt7kD4E6+zkFhot+G1/X65IgG5FukQ2Vh6xzEJnJwDveTQGiUnwKLJ3VU5JXU/QySoiVXadr06XYLI50eamjdvrsEKlvKjRhKajV5r6NCh0qCB858oMG2GxPNevXpJYmKivPbaa5KdnV26mg6d5JGUjrwk+MMf/iCDBw+Wv/3tbzJq1ChZtGiRbN26Vd5++22nfzaimsrKytIgf+fOndI6TOTsZZFC864UdE2GrX0lwZySfbJELNkiwflBMn5UApv4ktOg+S56yaE1Cip9o3Clg6ekBlDZQSL1mmbJP+a9qYt3unbtyj5z5B9B06uvviq//e1vtVhkeRAwHT16VJxtwoQJcuHCBXn22Wc1mRsBG/p2mcneKSkpuqLO1L9/f1m4cKE888wz8t///d+aZ4VE9s6dOzv9sxFVV1FRka70RDVwczHFr/t3ktTN5+VwVqoUBWlauEhRyRrussov4+50USTwkkXa1Y+UEX3i+AMhp0LzXfSSQ2sUVPp28JSUrCCL1GsTITHdDLl8OVOvweg/h3IwaCNE5E0sBjonUrmQCI5VdCi1gCarziqfYI6GIfGceSf+Cb96Bw4ckO+++04uXrxY2osONxOMmKJZL3rJae+58PJ7z+GuhREmBEwxAQ3lzcfGS5fY5u7+3yMf7z0XXlHvOYwuWUQuBVokIKahPPbmeGkd31g2bdoka9as0WsgYMQJVfCddW0l71Lg4nuhK+7f7D1H5AZYkPDtt9+WjsjWr19fpy3Q6ge96KBrbLQ230UvueS0dMm/XCi2MEOuailfcCWHCVNyGGGa/dCtDJjIZWK7Rstjc8fJvKeXSlpyulzOL5Qwm3HtKSm5ARbJDw6S+u0i5aHZt0pslytB/IABA7STA6ahd+zYoY2q9+/fLzfccIPmmlqtXF1Hno1BE1EtysnJkZUrV2qhVow0YUUoppFx0yjrKQuBE5rvopfc56t3aKXwQrGJYTHEYljEKgGa9I0cJkzJRUZgOIrItYHTMwsnyqZvDsjqz3dI2uFULQqGOkwoK4BVcpEdGsuo8QnSZ0ScRERefU6iNM2YMWOkd+/eml5x4sQJ/Z1Aq6ubbrpJG1ebDw5EnoZBE1EtQGFWLEJYtWqV5OUh40O0NAduEpUtmkAgNHF4T7ljWHfZciBFK4bn5BVKWIhVyxNglVxQoFe1kSQvh0Bo+MSeMuyO7toaBZW+UbgSdZhQViCud4wmj1ckOjpaF/GgFyhWXWOKGquxsSobU9QVlYYhchcGTUQudvjwYZ2KQ1V7wMIF3BRQTb8qEBj169RG+nVy0QclqiIERuglV93WKBhRwpR0x44dZd26ddpk/fjx47rCuUePHroSu25djp6S52DQROQiaWlpmuR96NAhfR0WFiY33nijdO/e/apVnkT+DlPTCJDwu4FRp7179+oUNkahUDYGJWYwlU3kbgyaiJwM029YIYSVQqhphgAJF31c/Csq1UHk7zBVPX78+NJ8J5SWwYMHAig0W/fW9lzkOxg0ETkJAiSsCFqxYoUWXQVc5IcPH65tgIjIMchrmjJliv4+YaUdRm1Rc4+/T+RuDJqInAB5GOaTMURGRvLJmKgGMEKLvCYsmDBHbpOSkuTIkSMcuSW3YdBEVAMomoZ+hsjBADR7Zg4GkfNgShujteg9auYIbty4UWs8MUeQahuDJqJqVrI1V/ugDQrgos7VPkSugdFb9Dy1X426bNmy0pYsVV2NSlQdDJqIqgAFKc26MijRD6wrQ1R72rdvL23bti2te4bq+h9++KHDdc+IaoJBE5GDTp8+XVrBGNDTCNMGrGBMVLtQfqBPnz5a48mssL9v3z45ePBghRX2iWqKQRNRJS5fvlzaKwvQH4u9sojcD7XPRo0aJb169dIHmmPHjsnatWv1d/XaXo5EzsCgiagcyFViV3Yiz4cq+/fee68cOHBAk8XRkmXJkiWl+U4tWrRw90ckH8GgiaiMvCUM8+Pim5GRUdonCxffVq1a8XgReSCMKGGqHLWcNmzYoCNOJ0+elHfffVcSEhJk2LBhUr9+fXd/TPJyDJqI7Jw/f15X5iQnJ5d2ZMcwf9euXTnMT+QFgoKCZODAgdKtWzedVt+5c6du+/fv1/f79u2r+xBVB88cIhHJzc3VhFKsyMFIExJN+/Xrp7lLqL1ERN4Fo0pjx44tzXc6deqUBlE///yzrrKLi4vjgxBVGYMmEn9vfWIuXUbgBBjix0W1YcOG7v54RFRDLVu2lAceeEB2796tpUIw5f7ZZ59p2QL0s0M+FJGjGDSR38IUHJ5AL1y4oK+bNGmieUu4mBKRb+U7YYodo0s//fSTFqU9evSovPXWW6VFabESj6gyDJrI76Snp2uSN5K9ITQ0VC+auHii3xUR+SbUbjJbr6D9EfKcMNKMgrVDhgzRqTxMzROVh0ET+Y38/HxdUYO+VcXFxfr02bt3b71YInAiIv+Aqffbb79d6zphtBlVxfEnAiiMNsfGxrr7I5KHYtBEPg+J3Sh2hyTQ7OxsfQ8XReQzNG7c2N0fj4jcBP3qHnzwQU0OX7Fihfaz++STT+S6667Tav/od0dkL8CbplTuvvtuCQ8P195CSOxDpeaK9n/00UelY8eOOooQExMjjz32mHalJ/+BlifvvPOO/Pvf/9aAqVGjRtr0E+cSAyYiwpQ8puVwv0BrFrw+dOiQvPnmmzqNn5eXx4NE3jfShJvcmTNndB66sLBQJk2apE8ICxcuLLdPGLbZs2drI8fjx4/LQw89pO8tXry41j8/1S4008VKGayYMXMZBg8erBdF5iwQ0bXwcI2pOQRQqNV2+PBhLZK5a9cuzYNC3SfmPJJXBE1I1sN8M0ri44SG119/XUaOHKlBEao1X6tz587yxRdflL7GdMyLL74oEydO1PYYLG7mmxBQY2XMunXr9O+ApE9c9FCokoioIlFRUfqQnpSUpMFTWlqaLF26tDTfCbMW5L+8ImhCtI8pOTNgAlRpRtSP3mC33XabQ/8OpuYwvVdRwIRkYWz2IxbkHXlL6HKOkUhzChYXN1zkmjdv7u6PR0ReBu1Y2rVrJ5s3b5bVq1frTMf7778vnTp10jpuERER7v6I5AZeETSdPXtWa+jYQ+CD/BR8zRFI8HvhhRd0Sq8is2bNkpkzZ9bo81LtwsUMI5EpKSn6GoExLmq4uLHDORFVl9kZADWekCiOhPG9e/dquZIBAwboZrVaeYD9iFsTwadPn643tYo2dK2uKYwWjRo1SnOb/vKXv1S474wZM3SkwtyQSEyeCYndSPB+++23NWBCII28pUceeUSnZxkwEZEz1K1bV0aPHq0P3a1bt9YUD4w+vfHGG1rjCSPd5B/cOtL05JNPyv3331/hPhgebdasmTZStYeTFivk8LWKZGVl6RQN+hAtWbKk0qcC9BljrzHPhhpLmJZds2ZN6VQqgiRM2XLInIhcBVP99913n+bZYmUdHqyRO4spPNxnysqvJd/i1qAJS74dWfaN4dGLFy/Ktm3btGozYKgUfcOwGqqiESbU4kEQhBGJkJAQp35+ql14mjOTMxEwmxcxJmcSUW3BCDZmLZDzhHxbtGUxS5tghd2wYcO46MSHeUVOExqo4sY4ZcoUmTdvnq6KwhTMHXfcURrZo4M1TtaPPvpIEhMTNWBCcbKcnBwtVobXZlI3AjUuO/cu6A+HYOnIkSOlw+X4eeMixWk4IqptmLUYNGiQXoPM8iYooosFKXgfD/Rcpe17vCJoggULFmighBslVs2NGzdO5syZU/p1BFJIzkOQBEjYwxQOtG/f/qp/C40aUQmWPF9ubq7mDmD4GyNN+Nn37dtXL0qcRiUid8PCk9/85jfakgkLUlALEEEUZkYw04Hq4nyw8x1eEzRhpVx5hSwBQZB9Mh76iTE5z3th6hUXnZUrV2rgBKjujlVxbG1ARJ6mVatWMnnyZNm5c6e2bMrIyJBFixZpXi6Cp2tXgJN38pqgifwHRgLxxGYm/2M6FRcdNtEkIk+GESVM1yGlxGwOnpycrGklbA7uGxg0kcfAkxmKU2JlCiBxf+jQoVrUlO0LiMhbIHUAq3l79Oih1zSUzkGKAfKeMAvCa5r3YtBEbldQUKBPZViJgnICeFrDRQUXl7CwMHd/PCKiaqeVTJgwQUebsJAFo+fffPNNaUsWTN2Rd2HQRG6DnDM0w0TS5OXLl/W9tm3b6sWE8/9E5CsQHE2dOrU0TxOrgT/++GOJi4vTPE0EV+QdGDSRW5w8eVLzllAqAho2bKglIpDszZUmRORrkGKAvCYU4l21apU2oMe0HWrPYUXwwIEDuSLYCzBoolqFWllYWYIRJqhTp45eLHDRYE0TIvJ1oaGhMmLECE1BwIMjpu7WrVunq+5QUichIYEPjh6MQRPVCtTRMqvn4u+AVSY33nijtrghIvInWBU8ceJEOXTokLZkQZeDr776SkegkKKAEgbkeRg0kcvzlrAaDitI0AoHWrZsqReFFi1a8OgTkd9CKgJSElBOBavrUMgXxTHnz58vXbp00RV4KJ5JnoNBE7nM2bNndfj5+PHj+hojSkh6xJw+85aIiEpuxEFB0r9/f+natav2Vd2+fbuWJ0DO04ABA/RrlTWbp9rBoImcLjs7W1eIoJUNRprMCwJ++ZHDREREv1SvXj259dZbS/Od0AgYSeMIovDAiUbBfOB0LwZN5DSosYT5ePyS5+fn63udOnXSIeYGDRrwSBMROQCN6CdNmiR79+7V1IbMzExZvHixxMTEaGpD8+bNeRzdhEETOQWWzSKZMTU1VV83a9ZMf7lbt27NI0xEVEUYUUIqA3KesLoOW0pKirz99ttaaRyLaOrWrcvjWssYNFGNIEhCsISgCVDBG8tmsTKOrU+IiGoGuUzojtC9e3ctBLxnzx5NfcAo1ODBgyUxMVECAwN5mGsJgyaqlry8PF3pgRUfNptNA6Q+ffrIoEGDtGccERE5T0REhIwbN04LZCLf6cyZM/rAiirjKAzcoUMH5jvVAgZNVCUIkJCUiBUeOTk5+h5+WfFLGxUVxaNJRORCyGuaPHmyFsNEoeC0tDT55z//Ke3bt9frMOo/keswaCKHHTt2TJ9wzp07p68RJN188836y0pERLUDI/uYrsNqujVr1sjGjRvl8OHDWl0cI1GYtkPlcXI+Bk1UKRSlxAqOffv26WtMv+GXEr+cnEsnInKP4OBgLUWAxHBcow8ePCibNm3SNlVIFMf7zC11LgZNVK6CggJte4L2J0VFRTpf3rNnTxk6dKgmfBMRkftFRkbKHXfcIUeOHJFvv/1WLly4IF9//bVs3bpVZwPatm3r7o/oMxg00S+gICWq0WKlRlZWlr7Xpk0bLSHQtGlTHjEiIg+EdixTp07VYAn18pBK8dFHH0l8fLyOSDVs2NDdH9HrMWiiq5w6dUrzlk6ePKmvUZQSyYVxcXFcmUFE5OGQMoGVzOhdh8AJART6f6IxcL9+/WTgwIHszFADDJpIYUQJK+J27NhRWhsEv1z4JUMbFCIi8h5IoRg5cqSmVGDK7ujRo5pugWs8ujSgzx1bslQd74Z+DrlKWHmxdu1azWGChIQELVCJBrtEROS9kFJxzz33aJI46jplZGTIl19+qS2vkHLRsmVLd39ErxIgXiI9PV3uvvtuCQ8P1ymjBx54QC5fvuxwjs6IESM0qsbJQleOCTpov/nmm1rrAwFTixYt9LiOHTuWARMRkY/AvQ8pFr///e/1gRiN05GK8d5778mSJUtKc1fJh0aaEDChAiqWVRYWFmozwwcffFAWLlxY6fe+9tprHIa0g+RAc7jW7KzN4VoiIt+GVIsbbrhBZxPMdAyUJ0DOE9MxfChowg8UyckYTuzVq5e+9/rrr+t87ezZs7UjdHlwUvztb3/TZDh/7wyNCt4rV67UsvsYaULCYP/+/fWXCE8eRETk+5B6MWbMGL2fmgt/EEShpx1W2WG1HfOdvDhoQp0gTMmZARNgZARFu1DI67bbbis3SLjrrrtk7ty50qxZM4f+W/n5+bqZLl26JN6uuLi4dAkqesYBl6ASEfk3pGT87ne/0ybAmMVBIePPP/+cJWa8PWg6e/asNGnS5BfDjI0aNdKvleePf/yjjqQgonbUrFmzZObMmeIr7IudmUmBSP5D3SUiIvJvGFFCeYKOHTvKunXrZP369doy66233tKK4ihmXLduXXd/TI/h1qBp+vTp8tJLL1U6NVcd//73v3W4Ec1lq2LGjBnyxBNPXDXS1KpVK/E2aOKIlRKozQHoQ8Sy+kREVBakaCBAQk87FDbeu3evpnLgT7bN8pCg6cknn5T777+/wn3atWunU2vnz5//xVJ5rKgrb9oNARNGWTCtZ2/cuHGa8IapqvJ6+WDzVphaNBs42mw2ncJkA0ciInIE7pnjx4/X+wbynTCbg9kKBFA3s0G7e4Omxo0b61YZFFjEXCt+aCjUZQZFCApQ+bS8UazJkydf9R6GIF999VUZPXq0+BocCyS947hkZ2fre+3bt9eTPCoqyt0fj4iIvEjr1q1lypQpOluD+0pqaqosWLBAOnTooPcV9LvzR16R04SkZeTh4Ac4b948LTnwyCOPaINCc+Ucak6g/gT67CQmJuoIVFmjUDExMT7XvDAlJUWfCFCSAXAy46TGyU1ERFQdmKnAQEWnTp1k9erVsnnzZklKStJZHAxYDBo0SEJCQvzq4HpF0ASIcBEoITDCDxLTbHPmzCn9OgIpVDzFijl/kZmZqXPPWPkAmFbE3DOCRpQTICIiqikERngQ79mzp+bKInDCqvadO3dqrizyoHBf9gdeEzRhpVxFhSyxGgy1hypS2de9BQJErHLAhtwuwCoHnLxc5UBERK4QFRWlZXwQNCHPCQuOli1bpiVtMBuEKT1f5zVBk68oLrLJ3o3HJf2giK1IZNXiXRLdJkriE2MkMCig0qAPKxlQT8OsH4WTFE8A/l64k4iIakeHDh10kRYKTmNRFZLFP/jgA53GQw3FaxdglaWo2CYb9x6Xg+kiRTaRxat2SZvoKEmMj5GgQM8dtbIYvjL84iIITiIiInQqDH3vqiszLVs2Lt8vaxbvlLSkVCnIyROLIWINtopYAyWyfZQMGp8gfUfGS0TkL2tinD59WvOWTpw4oa/xmVC59frrr2flViIicovs7GztNIFq4ggnUEMR9REHDBhQZqeJtMxsWb5xvyxes1OS0lIlpyBPDItIsNUqVgmU9pFRMn5QgozsGy+REXU94v5tj0FTLRz0I7tOy7ynlkrW0XQJzi+UUJshVkPEoj8BkUJULw+wSH6wVeq3bSQPzR4tsV2vJLijKTEa6mJlHFitVm17ghWF+DsREZG7nS0pTYDCmGarFjzYd+7cufTBfteR0/LUvKVyNCtd8oMLxRZqiIHbmKXkflgoEpBjkeB8q7St30hmPzRausaW3yatMgya3KCmBx0B05xpX4gtJUPCiw2pa4iEImkbKxNQKgC1lUQkFxG7ReRSoEUCYhrKtDlj5UJOitZcKigoKC2ZgKFPZ0XMREREzmIYhhakNluyAIpDI4UkLc8i0+Z8ISm2DCkON8TAIFI5N0NLtkjgJYvEBDSUuY+Nq3bgxKDJDWpy0DEl9//u/ETyDp6ThkWGYJa3PlYilGzmeZJXsmWJCE6ztECLZEdZpNVwmwSFipZVQJKdN1YmJyIi/1JYWKir63766Sf9e26RyMqzIXI2OF+KGhni6M0wKMMicSFNZeEzE6s1VeeKoImJ4C6EHCZMyUUWXwmYGpacJ2FlnCc5dj+MomJDctMMyTsTLHf/8RZJSEhg3hIREXkFq9WqNZy6deum6SWLVu6Ss8V5UoS4pQo3w+JiQ5LT0uSbTQdk4vArha3dzXNT1H1glRySvpHDhCk5nB/YIkrOGfO8Mf+O9819EE/XKxaxZkRJl85dGTAREZHXCQ8Pl9G3jpHMOo2lGDc2bFW4GWIKLz+4SBav3qmr7TwBgyYX2b85RdIOp0qYzdBp25CSoNo8ZyLsNjNQMoPusJIt/UiaHNiS4qqPSERE5FKb96fIictZIvWuuck5cjMMFU0WT0q7IFsOeMa9kEGTi5w/cVEshTaxluS5mVO35vmC8wcjlfbnkblhf12oWWjTf4eIiMgbnTh/UQotNqnJzbBQbPrveALmNLlIfm6hSElZgQC7LbBks9odfPM9+/3wfRbDkLwcFCQgIiLyPrn5hbgV1uhmaFgMycnzjHshgyYXCQ61Xvlhl+S3mVtxyWb++Avt3rPfD99nWCwSEsZaTERE5J1Cg61XajDV4GZoMSwSFuIZ90IGTS7SpFUDMawBeh7k262kxGb+6ANLzo+ca76O/bUykzVA/x0iIiJv1KpJA7EaAVKTm6FVAvTf8QTMaXIR9JJDaxRU+s61W0mZXVKCItNuyyp53zxfsH9ugEUiOzSWuN4xrvqIRERELpUYH6OtUVDpuzo3w4Bci3SIbCy94zzjXsigyUXQfBe95NAaBZW+s+zOj4slW4bd383zRc8ZC5ZZBsng8QmVNvElIiLyVEGBAdpLDq1RUOm7KjdD7B+cHyTjByd4TBNfz/gUPgrNd9FLDq1RzPMCW1oZm/k17If967eLlD4j4tz9v0BERFQjI/vGay85tEapys0Q+7erHykj+njOvZBBkwtFRNbV5rvoJZcRZJE0i8gFEUmVK3+am/kaX8d+2P+h2bfq9xMREXmzyIi62nwXveTQGsWC4KiCmyG+jv2w/+yHbq1WCxVXsRjosEcu7V2Dpr3znl4qWcnpWiEcBS9LGjvrgoKCkhwmTMlhhAkBU2yX5vypEBGRz9h15LQ8PW+pJGelS35wodjCDLn2ZogcJkzJYYQJAVOX2OrfC9mw1w0QLDVo0EBOnDhRo4Z/menZsvX7Q7JuyW5JT07TwpUWMcTA2WINkEaxUTJgbGfpddN1EtHIc6JqIiIiZ0nPzJbvtx6SJet2S3J6mhauFIuBGju6Si62UZSMHdBZbup1nTSq4QgTgiY0ur948aIOfjgDR5oqkZycLLGxsU452ERERFS7MOjRsmVLp/xbrNNUiUaNGumfKSkpTotU/ZUZ9dd01M7f8TjyWHoanpM8lp56Tu7bt0+io6Od9u8yaKpEQMCVXHkETLzROweOI48lj6Mn4TnJ4+hpeE46R4sWLUrv487A1XNEREREDmDQREREROQABk2VCA4Olueee07/pJrhsXQOHkfn4bHkcfQ0PCc9+zhy9RwRERGRAzjSREREROQABk1EREREDmDQREREROQABk1EREREDmDQVIYXX3xR+vfvL2FhYdp3zhHoe/zss89K8+bNJTQ0VH71q19JUlKS+LP09HS5++67tUgbjuMDDzwgly9frvB7hgwZIhaL5artoYceEn8zd+5cadOmjYSEhEifPn1k8+bNFe7/+eefS1xcnO7fpUsXWb58ea19Vl86lh988MEvzj98n79bs2aNjB49Wisr45h8+eWXlX7PqlWrpEePHrp6qX379nps/V1VjyOO4bXnI7azZ8+KP5s1a5b07t1b6tevL02aNJGxY8fKwYMHK/0+Z1wnGTSVoaCgQH7729/Kww8/7PCBfPnll2XOnDkyb9482bRpk9StW1duvvlmycvLE3+FgGnv3r3y/fffy7Jly/SC8eCDD1b6fVOmTJEzZ86Ubji2/uTTTz+VJ554QpfL/vzzz5KQkKDn0vnz58vcf/369XLnnXdqULp9+3a9gGDbs2eP+LuqHktAkG9//h0/flz8XXZ2th47BKCOOHr0qIwaNUqGDh0qO3bskMcff1wmT54s3377rfizqh5HEwIC+3MSgYI/W716tUybNk02btyo95fCwkIZPny4Ht/yOO06aVC53n//fSMiIqLSI2Sz2YxmzZoZ//u//1v63sWLF43g4GDjn//8p18e4X379hk4vbZs2VL63jfffGNYLBbj1KlT5X7f4MGDjT/84Q+GP0tMTDSmTZtW+rq4uNiIjo42Zs2aVeb+t99+uzFq1Kir3uvTp48xdepUw99V9Vg6+jvvz/B7vWTJkgr3+a//+i+jU6dOV703YcIE4+abb3bxp/Ot47hy5UrdLyMjo9Y+lzc6f/68HqfVq1eXu4+zrpMcaXICPFVhuBRTcib0qsNUwIYNG8Qf4f8bU3K9evUqfQ/HBz2AMBJXkQULFkhUVJR07txZZsyYITk5OeJPo5zbtm276lzCMcPr8s4lvG+/P2A0xV/PvZocS8AUcuvWrbXZ55gxY3S0lKqG56RzdevWTVM/brrpJlm3bh1Px2tkZmbqn40aNRJXn5Ns2OsE5vxy06ZNr3ofr/117hn/39cOIQcFBelJXdExueuuu/SGhTn/Xbt2yZ/+9Ccdmv7Xv/4l/iA1NVWKi4vLPJcOHDhQ5vfgePLcc86x7Nixo8yfP1+6du2qF+LZs2drfiMCp5YtW9bgJ+tfyjsn0Xk+NzdX8z6pcgiUkPKBh8/8/Hx59913Ne8TD57IFyMRm82m078DBgzQB+2qnpNVvUf7TdA0ffp0eemllyrcZ//+/ZokRjU/jtVln/OERD1cNIYNGyZHjhyR2NhY/mjIpfr166ebCQFTfHy8vPXWW/LCCy/w6FOtQhCPzf58xLXw1VdflY8//pg/DRHNbUJe0k8//VQrx8NvgqYnn3xS7r///gr3adeuXbX+7WbNmumf586d05u8Ca8xrOqPxxHH5Npk26KiIl1RZx4vR2CKEw4fPuwXQROmJQMDA/XcsYfX5R03vF+V/f1FdY7ltaxWq3Tv3l3PP3Jceeckkuw5ylQziYmJtRYgeLpHHnmkdJFRZSPBzrpO+k1OU+PGjXUUqaKtTp061fq327Ztqwf+xx9/LH0Pw9AYQrV/avWn44j/74sXL2pOiWnFihU6lGoGQo7AyhuwD0Z9GY5dz549rzqXcMzwurxzCe/b7w9YUeJr515tHMtrYXpv9+7dfnP+OQvPSdfBNdHfz0fDMDRgWrJkid5XcA+utXOy2unqPuz48ePG9u3bjZkzZxr16tXTv2PLysoq3adjx47Gv/71r9LXf/3rX40GDRoYX331lbFr1y5jzJgxRtu2bY3c3FzDX91yyy1G9+7djU2bNhk//fST0aFDB+POO+8s/frJkyf1OOLrcPjwYeP55583tm7dahw9elSPZbt27YxBgwYZ/mTRokW68vKDDz7QVYgPPvignltnz57Vr99zzz3G9OnTS/dft26dERQUZMyePdvYv3+/8dxzzxlWq9XYvXu34e+qeizxO//tt98aR44cMbZt22bccccdRkhIiLF3717Dn+HaZ14Hcdt45ZVX9O+4VgKOIY6lKTk52QgLCzOefvppPSfnzp1rBAYGGv/5z38Mf1bV4/jqq68aX375pZGUlKS/z1hZHBAQYPzwww+GP3v44Yd1leuqVauMM2fOlG45OTml+7jqOsmgqQz33XefntDXblj+WXrgRHR5sn3ZgT//+c9G06ZN9SI9bNgw4+DBg4Y/S0tL0yAJgWd4eLgxadKkqwJPBEb2xzUlJUUDpEaNGukxbN++vV50MzMzDX/z+uuvGzExMUadOnV02fzGjRuvKsuAc9TeZ599Zlx33XW6P5Z6f/3112741N5/LB9//PHSffG7PHLkSOPnn382/J259P3azTx2+BPH8trv6datmx5LPPzYXy/9VVWP40svvWTExsZq4I7r4pAhQ4wVK1YY/k7KOIbX3pNddZ20lHwAIiIiIqqA3+Q0EREREdUEgyYiIiIiBzBoIiIiInIAgyYiIiIiBzBoIiIiInIAgyYiIiIiBzBoIiIiInIAgyYiIiIiBzBoIiIiInIAgyYiIiIiBzBoIiIiInIAgyYi8isXLlyQZs2ayf/8z/+Uvrd+/XqpU6eO/Pjjj279bETk2diwl4j8zvLly2Xs2LEaLHXs2FG6desmY8aMkVdeecXdH42IPBiDJiLyS9OmTZMffvhBevXqJbt375YtW7ZIcHCwuz8WEXkwBk1E5Jdyc3Olc+fOcuLECdm2bZt06dLF3R+JiDwcc5qIyC8dOXJETp8+LTabTY4dO+buj0NEXoAjTUTkdwoKCiQxMVFzmZDT9Nprr+kUXZMmTdz90YjIgzFoIiK/8/TTT8vixYtl586dUq9ePRk8eLBERETIsmXL3P3RiMiDcXqOiPzKqlWrdGTp448/lvDwcAkICNC/r127Vv7xj3+4++MRkQfjSBMRERGRAzjSREREROQABk1EREREDmDQREREROQABk1EREREDmDQREREROQABk1EREREDmDQREREROQABk1EREREDmDQREREROQABk1EREREDmDQRERERCSV+//Xjj7X5NXwoQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -503,7 +539,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAD0CAYAAACGoBLMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAP01JREFUeJzt3Ql4VPXVP/CTZbIBCZCwBQi7BFnCGjbZpKJAESxUXHChgmhRa7W+hfexWvXvS/WlalUsbrhCUbBgBSxWWWUH2ddAgLBDQgghezL3/3wPufMOmGWSzD7fz/PcJ5nJBMebO/ee+/ud3zlBhmEYQkREREQVCq74x0RERETEoImIiIjIQRxpIiIiInIAgyYiIiIiBzBoIiIiInIAgyYiIiIiBzBoIiIiInJAqCMvCmRWq1VOnz4tderUkaCgIE+/HSIiInIAylBmZ2dLfHy8BAc7Z4yIQVMlEDA1b97cKTubiIiI3OvEiRPSrFkzp/xbDJoqgREmc6dHR0dXayfvST0jz875Vo5fyZSCsCKxRhkiFhHBwBXqsReJBOcGSXihRVrUrif/7zfDpVPrJtX6bxEREXmjPW6+Fl6+fFkHPczruDMEsY1K5Ts9JiZGsrKyqhU07TpyWqa++ZWkWTOlJNoQo5aIRIpIeGlGmVVECkQkTyQoRyTkcpAkBNeTWU+MlS5t4qv9hyUiIvIWuzxwLazp9bssTAR3oYysHPnD7G/0ICmuZ4gRKyINRCSu9GuDax/j53gdXv/M7G/094mIiHxZhh9dCxk0udCyjfvlaPZFjaqlrojUK91iy9jMn9UVfX1qdoZ8u+mAK98eERGRyy3zo2shgyYXKS6xysI1O6UgvOjqMGSd0i3m6sFgO3DM72P+7zV4fUF4sSxcvVP/HSIiIl9U7GfXQgZNLrJ5f5oczki/muiGedsIEYkSEfOgibHb6pQ+H1X6ukgRa6QhKRkXZMuBNFe9RSIiIpfa7GfXQgZNLnLi/CUpCrJeXRkQXnoAmBsOiNoiEl361TxAzA2vD8NCAqv+O0RERL7ohJ9dC1lywEXyCop0BaUupQy220JKN4vd3jefs39dkIgRZEhufpGr3iIREZFL5fnZtZBBk4tEhlv0GNGjxWq3lZRu5t+/yO45+9cZqAcRJFEROKKIiIh8T6SfXQsZNLlI84Z1xWIEXz0QUHsi324z//YhpQdI7nU/x+sL8bJg/XeIiIh8+lpY6B/XQgZNLpLcIUHaxsbJ9iunpCTPuHoA5NodJEV2Bwp+lmN3wOBrjkjruvWkV2KCq94iERGRS/VKbC7xkbUkKyf/2mucI9fCPJHgvCBpF9vAa66FTAR3kdCQYBk3MEnCCyxa3VSyS7csEblUumXafZ9l9xpUQ80RiS44LxvWr5Pi4mJXvU0iIiKXOHfunPxj3lypX5Kh1zSp4rUQ187wglAZNyhJr6negCNNLjSiTwf57PttcvDyOSkO0VQ4EcQ/eaUrA8zS8eZQJA6US1fLx8dJiDSvXSwrVqyQn376SW655Rbp0KGDBAXp7DAREZFXys3NlZUrV8q2bdvEMAxpWy9Y0goj5XR2rhSHVu1a2LpOrAzvnSjegr3nvLj3XFBuhvznP/+R7GwcQSItW7aUW2+9VRo3bly9vzYREZGLlJSUyNatW2XVqlWSn4/oR/RmHzf9Jy7mVeta+M4T46RzmyZe03uOQZMbdjoCJ/TPSc2+qFVRUazLKO3srONGhVfnbTEMiah65iO32w6SwsJCWbdunaxfv16n6TDS1L17dxkyZIjUqoWjjoiIyLMOHz4sy5cvl/T0dH3cqFEjue222/Rm3xnXwupg0OQBztrpaDiI/jkLVu+QlIx0ySnM16MkzGKRMAnRRDfM22IYMjbm58HQpUuX5Pvvv5e9e/fq4/DwcBk8eLD06tVLQkKQRUdEROReGRkZ8t1338mhQ4f0cVRUlN7U4+Y+ODjY6dfCqmDQ5AHO3unon7N+d6q8+9FcKbKK3HH7SGkZH6crAxxJdDt+/Lj8+9//lrNnz+rjuLg4nbJr27Ztjd8bERGRI/Lz82XNmjWyadMmsVqtGiAlJyfLoEGDJCICiUquvRZ6KmhiIrib4WDoc2OCrKx/9fHYQV0kLCzM4d9v0aKFTJ48WbZv365J4hgKnTt3rrRr106GDRumQRQREZErWK1W2bFjh15/cnKwHE70ph0371W5/tT0WugpDJp8ECL6Hj16SMeOHW2RfkpKihw5cqRKkT4REZGj0tLSdKbjzJkz+jg2NlaDJdy0BwoGTT4MgRFGlzB3jDllBE4bN26UXbt2yc033yzdunUrc06ZiIjIUZjewkruvXY5tbg5x016oOXU+twVddasWZqNj4Chd+/esnnzZod+b/78+brybMyYMeJvMCR6zz33yL333qvfo0bGkiVL5L333pNjx455+u0REZEPKioq0vIBb7/9ti1g6t69uzz++OPSt2/fgAuYfG6k6YsvvpCnnnpKZs+erQHTG2+8oUODBw8elIYNG5b7ewgc/vCHP8iAAQPEn2FeuVWrVrJlyxY90FGN9ZNPPpEbb7xR62TUresdvXuIiMh7oSAlgiSMLiGZ2synve222wK+TqBPBU2vvfaaJkFPnDhRHyN4Wrp0qcyZM0emTZtWbrEtjMC88MILsnbtWl26788Q+ffp00c6d+6sFVlRTXzfvn26HLRfv37Sv39/n0i2IyIi9zt9+rTmLZ04cUIfY/UZ0kDYkcLHgiYUeURJ9unTp9ueQ77OL37xC9mwYUO5v/fiiy/qKNRDDz2kQVNlCgoKdDOZUbavQeHLX/7yl1rHCR8AjLYhaRyr7rDPEFSxJQsREcGVK1fkhx9+0JVxYLFY5KabbtJpOHxPPhY0YWk9Ro1QZdQeHh84cKDM3/nxxx/lww8/tB0EjpgxY4aOSvkL7J/7779f9xGSxTHStmjRIp3Cw1Br06ZNPf0WiYjIQ9BpAiuwcVONwQnATTVurp1V28if+EzQVFXo13bffffJ+++/X6XaERjJQt6U/UhT8+bNxZdhRAlDq1gWilE5jLidPHlSPvjgA+natauutKtTp46n3yYREbkxbwlpG2h9kpmZqc/Fx8frzbSvX/NcyWeCJgQ+yNdBcrM9PC6rgS1qFmFKatSoUdcU5YLQ0FBNHm/Tps3Pfg9LKbH5I/x/IxkegRKGYXfu3KmjcMh5wvPIhcJriIjIf50/f16DpdTUVH1cu3ZtGTp0qCQlJTFtoxI+c4VE8jIKOuJib5YNQBCEx4899tjPXp+YmCi7d+++5rlnn31WR6D+9re/BXQkjVEl7MOePXtqvtOpU6d0PyJpHAl/7du35weHiMjP5OXl6QKhrVu36kiTuXAIN83+OlgQsEETYNrsgQce0Is9imqh5ADKuJur6ZC7gxwd5CWhjlOnTp2u+X1zyf31zweqZs2aaYI8imGiGTCGaFHWAWULMERbURkHIiLyDRhgQKCEUjQInMyBBdwk16tXz9Nvz6f4VNA0fvx4uXDhgjz33HPasBbTTBgpMZPDUeKdFbCrnu+EIVnkPCFxfv369XL06FEt54CRPXSrRtdqIiLyPZiCw3US107AzTDqG7Zu3drTb80n+VTQBJiKK2s6DhBFV+Tjjz920bvyfZj+NFuvoKDZ/v379c5kz549MnjwYB3dC8Tqr0REvujixYu6Yhr5uxAZGak3wbgZ5uBCAAVN5FoYqr3zzjt1tAmJgki0x10KamTh7qSs5HkiIvIOqDOIFdLoQ4oyPZhNQL0+3PwicKKaYdBEZUJe08MPP6zJ4StWrNCh3c8//1xuuOEGnQdHd2siIvIOSOzGimgs6kGhSsBNLm52GzRo4Om35zcYNFG5MISLabmOHTvK6tWrtSAm6nocPnxYV1wMHDiQKy6IiDwMLU8wI4AWKFC/fn0NllCbj50fnItBE1UKQ7pYTYcAClN2CJqQMI67GuRBISGfc+RERO6F4stY+WyW10Fu6qBBg3R1OWvuuQaDJqpSgVE0P05JSdHgKSMjQ7755htNGEdQlZCQwL1JRORiRUVFeuO6bt06/R6wiAc3sShUSa7DoImqDEO+WK66efNmnbY7c+aMfPTRR1r/Cv2K0BWbiIicn7eEDg5Y4ZyVlaXP4WYVN61NmjTh7nYDBk1ULSg/gO7XXbp00URxJIyjPAEaA/fv3183dsYmInIO3Jwibwn1CAHNdG+55RbNOWXekvswaKIaqVWrlvb3M/Odjh8/rqNP27dv5weaiKiG0PUCK+JwTgXkKvHG1HMYNJFTYGgYLW7sh46/+uorncLD0DG6ZxMRkWNQY2nTpk2yZs0arb0ETIHwPAZN5DQYIsZQMWo5bdiwQduyYCns+++/ryvs0EWbSYpERBXnLZmLbVDV27wp5WIb78CgiZwOuUyo4YRAyVwOu2PHDh2FwvO9e/fmclgiouugiDBan6Csi5n+gJtNnEuZt+QdGDSRyyBR8Ve/+pWW8DcLryGIQtI4qopjRIonAiIKdHl5eZoLinQGjDSh7h0LCHsnBk3kcs2bN5dJkybZSvxjyHn+/PlatgBVa9F1m4go0FitVlurKgRO0L59e11Ew1ZV3olBE7kFRpQwxNyhQwdbM8nU1FSZPXs2m0kSUcBBU3SMwJ8/f14foz8cm6J7PwZN5Fbh4eFaALN79+66yg51nTAkjbynIUOGSI8ePdiShYj8VmZmpp779u/fr48jIiL03IeyLWxH5f0YNJFHoKHk+PHjdbQJq0Rwt7Vs2TJtyYK7LUzdERH5i8LCQh1lx8pilBPA6DsCpcGDB0tUVJSn3x45iEETeRSCoylTpsi2bdtk5cqVGjx99tlnkpiYqPP6CK6IiHwVErt37dqli2CuXLmiz7Vq1UpLCDCf0/cwaCKPw5A0VtihcNuqVatky5YtOm2HWiVYQTJgwACd1iMi8iUnT57UvKVTp07p43r16unKYSR7c+Wwb2LQRF4jMjJShg8frnlNmLLD1B26eGPVHWqVJCUl8URDRF7v8uXLulIYI0wQFhamN3+4CUQbFPJd/OuR18GQ9YQJE+TQoUNa6A0lCr7++msdgcKQNkoYEBF5m6KiIls3BHwPWDV88803S506dTz99sgJGDSRV8LQNYaw27RpY+u/hOKYc+bMkc6dO+sKPBTPJCLyhrwlrIbDqrhLly7pc82aNdObvKZNm3r67ZETMWgir2Z29MbUHArAodM3yhMg5wnP9+vXT9u2EBF5wtmzZzWd4NixY/oYI0pYxIIcTeYt+Z9g8TGzZs2Sli1bam0L9DBDjZ/yoFEs5pGRfIcNoxMVvZ68Fxr93n777TJ58mSdnsPQN5LGcTzs3btX7/SIiNwlJydHlixZIu+9954GTLjBQ2/Nxx57TEfDGTD5J58aafriiy/kqaee0irSCJjeeOMNrelz8ODBMpdu4qJ6991362gEgqxXXnlFVy7gIsshU98UHx8vEydO1L8hhsKzsrJk4cKFkpCQoEPh6AZOROQqqLGE/EpcXwoKCvS5jh076k153bp1ueP9XJDhQ7foCJSwNP3tt9+29e3BqMPjjz8u06ZNc+hgx4gTfv/+++93eBVETEyMXpydlUODImczZszQ76dPn64rK6jqMNqE1XXYiouL9TlUGkfSJbqDExE5E8qgYHFKenq6Pm7cuLHerLVo0YI72guvha64fof60s5FAUTsWPv6PojusVrBEbm5uXqhrahgIu4czLsHc6eTd0IuE6rpduvWTQvH7dmzR5tfYhRq0KBBkpycLCEhIZ5+m0Tk4xAkIVhC0ASo4I2bM5x72PoksIT60kGLkaJGjRpd8zweIynYEX/84x91egeBVnkQ9b7wwgs1fr/kPriTGDt2rI5CopDcmTNn9ASHIBvTt+3ateOfg4iqLD8/X1avXq25sJjZQICEGQ/kLiHlgwKPzwRNNfWXv/xF5s+fr/PQFR3sGMlC3pT9SBPrAvkG5DVNmjRJi2GisFxGRobMmzdP2rZtq7ls6CJORFQZBEhYqYsVu5ihANx84TwSFxfHHRjAfCZowoGKqZZz585d8zweY165IjNnztSgCVM4Xbp0qfC1aNfBlh2+C3eCGDK/8cYbtbbTxo0b5fDhw1pdHCNRmLZD5XEiorJgJRxGrM1rDa49GLHGzReRzwRNSBBDew2MIIwZM8Z2N4DHWOJZnldffVVefvllraOBjtIUGBD4olYKEsMxVYfq4iiSibYGyEXA88xFICITilJiRe6+ffts5xDkTOJmi7mR5HNBE2Da7IEHHtDgB0m+KDmAWhlYgg5YEYdSAmY2PkoMPPfcczpFg9pOKEJm1vzBRv4vNjZWy04cOXJEA+cLFy7I0qVLZevWrXr3iG7jRBS4sMgIbU+woAircFFfCTdVQ4YM4Spc8u2gafz48XrRQyCEAAg9fTCMaiaHp6WlXTN68Pe//10/EOPGjbvm33n++eflz3/+s9vfP3kO2rFMmTJFgyXktWHo/dNPP5UOHTroiBRKURBR4EC1HXQXQNpGdna2Poeba5QQuH7BEZFPBk2AqbjypuNwMbRnlrUnAgyxY+ULqvXiWEEAhX5RmLrr27evVo9nzSwi/3fq1Cm94T558qQ+RlFKJHknJiaykjf5V9BEVFOosTJixAjNkcOU3dGjR3V4fseOHVqOAosF2AKByP9gRAkr4vBZN2u94WYJN01og0JUGR4lFLAwBH/fffdpGx4ki2dmZsrixYu1RQKG6NGlnIh8H3KVsJJ27dq1mrIBaAI+dOhQbbBL5CgGTRTQMKKEIXksJzZPqhi6//DDD3XECSNPPKkS+W7ekv1NEWCxEG+KqLoYNBHhgxAaKjfddJPefZrD9yhPgJwnDt8T+R4s9jCn3wErpjn9TjXFoInIDkaVRo8erWUtzERRBFHoaYdVdlhtx3wnIu+FCt4rV67UNkoYacICkH79+ulNERd6UE0xaCIqA4bwf/Ob32gTYBS8Q+G7BQsWcEkykZdCb1KzpAh6xgFLipCzMWgiKgdGlFCeoH379rJu3TpZv369lrF49913WfyOyIvYF681F3kgbwl1l4iciUETUSUwpI/qwOhph0J4e/fu1aF/fEUvO7ZZIPIMNOU22yQB+kqyTRK5EoMmIgehAB6qyyNIQr4TqtLj7hYBFBt6ErlPQUGBrSE3epCiEwQbcpM7MGgiqqIWLVrI5MmTZfv27Zoknp6eLnPnzpV27dpp8IR+d0TkfAiQsLIVnzv0HQWUC8HnLi4ujrucXI5BE1E14M4WFcU7duwoq1evls2bN0tKSormVqCZNKbtIiIiuG+JnAS9RTHCe+bMGX2MmxMES7hZIXIXBk1ENYDACCduBFDIrUDghCkD1HhCbgXyoOybSBNR1WRlZekKVuQQQnh4uN6U4OYE5QSI3IlBE5ETYGrgnnvu0aAJeU5IUF2yZIkugcYqHkzpEZHjioqKdNUqNrRBge7du+vNSK1atbgrySMYNBE5EaYKWrdurf3rUC8GyeIff/yx3HjjjVocE8nkRFQ+FKTEqBJGly5fvqzP4aYDI7pNmjThriOPYtBE5GSYMujTp4/WeEJlYlQT37dvny6LRmXi/v37szIxURlOnz6teUsnTpzQxzExMTJs2DBW4ievwaCJyEUwhfDLX/5SW7Jgyg6FMbFMGqvu0AMLQRVbshCJXLlyRX744QddGQcWi0XbnvTt21e/J/IWDJqIXKxx48Zy//33a/NfsyXLokWLdAoP+U5o2UIUiJCrtGnTJr2ZKCws1OdwM4GbiujoaE+/PaKfYdBE5AYYUUJe0w033CAbNmyQtWvXajPgDz74QLp27arJrWgWXJGSYqvs35wm509ckoK8IgmPtEjD5nWlQ3KChIRyhR65X3GJVTbvT5MT5y9JXkGRRIZbpHnDupLcIUFCQ4IrzFvCdDVWnF68eFGfi4+P15uI5s2bu/H/gKhqGDQRuVFoaKgMGDBAkpKSdDoCpQkwJYGcJzyPXCi8xl5WRo5sXLZf1izcKRmH0yWoyCpiIBITMSzBEts2TgaOS5I+IzpITCxXFZHrZWTlyLKN+2Xhmp1yOCNdioKs5iEpFiNY2sbGybiBSTKiTweJjbn2mDx//rxOV6empurj2rVry9ChQ/Uzwelq8nYMmog8AFMPd9xxh60ly6lTpzSIQtI4El/RJBgXkCO7TsvsP3wj2UcvSnhBkdSzGmIpvTjhIlWEfJDtp2TRvvPy/Wfb5JGZo6RNl3j+Tclldh05LX+Y/Y0czb4oBeFFYq1nyPUH5fYrp2TfovPy2ffbZOYjo6RLm3jJy8vTFaWYlsZIk7lgAjcLqL1E5AsYNBF5ULNmzeShhx7SESc0A87MzJQvvvhCWrVqJR0Sesjnf1oh1rRMiS0xpJYhEonifqhIjpYS6MElInklhuTkFcrlg+fkzalfyROzxjJwIpcFTFPf/ErSrJlSEmuIgUGkMg7KkjxD8nIK5eDlc/LbN7+SqUMT5cSB7Ro4QWJiopbgqF+/Pv9S5FMYNBF5GEaUMDXRoUMHzXVCzlPKvqPy3cyjEpMpEmsVQXUnZDxFlG7m9Sm/dIswREKKDclMy5TZz3wjz86bwKk6cvqUHEaYEDAVY3SpkoPSiBApDjHkWPpFmfHlehnRSqRFfEOtt4RaZkS+yOeyR2fNmiUtW7bU9hW9e/fWnl8VWbBggd7V4PVYlbFs2TK3vVeiqggLC9PcjqlTp0pkfmMJyxKJKQ2Y6pVusWVs5s/wuugSQ7JTM2TTtwe488mpkMOEKbmSaKNKB6VRV+RymEjt5p1kypQpDJjIp/lU0IRpi6eeekqef/55zf3A3TnuWpBYWJb169fL3XffrdMfqI0zZswY3fbs2eP2907kqOg6MZJzNFRqW0Vql97MY4spDYzM65X5fYzdazCFF15QLKsX7tTVdkTOWiWHpG/kMOmUXFUOytoi1jpBsvV4lliR80QUSNNzDzzwgAYhAwcOFHd77bXXZPLkyTJx4kR9PHv2bFm6dKnMmTNHpk2b9rPX/+1vf9MlrM8884w+fumll7ROzttvv62/S+SNUFYAq+QwAxJZOvMRhYCo9BqE79GmtAQrlUp/BwnhyBbB6yOthmQcuiC716fKjX0SPPx/Q/5g497jkpKRLta61TsorZGGpGRckC0H0qRvx5Ye/r8hcmPQhI7TKDyGXkAIXhBEuaM4Hwqfbdu2TaZPn257Dt3j8V6QA1IWPI+RKXsYmVq8eHG5/52CggLdTGbvIyJ3QR0mlBWwlObXmikj5nUKo0+W0muSlH41f47XWwyRwpx8+ejduVJ/Jf9uVHMHL4rkFqLERTUPyjA8ZdV6Tn078i9CATQ9h4ADy6MfffRRnS5DftHw4cNl4cKF2pXaVdLT06WkpEQaNWp0zfN4jKaoZcHzVXk9zJgxQ/sdmRsLrZG7oXAllm4HlX5AzS2kdLOU3u1Y7J6zf11Q6WZ13ceRAgxmeg3zwKrmQWkEGZKbz4OSAnD1XIMGDXQEBxtyiz766CO57777tEjZhAkT5Le//a12e/dFGMmyH53CSBMDJ3InVPrWi0zpYiRzKynd7G/mzefsX4fftYRZ5PY7hsmgsV34x6MaW7hql+z453dSIkViVOegxE2AESRREewjRwFccuDMmTOaI4QNhcpGjBghu3fv1nYRr776qvz+97932huNi4vT/8a5c+eueR6P0durLHi+Kq8HFFljoTXyJLRGMUKDBZ24CuzKCmAzLzlm+kjudT/H67WDV1iIxLeM0xV5RDXVMj5OLDjqMJtQzYPSIsHaYoUooKbnMAX31Vdfafd25DVhSf+TTz4pp0+flk8++UQL9H355Zfy4osvOvWN4uTfo0cPrZpsslqt+hidsMuC5+1fDwjwyns9kTeIbhoixdElkmP83/UHX3NEJBt5hXZbdunz5uuQd5sXHCSx7RpIYi8mgZNzoJccWqME5wZdPciqclDmihg5Ig1DLdKl1bXpEkR+P9LUpEkTDVawlB81ktBs9HpDhgyRunWdf0eBaTMknvfs2VOSk5PljTfekJycHNtqOnSSR1I68pLgd7/7nQwaNEj++te/ysiRI2X+/PmydetWee+995z+3ohqKjs7W4P8nTt3SlQLkStnRXKKrl6DQq/Lr7WvI4hrU7Z5rQoSKQgPlZHjktjEl5wGzXfRSw6tUVDpG4UrHT8oRUJzRBrVzpbZf39HF+906dKFfeYoMIKm119/XX79619rscjyIGA6evSoONv48ePlwoUL8txzz2kyNwI29O0yk73T0tJ0RZ2pX79+Mm/ePHn22Wflv//7vzXPConsnTp1cvp7I6qu4uJiXemJauDmYop+v+wom9PPS/bhdAktvlrcprh0JKmsiuC4Nl1CDl5IkNRpHSu9hyfyD0JOhea76CWH1iio9O3oQRmaHSQta8dI1wRDrlzJ0nMw+s+hHAzaCBH5kiADnROpXEgExyo6lFpAk1VnlU8wR8OQeM68k8CEj96BAwfku+++k0uXLtl60eFighFTNOtFLzn0nouuqPdc6QgTAqbghHryxDvjpE3nJp7+3yN/7z0XXX7vORyUQTkiIZeDJCG4nrzzxDjp0KKBbNq0SdasWaPnQMCIE6rgO+vcSr6l0MXXQldcv9l7jsgDsCBh+fLlthHZOnXq6LQFWv2gFx206RKvzXfRSy4j9aJcKSiSKKtxTUP5wtIcJkzJYYTpkZm3M2Ail+nSJl5mPTFWnpn9jaRmXJSCK0VijTLk+oMyOC9IwgtCpXWdWJn5yO3Suc3VIL5///7ayQHT0Dt27NBG1fv375ebbrpJc00tFq6uI+/GoInIjXJzc2XlypVaqBUjTVgRimlkXDTKustC4ITmu+glt3rBDq0ULkVWDBGLgeDKEqxJ38hhwpRcTCxu/YlcGzjNe3aCfLvpgCxYvUMOZ6Rr4UrUYUJZAaySaxfbQMaNTJLhvRMlNubaYxKlaUaPHi29evXS9IoTJ07oZwKtrm655RZtXG3eOBB5GwZNRG6AwqxYhLBq1SrJz0fCh2hpDlwkKls0gUBo2IQeMvSubnJgS5pWDM/PLZKIKIuWJ8AquZBQn2ojST4OgdCEYT3krqHdtDUKKn2jcCXqMKGsQK/EBE0er0h8fLwu4kEvUKy6xhQ1VmNjVTamqCsqDUPkKQyaiFzs8OHDOhWHqvaAhQu4KKCaflUgMOrYt6V0ZMUM8hIIjNBLrrqtUTCihCnp9u3by7p167TJ+vHjx3WFc/fu3XUldq1aHD0l78GgichFMjIyNMn70KFD+jgqKkpuvvlm6dat2zWrPIkCHaamESDhs4FRp7179+oUNkahUDYGJWYwlU3kaQyaiJwM029YIYSVQqhphgAJJ32c/Csq1UEU6DBVPW7cOFu+E0rL4MYDARSarftqey7yHwyaiJwEARJWBK1YsUKLrgJO8sOGDdM2QETkGOQ1TZ48WT9PWGmHUVvU3OPniTyNQROREyAPw7wzhtjYWN4ZE9UARmiR14QFE+bIbUpKihw5coQjt+QxDJqIagBF09DPEDkYgGbPzMEgch5MaWO0Fr1HzRzBjRs3ao0n5giSuzFoIqpmJVtztQ/aoABO6lztQ+QaGL1Fz1P71ahLliyxtWSp6mpUoupg0ERUBShIadaVQYl+YF0ZIvdp27attGrVylb3DNX1P/nkE4frnhHVBIMmIgedPn3aVsEY0NMI0wasYEzkXig/0Lt3b63xZFbY37dvnxw8eLDCCvtENcWgiagSV65csfXKAvTHYq8sIs9D7bORI0dKz5499Ybm2LFjsnbtWv2sXt/LkcgZGDQRlQO5SuzKTuT9UGX//vvvlwMHDmiyOFqyLFq0yJbv1LRpU0+/RfITDJqIyshbwjA/Tr6ZmZm2Plk4+TZv3pz7i8gLYUQJU+Wo5bRhwwYdcTp58qR88MEHkpSUJEOHDpU6dep4+m2Sj2PQRGTn/PnzujInNTXV1pEdw/xdunThMD+RDwgNDZUBAwZI165ddVp9586duu3fv1+f79Onj76GqDp45BCJSF5eniaUYkUORpqQaNq3b1/NXULtJSLyLRhVGjNmjC3f6dSpUxpE/fTTT7rKLjExkTdCVGUMmkgCvfWJuXQZgRNgiB8n1Xr16nn67RFRDTVr1kweeugh2b17t5YKwZT7l19+qWUL0M8O+VBEjmLQRAELU3C4A71w4YI+btiwoeYt4WRKRP6V74Qpdowu/fjjj1qU9ujRo/Luu+/aitJiJR5RZRg0UcC5ePGiJnkj2RsiIyP1pImTJ/pdEZF/Qu0ms/UK2h8hzwkjzShYO3jwYJ3Kw9Q8UXkYNFHAKCgo0BU16FtVUlKid5+9evXSkyUCJyIKDJh6v/POO7WuE0abUVUcXxFAYbS5TZs2nn6L5KUYNJHfQ2I3it0hCTQnJ0efw0kR+QwNGjTw9NsjIg9Bv7qHH35Yk8NXrFih/ew+//xzueGGG7TaP/rdEdkL9qUplXvvvVeio6O1txAS+1CpuaLXP/7449K+fXsdRUhISJAnnnhCu9JT4EDLk/fff1/+9a9/acBUv359bfqJY4kBExFhSh7TcrheoDULHh86dEjeeecdncbPz8/nTiLfG2nCRe7MmTM6D11UVCQTJ07UO4R58+aV2ycM28yZM7WR4/Hjx+WRRx7R5xYuXOj290/uhWa6WCmDFTNmLsOgQYP0pMicBSK6Hm6uMTWHAAq12g4fPqxFMnft2qV5UKj7xJxH8omgCcl6mG9GSXwc0PDWW2/JiBEjNChCtebrderUSb766ivbY0zHvPzyyzJhwgRtj8HiZv4JATVWxqxbt06/ByR94qSHQpVERBWJi4vTm/SUlBQNnjIyMuSbb76x5Tth1oICl08ETYj2MSVnBkyAKs2I+tEb7I477nDo38HUHKb3KgqYkCyMzX7EgnwjbwldzjESaU7B4uSGk1yTJk08/faIyMegHUvr1q1l8+bNsnr1ap3p+Oijj6Rjx45axy0mJsbTb5E8wCeCprNnz2oNHXsIfJCfgp85Agl+L730kk7pVWTGjBnywgsv1Oj9knvhZIaRyLS0NH2MwBgnNZzc2OGciKrL7AyAGk9IFEfC+N69e7VcSf/+/XWzWCzcwQHEo4ng06ZN04taRRu6VtcURotGjhypuU1//vOfK3zt9OnTdaTC3JBITN4Jid1I8H7vvfc0YEIgjbylxx57TKdnGTARkTPUqlVLRo0apTfdLVq00BQPjD69/fbbWuMJI90UGDw60vT000/Lgw8+WOFrMDzauHFjbaRqDwctVsjhZxXJzs7WKRr0IVq0aFGldwXoM8ZeY94NNZYwLbtmzRrbVCqCJEzZcsiciFwFU/0PPPCA5tliZR1urJE7iyk8XGfKyq8l/+LRoAlLvh1Z9o3h0UuXLsm2bdu0ajNgqBR9w7AaqqIRJtTiQRCEEYmIiAinvn9yL9zNmcmZCJjNkxiTM4nIXTCCjVkL5Dwh3xZtWczSJlhhN3ToUC468WM+kdOEBqq4ME6ePFlmz56tq6IwBXPXXXfZInt0sMbB+umnn0pycrIGTChOlpubq8XK8NhM6kagxmXnvgX94RAsHTlyxDZcjr83TlKchiMid8OsxcCBA/UcZJY3QRFdLEjB87ih5ypt/+MTQRPMnTtXAyVcKLFqbuzYsfLmm2/afo5ACsl5CJIACXuYwoG2bdte82+hUSMqwZL3y8vL09wBDH9jpAl/+z59+uhJidOoRORpWHjyq1/9SlsyYUEKagEiiMLMCGY6UF2cN3b+w2eCJqyUK6+QJSAIsk/GQz8xJuf5Lky94qSzcuVKDZwA1d2xKo6tDYjI2zRv3lwmTZokO3fu1JZNmZmZMn/+fM3LRfB0/Qpw8k0+EzRR4MBIIO7YzOR/TKfipMMmmkTkzTCihOk6pJSYzcFTU1M1rYTNwf0DgybyGrgzQ3FKrEwBJO4PGTJEi5qyfQER+QqkDmA1b/fu3fWchtI5SDFA3hNmQXhO810MmsjjCgsL9a4MK1FQTgB3azip4OQSFRXl6bdHRFTttJLx48fraBMWsmD0/Ntvv7W1ZMHUHfkWBk3kMcg5QzNMJE1euXJFn2vVqpWeTDj/T0T+AsHRlClTbHmaWA382WefSWJiouZpIrgi38CgiTzi5MmTmreEUhFQr149LRGBZG+uNCEif4MUA+Q1oRDvqlWrtAE9pu1Qew4rggcMGMAVwT6AQRO5FWplYWUJRpggLCxMTxY4abCmCRH5u8jISBk+fLimIODGEVN369at01V3KKmTlJTEG0cvxqCJ3AJ1tMzqufgesMrk5ptv1hY3RESBBKuCJ0yYIIcOHdKWLOhy8PXXX+sIFFIUUMKAvA+DJnJ53hJWw2EFCVrhQLNmzfSk0LRpU+59IgpYSEVASgLKqWB1HQr5ojjmnDlzpHPnzroCD8UzyXswaCKXOXv2rA4/Hz9+XB9jRAlJj5jTZ94SEVHphTg0VPr16yddunTRvqrbt2/X8gTIeerfv7/+rLJm8+QeDJrI6XJycnSFCFrZYKTJPCHgw48cJiIi+rnatWvL7bffbst3QiNgJI0jiMINJxoF84bTsxg0kdOgxhLm4/EhLygo0Oc6duyoQ8x169blniYicgAa0U+cOFH27t2rqQ1ZWVmycOFCSUhI0NSGJk2acD96CIMmcgosm0UyY3p6uj5u3LixfrhbtGjBPUxEVEUYUUIqA3KesLoOW1pamrz33ntaaRyLaGrVqsX96mYMmqhGECQhWELQBKjgjWWzWBnH1idERDWDXCZ0R+jWrZsWAt6zZ4+mPmAUatCgQZKcnCwhISHczW7CoImqJT8/X1d6YMWH1WrVAKl3794ycOBA7RlHRETOExMTI2PHjtUCmch3OnPmjN6woso4CgO3a9eO+U5uwKCJqgQBEpISscIjNzdXn8OHFR/auLg47k0iIhdCXtOkSZO0GCYKBWdkZMg//vEPadu2rZ6HUf+JXIdBEzns2LFjeodz7tw5fYwg6dZbb9UPKxERuQdG9jFdh9V0a9askY0bN8rhw4e1ujhGojBth8rj5HwMmqhSKEqJFRz79u3Tx5h+w4cSH07OpRMReUZ4eLiWIkBiOM7RBw8elE2bNmmbKiSK43nmljoXgyYqV2FhobY9QfuT4uJinS/v0aOHDBkyRBO+iYjI82JjY+Wuu+6SI0eOyPLly+XChQuydOlS2bp1q84GtGrVytNv0W8waKKfQUFKVKPFSo3s7Gx9rmXLllpCoFGjRtxjREReCO1YpkyZosES6uUhleLTTz+VDh066IhUvXr1PP0WfR6DJrrGqVOnNG/p5MmT+hhFKZFcmJiYyJUZREReDikTWMmM3nUInBBAof8nGgP37dtXBgwYwM4MNcCgiRRGlLAibseOHbbaIPhw4UOGNihEROQ7kEIxYsQITanAlN3Ro0c13QLneHRpQJ87tmSpOl4NAxxylbDyYu3atZrDBElJSVqgEg12iYjIdyGl4r777tMkcdR1yszMlMWLF2vLK6RcNGvWzNNv0acEi4+4ePGi3HvvvRIdHa1TRg899JBcuXLF4Ryd4cOHa1SNg4Wu7hN00H7nnXe01gcCpqZNm+p+HTNmDAMmIiI/gWsfUix++9vf6g0xGqcjFePDDz+URYsW2XJXyY9GmhAwoQIqllUWFRVpM8OHH35Y5s2bV+nvvvHGGxyGtIPkQHO41uyszeFaIiL/hlSLm266SWcTzHQMlCdAzhPTMfwoaMIfFMnJGE7s2bOnPvfWW2/pfO3MmTO1I3R5cFD89a9/1WS4QO8MjQreK1eu1LL7GGlCwmC/fv30Q4Q7DyIi8n9IvRg9erReT82FPwii0NMOq+yw2o75Tj4cNKFOEKbkzIAJMDKCol0o5HXHHXeUGyTcc889MmvWLGncuLFD/62CggLdTJcvXxZfV1JSYluCip5xwCWoRESBDSkZv/nNb7QJMGZxUMh4wYIFLDHj60HT2bNnpWHDhj8bZqxfv77+rDy///3vdSQFEbWjZsyYIS+88IL4C/tiZ2ZSIJL/UHeJiIgCG0aUUJ6gffv2sm7dOlm/fr22zHr33Xe1ojiKGdeqVcvTb9NreDRomjZtmrzyyiuVTs1Vx7/+9S8dbkRz2aqYPn26PPXUU9eMNDVv3lx8DZo4YqUEanMA+hCxrD4REZUFKRoIkNDTDoWN9+7dq6kc+Mq2WV4SND399NPy4IMPVvia1q1b69Ta+fPnf7ZUHivqypt2Q8CEURZM69kbO3asJrxhqqq8Xj7YfBWmFs0GjlarVacw2cCRiIgcgWvmuHHj9LqBfCfM5mC2AgHUrWzQ7tmgqUGDBrpVBgUWMdeKPxoKdZlBEYICVD4tbxRr0qRJ1zyHIcjXX39dRo0aJf4G+wJJ79gvOTk5+lzbtm31II+Li/P02yMiIh/SokULmTx5ss7W4LqSnp4uc+fOlXbt2ul1Bf3uApFP5DQhaRl5OPgDzp49W0sOPPbYY9qg0Fw5h5oTqD+BPjvJyck6AlXWKFRCQoLfNS9MS0vTOwKUZAAczDiocXATERFVB2YqMFDRsWNHWb16tWzevFlSUlJ0FgcDFgMHDpSIiIiA2rk+ETQBIlwESgiM8IfENNubb75p+zkCKVQ8xYq5QJGVlaVzz1j5AJhWxNwzgkaUEyAiIqopBEa4Ee/Ro4fmyiJwwqr2nTt3aq4s8qBwXQ4EPhM0YaVcRYUssRoMtYcqUtnPfQUCRKxywIbcLsAqBxy8XOVARESuEBcXp2V8EDQhzwkLjpYsWaIlbTAbhCk9f+czQZO/KCm2yt6Nx+XiQRFrsciqhbskvmWcdEhOkJDQ4EqDPqxkQD0Ns34UDlLcAQR64U4iInKPdu3a6SItFJzGoioki3/88cc6jYcaitcvwHL2tdCTggx/GX5xEQQnMTExOhWGvnfVlZWRIxuX7Zc1C3dKRkq6FObmS5AhYgm3iFhCJLZtnAwclyR9RnSQmNif18Q4ffq05i2dOHFCH+M9oXLrjTfeyMqtRETkETk5OdppAtXEEU6ghiLqI/bv37/MThM1vRZ64vptj0GTG3b6kV2nZfYfvpHsoxclvKBIIq2GWAyRIP0LiBShenlwkBSEW6ROq/ryyMxR0qbL1QR3NCVGQ12sjAOLxaJtT7CiEN8TERF52tnS0gQojGm2asGNfadOnWw39jW5FlYHgyYPqOlOx0Hy5tSvxJqWKdElhtQyRCKRtI2VCSgVgNpKIpKHiD1I5HJIkAQn1JOpb46RC7lpWnOpsLDQVjIBQ5/OipiJiIicxTAMLUhttmQBFIdGCkl+RlC1roVPzBpb7cCJQZMH1GSnYxjy/939ueQfPCf1ig3BLG8drEQo3cwDJb90yxYRHGYZIUGSExckzYdZJTRStKwCkux8sTI5EREFlqKiIl1d9+OPP+r3xXkiZ1dGSPjZAqlfhWthZmiQRCQ2kmfnTajWVJ0rgiYmgrsQ5m0xDBlbcvUgqVd6oESVcaDk2v0xiksMycswJP9MuNz7+9skKSmJeUtEROQTLBaL1nDq2rWrppesnL9LSs7mS3SxVOlaWFJiSEZqhmz69oAMm3C1sLWneW+Kuo/DygAkumHeFsOQOECwxaBMvfzfgWN+j+fN1yCerl0iYsmMk86dujBgIiIinxMdHS23jxotYVkNpFbJ1Wtbla6Fhkh4QbGsXrhTr6negEGTi+zfnCYZh9MlymrovG1EaVRtHjQxdpsZKJlRd1TpdvFIhhzYkuaqt0hEROTya+GVE9lS+7prnCPXQlw7kSyekXLBa66FDJpc5PyJSxJUZBVLaaKbOXdrHjA4gDDDan8gmRterws1i6z67xAREfmi8352LWROk4sU5BWJlC6lDLbbQko3i93ON5+zfx1+L8gwJD8XizCJiIh8T4GfXQsZNLlIeKRF/9qoHGq120pKN/PPX2T3nP3r8HtGUJBERLEWExER+aZwP7sWMmhykYbN64phCdYDocBuKSU2808fUnqA5F73c7xeKzNZgvXfISIi8kUN/exayJwmF0H/HJSDR3XTPLullDmlNSiy7Lbs0ufNAwavzwsOkth2DSSxV4Kr3iIREZFLdfCzayGDJhdBw0H0z0E5eFQ3zbY7QC6ZhbvsvjcPGD1ogkQKwkNl0Lgkr25cSEREFEjXQu94F34KDQfRPwfl4M0DA1tGGZv5M7wOr6/TOlZ6D0/09P8CERFRjfTxo2shgyYXQtl3NBxE/xyUg88IErkgIuly9au5mY/xc7wOr39k5u017vBMRETkaTF+dC0MMtBhj1zau0Y7Oz/zjWSnXu3sjIKXltKllEZpohvmbTEMiagaB0mbzk34VyEiIr9xxM3XQjbs9QAES3Xr1pUTJ07UqOFf1sUc2fqfQ7Ju0W65mJqhxbqCxBADh4slWOq3iZP+YzpJz1tukJj63hNVExEROUuWG6+FCJrQ6P7SpUs6+OEMHGmqRGpqqrRp08YpO5uIiIjcC4MezZo1c8q/xTpNlahfv75+TUtLc1qkGqjMqL+mo3aBjvuR+9Lb8JjkvvTWY3Lfvn0SHx/vtH+XQVMlgoOv5sojYOKF3jmwH7kvuR+9CY9J7kdvw2PSOZo2bWq7jjsDV88REREROYBBExEREZEDGDRVIjw8XJ5//nn9SjXDfekc3I/Ow33J/ehteEx6937k6jkiIiIiB3CkiYiIiMgBDJqIiIiIHMCgiYiIiMgBDJqIiIiIHMCgqQwvv/yy9OvXT6KiorTvnCPQ9/i5556TJk2aSGRkpPziF7+QlJQUCWQXL16Ue++9V4u0YT8+9NBDcuXKlQp/Z/DgwRIUFHTN9sgjj0igmTVrlrRs2VIiIiKkd+/esnnz5gpfv2DBAklMTNTXd+7cWZYtW+a29+pP+/Ljjz/+2fGH3wt0a9askVGjRmllZeyTxYsXV/o7q1atku7du+vqpbZt2+q+DXRV3Y/Yh9cfj9jOnj0rgWzGjBnSq1cvqVOnjjRs2FDGjBkjBw8erPT3nHGeZNBUhsLCQvn1r38tjz76qMM78tVXX5U333xTZs+eLZs2bZJatWrJrbfeKvn5+RKoEDDt3btX/vOf/8iSJUv0hPHwww9X+nuTJ0+WM2fO2Dbs20DyxRdfyFNPPaXLZX/66SdJSkrSY+n8+fNlvn79+vVy9913a1C6fft2PYFg27NnjwS6qu5LQJBvf/wdP35cAl1OTo7uOwSgjjh69KiMHDlShgwZIjt27JAnn3xSJk2aJMuXL5dAVtX9aEJAYH9MIlAIZKtXr5apU6fKxo0b9fpSVFQkw4YN0/1bHqedJw0q10cffWTExMRUuoesVqvRuHFj43//939tz126dMkIDw83/vGPfwTkHt63b5+Bw2vLli2257799lsjKCjIOHXqVLm/N2jQION3v/udEciSk5ONqVOn2h6XlJQY8fHxxowZM8p8/Z133mmMHDnymud69+5tTJkyxQh0Vd2Xjn7mAxk+14sWLarwNf/1X/9ldOzY8Zrnxo8fb9x6660ufnf+tR9Xrlypr8vMzHTb+/JF58+f1/20evXqcl/jrPMkR5qcAHdVGC7FlJwJveowFbBhwwYJRPj/xpRcz549bc9h/6AHEEbiKjJ37lyJi4uTTp06yfTp0yU3N1cCaZRz27Zt1xxL2Gd4XN6xhOftXw8YTQnUY68m+xIwhdyiRQtt9jl69GgdLaWq4THpXF27dtXUj1tuuUXWrVvHw/E6WVlZ+rV+/fri6mOSDXudwJxfbtSo0TXP43Ggzj3j//v6IeTQ0FA9qCvaJ/fcc49esDDnv2vXLvnjH/+oQ9P//Oc/JRCkp6dLSUlJmcfSgQMHyvwd7E8ee87Zl+3bt5c5c+ZIly5d9EQ8c+ZMzW9E4NSsWbMa/GUDS3nHJDrP5+Xlad4nVQ6BElI+cPNZUFAgH3zwgeZ94sYT+WIkYrVadfq3f//+eqNd1WOyqtfogAmapk2bJq+88kqFr9m/f78miVHN92N12ec8IVEPJ42hQ4fKkSNHpE2bNvzTkEv17dtXNxMCpg4dOsi7774rL730Evc+uRWCeGz2xyPOha+//rp89tln/GuIaG4T8pJ+/PFHt+yPgAmann76aXnwwQcrfE3r1q2r9W83btxYv547d04v8iY8xrBqIO5H7JPrk22Li4t1RZ25vxyBKU44fPhwQARNmJYMCQnRY8ceHpe33/B8VV4fKKqzL69nsVikW7duevyR48o7JpFkz1GmmklOTnZbgODtHnvsMdsio8pGgp11ngyYnKYGDRroKFJFW1hYWLX+7VatWumO/+GHH2zPYRgaQ6j2d62BtB/x/33p0iXNKTGtWLFCh1LNQMgRWHkD9sGoP8O+69GjxzXHEvYZHpd3LOF5+9cDVpT427Hnjn15PUzv7d69O2COP2fhMek6OCcG+vFoGIYGTIsWLdLrCq7Bbjsmq52u7seOHz9ubN++3XjhhReM2rVr6/fYsrOzba9p37698c9//tP2+C9/+YtRt25d4+uvvzZ27dpljB492mjVqpWRl5dnBKrbbrvN6Natm7Fp0ybjxx9/NNq1a2fcfffdtp+fPHlS9yN+DocPHzZefPFFY+vWrcbRo0d1X7Zu3doYOHCgEUjmz5+vKy8//vhjXYX48MMP67F19uxZ/fl9991nTJs2zfb6devWGaGhocbMmTON/fv3G88//7xhsViM3bt3G4GuqvsSn/nly5cbR44cMbZt22bcddddRkREhLF3714jkOHcZ54Hcdl47bXX9HucKwH7EPvSlJqaakRFRRnPPPOMHpOzZs0yQkJCjH//+99GIKvqfnz99deNxYsXGykpKfp5xsri4OBg4/vvvzcC2aOPPqqrXFetWmWcOXPGtuXm5tpe46rzJIOmMjzwwAN6QF+/YfmnbceJ6PJk+7IDf/rTn4xGjRrpSXro0KHGwYMHjUCWkZGhQRICz+joaGPixInXBJ4IjOz3a1pamgZI9evX133Ytm1bPelmZWUZgeatt94yEhISjLCwMF02v3HjxmvKMuAYtffll18aN9xwg74eS72XLl3qgXft+/vyySeftL0Wn+URI0YYP/30kxHozKXv12/mvsNX7Mvrf6dr1666L3HzY3++DFRV3Y+vvPKK0aZNGw3ccV4cPHiwsWLFCiPQSRn78PprsqvOk0Glb4CIiIiIKhAwOU1ERERENcGgiYiIiMgBDJqIiIiIHMCgiYiIiMgBDJqIiIiIHMCgiYiIiMgBDJqIiIiIHMCgiYiIiMgBDJqIiIiIHMCgiYiIiMgBDJqIiIiIHMCgiYgCyoULF6Rx48byP//zP7bn1q9fL2FhYfLDDz949L0RkXdjw14iCjjLli2TMWPGaLDUvn176dq1q4wePVpee+01T781IvJiDJqIKCBNnTpVvv/+e+nZs6fs3r1btmzZIuHh4Z5+W0TkxRg0EVFAysvLk06dOsmJEydk27Zt0rlzZ0+/JSLycsxpIqKAdOTIETl9+rRYrVY5duyYp98OEfkAjjQRUcApLCyU5ORkzWVCTtMbb7yhU3QNGzb09FsjIi/GoImIAs4zzzwjCxculJ07d0rt2rVl0KBBEhMTI0uWLPH0WyMiL8bpOSIKKKtWrdKRpc8++0yio6MlODhYv1+7dq38/e9/9/TbIyIvxpEmIiIiIgdwpImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIjIAQyaiIiIiBzAoImIiIhIKvf/ASwGPtdeKDdSAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -513,7 +549,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -523,7 +559,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAD0CAYAAACGoBLMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQKhJREFUeJzt3Qd8VGW6P/BnkgwpQAIktAChBCSREmpo0mRFgUVwYcWChRVEF3Vdy124H1dX/XtZvay6KC42rLCouOiCuDaqdJBeQ4KEDimEkJ7M+X9+Dzm5A6ZMkplM+30/91wyk0l2PDlzznPe93mfx2IYhiFEREREVKmAyr9NRERERAyaiIiIiBzEkSYiIiIiBzBoIiIiInIAgyYiIiIiBzBoIiIiInIAgyYiIiIiBwQ58iJ/ZrPZ5NSpU9KwYUOxWCzufjtERETkAJShzM7OlujoaAkIcM4YEYOmKiBgatOmjVN2NhEREdWt48ePS+vWrZ3yuxg0VQEjTOZODw8Pr9FOTtl7WhY89bVcOpYp9QqKJMxmiFVEMG6FcuxFIpIbYJHCYKs0aNtYfvf/RkmHri1r9L9FRETkiVLq+Fp48eJFHfQwr+POYGEblap3ekREhGRlZdUoaErefUrmzvhcbKmZEl5iSH1DJFREgksTymwiUiAieSKSYxG5GGiRgJjG8si8CRLbPbrGf1giIiJPkeyGa2Ftr9/lYSK4C2Wl58j8J5bpQdK42JBIQ6SpiETJ5X/NzXyM7+N1eP38J5fpzxMREXmzLB+6FjJocqFNKw5I9tEMjaobiUjj0i2ynM38Hl6H12enpMvmrw+68u0RERG53CYfuhYyaHKRkmKbrF2yS4ILinQYEjOq2CJKDwbzwDG/xvPma/D64IJiWbNkl/4eIiIib1TiY9dCBk0ucmBLqqQfSdNEN8zbhohIGA4CuwPG3PTgKP0+XofXh9oMSU86Lwe3prrqLRIREbnUAR+7FjJocpFzxy+IpcimKwOCSw8Ac8MB0QBDj6X/mgeIueH19fBLimz6e4iIiLzROR+7FrLkgIsU5BXpGkpLaWRqboGlm9Vu55vP2b8OP2cxDMnPxSJMIiIi71PgY9dCBk0uEhxq1b82ak/Y7LaS0s388xfZPWf/OvycYbFISBgOKSIiIu8T7GPXQgZNLtKsTSMxrAF6IKD2RL7dZv7pA0sPkNyrvo/XF+IF1gD9PURERN58LSz0kWshgyYXiU+MkciOUXJpx0nJKzH0AMi1O0iK7A4UfC/H7oDJLX3cqENjiesb46q3SERE5FJxfdtIaHR9ycnKv+Ia58i1EIUu8wIsEtmpqcdcC5kI7iKBQQEyZGKCFARbtbpptlzeskTkQumWafc1njdfg4MmJ1CkIPycbNi4XoqLi131NomIiFzi7NmzsuifC6WkSbpe03Btq9a10CJSEBwkQycm6DXVE3CkyYX6j46X7z/aLhcPnZXAYszMihSXRs8hdqXjzaHI7NKDBuXjJSpQGrQplpUrV8pPP/0kN9xwg8THx4vFgrQ4IiIiz5SbmyurVq2S7du3i2EY0rhjgBSmhkr2qVwJqua1sGGHSOk3Kk48BXvPeXDvuVxLunz33XeSnY1DSKRdu3Zy4403SosWLWr21yYiInKRkpIS2bZtm6xevVry8xH+iN7s46Y/43heza6Fb0yU2G4tPab3HIOmOtjpCJzQPyc7JUOroqJYl7V0CSb+X2HpvC2GIRFVPzDn5rKDpLCwUNavXy8bNmzQaTqMNPXq1UuGDx8u9eujDBgREZF7HTlyRL755htJS0vTx82bN5ebbrpJb/adcS2sCQZNbuCsnY6Gg+ifs+aznZKelCaFOfl6oFjrWUXqBWqiG+ZtMQwZEfnLYOjChQvy/fffy759+/RxcHCwDBs2TPr27SuBgUijIyIiqlvp6eny7bffyuHDh/VxWFiY3tTj5j4gIMDp18LqYNDkBs7e6eifs2dDirz35kKxFYncfMsYiW4XpSsDHEl0O3bsmPznP/+RM2fO6OOoqCidsuvYsWOt3xsREZEj8vPzZe3atbJ582ax2WwaICUmJsrQoUMlJASZSq69FroraGIieB3DwXBt/xhpsury46ETuku9eloo3iFt27aVadOmyY4dOzRJHEOhCxculE6dOsnIkSM1iCIiInIFm80mO3fu1OtPTg7Ww4netOPmvTrXn9peC92FQZMXQkTfu3dv6dKlS1mkn5SUJMnJydWK9ImIiByVmpqqMx2nT5/Wx5GRkRos4abdXzBo8mIIjDC6hLljzCkjcNq0aZPs3r1brr/+eunZs2e5c8pERESOwvQWVnLvs8upxc05btL9LafW666o8+bN02x8BAz9+vWTLVu2OPRzixcv1pVn48ePF1+DIdE77rhD7rzzTv0aNTKWL18ub731lvz888/ufntEROSFioqKtHzA66+/XhYw9erVSx5++GEZMGCA3wVMXjfS9Mknn8hjjz0m8+fP14Dp1Vdf1aHBQ4cOSbNmzSr8OQQOTzzxhAwePFh8GeaV27dvL1u3btUDHdVYP/jgA7n22mu1TkajRp7Ru4eIiDwXClIiSMLoEpKpzXzam266ye/rBHpV0PTyyy9rEvSUKVP0MYKnr776ShYsWCAzZ86ssNgWRmCeffZZWbdunS7d92WI/Pv37y/dunXTiqyoJr5//35dDjpw4EAZNGiQVyTbERFR3Tt16pTmLR0/flwfY/UZ0kDYkcLLgiYUeURJ9lmzZpU9h3ydX/3qV7Jx48YKf+65557TUaj77rtPg6aqFBQU6GYyo2xvg8KXv/71r7WOEz4AGG1D0jhW3WGfIahiSxYiIoJLly7JDz/8oCvjwGq1ynXXXafTcPiavCxowtJ6jBqhyqg9PD548GC5P/Pjjz/Ku+++W3YQOGL27Nk6KuUrsH/uvvtu3UdIFsdI29KlS3UKD0OtrVq1cvdbJCIiN0GnCazAxk01BicAN9W4uXZWbSNf4jVBU3WhX9tdd90lb7/9drVqR2AkC3lT9iNNbdq0EW+GESUMrWJZKEblMOJ24sQJeeedd6RHjx660q5hw4bufptERFSHeUtI20Drk8zMTH0uOjpab6a9/ZrnSl4TNCHwQb4Okpvt4XF5DWxRswhTUmPHjr2iKBcEBQVp8nhsbOwvfg5LKbH5Ivx3IxkegRKGYXft2qWjcMh5wvPIhcJriIjId507d06DpZSUFH3coEEDGTFihCQkJDBtowpec4VE8jIKOuJib5YNQBCExw899NAvXh8XFyd79uy54rmnnnpKR6D+/ve/+3UkjVEl7MM+ffpovtPJkyd1PyJpHAl/nTt35geHiMjH5OXl6QKhbdu26UiTuXAIN82+Oljgt0ETYNrsnnvu0Ys9imqh5ADKuJur6ZC7gxwd5CWhjlPXrl2v+Hlzyf3Vz/ur1q1ba4I8imGiGTCGaFHWAWULMERbWRkHIiLyDhhgQKCEUjQInMyBBdwkN27c2N1vz6t4VdA0adIkOX/+vDz99NPasBbTTBgpMZPDUeKdFbCrn++EIVnkPCFxfsOGDXL06FEt54CRPXSrRtdqIiLyPpiCw3US107AzTDqG3bo0MHdb80reVXQBJiKK286DhBFV+b999930bvyfpj+NFuvoKDZgQMH9M5k7969MmzYMB3d88fqr0RE3igjI0NXTCN/F0JDQ/UmGDfDHFzwo6CJXAtDtbfeequONiFREIn2uEtBjSzcnZSXPE9ERJ4BdQaxQhp9SFGmB7MJqNeHm18ETlQ7DJqoXMhruv/++zU5fOXKlTq0+/HHH8s111yj8+Dobk1ERJ4Bid1YEY1FPShUCbjJxc1u06ZN3f32fAaDJqoQhnAxLdelSxdZs2aNFsREXY8jR47oioshQ4ZwxQURkZuh5QlmBNACBZo0aaLBEmrzsfODczFooiphSBer6RBAYcoOQRMSxnFXgzwoJORzjpyIqG6h+DJWPpvldZCbOnToUF1dzpp7rsGgiapVYBTNj5OSkjR4Sk9Pl2XLlmnCOIKqmJgY7k0iIhcrKirSG9f169fr14BFPLiJRaFKch0GTVRtGPLFctUtW7botN3p06flvffe0/pX6FeErthEROT8vCV0cMAK56ysLH0ON6u4aW3ZsiV3dx1g0EQ1gvID6H7dvXt3TRRHwjjKE6Ax8KBBg3RjZ2wiIufAzSnyllCPENBM94YbbtCcU+Yt1R0GTVQr9evX1/5+Zr7TsWPHdPRpx44d/EATEdUSul5gRRzOqYBcJd6Yug+DJnIKDA2jxY390PHnn3+uU3gYOkb3bCIicgxqLG3evFnWrl2rtZeAKRDux6CJnAZDxBgqRi2njRs3alsWLIV9++23dYUdumgzSZGIqPK8JXOxDap6mzelXGzjGRg0kdMhlwk1nBAomcthd+7cqaNQeL5fv35cDktEdBUUEUbrE5R1MdMfcLOJcynzljwDgyZyGSQq/uY3v9ES/mbhNQRRSBpHVXGMSPFEQET+Li8vT3NBkc6AkSbUvWMBYc/EoIlcrk2bNjJ16tSyEv8Ycl68eLGWLUDVWnTdJiLyNzabraxVFQIn6Ny5sy6iYasqz8SgieoERpQwxBwfH1/WTDIlJUXmz5/PZpJE5HfQFB0j8OfOndPH6A/Hpuiej0ET1ang4GAtgNmrVy9dZYe6ThiSRt7T8OHDpXfv3mzJQkQ+KzMzU899Bw4c0MchISF67kPZFraj8nwMmsgt0FBy0qRJOtqEVSK421qxYoW2ZMHdFqbuiIh8RWFhoY6yY2Uxyglg9B2B0rBhwyQsLMzdb48cxKCJ3ArB0fTp02X79u2yatUqDZ4++ugjiYuL03l9BFdERN4Kid27d+/WRTCXLl3S59q3b68lBJjP6X0YNJHbYUgaK+xQuG316tWydetWnbZDrRKsIBk8eLBO6xEReZMTJ05o3tLJkyf1cePGjXXlMJK9uXLYOzFoIo8RGhoqo0aN0rwmTNlh6g5dvLHqDrVKEhISeKIhIo938eJFXSmMESaoV6+e3vzhJhBtUMh78a9HHgdD1pMnT5bDhw9roTeUKPjyyy91BApD2ihhQETkaYqKisq6IeBrwKrh66+/Xho2bOjut0dOwKCJPBKGrjGEHRsbW9Z/CcUxFyxYIN26ddMVeCieSUTkCXlLWA2HVXEXLlzQ51q3bq03ea1atXL32yMnYtBEHs3s6I2pORSAQ6dvlCdAzhOeHzhwoLZtISJyhzNnzmg6wc8//6yPMaKERSzI0WTeku8JEC8zb948adeunda2QA8z1PipCBrFYh4ZyXfYMDpR2evJc6HR78033yzTpk3T6TkMfSNpHMfDvn379E6PiKiu5OTkyPLly+Wtt97SgAk3eOit+dBDD+loOAMm3+RVI02ffPKJPPbYY1pFGgHTq6++qjV9Dh06VO7STVxUb7/9dh2NQJD14osv6soFXGQ5ZOqdoqOjZcqUKfo3xFB4VlaWLFmyRGJiYnQoHN3AiYhcBTWWkF+J60tBQYE+16VLF70pb9SoEXe8j7MYXnSLjkAJS9Nff/31sr49GHV4+OGHZebMmQ4d7Bhxws/ffffdDq+CiIiI0Iuzs3JoUORs9uzZ+vWsWbN0ZQVVH0absLoOW3FxsT6HSuNIukR3cCIiZ0IZFCxOSUtL08ctWrTQm7W2bdtyR3vgtdAV1+8gb9q5KICIHWtf3wfRPVYrOCI3N1cvtJUVTMSdg3n3YO508kzIZUI13Z49e2rhuL1792rzS4xCDR06VBITEyUwMNDdb5OIvByCJARLCJoAFbxxc4ZzD1uf+JcgbzpoMVLUvHnzK57HYyQFO+JPf/qTTu8g0KoIot5nn3221u+X6g7uJCZMmKCjkCgkd/r0aT3BIcjG9G2nTp345yCiasvPz5c1a9ZoLixmNhAgYcYDuUtI+SD/4zVBU2399a9/lcWLF+s8dGUHO0aykDdlP9LEukDeAXlNU6dO1WKYKCyXnp4uixYtko4dO2ouG7qIExFVBQESVupixS5mKAA3XziPREVFcQf6Ma8JmnCgYqrl7NmzVzyPx5hXrsycOXM0aMIUTvfu3St9Ldp1sGWH98KdIIbMr732Wq3ttGnTJjly5IhWF8dIFKbtUHmciKg8WAmHEWvzWoNrD0ascfNF5DVBExLE0F4DIwjjx48vuxvAYyzxrMhLL70kL7zwgtbRQEdp8g8IfFErBYnhmKpDdXEUyURbA+Qi4HnmIhCRCUUpsSJ3//79ZecQ5EziZou5keR1QRNg2uyee+7R4AdJvig5gFoZWIIOWBGHUgJmNj5KDDz99NM6RYPaTihCZtb8wUa+LzIyUstOJCcna+B8/vx5+eqrr2Tbtm1694hu40Tkv7DICG1PsKAIq3BRXwk3VcOHD+cqXPLuoGnSpEl60UMghAAIPX0wjGomh6empl4xevCPf/xDPxATJ0684vc888wz8pe//KXO3z+5D9qxTJ8+XYMl5LVh6P3DDz+U+Ph4HZFCKQoi8h+otoPuAkjbyM7O1udwc40SAlcvOCLyyqAJMBVX0XQcLob2zLL2RIAhdqx8QbVeHCsIoNAvClN3AwYM0OrxrJlF5PtOnjypN9wnTpzQxyhKiSTvuLg4VvIm3wqaiGoLNVZGjx6tOXKYsjt69KgOz+/cuVPLUWCxAFsgEPkejChhRRw+62atN9ws4aYJbVCIqsKjhPwWhuDvuusubcODZPHMzEz54osvtEUChujRpZyIvB9ylbCSdt26dZqyAWgCPmLECG2wS+QoBk3k1zCihCF5LCc2T6oYun/33Xd1xAkjTzypEnlv3pL9TRFgsRBviqimGDQR4YMQFCTXXXed3n2aw/coT4CcJw7fE3kfLPYwp98BK6Y5/U61xaCJyA5GlcaNG6dlLcxEUQRR6GmHVXZYbcd8JyLPhQreq1at0jZKGGnCApCBAwfqTREXelBtMWgiKgeG8H/3u99pE2AUvEPhu88++4xLkok8FHqTmiVF0DMOWFKEnI1BE1EFMKKE8gSdO3eW9evXy4YNG7SMxZtvvsnid0QexL54rbnIA3lLqLtE5EwMmoiqgCF9VAdGTzsUwtu3b58O/eNf9LJjmwUi90BTbrNNEqCvJNskkSsxaCJyEArgobo8giTkO6EqPe5uEUCxoSdR3SkoKChryI0epOgEwYbcVBcYNBFVU9u2bWXatGmyY8cOTRJPS0uThQsXSqdOnTR4Qr87InI+BEhY2YrPHfqOAsqF4HMXFRXFXU4ux6CJqAZwZ4uK4l26dJE1a9bIli1bJCkpSXMr0Ewa03YhISHct0ROgt6iGOE9ffq0PsbNCYIl3KwQ1RUGTUS1gMAIJ24EUMitQOCEKQPUeEJuBfKg7JtIE1H1ZGVl6QpW5BBCcHCw3pTg5gTlBIjqEoMmIifA1MAdd9yhQRPynJCgunz5cl0CjVU8mNIjIscVFRXpqlVsaIMCvXr10puR+vXrc1eSWzBoInIiTBV06NBB+9ehXgySxd9//3259tprtTgmksmJqGIoSIlRJYwuXbx4UZ/DTQdGdFu2bMldR27FoInIyTBl0L9/f63xhMrEqCa+f/9+XRaNysSDBg1iZWKicpw6dUrzlo4fP66PIyIiZOTIkazETx6DQRORi2AK4de//rW2ZMGUHQpjYpk0Vt2hBxaCKrZkIRK5dOmS/PDDD7oyDqxWq7Y9GTBggH5N5CkYNBG5WIsWLeTuu+/W5r9mS5alS5fqFB7yndCyhcgfIVdp8+bNejNRWFioz+FmAjcV4eHh7n57RL/AoImoDmBECXlN11xzjWzcuFHWrVunzYDfeecd6dGjhya3ollwZUqKbXJgS6qcO35BCvKKJDjUKs3aNJL4xBgJDOIKPap7xSU22XIgVY6fuyB5BUUSGmyVNs0aSWJ8jAQFBlSat4Tpaqw4zcjI0Oeio6P1JqJNmzZ1+F9AVD0MmojqUFBQkAwePFgSEhJ0OgKlCTAlgZwnPI9cKLzGXlZ6jmxacUDWLtkl6UfSxFJkEzEQiYkY1gCJ7BglQyYmSP/R8RIRyVVF5HrpWTmyYtMBWbJ2lxxJT5Mii808JMVqBEjHyCiZOCRBRvePl8iIK4/Jc+fO6XR1SkqKPm7QoIGMGDFCPxOcriZPx6CJyA0w9XDLLbeUtWQ5efKkBlFIGkfiK5oE4wKSvPuUzH9imWQfzZDggiJpbDPEWnpxwkWqCPkgO07K0v3n5PuPtssDc8ZKbPdo/k3JZXYnn5In5i+To9kZUhBcJLbGhlx9UO64dFL2Lz0nH32/XeY8MFa6x0ZLXl6erijFtDRGmswFE7hZQO0lIm/AoInIjVq3bi333XefjjihGXBmZqZ88skn0r59e4mP6S0f/3ml2FIzJbLEkPqGSCiK+6EiOVpKoAeXiOSVGJKTVygXD52VuTM+l0fmTWDgRC4LmGbM/VxSbZlSEmmIgUGkcg7KkjxD8nIK5dDFs/L7uZ/LjBFxcvzgDg2cIC4uTktwNGnShH8p8ioMmojcDCNKmJqIj4/XXCfkPCXtPyrfzjkqEZkikTYRVHdCxlNI6WZen/JLtxBDJLDYkMzUTJn/5DJ5atFkTtWR06fkMMKEgKkYo0tVHJRGiEhxoCE/p2XI7E83yOj2Im2jm2m9JdQyI/JGXpc9Om/ePGnXrp22r+jXr5/2/KrMZ599pnc1eD1WZaxYsaLO3itRddSrV09zO2bMmCGh+S2kXpZIRGnA1Lh0iyxnM7+H14WXGJKdki6bvz7InU9OhRwmTMmVhBvVOiiNRiIX64k0aNNVpk+fzoCJvJpXBU2YtnjsscfkmWee0dwP3J3jrgWJheXZsGGD3H777Tr9gdo448eP123v3r11/t6JHBXeMEJyjgZJA5tIg9KbeWwRpYGReb0yv46wew2m8IILimXNkl262o7IWavkkPSNHCadkqvOQdlAxNbQItuOZYkNOU9E/jQ9d88992gQMmTIEKlrL7/8skybNk2mTJmij+fPny9fffWVLFiwQGbOnPmL1//973/XJaxPPvmkPn7++ee1Ts7rr7+uP0vkiVBWAKvkMAMSWjrzEYaAqPQahK/RprQEK5VKfwYJ4cgWwetDbYakHz4vezakyLX9Y9z8X0O+YNO+Y5KUnia2RjU7KG2hhiSln5etB1NlQJd2bv6vIarDoAkdp1F4DL2AELwgiKqL4nwofLZ9+3aZNWtW2XPoHo/3ghyQ8uB5jEzZw8jUF198UeH/TkFBgW4ms/cRUV1BHSaUFbCW5teaKSPmdQqjT9bSa5KU/mt+H6+3GiKFOfny3psLpckq/t2o9g5liOQWosRFDQ/KenjKpvWcBnThX4T8aHoOAQeWRz/44IM6XYb8olGjRsmSJUu0K7WrpKWlSUlJiTRv3vyK5/EYTVHLg+er83qYPXu29jsyNxZao7qGwpVYum0p/YCaW2DpZi2927HaPWf/OkvpZnPdx5H8DGZ6DfPAquFBaVgMyc3nQUl+uHquadOmOoKDDblF7733ntx1111apGzy5Mny+9//Xru9eyOMZNmPTmGkiYET1SVU+taLTOliJHMrKd3sb+bN5+xfh5+11rPKzbeMlKETuvOPR7W2ZPVu2fmvb6VEisSoyUGJmwDDImEh7CNHflxy4PTp05ojhA2FykaPHi179uzRdhEvvfSS/PGPf3TaG42KitL/jbNnz17xPB6jt1d58Hx1Xg8ossZCa+ROaI1iBAUIOnEV2JUVwGZecsz0kdyrvo/XaweveoES3S5KV+QR1Va76Cix4qjDbEIND0qrBGiLFSK/mp7DFNznn3+u3duR14Ql/Y8++qicOnVKPvjgAy3Q9+mnn8pzzz3n1DeKk3/v3r21arLJZrPpY3TCLg+et389IMCr6PVEniC8VaAUh5dIjvF/1x/8myMi2cgrtNuyS583X4e827wAi0R2aipxfZkETs6BXnJojRKQa7l8kFXnoMwVMXJEmgVZpXv7K9MliHx+pKlly5YarGApP2okodno1YYPHy6NGjn/jgLTZkg879OnjyQmJsqrr74qOTk5Zavp0EkeSenIS4I//OEPMnToUPnb3/4mY8aMkcWLF8u2bdvkrbfecvp7I6qt7OxsDfJ37dolYW1FLp0RySm6fA0Kuiq/1r6OIK5N2ea1yiJSEBwkYyYmsIkvOQ2a76KXHFqjoNI3Clc6flCKBOWING+QLfP/8YYu3unevTv7zJF/BE2vvPKK/Pa3v9VikRVBwHT06FFxtkmTJsn58+fl6aef1mRuBGzo22Ume6empuqKOtPAgQNl0aJF8tRTT8l///d/a54VEtm7du3q9PdGVFPFxcW60hPVwM3FFAN/3UW2pJ2T7CNpElR8ubhNcelIUnkVwXFtuoAcvECLNOwQKf1GxfEPQk6F5rvoJYfWKKj07ehBGZRtkXYNIqRHjCGXLmXpORj951AOBm2EiLyJxUDnRKoQEsGxig6lFtBk1VnlE8zRMCSeM+/EP+Gjd/DgQfn222/lwoULZb3ocDHBiCma9aKXHHrPhVfWe650hAkBU0BMY3nkjYkS262lu//zyNd7z4VX3HsOB6UlRyTwokViAhrLG49MlPi2TWXz5s2ydu1aPQcCRpxQBd9Z51byLoUuvha64vrN3nNEboAFCd98803ZiGzDhg112gKtftCLDmK7R2vzXfSSS0/JkEsFRRJmM65oKF9YmsOEKTmMMD0w52YGTOQy3WOjZd4jE+TJ+cskJT1DCi4ViS3MkKsPyoA8iwQXBEmHhpEy54GbpVvs5SB+0KBB2skB09A7d+7URtUHDhyQ6667TnNNrVauriPPxqCJqA7l5ubKqlWrtFArRpqwIhTTyLholHeXhcAJzXfRS27NZzu1UrgU2TBELAaCK2uAJn0jhwlTchGRuPUncm3gtOipyfL15oPy2ZqdciQ9TQtXog4TygpglVynyKYycUyCjOoXJ5ERVx6TKE0zbtw46du3r6ZXHD9+XD8TaHV1ww03aONq88aByNMwaCKqAyjMikUIq1evlvx8JHyIlubARaKqRRMIhEZO7i0jbuspB7emasXw/NwiCQmzankCrJILDPKqNpLk5RAITR7ZW24b0VNbo6DSNwpXog4Tygr0jYvR5PHKREdH6yIe9ALFqmtMUWM1NlZlY4q6stIwRO7CoInIxY4cOaJTcahqD1i4gIsCqulXBwKjLgPaSRdWzCAPgcAIveRq2hoFI0qYku7cubOsX79em6wfO3ZMVzj36tVLV2LXr8/RU/IcDJqIXCQ9PV2TvA8fPqyPw8LC5Prrr5eePXtescqTyN9hahoBEj4bGHXat2+fTmFjFAplY1BiBlPZRO7GoInIyTD9hhVCWCmEmmYIkHDSx8m/slIdRP4OU9UTJ04sy3dCaRnceCCAQrN1b23PRb6DQRORkyBAwoqglStXatFVwEl+5MiR2gaIiByDvKZp06bp5wkr7TBqi5p7/DyRuzFoInIC5GGYd8YQGRnJO2OiWsAILfKasGDCHLlNSkqS5ORkjtyS2zBoIqoFFE1DP0PkYACaPTMHg8h5MKWN0Vr0HjVzBDdt2qQ1npgjSHWNQRNRDSvZmqt90AYFcFLnah8i18DoLXqe2q9GXb58eVlLluquRiWqCQZNRNWAgpRmXRmU6AfWlSGqOx07dpT27duX1T1Ddf0PPvjA4bpnRLXBoInIQadOnSqrYAzoaYRpA1YwJqpbKD/Qr18/rfFkVtjfv3+/HDp0qNIK+0S1xaCJqAqXLl0q65UF6I/FXllE7ofaZ2PGjJE+ffroDc3PP/8s69at08/q1b0ciZyBQRNRBZCrxK7sRJ4PVfbvvvtuOXjwoCaLoyXL0qVLy/KdWrVq5e63SD6CQRNROXlLGObHyTczM7OsTxZOvm3atOH+IvJAGFHCVDlqOW3cuFFHnE6cOCHvvPOOJCQkyIgRI6Rhw4bufpvk5Rg0Edk5d+6crsxJSUkp68iOYf7u3btzmJ/ICwQFBcngwYOlR48eOq2+a9cu3Q4cOKDP9+/fX19DVBM8cohEJC8vTxNKsSIHI01INB0wYIDmLqH2EhF5F4wqjR8/vizf6eTJkxpE/fTTT7rKLi4ujjdCVG0Mmkj8vfWJuXQZgRNgiB8n1caNG7v77RFRLbVu3Vruu+8+2bNnj5YKwZT7p59+qmUL0M8O+VBEjmLQRH4LU3C4Az1//rw+btasmeYt4WRKRL6V74Qpdowu/fjjj1qU9ujRo/Lmm2+WFaXFSjyiqjBoIr+TkZGhSd5I9obQ0FA9aeLkiX5XROSbULvJbL2C9kfIc8JIMwrWDhs2TKfyMDVPVBEGTeQ3CgoKdEUN+laVlJTo3Wffvn31ZInAiYj8A6beb731Vq3rhNFmVBXHvwigMNocGxvr7rdIHopBE/k8JHaj2B2SQHNycvQ5nBSRz9C0aVN3vz0ichP0q7v//vs1OXzlypXaz+7jjz+Wa665Rqv9o98dkb0Ab5pSufPOOyU8PFx7CyGxD5WaK3v9ww8/LJ07d9ZRhJiYGHnkkUe0Kz35D7Q8efvtt+Xf//63BkxNmjTRpp84lhgwERGm5DEth+sFWrPg8eHDh+WNN97Qafz8/HzuJPK+kSZc5E6fPq3z0EVFRTJlyhS9Q1i0aFGFfcKwzZkzRxs5Hjt2TB544AF9bsmSJXX+/qluoZkuVspgxYyZyzB06FA9KTJngYiuhptrTM0hgEKttiNHjmiRzN27d2seFOo+MeeRvCJoQrIe5ptREh8HNLz22msyevRoDYpQrflqXbt2lc8//7zsMaZjXnjhBZk8ebK2x2BxM9+EgBorY9avX69fA5I+cdJDoUoiospERUXpTXpSUpIGT+np6bJs2bKyfCfMWpD/8oqgCdE+puTMgAlQpRlRP3qD3XLLLQ79HkzNYXqvsoAJycLY7EcsyDvyltDlHCOR5hQsTm44ybVs2dLdb4+IvAzasXTo0EG2bNkia9as0ZmO9957T7p06aJ13CIiItz9FskNvCJoOnPmjNbQsYfAB/kp+J4jkOD3/PPP65ReZWbPni3PPvtsrd4v1S2czDASmZqaqo8RGOOkhpMbO5wTUU2ZnQFQ4wmJ4kgY37dvn5YrGTRokG5Wq5U72I+4NRF85syZelGrbEPX6trCaNGYMWM0t+kvf/lLpa+dNWuWjlSYGxKJyTMhsRsJ3m+99ZYGTAikkbf00EMP6fQsAyYicob69evL2LFj9aa7bdu2muKB0afXX39dazxhpJv8g1tHmh5//HG59957K30NhkdbtGihjVTt4aDFCjl8rzLZ2dk6RYM+REuXLq3yrgB9xthrzLOhxhKmZdeuXVs2lYogCVO2HDInIlfBVP8999yjebZYWYcba+TOYgoP15ny8mvJt7g1aMKSb0eWfWN49MKFC7J9+3at2gwYKkXfMKyGqmyECbV4EARhRCIkJMSp75/qFu7mzORMBMzmSYzJmURUVzCCjVkL5Dwh3xZtWczSJlhhN2LECC468WFekdOEBqq4ME6bNk3mz5+vq6IwBXPbbbeVRfboYI2D9cMPP5TExEQNmFCcLDc3V4uV4bGZ1I1AjcvOvQv6wyFYSk5OLhsux98bJylOwxFRXcOsxZAhQ/QcZJY3QRFdLEjB87ih5ypt3+MVQRMsXLhQAyVcKLFqbsKECTJ37tyy7yOQQnIegiRAwh6mcKBjx45X/C40akQlWPJ8eXl5mjuA4W+MNOFv379/fz0pcRqViNwNC09+85vfaEsmLEhBLUAEUZgZwUwHqovzxs53eE3QhJVyFRWyBARB9sl46CfG5DzvhalXnHRWrVqlgROgujtWxbG1ARF5mjZt2sjUqVNl165d2rIpMzNTFi9erHm5CJ6uXgFO3slrgibyHxgJxB2bmfyP6VScdNhEk4g8GUaUMF2HlBKzOXhKSoqmlbA5uG9g0EQeA3dmKE6JlSmAxP3hw4drUVO2LyAib4HUAazm7dWrl57TUDoHKQbIe8IsCM9p3otBE7ldYWGh3pVhJQrKCeBuDScVnFzCwsLc/faIiGqcVjJp0iQdbcJCFoyef/3112UtWTB1R96FQRO5DXLO0AwTSZOXLl3S59q3b68nE87/E5GvQHA0ffr0sjxNrAb+6KOPJC4uTvM0EVyRd2DQRG5x4sQJzVtCqQho3LixlohAsjdXmhCRr0GKAfKaUIh39erV2oAe03aoPYcVwYMHD+aKYC/AoInqFGplYWUJRpigXr16erLASYM1TYjI14WGhsqoUaM0BQE3jpi6W79+va66Q0mdhIQE3jh6MAZNVCdQR8usnouvAatMrr/+em1xQ0TkT7AqePLkyXL48GFtyYIuB19++aWOQCFFASUMyPMwaCKX5y1hNRxWkKAVDrRu3VpPCq1ateLeJyK/hVQEpCSgnApW16GQL4pjLliwQLp166Yr8FA8kzwHgyZymTNnzujw87Fjx/QxRpSQ9Ig5feYtERGVXoiDgmTgwIHSvXt37au6Y8cOLU+AnKdBgwbp96pqNk91g0ETOV1OTo6uEEErG4w0mScEfPiRw0RERL/UoEEDufnmm8vyndAIGEnjCKJww4lGwbzhdC8GTeQ0qLGE+Xh8yAsKCvS5Ll266BBzo0aNuKeJiByARvRTpkyRffv2aWpDVlaWLFmyRGJiYjS1oWXLltyPbsKgiZwCy2aRzJiWlqaPW7RooR/utm3bcg8TEVUTRpSQyoCcJ6yuw5aamipvvfWWVhrHIpr69etzv9YxBk1UKwiSECwhaAJU8MayWayMY+sTIqLaQS4TuiP07NlTCwHv3btXUx8wCjV06FBJTEyUwMBA7uY6wqCJaiQ/P19XemDFh81m0wCpX79+MmTIEO0ZR0REzhMRESETJkzQApnIdzp9+rTesKLKOAoDd+rUiflOdYBBE1ULAiQkJWKFR25urj6HDys+tFFRUdybREQuhLymqVOnajFMFApOT0+Xf/7zn9KxY0c9D6P+E7kOgyZy2M8//6x3OGfPntXHCJJuvPFG/bASEVHdwMg+puuwmm7t2rWyadMmOXLkiFYXx0gUpu1QeZycj0ETVQlFKbGCY//+/foY02/4UOLDybl0IiL3CA4O1lIESAzHOfrQoUOyefNmbVOFRHE8z9xS52LQRBUqLCzUtidof1JcXKzz5b1795bhw4drwjcREblfZGSk3HbbbZKcnCzffPONnD9/Xr766ivZtm2bzga0b9/e3W/RZzBool9AQUpUo8VKjezsbH2uXbt2WkKgefPm3GNERB4I7VimT5+uwRLq5SGV4sMPP5T4+HgdkWrcuLG736LXY9BEVzh58qTmLZ04cUIfoyglkgvj4uK4MoOIyMMhZQIrmdG7DoETAij0/0Rj4AEDBsjgwYPZmaEWGDSRwogSVsTt3LmzrDYIPlz4kKENChEReQ+kUIwePVpTKjBld/ToUU23wDkeXRrQ544tWaqPV0M/h1wlrLxYt26d5jBBQkKCFqhEg10iIvJeSKm46667NEkcdZ0yMzPliy++0JZXSLlo3bq1u9+iVwkQL5GRkSF33nmnhIeH65TRfffdJ5cuXXI4R2fUqFEaVeNgocv7BB2033jjDa31gYCpVatWul/Hjx/PgImIyEfg2ocUi9///vd6Q4zG6UjFePfdd2Xp0qVluavkQyNNCJhQARXLKouKirSZ4f333y+LFi2q8mdfffVVDkPaQXKgOVxrdtbmcC0RkW9DqsV1112nswlmOgbKEyDniekYPhQ04Q+K5GQMJ/bp00efe+2113S+ds6cOdoRuiI4KP72t79pMpy/d4ZGBe9Vq1Zp2X2MNCFhcODAgfohwp0HERH5PqRejBs3Tq+n5sIfBFHoaYdVdlhtx3wnLw6aUCcIU3JmwAQYGUHRLhTyuuWWWyoMEu644w6ZN2+etGjRwqH/rYKCAt1MFy9eFG9XUlJStgQVPeOAS1CJiPwbUjJ+97vfaRNgzOKgkPFnn33GEjPeHjSdOXNGmjVr9othxiZNmuj3KvLHP/5RR1IQUTtq9uzZ8uyzz4qvsC92ZiYFIvkPdZeIiMi/YUQJ5Qk6d+4s69evlw0bNmjLrDfffFMriqOYcf369d39Nj2GW4OmmTNnyosvvljl1FxN/Pvf/9bhRjSXrY5Zs2bJY489dsVIU5s2bcTboIkjVkqgNgegDxHL6hMRUXmQooEACT3tUNh43759msqBf9k2y0OCpscff1zuvffeSl/ToUMHnVo7d+7cL5bKY0VdRdNuCJgwyoJpPXsTJkzQhDdMVVXUywebt8LUotnA0Waz6RQmGzgSEZEjcM2cOHGiXjeQ74TZHMxWIIC6kQ3a3Rs0NW3aVLeqoMAi5lrxR0OhLjMoQlCAyqcVjWJNnTr1iucwBPnKK6/I2LFjxddgXyDpHfslJydHn+vYsaMe5FFRUe5+e0RE5EXatm0r06ZN09kaXFfS0tJk4cKF0qlTJ72uoN+dP/KKnCYkLSMPB3/A+fPna8mBhx56SBsUmivnUHMC9SfQZycxMVFHoMobhYqJifG55oWpqal6R4CSDICDGQc1Dm4iIqKawEwFBiq6dOkia9askS1btkhSUpLO4mDAYsiQIRISEuJXO9crgiZAhItACYER/pCYZps7d27Z9xFIoeIpVsz5i6ysLJ17xsoHwLQi5p4RNKKcABERUW0hMMKNeO/evTVXFoETVrXv2rVLc2WRB4Xrsj/wmqAJK+UqK2SJ1WCoPVSZqr7vLRAgYpUDNuR2AVY54ODlKgciInKFqKgoLeODoAl5TlhwtHz5ci1pg9kgTOn5Oq8JmnxFcYlNNu07JocyRIptIktW75Z20VGSGB8jQYEBVQZ9WMmAehpm/SgcpLgD8PfCnUREVDc6deqki7RQcBqLqpAs/v777+s0HmooXr0AqzwlxTbZt+mYZBwSsRWLrF6yW6LbRUl8YowEBnnuqJXF8JXhFxdBcBIREaFTYeh7V1PpWTmyYtMBWbJ2lySlp0luYb4YFpFgq1WsEigdI6Nk4pAEGd0/XiIjflkT49SpU5q3dPz4cX2M94TKrddeey0rtxIRkVvk5ORopwlUE0c4gRqKqI84aNCgcjtNZKXnyKYVB2Ttkl2SnpQmhbn5YjFErMFWEWugRHaMkiETE6T/6HiJiKzvEddvewya6mCn704+JU/MXyZHszOkILhIbKGGGFbsff0/kSKRgFyLBBdYpX3DJjLngbHSPfZygjuaEqOhLlbGgdVq1bYnWFGIr4mIiNztTGlpAhTGNFu14Ma+a9euZTf2ybtPyfwnlkn20QwJLiiSUJshVqP0OmjRS6HkBlikINgqDds3kQfmjJXY7hW3SasKgyY3qO1OR8A0Y+7nkmrLlJJwQwwEzqHI2sbSBNQKQHElEckTseSIBF60SExAY5k7Y7zknk/VmkuFhYVlJRMw9OmsiJmIiMhZDMPQgtRmSxZAcWikkOSnW2TujM/Flpop4SWG1DcqvBRKjkXkYqBFAmIayyPzJtQ4cGLQ5Aa12emYkrv9/30sh/LPSnFjQwTTvA2xFKF0M4+U/NItW0QuiASmWyQqxyIj29gkNEi0rAKS7LyxMjkREfmXoqIiXV33448/6tfFeSJnVoVI8JkCaVJsOHoplMwgi4TENZenFk2u0VSdK4ImJoK7EHKYMCVXElkaMDUuPVLCyjlScv/vr1FSbEh6niGn84Plj3feJAkJCcxbIiIir2C1WrWGU48ePTS9ZNXi3VJyJl/Ci6t1KZSSEkPSU9Jl89cHZeTky4Wt3c1zU9R9YJUckr6Rw6RTcg1LtwjUqZf/O3LMryPsXlNfpKSBSKY1Srp2686AiYiIvE54eLjcPHac1MtqKvVL9NJWvUuhIRJcUCxrluzS1XaegEGTi2w5kCpH0tPEFlY6cRtSGlabR02E3VYaKJWF3fg3TCQ5I122Hkx11VskIiJyqQNbUuXS8WxpcNUlzpFLIS6dSBZPTzovB7d6xrWQQZOLHD93QYosNhFraaabOXlrHjE4gjDFan8kmRteXw8rCWz6e4iIiLzRueMXxFJkq82lUKTIpr/HEzCnyUXyCopEC2BZSkNTcwss3ax2e998zv51FhHDYkhuPhZhEhEReZ+CvCLBxbAWl0LURpL8XM+4FjJocpHQYOvl2hOInGx2W0npZv79i+yes38dDjLDImEhrMVERETeKTjUenkQoOaXQjEsFgkJ84xrIYMmF2nTrJFYjYDLR0KB3VpKbObfPrD0CMm96vt4fSFeFqC/h4iIyBs1a9NIDGtAbS6FItYA/T2egDlNLoJecmiNgkrfWq3LXEuZU1qEIstuyy593jxi8kQC8izSKbKp9I2LcdVbJCIicqn4xBhtjYJK3zW4FEpegEUiOzWVuL6ecS1k0OQiaL6LXnJojYJK33o0mEfIBbNyl93X5hGTfbkyeHBBkEwcmlBlE18iIiJPFRgUoL3k0BoFlb6rcSnU1xcEB8nQiQke08TXM96Fj0LzXfSSQ2uUsiMDW3o5m/k9VAS/aJEODSNlVL84d/8nEBER1Ur/0fHaSw6tUapxKdTXN+wQKf1Gec61kEGTC0VG1Nfmu+glF5RpEQuOiPMiklb67/krH+P7eB1eP+eBm/XniYiIvFlEZH1tvotecmiNkm6p9FKo38fr8PoH5txcoxYqrmIx0GGPXNq7Bk17n5y/TFKyM7RCuBa8RAYcltdh7xdezmHClBxGmBAwdYttyb8KERH5jOTdp2T+k8skOyVDgguKJMxmXH0p1BwmTMlhhAkBU2y3ml8L2bDXDRAsNWrUSI4fP16rhn8ZWTny3bbDsnT9HknJSNfClWIxsJZSV8nFNomS8YO6yg19rpEmHGEiIiIflJWRI9u+Oyzrl+6RjJR0LVxpEUMMhE7WAGkSGyWDxneVPjdcIxFNajfChKAJje4vXLiggx/OwJGmKqSkpEhsbKxTdjYRERHVLQx6tG7d2im/i3WaqtCkSRP9NzU11WmRqr8yo/7ajtr5O+5H7ktPw2OS+9JTj8n9+/dLdHS0034vg6YqBARczpVHwMQLvXNgP3Jfcj96Eh6T3I+ehsekc7Rq1arsOu4MXD1HRERE5AAGTUREREQOYNBUheDgYHnmmWf0X6od7kvn4H50Hu5L7kdPw2PSs/cjV88REREROYAjTUREREQOYNBERERE5AAGTUREREQOYNBERERE5AAGTeV44YUXZODAgRIWFqZ95xyBvsdPP/20tGzZUkJDQ+VXv/qVJCUliT/LyMiQO++8U4u0YT/ed999cunSpUp/ZtiwYWKxWK7YHnjgAfE38+bNk3bt2klISIj069dPtmzZUunrP/vsM4mLi9PXd+vWTVasWFFn79WX9uX777//i+MPP+fv1q5dK2PHjtXKytgnX3zxRZU/s3r1aunVq5euXurYsaPuW39X3f2IfXj18YjtzJkz4s9mz54tffv2lYYNG0qzZs1k/PjxcujQoSp/zhnnSQZN5SgsLJTf/va38uCDDzq8I1966SWZO3euzJ8/XzZv3iz169eXG2+8UfLz88VfIWDat2+ffPfdd7J8+XI9Ydx///1V/ty0adPk9OnTZRv2rT/55JNP5LHHHtPlsj/99JMkJCTosXTu3LlyX79hwwa5/fbbNSjdsWOHnkCw7d27V/xddfclIMi3P/6OHTsm/i4nJ0f3HQJQRxw9elTGjBkjw4cPl507d8qjjz4qU6dOlW+++Ub8WXX3owkBgf0xiUDBn61Zs0ZmzJghmzZt0utLUVGRjBw5UvdvRZx2njSoQu+9954RERFR5R6y2WxGixYtjP/93/8te+7ChQtGcHCw8c9//tMv9/D+/fsNHF5bt24te+7rr782LBaLcfLkyQp/bujQocYf/vAHw58lJiYaM2bMKHtcUlJiREdHG7Nnzy739bfeeqsxZsyYK57r16+fMX36dMPfVXdfOvqZ92f4XC9durTS1/zXf/2X0aVLlyuemzRpknHjjTe6+N351n5ctWqVvi4zM7PO3pc3OnfunO6nNWvWVPgaZ50nOdLkBLirwnAppuRM6FWHqYCNGzeKP8J/N6bk+vTpU/Yc9g96AGEkrjILFy6UqKgo6dq1q8yaNUtyc3PFn0Y5t2/ffsWxhH2GxxUdS3je/vWA0RR/PfZqsy8BU8ht27bVZp/jxo3T0VKqHh6TztWjRw9N/bjhhhtk/fr1PByvkpWVpf82adJEXH1MsmGvE5jzy82bN7/ieTz217ln/HdfPYQcFBSkB3Vl++SOO+7QCxbm/Hfv3i1/+tOfdGj6X//6l/iDtLQ0KSkpKfdYOnjwYLk/g/3JY885+7Jz586yYMEC6d69u56I58yZo/mNCJxat25di7+sf6nomETn+by8PM37pKohUELKB24+CwoK5J133tG8T9x4Il+MRGw2m07/Dho0SG+0q3tMVvca7TdB08yZM+XFF1+s9DUHDhzQJDGq/X6sKfucJyTq4aQxYsQISU5OltjYWP5pyKUGDBigmwkBU3x8vLz55pvy/PPPc+9TnUIQj83+eMS58JVXXpGPPvqIfw0RzW1CXtKPP/5YJ/vDb4Kmxx9/XO69995KX9OhQ4ca/e4WLVrov2fPntWLvAmPMazqj/sR++TqZNvi4mJdUWfuL0dgihOOHDniF0ETpiUDAwP12LGHxxXtNzxfndf7i5rsy6tZrVbp2bOnHn/kuIqOSSTZc5SpdhITE+ssQPB0Dz30UNkio6pGgp11nvSbnKamTZvqKFJlW7169Wr0u9u3b687/ocffih7DsPQGEK1v2v1p/2I/+4LFy5oTolp5cqVOpRqBkKOwMobsA9GfRn2Xe/eva84lrDP8LiiYwnP278esKLE1469utiXV8P03p49e/zm+HMWHpOug3Oivx+PhmFowLR06VK9ruAaXGfHZI3T1X3YsWPHjB07dhjPPvus0aBBA/0aW3Z2dtlrOnfubPzrX/8qe/zXv/7VaNSokfHll18au3fvNsaNG2e0b9/eyMvLM/zVTTfdZPTs2dPYvHmz8eOPPxqdOnUybr/99rLvnzhxQvcjvg9HjhwxnnvuOWPbtm3G0aNHdV926NDBGDJkiOFPFi9erCsv33//fV2FeP/99+uxdebMGf3+XXfdZcycObPs9evXrzeCgoKMOXPmGAcOHDCeeeYZw2q1Gnv27DH8XXX3JT7z33zzjZGcnGxs377duO2224yQkBBj3759hj/Duc88D+Ky8fLLL+vXOFcC9iH2pSklJcUICwsznnzyST0m582bZwQGBhr/+c9/DH9W3f34yiuvGF988YWRlJSkn2esLA4ICDC+//57w589+OCDusp19erVxunTp8u23Nzcste46jzJoKkc99xzjx7QV29Y/lm240R0ebJ92YE///nPRvPmzfUkPWLECOPQoUOGP0tPT9cgCYFneHi4MWXKlCsCTwRG9vs1NTVVA6QmTZroPuzYsaOedLOysgx/89prrxkxMTFGvXr1dNn8pk2brijLgGPU3qeffmpcc801+nos9f7qq6/c8K69f18++uijZa/FZ3n06NHGTz/9ZPg7c+n71Zu57/Av9uXVP9OjRw/dl7j5sT9f+qvq7scXX3zRiI2N1cAd58Vhw4YZK1euNPydlLMPr74mu+o8aSl9A0RERERUCb/JaSIiIiKqDQZNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNRORXzp8/Ly1atJD/+Z//KXtuw4YNUq9ePfnhhx/c+t6IyLOxYS8R+Z0VK1bI+PHjNVjq3Lmz9OjRQ8aNGycvv/yyu98aEXkwBk1E5JdmzJgh33//vfTp00f27NkjW7duleDgYHe/LSLyYAyaiMgv5eXlSdeuXeX48eOyfft26datm7vfEhF5OOY0EZFfSk5OllOnTonNZpOff/7Z3W+HiLwAR5qIyO8UFhZKYmKi5jIhp+nVV1/VKbpmzZq5+60RkQdj0EREfufJJ5+UJUuWyK5du6RBgwYydOhQiYiIkOXLl7v7rRGRB+P0HBH5ldWrV+vI0kcffSTh4eESEBCgX69bt07+8Y9/uPvtEZEH40gTERERkQM40kRERETkAAZNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNRERERA5g0ERERETkAAZNRERERA5g0EREREQkVfv/SR8+1251EmUAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -533,7 +569,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/qutip-dqpt.ipynb b/examples/qutip-dqpt.ipynb new file mode 100644 index 00000000..c6a9e700 --- /dev/null +++ b/examples/qutip-dqpt.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dynamical Quantum Phase Transitions\n", + "Using qutip backend" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qse\n", + "import qutip as qp\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAFdCAYAAADrOtLuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAALFFJREFUeJzt3Q10VOWdx/H/JJAXlIR3kqzhXcEXkihKiqsrrNGIHArnrC2yrSAFXDm0K82KlT0tcdceU10WwTWFVksBe1oQlFgrRhQFFgUpAQQtegCj4SWBwJKEBEggc/f8HzPjDCSBAMmdmef7OedxMneeudy5Prnzy73P81yP4ziOAAAAWCTK7Q0AAABoawQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrtHN7A0KR1+uVQ4cOSceOHcXj8bi9OQAA4CLo1IYnTpyQlJQUiYpq/hwPAagRGn5SU1MvZl8DAIAQs3//frnmmmuarUMAaoSe+fHtwISEhNb5vwMAAK6oqqoqcwLD9z3eHAJQI3yXvTT8EIAAAAgvF9N9hU7QAADAOpwBAsLY2XqvbNldIvuPVMip2jMSH9teUnt0kqHX95J20fx9A9oVQsfZEDteEYCAMHSsskZWb94tKzd8InuPHZUzHq84etpXRNo7UTKgazd54B/S5f7vXC9dE69ye3MRJmhXsKldeRwdM4bzOlElJiZKZWUlfYAQcnbuOySPL3xTik/8n9TGnhFvB0ekfcPRRH+bz4hEnfRIbG176duxi8x5dLSk9U9xe7MR4mhXiIR21ZLvb1fPkW/YsEFGjx5txutrh6WCgoJm6z/88MOm3rnlxhtv9Nd56qmnznt90KBBbfBpgLY5mEx/4TX54vRhOdW1Tup7OuL0EHGSRJzkhsceYpbr61pP6+v7ANoV2tLOED9euRqAampqJD09XfLz8y+q/vz586W0tNRfdJh6ly5d5Hvf+15QPQ1EgfU2btzYSp8AaNvTyPqXVIn3uJzt7IjTVUS6i0i3hsfuwc/1da2n9WcufNO8H6BdgeNVCPQBGjlypCkXS09rafHRM0bHjx+XSZMmBdVr166dJCUlXdFtBdym19D1NHJ9V0ekk4h01kmrRKSDiMQ1/DnjFZHTInLy29/u+npHvjx2TN7++HP54b1D3P4YCDG0K9jarsJ6mMjvfvc7ycrKkt69ewct37Nnj7ms1q9fP/nBD34gJSUlza6ntrbWXDcMLECojZ7QDoR6Dd25quFAokX/HtCDi+8A4/s58ds6Wr829qysXP+JWQ9Au0JrCpfjVVQ4367i7bfflilTpgQtz8zMlMWLF0thYaEsWLBAiouL5c477zT3BmlKXl6e/+ySFm6DgVCjQ0d19ITpQBjf8BeU/iXlO7gkBpSODct9f2nFi3jjHdlzrFz++nnzfwzALrQr2NyuwjYALVmyRDp16iRjx44NWq6X1LRPUFpammRnZ8vq1auloqJCXn311SbXNWvWLNNj3Fe0bxEQSnTeDB06akZPxDYcKHxFDxxX69TlDY++A4mvaP0YHWzhNesBaFdoTeFyvArLeYB05P6iRYvkoYcekpiYmGbraki67rrrZO/evU3WiY2NNQUIVTppmJmvwtPwZ4uvRDeU9gG/zb5lgfU8Io7HkZOnz7j7QRBSaFewuV2F5Rmg9evXm0AzefLkC9atrq6Wffv2SXJycptsG9AadMZUc2cbPap4A0p9Q9HjxNmGR9+ywHqOTvrlkQ5xeuQBaFdoPeFyvHL1DJCGk8AzM9pfZ8eOHWZoe69evcylqYMHD8rSpUvP6/ysfX1uuumm89b5+OOPm7mFtGO09hPKzc2V6OhoGT9+fJt8JqA16HTxOmOqOWDUNoyc8BXfMSK64UBy8pzXtX6dVosy6wFoV2hN4XK8cjUAbd26VUaMGOF/npOTYx4nTpxoOjLrHD7njuDSPjqvvfaamROoMQcOHDBh59ixY9K9e3e54447ZPPmzeZnIFzpvXJ0uvjt1Qel/pTz7dBR38HkTMABRV+rCTiwnBKJOuWRa7t2l9sG9XL5kyCU0K5gc7tyNQANHz7c9Odpioagc+korZMndU81btmyZVds+4BQoTcK1Hvl/G3VETlVUydOXMBv75km5tXQgY8nRDw1IrG17eSBUencIBW0K3C8Cuc+QICN9EaBeq+c6CqPiA6OON5QjjVSfK9ViKnfr2NXGZnJLWFAuwLHKx8CEBAm9C7JeqPAXlGdpd1xj3g06JSLyNGGx/Lg5/q61tP6cx79LneFB+0KHK8CcDf4RnA3eIQyvVGg3tvry6burlz3zTV0veylZ340/AzuzyhI0K4Q+cerqhbcDZ4AdJk7EHCD3thU75WzYv0OM+OqThqm82bo0FEdPaEdCB+4K91c9tIzRwDtCjYcr6oIQJeHAIRwoffK0enidcZUnTRM583QoaM6ekI7TgO0K9h0vKoiALXdDgQAAOH3/c2fiAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFjH1QC0YcMGGT16tKSkpIjH45GCgoJm669bt87UO7eUlZUF1cvPz5c+ffpIXFycZGZmypYtW1r5kwAAgHDiagCqqamR9PR0E1ha4osvvpDS0lJ/6dGjh/+15cuXS05OjuTm5sq2bdvM+rOzs+XIkSOt8AkAAEA4aufmPz5y5EhTWkoDT6dOnRp9be7cuTJ16lSZNGmSeb5w4UJ56623ZNGiRfLkk09e9jYDAIDwF5Z9gDIyMiQ5OVnuuece+fDDD/3L6+rqpKioSLKysvzLoqKizPNNmzY1ub7a2lqpqqoKKgAAIHKFVQDS0KNndF577TVTUlNTZfjw4eZSlzp69KjU19dLz549g96nz8/tJxQoLy9PEhMT/UXXCwAAIperl8BaauDAgab43H777bJv3z55/vnn5ZVXXrnk9c6aNcv0G/LRM0CEIAAAIldYBaDGDB06VDZu3Gh+7tatm0RHR8vhw4eD6ujzpKSkJtcRGxtrCgAAsENYXQJrzI4dO8ylMRUTEyNDhgyRtWvX+l/3er3m+bBhw1zcSgAAEEpcPQNUXV0te/fu9T8vLi42gaZLly7Sq1cvc2nq4MGDsnTpUvP6vHnzpG/fvnLjjTfK6dOn5eWXX5b3339f1qxZ41+HXsqaOHGi3HrrrebskL5Hh9v7RoUBAAC4GoC2bt0qI0aM8D/39cPRALN48WIzx09JSUnQKK9/+7d/M6GoQ4cOkpaWJu+9917QOsaNGyfl5eUye/Zs0/FZR4wVFhae1zEaAADYy+M4juP2RoQa7QSto8EqKyslISHB7c0BAABX+Ps77PsAAQAAtBQBCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArONqANqwYYOMHj1aUlJSxOPxSEFBQbP1X3/9dbnnnnuke/fukpCQIMOGDZN33nknqM5TTz1l1hVYBg0a1MqfBAAAhBNXA1BNTY2kp6dLfn7+RQcmDUCrV6+WoqIiGTFihAlQ27dvD6p34403Smlpqb9s3LixlT4BAAAIR+3c/MdHjhxpysWaN29e0PNnnnlG3njjDXnzzTfl5ptv9i9v166dJCUlXdFtBQAAkSOs+wB5vV45ceKEdOnSJWj5nj17zGW1fv36yQ9+8AMpKSlpdj21tbVSVVUVVAAAQOQK6wA0Z84cqa6ulu9///v+ZZmZmbJ48WIpLCyUBQsWSHFxsdx5550mKDUlLy9PEhMT/SU1NbWNPgEAAHCDx3EcR0KAdlZetWqVjB079qLq//GPf5SpU6eaS2BZWVlN1quoqJDevXvL3LlzZfLkyU2eAdLio2eANARVVlaaztYAACD06fe3nsi4mO9vV/sAXaply5bJlClTZMWKFc2GH9WpUye57rrrZO/evU3WiY2NNQUAANgh7C6B/elPf5JJkyaZx1GjRl2wvl4i27dvnyQnJ7fJ9gEAgNDn6hkgDSeBZ2a0v86OHTtMp+ZevXrJrFmz5ODBg7J06VL/Za+JEyfK/PnzTV+fsrIyszw+Pt6c8lKPP/64GRqvl70OHTokubm5Eh0dLePHj3fpUwIAgFDj6hmgrVu3muHrviHsOTk55ufZs2eb5zqHT+AIrt/+9rdy9uxZmT59ujmj4yuPPfaYv86BAwdM2Bk4cKDpHN21a1fZvHmzmTwRAAAgpDpBh2snKgAAEH7f32HXBwgAAOByEYAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6rgagDRs2yOjRoyUlJUU8Ho8UFBRc8D3r1q2TW265RWJjY2XAgAGyePHi8+rk5+dLnz59JC4uTjIzM2XLli2t9AkAAEA4cjUA1dTUSHp6ugksF6O4uFhGjRolI0aMkB07dsiMGTNkypQp8s477/jrLF++XHJyciQ3N1e2bdtm1p+dnS1HjhxpxU8CAADCicdxHEdCgJ4BWrVqlYwdO7bJOj/72c/krbfekk8//dS/7MEHH5SKigopLCw0z/WMz2233SYvvviiee71eiU1NVV+8pOfyJNPPtnoemtra03xqaqqMu+prKyUhISEK/gpAQBAa9Hv78TExIv6/g6rPkCbNm2SrKysoGV6dkeXq7q6OikqKgqqExUVZZ776jQmLy/P7DBf0fADAAAiV1gFoLKyMunZs2fQMn2uie/UqVNy9OhRqa+vb7SOvrcps2bNMmnRV/bv399qnwEAALivndsbEAq0Q7UWAABgh7AKQElJSXL48OGgZfpcr/PFx8dLdHS0KY3V0fcCAACE3SWwYcOGydq1a4OWvfvuu2a5iomJkSFDhgTV0U7Q+txXBwAAwNUAVF1dbYaza/ENc9efS0pK/H1zJkyY4K//6KOPypdffilPPPGEfP755/LrX/9aXn31VfnpT3/qr6ND4F966SVZsmSJ7N69W6ZNm2aG20+aNMmFTwgAAEKRq5fAtm7daub0CQwvauLEiWaCw9LSUn8YUn379jXD4DXwzJ8/X6655hp5+eWXzUgwn3Hjxkl5ebnMnj3bdHzOyMgwQ+TP7RgNAADsFTLzAIXrPAIAACA0ROw8QAAAAFcCAQgAAFiHAAQAAKxDAAIAANYJq4kQYYez9V7ZsrtE9h+pkFO1ZyQ+tr2k9ugkQ6/vJe2iyeygXSF0cLwKXwQghIxjlTWyevNuWbnhE9l77Kic8XhFhyh6RKS9EyUDunaTB/4hXe7/zvXSNfEqtzcXYYJ2BdoVGsMw+EYwDL7t7dx3SB5f+KYUn/g/qY09I94Ojkj7hvSjKeiMSNRJj8TWtpe+HbvInEdHS1r/FBe2FOGEdgXalV2qWjAMngB0mTsQV+ZLavoLr0mJ97jUJzji6MmdeL1LbUMvNa+I1IrIKRFPjUh0lUd6RXWW/H/9J0IQaFdoUxyvQhvzACGsLk/omR8NP2c7O+J0FZHuItKt4bF78HN9Xetp/ZkL3zTvB2hX4HiFlqJHKVylfX70spee+ZFOItK5oXRtpPhe6ySm/pcnjsnbH3/O/0HQrsDxCq0fgPQ+XRs2bGj5vwQ0MnpCOzxrnx9z2atjQ0n8JuT4A5Hv58Rv62j92tizsnL9J2Y9AO0KrYnjVeRpcQDSfjFZWVly7bXXyjPPPCMHDx5snS1DxNOh7jray3R41j4/cSLSQUR8YSgxoHRsWN6hoV68iDfekT3HyuWvn397w1yAdgWOV2iVAFRQUGBCz7Rp02T58uXSp08fGTlypKxcuVLOnDnT0tXBYjrPjw51N6O9YhuCja9o0LlaRBIaHn3Bx1e0fowODvOa9QC0K3C8Qqv3Aerevbvk5OTIJ598Ih9//LEMGDBAHnroIUlJSZGf/vSnsmfPnktZLSyjkxzqCHcz1D0qoEQ3lPYNM1W1D1gWWM8j4ngcOXma4A3aFTheoQ07QZeWlsq7775rSnR0tNx///2ya9cuueGGG+T555+/nFXDAjrDs2Yfk4K8AaW+oWiuOdvw6FsWWM/ReRw80iFOExJAuwLHK7TiTNB6mevPf/6z/P73v5c1a9ZIWlqazJgxQ/75n//ZP2fOqlWr5Ec/+pE5GwQ0RW9voTM8m4Cj8/ycDii+TBPdEHxOnvO61q/TalFmPQDtCq2J41XkaXEASk5OFq/XK+PHj5ctW7ZIRkbGeXVGjBghnTrxpYTm6b299PYW26sPSv0p55tgczIg/JwJCED6Wk1AEDolEnXKI9d27S63DerFrgbtCq2K41XkaXEA0ktb3/ve9yQuTnuiNk7DT3Fx8eVuGyKc3thU7+31t1VH5FRNnThxAS1Sw09cwEzQvnB04puiM0LH1raTB0alc4NU0K7A8Qqt3wdIOzs3F36AltAbm+q9vfT2FqKDuY43lGONFN9rFd/cDqNfx64yMnMQOxy0K7QJjleRhZmg4Sq9q7ve2FTv7dXuuEc8GnTKReRow2N58HN9Xetp/TmPfpe7woN2BY5XuCTcDLUR3AzVnRsM6r29vmzqbvB13/T50cteeuZHw8/g/skubCnCCe0KtCu7VHE3+Lbbgbhy9Mamem+vFet3mBmidZJDnedHh7rraC/t8PzAXenmspeeOQJoV3ALx6vQRABqwx2I1rnnjt7eQmd41kkOdZ4fHYKqo7204zRAu0Ko4HgVWghAbbgDAQBA+H1/8+c0AACwDgEIAABYJyQCUH5+vrmrvM4vlJmZaWaYbsrw4cPF4/GcV0aNGuWv8/DDD5/3+n333ddGnwYAAETcTNBX2vLly82d5RcuXGjCz7x58yQ7O1u++OIL6dGjx3n1X3/9damrq/M/P3bsmKSnp5vZqQNp4NH7lfnExsa28icBAADhwvUzQHPnzpWpU6fKpEmTzF3kNQh16NBBFi1a1Gj9Ll26SFJSkr/onei1/rkBSANPYL3OnTu30ScCAAChztUApGdyioqKJCsr69sNiooyzzdt2nRR6/jd734nDz74oFx1VfC8MOvWrTNnkAYOHCjTpk0zZ4qaUltba3qOBxYAABC5XA1AR48elfr6eunZs2fQcn1eVlZ2wfdrX6FPP/1UpkyZct7lr6VLl8ratWvl2WeflfXr18vIkSPNv9WYvLw8M2zOV1JTUy/zkwEAgFDmeh+gy6FnfwYPHixDhw4NWq5nhHz09bS0NOnfv785K3T33Xeft55Zs2aZfkg+egaIEAQAQORy9QxQt27dJDo6Wg4fPhy0XJ9rv53m1NTUyLJly2Ty5MkX/Hf69etn/q29e/c2+rr2F9IJkwILAACIXK4GoJiYGBkyZIi5VOXj9XrN82HDhjX73hUrVpi+Oz/84Q8v+O8cOHDA9AFKTubmmQAAIARGgemlp5deekmWLFkiu3fvNh2W9eyOjgpTEyZMMJeoGrv8NXbsWOnatWvQ8urqapk5c6Zs3rxZvvrqKxOmxowZIwMGDDDD6wEAAFzvAzRu3DgpLy+X2bNnm47PGRkZUlhY6O8YXVJSYkaGBdI5gjZu3Chr1qw5b316SW3nzp0mUFVUVEhKSorce++98vTTTzMXEAAAMDyO4zjf/AgfboYKAED44WaoAAAAodwHCAAAoK0RgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHVCIgDl5+dLnz59JC4uTjIzM2XLli1N1l28eLF4PJ6gou8L5DiOzJ49W5KTkyU+Pl6ysrJkz549bfBJAABAOHA9AC1fvlxycnIkNzdXtm3bJunp6ZKdnS1Hjhxp8j0JCQlSWlrqL19//XXQ688995y88MILsnDhQvn444/lqquuMus8ffp0G3wiAAAQ6lwPQHPnzpWpU6fKpEmT5IYbbjChpUOHDrJo0aIm36NnfZKSkvylZ8+eQWd/5s2bJz//+c9lzJgxkpaWJkuXLpVDhw5JQUFBG30qAAAQylwNQHV1dVJUVGQuUfk3KCrKPN+0aVOT76uurpbevXtLamqqCTmfffaZ/7Xi4mIpKysLWmdiYqK5tNbUOmtra6WqqiqoAACAyOVqADp69KjU19cHncFR+lxDTGMGDhxozg698cYb8oc//EG8Xq/cfvvtcuDAAfO6730tWWdeXp4JSb6iwQoAAEQu1y+BtdSwYcNkwoQJkpGRIXfddZe8/vrr0r17d/nNb35zyeucNWuWVFZW+sv+/fuv6DYDAIDQ4moA6tatm0RHR8vhw4eDlutz7dtzMdq3by8333yz7N271zz3va8l64yNjTUdqwMLAACIXK4GoJiYGBkyZIisXbvWv0wvaelzPdNzMfQS2q5du8yQd9W3b18TdALXqX16dDTYxa4TAABEtnZub4AOgZ84caLceuutMnToUDOCq6amxowKU3q56+/+7u9MPx31n//5n/Kd73xHBgwYIBUVFfJf//VfZhj8lClT/CPEZsyYIb/85S/l2muvNYHoF7/4haSkpMjYsWNd/awAACA0uB6Axo0bJ+Xl5WbiQu2krH17CgsL/Z2YS0pKzMgwn+PHj5th81q3c+fO5gzSRx99ZIbQ+zzxxBMmRD3yyCMmJN1xxx1mnedOmAgAAOzkcXTiHATRS2Y6Gkw7RNMfCACAyPv+DrtRYAAAAJeLAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKwTEgEoPz9f+vTpI3FxcZKZmSlbtmxpsu5LL70kd955p3Tu3NmUrKys8+o//PDD4vF4gsp9993XBp8EAACEA9cD0PLlyyUnJ0dyc3Nl27Ztkp6eLtnZ2XLkyJFG669bt07Gjx8vH3zwgWzatElSU1Pl3nvvlYMHDwbV08BTWlrqL3/605/a6BMBAIBQ53Ecx3FzA/SMz2233SYvvviiee71ek2o+clPfiJPPvnkBd9fX19vzgTp+ydMmOA/A1RRUSEFBQWXtE1VVVWSmJgolZWVkpCQcEnrAAAAbasl39+ungGqq6uToqIicxnLv0FRUea5nt25GCdPnpQzZ85Ily5dzjtT1KNHDxk4cKBMmzZNjh071uQ6amtrzU4LLAAAIHK5GoCOHj1qzuD07NkzaLk+Lysru6h1/OxnP5OUlJSgEKWXv5YuXSpr166VZ599VtavXy8jR440/1Zj8vLyTGL0FT0DBQAAIlc7CWO/+tWvZNmyZeZsj3ag9nnwwQf9Pw8ePFjS0tKkf//+pt7dd9993npmzZpl+iH56BkgQhAAAJHL1TNA3bp1k+joaDl8+HDQcn2elJTU7HvnzJljAtCaNWtMwGlOv379zL+1d+/eRl+PjY011woDCwAAiFyuBqCYmBgZMmSIuVTlo52g9fmwYcOafN9zzz0nTz/9tBQWFsqtt956wX/nwIEDpg9QcnLyFdt2AAAQvlwfBq+XnnRunyVLlsju3btNh+WamhqZNGmSeV1HduklKh/t0/OLX/xCFi1aZOYO0r5CWqqrq83r+jhz5kzZvHmzfPXVVyZMjRkzRgYMGGCG1wMAALjeB2jcuHFSXl4us2fPNkEmIyPDnNnxdYwuKSkxI8N8FixYYEaPPfDAA0Hr0XmEnnrqKXNJbefOnSZQ6VB47SCt8wTpGSO91AUAAOD6PEChiHmAAAAIP2EzDxAAAIAbCEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACs087tDbDF2XqvbNldIvuPVMip2jMSH9teUnt0kqHX95J20eRQ0K4QOjhewQYEoFZ2rLJGVm/eLSs3fCJ7jx2VMx6vOCLiEZH2TpQM6NpNHviHdLn/O9dL18SrWntzECFoV6BdAZfH4ziOfh8jQFVVlSQmJkplZaUkJCRc8r7Zue+QPL7wTSk+8X9SG3tGvB0ckfYN6Uf3+hmRqJMeia1tL307dpE5j46WtP4p/L8A7QptjuMVbPv+JgBd5g5s7mAy/YXXpMR7XOoTHHH05E68iMQ29LzyikitiJwS8dSIRFd5pFdUZ8n/138iBIF2hTbF8Qo2fn/T+aSVLk/omR8NP2c7O+J0FZHuItKt4bF78HN9Xetp/ZkL3zTvB2hXaAscr2CrkAhA+fn50qdPH4mLi5PMzEzZsmVLs/VXrFghgwYNMvUHDx4sq1evDnpdr+rNnj1bkpOTJT4+XrKysmTPnj3SVrTPj1720jM/0klEOjeUro0U32udxNT/8sQxefvjz9tsWxE+aFegXQERFICWL18uOTk5kpubK9u2bZP09HTJzs6WI0eONFr/o48+kvHjx8vkyZNl+/btMnbsWFM+/fRTf53nnntOXnjhBVm4cKF8/PHHctVVV5l1nj59uk1GT2iHZ+3zYy57dWwoid+EHH8g8v2c+G0drV8be1ZWrv/ErAegXYHjFRChAWju3LkydepUmTRpktxwww0mtHTo0EEWLVrUaP358+fLfffdJzNnzpTrr79enn76abnlllvkxRdf9J/9mTdvnvz85z+XMWPGSFpamixdulQOHTokBQUFrf55dKi7jvYyHZ61z0+ciHQQEV8YSgwoHRuWd2ioFy/ijXdkz7Fy+evnJa2+rQgftCvQroAICkB1dXVSVFRkLlH5NygqyjzftGlTo+/R5YH1lZ7d8dUvLi6WsrKyoDraIUovrTW1ztraWtNxKrBcKp3nR4e6m9FesQ3Bxlc06FwtIgkNj77g4ytaP0YHh3nNegDaFVoTxyvYzNUAdPToUamvr5eePXsGLdfnGmIao8ubq+97bMk68/LyTEjyldTU1Ev+TDrJoZlXwNOwd30luqG0b5h9qX3AssB6HhHH48jJ02cueRsQeWhXoF0BEXYJLBTMmjXLDJnzlf3791/yunSGZ80+JgV5A0p9Q9Fcc7bh0bcssJ6jcxN4pEOcJiSAdoXWw/EKNnN1Juhu3bpJdHS0HD58OGi5Pk9KSmr0Pbq8ufq+R12mo8AC62RkZDS6ztjYWFOuBL29hc7wbAKOzvNzOqD4Mk10Q/A5ec7rWr9Oq0WZ9QC0K7QmjlewmatngGJiYmTIkCGydu1a/zKv12ueDxs2rNH36PLA+urdd9/11+/bt68JQYF1tE+PjgZrap1Xkt7bS29voTM86ySHJtho0NGpfU6ISGVAOdGw3BeETolEnfLItV27y22DerX6tiJ80K5AuwIi7BKYDoF/6aWXZMmSJbJ7926ZNm2a1NTUmFFhasKECeYSlc9jjz0mhYWF8t///d/y+eefy1NPPSVbt26VH//4x+Z1j8cjM2bMkF/+8pfy5z//WXbt2mXWkZKSYobLtza9sane20tvb6EzPJuQ4ws+FQ3leMDPviB04psZoWNr28kDd6Vzg1TQrsDxCojkm6GOGzdOysvLzcSF2klZL1NpwPF1Yi4pKTEjw3xuv/12+eMf/2iGuf/7v/+7XHvttWZ4+0033eSv88QTT5gQ9cgjj0hFRYXccccdZp06cWJb0BubvvJekXxRdVjORjfcak37/egZobiAW2H4Ln1pAKr45nYY/Tp2lZGZg9pkOxFeaFegXQFXDvcCC7F7gf36Xx+Qwf2/7bsE0K7Q2jheIVJwM9Q23IEXOqjovb2+bOpu8HXf9PnRy1565mfOo98l/IB2BVdwvEIkIAC14Q68mBsN6r29VqzfYWaI1kkOdZ4fHequo720w7P2+dHLXl0T9TQRQLuCOzheIdwRgNpwB14svbeX3t5CZ17VSQ51nh8dgqqjvbTjNEC7QqjgeIVwRQBqwx0IAADC7/ubUw8AAMA6rg+DD0V6R3l1OTdFBQAAbcv3ve37Hm8OAagRJ07oxDxyWTdFBQAA7n2P66Ww5jAPUCP0dhyHDh2Sjh07mpmlr3Q61WClN1ylfxH7inbV9vgdZF/RrtzVmr+DeuZHw4/e/SFwEuXGcAaoEbrTrrnmGmlN+j+dAMS+ol25h99B9hXtKjJ/By905seHTtAAAMA6BCAAAGAdAlAbi42NldzcXPMI9hXtqu3xO8i+ol25K1R+B+kEDQAArMMZIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAagX5+fnSp08fiYuLk8zMTNmyZUuz9VesWCGDBg0y9QcPHiyrV68WW7RkXy1evNjMzB1Y9H2RbsOGDTJ69Ggzs6l+5oKCggu+Z926dXLLLbeYURYDBgww+84WLd1fuq/ObVdaysrKJJLl5eXJbbfdZma879Gjh4wdO1a++OKLC77PxuPVpewrW49XasGCBZKWluaf6HDYsGHy9ttvS6i1KwLQFbZ8+XLJyckxQ/y2bdsm6enpkp2dLUeOHGm0/kcffSTjx4+XyZMny/bt280vlpZPP/1UIl1L95XSX6bS0lJ/+frrryXS1dTUmH2jYfFiFBcXy6hRo2TEiBGyY8cOmTFjhkyZMkXeeecdsUFL95ePfqEFti39ootk69evl+nTp8vmzZvl3XfflTNnzsi9995r9l9TbD1eXcq+svV4pfROCr/61a+kqKhItm7dKv/4j/8oY8aMkc8++0xCql05uKKGDh3qTJ8+3f+8vr7eSUlJcfLy8hqt//3vf98ZNWpU0LLMzEznX/7lXyL+/0xL99Xvf/97JzEx0bGZ/squWrWq2TpPPPGEc+ONNwYtGzdunJOdne3Y5mL21wcffGDqHT9+3LHZkSNHzH5Yv359k3VsPl61dF9xvArWuXNn5+WXX3ZCqV1xBugKqqurM4k3Kysr6L5i+nzTpk2NvkeXB9ZXehakqfo27ytVXV0tvXv3NjfSa+4vCpvZ2qYuV0ZGhiQnJ8s999wjH374odimsrLSPHbp0qXJOrSti99XiuOVSH19vSxbtsycLdNLYaHUrghAV9DRo0fN/+yePXsGLdfnTfUn0OUtqW/zvho4cKAsWrRI3njjDfnDH/4gXq9Xbr/9djlw4EAbbXV4aKpN6R2YT5065dp2hSoNPQsXLpTXXnvNFA3Xw4cPN5dlbaG/S3qp9O///u/lpptuarKercerS9lXth+vdu3aJVdffbXph/joo4/KqlWr5IYbbgipdsXd4BE29K+HwL8g9GBy/fXXy29+8xt5+umnXd02hC/9otIS2K727dsnzz//vLzyyitiA+3fov0tNm7c6PamRMy+sv14NXDgQNMHUc+WrVy5UiZOnGj6UjUVgtzAGaArqFu3bhIdHS2HDx8OWq7Pk5KSGn2PLm9JfZv31bnat28vN998s+zdu7eVtjI8NdWmtENmfHy8a9sVToYOHWpNu/rxj38sf/nLX+SDDz4wnVebY+vx6lL2le3Hq5iYGDMCdciQIWYUnQ5MmD9/fki1KwLQFf4frv+z165d61+mpz31eVPXPnV5YH2lowyaqm/zvjqXXkLT06x6CQPfsrVNXUn6l2uktyvtI65f6Hpp4v3335e+ffte8D22tq1L2Vfnsv145fV6pba2NrTaVat2sbbQsmXLnNjYWGfx4sXO3/72N+eRRx5xOnXq5JSVlZnXH3roIefJJ5/01//www+ddu3aOXPmzHF2797t5ObmOu3bt3d27drlRLqW7qv/+I//cN555x1n3759TlFRkfPggw86cXFxzmeffeZEshMnTjjbt283RX9l586da37++uuvzeu6j3Rf+Xz55ZdOhw4dnJkzZ5o2lZ+f70RHRzuFhYWODVq6v55//nmnoKDA2bNnj/m9e+yxx5yoqCjnvffecyLZtGnTzKjKdevWOaWlpf5y8uRJfx2OV5e+r2w9XindDzpCrri42Nm5c6d57vF4nDVr1oRUuyIAtYL/+Z//cXr16uXExMSYod6bN2/2v3bXXXc5EydODKr/6quvOtddd52pr8OX33rrLccWLdlXM2bM8Nft2bOnc//99zvbtm1zIp1vmPa5xbdv9FH31bnvycjIMPuqX79+ZkiuLVq6v5599lmnf//+5supS5cuzvDhw53333/fiXSN7SMtgW2F49Wl7ytbj1fqRz/6kdO7d2/z2bt37+7cfffd/vATSu3Ko/9p3XNMAAAAoYU+QAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIQMQrLy+XpKQkeeaZZ/zLPvroI4mJiZG1a9e6um0A3MHNUAFYYfXq1TJ27FgTfAYOHCgZGRkyZswYmTt3rtubBsAFBCAA1pg+fbq89957cuutt8quXbvkr3/9q8TGxrq9WQBcQAACYI1Tp07JTTfdJPv375eioiIZPHiw25sEwCX0AQJgjX379smhQ4fE6/XKV1995fbmAHARZ4AAWKGurk6GDh1q+v5oH6B58+aZy2A9evRwe9MAuIAABMAKM2fOlJUrV8onn3wiV199tdx1112SmJgof/nLX9zeNAAu4BIYgIi3bt06c8bnlVdekYSEBImKijI//+///q8sWLDA7c0D4ALOAAEAAOtwBggAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAAYpv/B/Ln55OpgEuAAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# qbits = qse.lattices.ring(1., 8)\n", + "qbits = qse.lattices.triangular(1., 3, 3)\n", + "qbits.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def distance_func(distance, tolerance=0.01):\n", + " \"\"\"\n", + " Simple distance function that only includes nearest neighbours.\n", + " \n", + " This function returns a coefficient of 1.0 if the input distance is approximately 1.0\n", + " (within a specified tolerance), otherwise it returns 0.0.\n", + " \"\"\"\n", + " if np.abs(distance-1) < tolerance:\n", + " return 1.\n", + " return 0.\n", + "\n", + "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", + "ext_field = [qse.Operator(\"X\", i, 1.0, qbits.nqbits) for i in range(qbits.nqbits)]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.00 Z0 Z1,\n", + " 1.00 Z0 Z3,\n", + " 1.00 Z1 Z2,\n", + " 1.00 Z1 Z3,\n", + " 1.00 Z1 Z4,\n", + " 1.00 Z2 Z4,\n", + " 1.00 Z2 Z5,\n", + " 1.00 Z3 Z4,\n", + " 1.00 Z3 Z6,\n", + " 1.00 Z4 Z5,\n", + " 1.00 Z4 Z6,\n", + " 1.00 Z4 Z7,\n", + " 1.00 Z5 Z7,\n", + " 1.00 Z5 Z8,\n", + " 1.00 Z6 Z7,\n", + " 1.00 Z7 Z8]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coupling" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1\n", + "0 3\n", + "1 2\n", + "1 3\n", + "1 4\n", + "2 4\n", + "2 5\n", + "3 4\n", + "3 6\n", + "4 5\n", + "4 6\n", + "4 7\n", + "5 7\n", + "5 8\n", + "6 7\n", + "7 8\n" + ] + }, + { + "data": { + "text/latex": [ + "Quantum object: dims=[[2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2]], shape=(512, 512), type='oper', dtype=CSR, isherm=True$$\\left(\\begin{array}{cc}16 & 1 & 1 & 0 & 1 & \\cdots & 0 & 0 & 0 & 0 & 0\\\\1 & 12 & 0 & 1 & 0 & \\cdots & 0 & 0 & 0 & 0 & 0\\\\1 & 0 & 8 & 1 & 0 & \\cdots & 0 & 0 & 0 & 0 & 0\\\\0 & 1 & 1 & 8 & 0 & \\cdots & 0 & 0 & 0 & 0 & 0\\\\1 & 0 & 0 & 0 & 10 & \\cdots & 0 & 0 & 0 & 0 & 0\\\\\\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots\\\\0 & 0 & 0 & 0 & 0 & \\cdots & 10 & 0 & 0 & 0 & 1\\\\0 & 0 & 0 & 0 & 0 & \\cdots & 0 & 8 & 1 & 1 & 0\\\\0 & 0 & 0 & 0 & 0 & \\cdots & 0 & 1 & 8 & 0 & 1\\\\0 & 0 & 0 & 0 & 0 & \\cdots & 0 & 1 & 0 & 12 & 1\\\\0 & 0 & 0 & 0 & 0 & \\cdots & 1 & 0 & 1 & 1 & 16\\end{array}\\right)$$" + ], + "text/plain": [ + "Quantum object: dims=[[2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2]], shape=(512, 512), type='oper', dtype=CSR, isherm=True\n", + "Qobj data =\n", + "[[16. 1. 1. ... 0. 0. 0.]\n", + " [ 1. 12. 0. ... 0. 0. 0.]\n", + " [ 1. 0. 8. ... 0. 0. 0.]\n", + " ...\n", + " [ 0. 0. 0. ... 8. 0. 1.]\n", + " [ 0. 0. 0. ... 0. 12. 1.]\n", + " [ 0. 0. 0. ... 1. 1. 16.]]" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hamiltonian = 0.\n", + "\n", + "for i in range(qbits.nqbits):\n", + " op = [qp.qeye(2)] * qbits.nqbits\n", + " op[i] = qp.sigmax()\n", + " hamiltonian += qp.tensor(op)\n", + "\n", + "\n", + "for i in range(qbits.nqbits-1):\n", + " for j in range(i+1, qbits.nqbits):\n", + " if qbits.get_distance(i, j) < 1.1:\n", + " print(i, j)\n", + " op = [qp.qeye(2)] * qbits.nqbits\n", + " op[i] = qp.sigmaz()\n", + " op[j] = qp.sigmaz()\n", + " hamiltonian += qp.tensor(op)\n", + "hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "initial_state = qp.tensor([qp.fock(2)]*qbits.nqbits)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'(1+0j) |000000000>'" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_state.basis_expansion()" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "times = np.linspace(0, 2*np.pi, 200)\n", + "\n", + "evolutions = qp.sesolve(hamiltonian, initial_state, times)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "loschmidt_amplitudes = np.array([initial_state.overlap(psi_evo) for psi_evo in evolutions.states])\n", + "loschmidt_echos = (np.conj(loschmidt_amplitudes) * loschmidt_amplitudes).real\n", + "#loschmidt_echos" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "rate_func = - np.log(loschmidt_echos) / qbits.nqbits" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(nrows=2, sharex=\"col\")\n", + "\n", + "axs[0].plot(times, loschmidt_echos)\n", + "axs[0].set_ylabel(\"Loschmidt Echos\")\n", + "\n", + "axs[1].plot(times, rate_func)\n", + "axs[1].set_ylabel(\"Rate Function\")\n", + "axs[1].set_xlabel(\"Time\")\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qse_testbed", + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From b3e4106b7c465fac66d2dcf2ae9ae3f601100c5d Mon Sep 17 00:00:00 2001 From: James Nelson Date: Wed, 18 Feb 2026 14:05:24 +0000 Subject: [PATCH 07/10] qutip nb --- examples/gate_based.ipynb | 71 +++++++++++++++++------------- examples/qutip-dqpt.ipynb | 29 ++++++------ qse/__init__.py | 2 +- qse/lattices/__init__.py | 10 +---- qse/{gate_based.py => operator.py} | 51 +++++++++++++++++++-- qse/qbits.py | 23 +++++----- tests/qse/lattices_test.py | 9 +--- 7 files changed, 118 insertions(+), 77 deletions(-) rename qse/{gate_based.py => operator.py} (54%) diff --git a/examples/gate_based.ipynb b/examples/gate_based.ipynb index ab7b8a94..aebc0a2c 100644 --- a/examples/gate_based.ipynb +++ b/examples/gate_based.ipynb @@ -50,16 +50,18 @@ } ], "source": [ - "h = np.sqrt(1 - 0.5*0.5)\n", + "h = np.sqrt(1 - 0.5 * 0.5)\n", "\n", - "positions = np.array([\n", - " [0., 0., 0.],\n", - " [1., 0., 0.],\n", - " [2., 0., 0.],\n", - " [0.5, h, 0.],\n", - " [1.5, h, 0.],\n", - " [2.5, h, 0.],\n", - " ])\n", + "positions = np.array(\n", + " [\n", + " [0.0, 0.0, 0.0],\n", + " [1.0, 0.0, 0.0],\n", + " [2.0, 0.0, 0.0],\n", + " [0.5, h, 0.0],\n", + " [1.5, h, 0.0],\n", + " [2.5, h, 0.0],\n", + " ]\n", + ")\n", "\n", "qbits = qse.Qbits(positions=positions)\n", "qbits.draw(show_labels=True, radius=\"nearest\")" @@ -105,16 +107,18 @@ } ], "source": [ - "h = np.sqrt(1 - 0.5*0.5)\n", + "h = np.sqrt(1 - 0.5 * 0.5)\n", "\n", - "positions = np.array([\n", - " [0., 0., 0.],\n", - " [-h, -0.5, 0.],\n", - " [-h, 0.5, 0.],\n", - " [1., 0., 0.],\n", - " [1+h, -0.5, 0.],\n", - " [1+h, 0.5, 0.],\n", - " ])\n", + "positions = np.array(\n", + " [\n", + " [0.0, 0.0, 0.0],\n", + " [-h, -0.5, 0.0],\n", + " [-h, 0.5, 0.0],\n", + " [1.0, 0.0, 0.0],\n", + " [1 + h, -0.5, 0.0],\n", + " [1 + h, 0.5, 0.0],\n", + " ]\n", + ")\n", "\n", "qbits = qse.Qbits(positions=positions)\n", "qbits.draw(show_labels=True, radius=\"nearest\")" @@ -159,13 +163,13 @@ "def distance_func(distance, tolerance=0.01):\n", " \"\"\"\n", " Simple distance function that only includes nearest neighbours.\n", - " \n", + "\n", " This function returns a coefficient of 1.0 if the input distance is approximately 1.0\n", " (within a specified tolerance), otherwise it returns 0.0.\n", " \"\"\"\n", - " if np.abs(distance-1) < tolerance:\n", - " return 1.\n", - " return 0." + " if np.abs(distance - 1) < tolerance:\n", + " return 1.0\n", + " return 0.0" ] }, { @@ -195,10 +199,10 @@ "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", "coupling\n", "# We can easily do something more complicated like a Heisenberg model:\n", - "# coupling = \n", - "# qbits.compute_interaction_hamiltonian(distance_func, \"X\") + \n", - "# qbits.compute_interaction_hamiltonian(distance_func, \"Y\") + \n", - "# qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n" + "# coupling =\n", + "# qbits.compute_interaction_hamiltonian(distance_func, \"X\") +\n", + "# qbits.compute_interaction_hamiltonian(distance_func, \"Y\") +\n", + "# qbits.compute_interaction_hamiltonian(distance_func, \"Z\")" ] }, { @@ -279,7 +283,9 @@ } ], "source": [ - "hamiltonian_qiskit = SparsePauliOp([i.to_str() for i in hamiltonian], [i.coef for i in hamiltonian])\n", + "hamiltonian_qiskit = SparsePauliOp(\n", + " [i.to_str() for i in hamiltonian], [i.coef for i in hamiltonian]\n", + ")\n", "print(hamiltonian_qiskit)\n", "ansatz = efficient_su2(qbits.nqbits, reps=1)" ] @@ -299,6 +305,7 @@ "\n", " return job.result()[0].data.evs\n", "\n", + "\n", "def run_sampler(params, shots=1000):\n", " \"\"\"Sample a circuit using a statevector simulator.\"\"\"\n", " sampler = StatevectorSampler()\n", @@ -347,9 +354,11 @@ "\n", "cost_hist = []\n", "opt_result = minimize(\n", - " compute_expectation, x0, method=\"BFGS\", \n", - " callback=lambda intermediate_result: cost_hist.append(intermediate_result.fun)\n", - " )\n", + " compute_expectation,\n", + " x0,\n", + " method=\"BFGS\",\n", + " callback=lambda intermediate_result: cost_hist.append(intermediate_result.fun),\n", + ")\n", "opt_result" ] }, @@ -471,7 +480,7 @@ } ], "source": [ - "samples_top = {i:j for i,j in samples.items() if j > 50}\n", + "samples_top = {i: j for i, j in samples.items() if j > 50}\n", "samples_top" ] }, diff --git a/examples/qutip-dqpt.ipynb b/examples/qutip-dqpt.ipynb index c6a9e700..22c36f4c 100644 --- a/examples/qutip-dqpt.ipynb +++ b/examples/qutip-dqpt.ipynb @@ -38,7 +38,7 @@ ], "source": [ "# qbits = qse.lattices.ring(1., 8)\n", - "qbits = qse.lattices.triangular(1., 3, 3)\n", + "qbits = qse.lattices.triangular(1.0, 3, 3)\n", "qbits.draw()" ] }, @@ -51,13 +51,14 @@ "def distance_func(distance, tolerance=0.01):\n", " \"\"\"\n", " Simple distance function that only includes nearest neighbours.\n", - " \n", + "\n", " This function returns a coefficient of 1.0 if the input distance is approximately 1.0\n", " (within a specified tolerance), otherwise it returns 0.0.\n", " \"\"\"\n", - " if np.abs(distance-1) < tolerance:\n", - " return 1.\n", - " return 0.\n", + " if np.abs(distance - 1) < tolerance:\n", + " return 1.0\n", + " return 0.0\n", + "\n", "\n", "coupling = qbits.compute_interaction_hamiltonian(distance_func, \"Z\")\n", "ext_field = [qse.Operator(\"X\", i, 1.0, qbits.nqbits) for i in range(qbits.nqbits)]" @@ -148,7 +149,7 @@ } ], "source": [ - "hamiltonian = 0.\n", + "hamiltonian = 0.0\n", "\n", "for i in range(qbits.nqbits):\n", " op = [qp.qeye(2)] * qbits.nqbits\n", @@ -156,8 +157,8 @@ " hamiltonian += qp.tensor(op)\n", "\n", "\n", - "for i in range(qbits.nqbits-1):\n", - " for j in range(i+1, qbits.nqbits):\n", + "for i in range(qbits.nqbits - 1):\n", + " for j in range(i + 1, qbits.nqbits):\n", " if qbits.get_distance(i, j) < 1.1:\n", " print(i, j)\n", " op = [qp.qeye(2)] * qbits.nqbits\n", @@ -173,7 +174,7 @@ "metadata": {}, "outputs": [], "source": [ - "initial_state = qp.tensor([qp.fock(2)]*qbits.nqbits)" + "initial_state = qp.tensor([qp.fock(2)] * qbits.nqbits)" ] }, { @@ -202,7 +203,7 @@ "metadata": {}, "outputs": [], "source": [ - "times = np.linspace(0, 2*np.pi, 200)\n", + "times = np.linspace(0, 2 * np.pi, 200)\n", "\n", "evolutions = qp.sesolve(hamiltonian, initial_state, times)" ] @@ -213,9 +214,11 @@ "metadata": {}, "outputs": [], "source": [ - "loschmidt_amplitudes = np.array([initial_state.overlap(psi_evo) for psi_evo in evolutions.states])\n", + "loschmidt_amplitudes = np.array(\n", + " [initial_state.overlap(psi_evo) for psi_evo in evolutions.states]\n", + ")\n", "loschmidt_echos = (np.conj(loschmidt_amplitudes) * loschmidt_amplitudes).real\n", - "#loschmidt_echos" + "# loschmidt_echos" ] }, { @@ -224,7 +227,7 @@ "metadata": {}, "outputs": [], "source": [ - "rate_func = - np.log(loschmidt_echos) / qbits.nqbits" + "rate_func = -np.log(loschmidt_echos) / qbits.nqbits" ] }, { diff --git a/qse/__init__.py b/qse/__init__.py index 2199a50d..5904d662 100644 --- a/qse/__init__.py +++ b/qse/__init__.py @@ -22,10 +22,10 @@ __version__ = importlib.metadata.version("qse") +from qse.operator import Operator, operators_to_qutip from qse.qbit import Qbit from qse.qbits import Qbits from qse.signal import Signal from qse.visualise import draw -from qse.gate_based import Operator from qse import calc, lattices, magnetic, utils, visualise # isort: skip diff --git a/qse/lattices/__init__.py b/qse/lattices/__init__.py index ddb166d5..3a30f541 100644 --- a/qse/lattices/__init__.py +++ b/qse/lattices/__init__.py @@ -10,12 +10,4 @@ "triangular", ] -from .lattices import ( - chain, - hexagonal, - kagome, - ring, - square, - torus, - triangular, -) +from .lattices import chain, hexagonal, kagome, ring, square, torus, triangular diff --git a/qse/gate_based.py b/qse/operator.py similarity index 54% rename from qse/gate_based.py rename to qse/operator.py index 842a52e5..42c74851 100644 --- a/qse/gate_based.py +++ b/qse/operator.py @@ -1,3 +1,6 @@ +import qutip as qp + + class Operator: """ Represents an operator in a quantum system. @@ -6,7 +9,7 @@ class Operator: ---------- operator: str | list[str] The type of qubit operator. - Currently only "X", "Y", "Z" are supported. + Currently only "X", "Y", "Z" are supported. "N" the number operator is supported for QuTiP. If a list, must be equal in length to the size of the qubits tuple. qubits: int | list[int] @@ -17,6 +20,7 @@ class Operator: nqubits: int The total number of qubits in the system. """ + def __init__(self, operator, qubits, coef, nqubits): if isinstance(qubits, int): qubits = [qubits] @@ -24,7 +28,7 @@ def __init__(self, operator, qubits, coef, nqubits): operator = [operator] * len(qubits) assert len(qubits) == len(operator) - + self.operator = operator self.qubits = qubits self.coef = coef @@ -48,5 +52,46 @@ def to_str(self): op[qi] = op_str return "".join(op) + def to_qutip(self): + """ + Generates a qutip representation of the operator. + + The string is constructed as a tensor product of identity (I) and operator, + where the operator is placed at the positions specified by `qubits`. + + Returns + ------- + str + A string of length `nqubits`, with "I" at all positions except for the qubits in `qubits`, + which are replaced by the operator. + """ + op = [qp.qeye(2)] * self.nqubits + for qi, op_str in zip(self.qubits, self.operator): + op[qi] = _qutip_converter(op_str) + return qp.tensor(op) + def __repr__(self): - return f"{self.coef:.2f} " + " ".join([f"{op}{q}" for op, q in zip(self.operator, self.qubits)]) + return f"{self.coef:.2f} " + " ".join( + [f"{op}{q}" for op, q in zip(self.operator, self.qubits)] + ) + + +def _qutip_converter(op): + if op == "X": + return qp.sigmax() + + if op == "Y": + return qp.sigmay() + + if op == "Z": + return qp.sigmaz() + + if op == "N": + return 0.5 * (1 - qp.sigmaz()) + + +def operators_to_qutip(operator_list): + operator = 0 + for op in operator_list: + operator += op.coef * op.to_qutip() + return operator diff --git a/qse/qbits.py b/qse/qbits.py index 3474fc7b..d8bae164 100644 --- a/qse/qbits.py +++ b/qse/qbits.py @@ -7,13 +7,12 @@ import numpy as np from ase.cell import Cell -from ase.geometry import ( - find_mic, -) +from ase.geometry import find_mic +from qse.operator import Operator from qse.qbit import Qbit from qse.visualise import draw as _draw -from qse.gate_based import Operator + class Qbits: """ @@ -1284,11 +1283,11 @@ def to_pulser(self): return Register.from_coordinates(self.positions[:, :2], prefix="q") def compute_interaction_hamiltonian( - self, - distance_func, - interaction, - tol = 1e-8, - ): + self, + distance_func, + interaction, + tol=1e-8, + ): """ Compute the interaction Hamiltonian the system of qubits. @@ -1314,11 +1313,11 @@ def compute_interaction_hamiltonian( """ ops = [] - for i in range(self.nqbits-1): - for j in range(i+1, self.nqbits): + for i in range(self.nqbits - 1): + for j in range(i + 1, self.nqbits): coef = distance_func(self.get_distance(i, j)) if np.abs(coef) > tol: - ops.append(Operator(interaction, (i,j), coef, self.nqbits)) + ops.append(Operator(interaction, (i, j), coef, self.nqbits)) return ops diff --git a/tests/qse/lattices_test.py b/tests/qse/lattices_test.py index a9e421ba..403acebe 100644 --- a/tests/qse/lattices_test.py +++ b/tests/qse/lattices_test.py @@ -2,14 +2,7 @@ import pytest import qse -from qse.lattices import ( - chain, - hexagonal, - kagome, - ring, - square, - triangular, -) +from qse.lattices import chain, hexagonal, kagome, ring, square, triangular _lattice_spacings = [0.5, 3.1] _repeats = [2, 3] From 350a2384eb92e56c4414d492381609b91ca8945f Mon Sep 17 00:00:00 2001 From: James Nelson Date: Wed, 18 Feb 2026 14:24:12 +0000 Subject: [PATCH 08/10] update --- qse/__init__.py | 3 ++- qse/operator.py | 20 ++++++++------------ qse/qbits.py | 11 ++++++----- 3 files changed, 16 insertions(+), 18 deletions(-) diff --git a/qse/__init__.py b/qse/__init__.py index 5904d662..59e55dec 100644 --- a/qse/__init__.py +++ b/qse/__init__.py @@ -11,9 +11,10 @@ "draw", "lattices", "magnetic", - "Operator", "Qbit", "Qbits", + "Operator", + "operators_to_qutip", "Signal", "utils", "visualise", diff --git a/qse/operator.py b/qse/operator.py index 42c74851..fbc4181d 100644 --- a/qse/operator.py +++ b/qse/operator.py @@ -9,8 +9,8 @@ class Operator: ---------- operator: str | list[str] The type of qubit operator. - Currently only "X", "Y", "Z" are supported. "N" the number operator is supported for QuTiP. - If a list, must be equal in length to the size of + Currently only "X", "Y", "Z" are supported. "N" the number operator is + supported for QuTiP. If a list, must be equal in length to the size of the qubits tuple. qubits: int | list[int] A single integer or list of integers representing the qubits @@ -44,8 +44,8 @@ def to_str(self): Returns ------- str - A string of length `nqubits`, with "I" at all positions except for the qubits in `qubits`, - which are replaced by the operator. + A string of length `nqubits`, with "I" at all positions except for the + qubits in `qubits`, which are replaced by the operator. """ op = ["I"] * self.nqubits for qi, op_str in zip(self.qubits, self.operator): @@ -54,21 +54,17 @@ def to_str(self): def to_qutip(self): """ - Generates a qutip representation of the operator. - - The string is constructed as a tensor product of identity (I) and operator, - where the operator is placed at the positions specified by `qubits`. + Generates a QuTiP representation of the operator. Returns ------- - str - A string of length `nqubits`, with "I" at all positions except for the qubits in `qubits`, - which are replaced by the operator. + qutip.Qobj + The QuTiP operator. """ op = [qp.qeye(2)] * self.nqubits for qi, op_str in zip(self.qubits, self.operator): op[qi] = _qutip_converter(op_str) - return qp.tensor(op) + return self.coef * qp.tensor(op) def __repr__(self): return f"{self.coef:.2f} " + " ".join( diff --git a/qse/qbits.py b/qse/qbits.py index d8bae164..14ade959 100644 --- a/qse/qbits.py +++ b/qse/qbits.py @@ -1298,18 +1298,19 @@ def compute_interaction_hamiltonian( Parameters ---------- distance_func : callable - A function that takes a distance (float) and returns the interaction coefficient (float). + A function that takes a distance (float) and returns the interaction + coefficient (float). interaction : str The type of interaction (e.g., "X", "Y", "Z") for the Hamiltonian terms. tol : float, optional - Tolerance threshold for including interaction terms. Terms with absolute coefficients - less than `tol` are discarded. Default is 1e-8. + Tolerance threshold for including interaction terms. Terms with absolute + coefficients less than `tol` are discarded. Default is 1e-8. Returns ------- list of InteractionTerm - A list of `InteractionTerm` objects, each representing a non-negligible interaction - between a pair of qubits. + A list of `InteractionTerm` objects, each representing a non-negligible + interaction between a pair of qubits. """ ops = [] From 899119884c9771ad7165cb72591cf08399e79188 Mon Sep 17 00:00:00 2001 From: James Nelson Date: Fri, 20 Feb 2026 13:37:24 +0000 Subject: [PATCH 09/10] add qutip nb --- examples/qutip_simulation.ipynb | 190 ++++++++++++++++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 examples/qutip_simulation.ipynb diff --git a/examples/qutip_simulation.ipynb b/examples/qutip_simulation.ipynb new file mode 100644 index 00000000..f99b702f --- /dev/null +++ b/examples/qutip_simulation.ipynb @@ -0,0 +1,190 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# QuTiP based workflow\n", + "\n", + "This notebook shows an example of how QuTiP can be used to run calculations on Qbits objects." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qse\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import qutip as qp" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Create qbits object" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qbits = qse.lattices.ring(1, 6) + qse.Qbits(positions=np.array([[2, 0, 0]]))\n", + "qbits.labels = list(range(qbits.nqbits))\n", + "qbits.draw(show_labels=True, radius=\"nearest\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Step 2: Create the Hamiltonian\n", + "Let's looks at the Heisenberg Model\n", + "$$\n", + "H = - \\sum_{} (J_{XX}X_i X_j + J_{YY}Y_i Y_j + J_{ZZ}Z_i Z_j)\n", + "$$\n", + "where $$ means only sum over nearest neighbour pairs $i$ and $j$.\n", + "\n", + "We'll measure how the Pauli Z expectation value of each qubit $\\langle Z_i \\rangle$ varies over time." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[-0.90 X0 X1,\n", + " -0.90 X0 X5,\n", + " -0.90 X0 X6,\n", + " -0.90 X1 X2,\n", + " -0.90 X2 X3,\n", + " -0.90 X3 X4,\n", + " -0.90 X4 X5,\n", + " -1.10 Y0 Y1,\n", + " -1.10 Y0 Y5,\n", + " -1.10 Y0 Y6,\n", + " -1.10 Y1 Y2,\n", + " -1.10 Y2 Y3,\n", + " -1.10 Y3 Y4,\n", + " -1.10 Y4 Y5,\n", + " -1.00 Z0 Z1,\n", + " -1.00 Z0 Z5,\n", + " -1.00 Z0 Z6,\n", + " -1.00 Z1 Z2,\n", + " -1.00 Z2 Z3,\n", + " -1.00 Z3 Z4,\n", + " -1.00 Z4 Z5]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def nearest_neigh(d, coupling_str):\n", + " return -coupling_str * (np.abs(d - 1) < 1e-2)\n", + "\n", + "\n", + "coupling_xx = qbits.compute_interaction_hamiltonian(\n", + " lambda x: nearest_neigh(x, 0.9), \"X\"\n", + ")\n", + "coupling_yy = qbits.compute_interaction_hamiltonian(\n", + " lambda x: nearest_neigh(x, 1.1), \"Y\"\n", + ")\n", + "coupling_zz = qbits.compute_interaction_hamiltonian(\n", + " lambda x: nearest_neigh(x, 1.0), \"Z\"\n", + ")\n", + "\n", + "couplings = coupling_xx + coupling_yy + coupling_zz\n", + "hamiltonian = qse.operators_to_qutip(couplings)\n", + "\n", + "couplings" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "times = np.linspace(0, 10, 50)\n", + "\n", + "# Define operators to get expectation values of.\n", + "e_ops = [qse.Operator(\"Z\", i, 1.0, qbits.nqbits) for i in range(qbits.nqbits)]\n", + "evolved_states = qp.sesolve(\n", + " hamiltonian,\n", + " qp.tensor([qp.fock(2)] * qbits.nqbits),\n", + " tlist=times,\n", + " e_ops=[op.to_qutip() for op in e_ops],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for qb in range(qbits.nqbits):\n", + " plt.plot(times, evolved_states.e_data[qb], label=qb)\n", + "\n", + "plt.ylabel(r\"$\\langle Z_i \\rangle$\")\n", + "plt.xlabel(\"Time\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qse_testbed", + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 89088d08278c16a8beb7499ed1b63f7f4938ef86 Mon Sep 17 00:00:00 2001 From: James Nelson Date: Mon, 23 Feb 2026 14:24:03 +0000 Subject: [PATCH 10/10] doc-string --- qse/operator.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/qse/operator.py b/qse/operator.py index fbc4181d..2a642052 100644 --- a/qse/operator.py +++ b/qse/operator.py @@ -87,6 +87,19 @@ def _qutip_converter(op): def operators_to_qutip(operator_list): + """ + Sum together a list of Operators into a single QuTiP Qobj. + + Parameters + ---------- + operator_list : list[Operator] + A list of Operators. + + Returns + ------- + qutip.Qobj + The QuTiP operator. + """ operator = 0 for op in operator_list: operator += op.coef * op.to_qutip()