From 48351dd80117f39d3df8f2e076beb931218ac02a Mon Sep 17 00:00:00 2001 From: Andrew Hardy Date: Wed, 4 Jun 2025 19:45:25 -0400 Subject: [PATCH 1/8] data --- .../06-Discrete_Lehman_Representation.ipynb | 201 +++++ .../06s-Discrete_Lehman_Representation.ipynb | 685 ++++++++++++++++++ 2 files changed, 886 insertions(+) create mode 100644 ModelDMFT/06-Discrete_Lehman_Representation.ipynb create mode 100644 ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb diff --git a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb new file mode 100644 index 0000000..f680c95 --- /dev/null +++ b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb @@ -0,0 +1,201 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "329ad08d", + "metadata": {}, + "source": [ + "# A DLR DMFT calculation\n", + "\n", + "The goal of this notebook is to make a more economical DMFT calculation using the Discrete Lehman Representation of Green's functions (DLR). If you are interested in more of the theory behind this method,a good first reference is [(here)](https://doi.org/10.1103/PhysRevB.86.085133), which this tutorial follows closely. \n", + "\n", + "You will construct first a simple self-consistent loop for the Sachdev-Ye-Kitaev model, and then an IPT calculation with a more compact and economical framework than in Tutorial 1. \n", + "\n", + "## Discrete Lehman Representation\n", + "Here we take advantage of the spectral representation of the Green's function\n", + "\\begin{equation}\n", + "G(\\tau)=-\\int_{-\\infty}^{\\infty} K(\\tau, \\omega) \\rho(\\omega) d \\omega\n", + "\\end{equation}\n", + "with the fermionic kernel being given by \n", + "\\begin{equation}\n", + "K(\\tau, \\omega)=\\frac{e^{-\\omega \\tau}}{1+e^{-\\beta \\omega}}\n", + "\\end{equation}\n", + "The kernel $K$ can be approximated by a low rank decomposition. This has some negative consequences, such as the ill-conditioning of analytic continuation (which you make have seen in the Pade approximates used in previous tutorials), but it also has some benefits. This behaviour can be exploited to provide a compact representation of $G$. \n", + "\\begin{equation}\n", + "G(\\tau) \\approx G_{\\mathrm{DLR}}(\\tau)=\\sum_{k=1}^r \\frac{e^{-\\omega_k \\tau}}{1+e^{-\\omega_k}} \\widehat{g}_k=\\sum_{k=1}^r \\widetilde{g}_k e^{-\\omega_k \\tau}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "fee0f10b", + "metadata": {}, + "source": [ + "### Constructing DLR Green's Functions\n", + "The DLR Green's function is constructed on $r$ Matsubara frequency points which are uniquely determined (independent of $G$) by a error $\\epsilon$ in the accuracy of the representation and a high-energy cutoff. $\\Lambda = \\beta \\omega_{max}$. \n", + "These values are given to TRIQS via the parameters `dlr_error` and `w_max` . In general, these should be convergence criterion. \n", + "Particular care is needed when approximating stochastic data, such as quantum Monte Carlo data, which might include statistical noise.\n", + " For the determinstic Dyson equations solved here, these should be made quite large and small respectively. Here you will see that the representation needs only $\\mathcal{O}(10^2)$ points to converge correctly, compared to $\\mathcal{O}(10^8)$ with a uniform Matsubara grid. \n", + "\n", + " The example below shows how to construct a fermionic Green's function in both Matsubara frequencies and imaginary time. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f916c67b", + "metadata": {}, + "outputs": [], + "source": [ + "from triqs.gf import *\n", + "from triqs.gf.tools import *\n", + "from triqs.operators import *\n", + "from triqs.gf.block_gf import *\n", + "from triqs.gf.descriptors import Function\n", + "import h5\n", + "import numpy as np\n", + "from triqs.plot.mpl_interface import *\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import json, sys, os\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c53fb03e", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.5,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "741f5e46", + "metadata": {}, + "outputs": [], + "source": [ + "gf_struct =[('up',1), ('dn',1)]\n", + "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + "# careful! does not work without symmetrize=True\n", + "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + "G_tau = make_gf_dlr_imtime(G_iw)\n", + "Sigma_iw = G_iw.copy()\n", + "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" + ] + }, + { + "cell_type": "markdown", + "id": "cbef9746", + "metadata": {}, + "source": [ + "### A word of caution\n", + "The DLR representation now allows one to evaluate $G(\\tau)$ for any $\\tau$, even if it is not included in the original grid. While these are faithful representations, the current TRIQS implementation does not impose additional properties of Green's functions, such as antiperiodicity. See the below examples for some subtleties in evaluating $G(\\tau)$. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cef335d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.50000001+2.1345501e-16j]]\n", + "[[0.00044346+2.40809328e-11j]]\n", + "[[-0.50000001-5.37912629e-16j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[nan+nanj]]\n", + "[[nan+nanj]]\n" + ] + } + ], + "source": [ + "G_iw << SemiCircular(2)\n", + "G_tau << make_gf_dlr_imtime(G_iw)\n", + "G_dlr = make_gf_dlr(G_iw[\"up\"]) # the DLR coefficents \n", + "\n", + "print(G_dlr(0.0)) # evaluating at tau = 0.0 for float\n", + "print(G_dlr(0)) # evaluating at iw_0 for int\n", + "print(G_dlr(50.0)) # evaluating at tau = beta gives density\n", + "print(G_dlr(45.0)) # evaluating at tau = 5.0\n", + "print(G_dlr(-5.0)) # evaluating at tau = -5.0 does not obey G(-tau) = -G(beta - tau)\n", + "print(G_dlr(-150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n", + "print(G_dlr(150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n" + ] + }, + { + "cell_type": "markdown", + "id": "d5547d81", + "metadata": {}, + "source": [ + "### Exercise 1 \n", + "Now we are going to evluate the self-consistent Dyson loop for the $O+1$D (impurity) Sachdev-Ye-Kitaev (SYK) model. The Hamiltonian is given by \n", + "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "where the $J_{ijkl}$ couplings between $N$ fermions that are random Gaussian couplings with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its' extensions [(here)](https://doi-org.myaccess.library.utoronto.ca/10.1103/RevModPhys.94.035004). Here we are just interested in the simple form of the self-energy in the large-$N$ limit of the model which is exactly solvable. Here we have (up to some prefactors)\n", + "\\begin{equation}\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau)\n", + "\\end{equation}\n", + "which has a superficial resemble to the IPT equations (except with the local $G$ rather than the Weiss $\\mathcal{G}_0$). Now it is your turn to write a self-consistent loop to solve for $G$. " + ] + }, + { + "cell_type": "markdown", + "id": "1b42178d", + "metadata": {}, + "source": [ + "### Optional Exercise 1b\n", + "To really see the power of DLR, try converging these equations down to lower $T$. To do this, take a higher $T$ solution as a guess and continue lowering $T$. Steps of $\\beta = 10, 20$ should be slow enough. As you approach the $\\beta = \\infty$ limit, your result should begin to match the conformal solution to these equations. Try comparing!\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "45fedad2", + "metadata": {}, + "source": [ + "### Exercise 2 \n", + "\n", + "Now that you see the power of DLR, try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. See how much quicker your calculations are compared to Tutorial 1. \n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb new file mode 100644 index 0000000..3222d42 --- /dev/null +++ b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb @@ -0,0 +1,685 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "329ad08d", + "metadata": {}, + "source": [ + "# A DLR DMFT calculation\n", + "\n", + "The goal of this notebook is to make a more economical DMFT calculation using the Discrete Lehman Representation of Green's functions (DLR). If you are interested in more of the theory behind this method,a good first reference is [(here)](https://doi.org/10.1103/PhysRevB.86.085133), which this tutorial follows closely. \n", + "\n", + "You will construct first a simple self-consistent loop for the Sachdev-Ye-Kitaev model, and then an IPT calculation with a more compact and economical framework than in Tutorial 1. \n", + "\n", + "## Discrete Lehman Representation\n", + "Here we take advantage of the spectral representation of the Green's function\n", + "\\begin{equation}\n", + "G(\\tau)=-\\int_{-\\infty}^{\\infty} K(\\tau, \\omega) \\rho(\\omega) d \\omega\n", + "\\end{equation}\n", + "with the fermionic kernel being given by \n", + "\\begin{equation}\n", + "K(\\tau, \\omega)=\\frac{e^{-\\omega \\tau}}{1+e^{-\\beta \\omega}}\n", + "\\end{equation}\n", + "The kernel $K$ can be approximated by a low rank decomposition. This has some negative consequences, such as the ill-conditioning of analytic continuation (which you make have seen in the Pade approximates used in previous tutorials), but it also has some benefits. This behaviour can be exploited to provide a compact representation of $G$. \n", + "\\begin{equation}\n", + "G(\\tau) \\approx G_{\\mathrm{DLR}}(\\tau)=\\sum_{k=1}^r \\frac{e^{-\\omega_k \\tau}}{1+e^{-\\omega_k}} \\widehat{g}_k=\\sum_{k=1}^r \\widetilde{g}_k e^{-\\omega_k \\tau}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "fee0f10b", + "metadata": {}, + "source": [ + "### Constructing DLR Green's Functions\n", + "The DLR Green's function is constructed on $r$ Matsubara frequency points which are uniquely determined (independent of $G$) by a error $\\epsilon$ in the accuracy of the representation and a high-energy cutoff. $\\Lambda = \\beta \\omega_{max}$. \n", + "These values are given to TRIQS via the parameters `dlr_error` and `w_max` . In general, these should be convergence criterion. \n", + "Particular care is needed when approximating stochastic data, such as quantum Monte Carlo data, which might include statistical noise.\n", + " For the determinstic Dyson equations solved here, these should be made quite large and small respectively. Here you will see that the representation needs only $\\mathcal{O}(10^2)$ points to converge correctly, compared to $\\mathcal{O}(10^8)$ with a uniform Matsubara grid. \n", + "\n", + " The example below shows how to construct a fermionic Green's function in both Matsubara frequencies and imaginary time. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f916c67b", + "metadata": {}, + "outputs": [], + "source": [ + "from triqs.gf import *\n", + "from triqs.gf.tools import *\n", + "from triqs.operators import *\n", + "from triqs.gf.block_gf import *\n", + "from triqs.gf.descriptors import Function\n", + "import h5\n", + "import numpy as np\n", + "from triqs.plot.mpl_interface import *\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import json, sys, os\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c53fb03e", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.5,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "741f5e46", + "metadata": {}, + "outputs": [], + "source": [ + "gf_struct =[('up',1), ('dn',1)]\n", + "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + "# careful! does not work without symmetrize=True\n", + "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + "G_tau = make_gf_dlr_imtime(G_iw)\n", + "Sigma_iw = G_iw.copy()\n", + "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" + ] + }, + { + "cell_type": "markdown", + "id": "cbef9746", + "metadata": {}, + "source": [ + "### A word of caution\n", + "The DLR representation now allows one to evaluate $G(\\tau)$ for any $\\tau$, even if it is not included in the original grid. While these are faithful representations, the current TRIQS implementation does not impose additional properties of Green's functions, such as antiperiodicity. See the below examples for some subtleties in evaluating $G(\\tau)$. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cef335d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.50000001+2.1345501e-16j]]\n", + "[[0.00044346+2.40809328e-11j]]\n", + "[[-0.50000001-5.37912629e-16j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[nan+nanj]]\n", + "[[nan+nanj]]\n" + ] + } + ], + "source": [ + "G_iw << SemiCircular(2)\n", + "G_tau << make_gf_dlr_imtime(G_iw)\n", + "G_dlr = make_gf_dlr(G_iw[\"up\"]) # the DLR coefficents \n", + "\n", + "print(G_dlr(0.0)) # evaluating at tau = 0.0 for float\n", + "print(G_dlr(0)) # evaluating at iw_0 for int\n", + "print(G_dlr(50.0)) # evaluating at tau = beta gives density\n", + "print(G_dlr(45.0)) # evaluating at tau = 5.0\n", + "print(G_dlr(-5.0)) # evaluating at tau = -5.0 does not obey G(-tau) = -G(beta - tau)\n", + "print(G_dlr(-150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n", + "print(G_dlr(150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n" + ] + }, + { + "cell_type": "markdown", + "id": "d5547d81", + "metadata": {}, + "source": [ + "### Exercise 1 \n", + "Now we are going to evluate the self-consistent Dyson loop for the $O+1$D (impurity) Sachdev-Ye-Kitaev (SYK) model. The Hamiltonian is given by \n", + "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "where the $J_{ijkl}$ couplings between $N$ fermions that are random Gaussian couplings with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its' extensions [(here)](https://doi-org.myaccess.library.utoronto.ca/10.1103/RevModPhys.94.035004). Here we are just interested in the simple form of the self-energy in the large-$N$ limit of the model which is exactly solvable. Here we have (up to some prefactors)\n", + "\\begin{equation}\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau)\n", + "\\end{equation}\n", + "which has a superficial resemble to the IPT equations (except with the local $G$ rather than the Weiss $\\mathcal{G}_0$). Now it is your turn to write a self-consistent loop to solve for $G$. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5711f528", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.001559070505714749 5\n", + "1.0349249103620503e-05 10\n", + "1.8579473901673987e-07 15\n" + ] + } + ], + "source": [ + "G_iw << SemiCircular(1.0)\n", + "G_tau << make_gf_dlr_imtime(G_iw)\n", + "error = 1.0\n", + "iter = 0\n", + "while error > params[\"threshold\"]:\n", + " for block, g in G_tau:\n", + " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2/4 * g.data[:,0,0]**2*np.flip(g.data[:,0,0])\n", + " #Sigma_tau[block].data[:,0,0] = params[\"J\"] * g.data[:,0,0]**3 # works only for particle hole symmetric systems\n", + "\n", + " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) \n", + " for block, g in G_tau:\n", + "\n", + " G_iw[block] << inverse(iOmega_n - Sigma_iw[block])\n", + " G_old = G_tau.copy()\n", + " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw)\n", + " #G_tau << make_gf_dlr_imtime(G_iw)\n", + " error = np.mean(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]) / G_old[\"up\"].data[:,0,0]))\n", + " # right now the spin blocks are the same / irrelevant. \n", + " iter += 1\n", + " if iter % 5 == 0:\n", + " print(error, iter)\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c0669c9e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G(\\tau)$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f728e5fc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(Sigma_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$\\Sigma$\")\n", + "plt.xlim(-20,20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1b42178d", + "metadata": {}, + "source": [ + "### Optional Exercise 1b\n", + "To really see the power of DLR, try converging these equations down to lower $T$. To do this, take a higher $T$ solution as a guess and continue lowering $T$. Steps of $\\beta = 50$ should be slow enough, although you can optimize this with your $\\alpha$ mixing parameter. As you approach the $\\beta = \\infty$ limit, your result should begin to match the conformal solution to these equations. Try comparing!\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1f5c2940", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.80,\n", + " \"w_max\": 20.0,\n", + " \"dlr_err\": 1e-10, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0ac25f3a", + "metadata": {}, + "outputs": [], + "source": [ + "betas = np.array([50.0,100.0, 150.0, 250.0, 350.0,400.0,450.0 ,500.0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "aaf1d1d6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.00018642980121496007 20 50.0\n", + "1.0551719818406181e-06 40 50.0\n", + "0.0010133481924638882 20 100.0\n", + "9.020256563906696e-06 40 100.0\n", + "9.256213401949465e-08 60 100.0\n", + "1.2355223139904116e-05 20 150.0\n", + "5.130730897831215e-08 40 150.0\n", + "1.3878098026234743e-05 20 250.0\n", + "5.989698240910868e-08 40 250.0\n", + "9.581600005583062e-06 20 350.0\n", + "4.130081612291154e-08 40 350.0\n", + "4.113186540783512e-06 20 400.0\n", + "1.7995074533369348e-08 40 400.0\n", + "3.6162068025034036e-06 20 450.0\n", + "1.608034789948581e-08 40 450.0\n", + "3.390955130622913e-06 20 500.0\n", + "1.43680989989107e-08 40 500.0\n" + ] + } + ], + "source": [ + "for i, beta in enumerate(betas):\n", + " gf_struct =[('up',1), ('dn',1)]\n", + " params[\"beta\"] = beta\n", + " \n", + " iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + " # careful! does not work without symmetrize=True\n", + "\n", + " G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + " G_tau = make_gf_dlr_imtime(G_iw)\n", + "\n", + " if i == 0:\n", + " G_iw << SemiCircular(2)\n", + " if i > 1:\n", + " tau = np.array([x.real for x in G_tau.mesh.values()], dtype=np.float64)\n", + " old_tau = np.array([x.real for x in G_old.mesh.values()], dtype=np.float64)\n", + " old_beta = np.max(old_tau)\n", + " tau_prime = tau*old_beta/params[\"beta\"]\n", + " G_dlr = make_gf_dlr(G_old)\n", + " for block, g in G_tau:\n", + " g.data[:,0,0] = np.array([G_dlr[\"up\"](t)[0,0] for t in tau_prime])\n", + " G_iw << make_gf_dlr_imfreq(G_tau)\n", + " G_tau << make_gf_dlr_imtime(G_iw)\n", + " Sigma_iw = G_iw.copy()\n", + " Sigma_tau = make_gf_dlr_imtime(Sigma_iw)\n", + " error = 1.0\n", + " iter = 0\n", + " while error > params[\"threshold\"]:\n", + " for block, g in G_tau:\n", + " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2/4 * g.data[:,0,0]**2*np.flip(g.data[:,0,0])\n", + " #Sigma_tau[block].data[:,0,0] = params[\"J\"] * g.data[:,0,0]**3 # works only for particle hole symmetric systems\n", + "\n", + " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) \n", + " for block, g in G_tau:\n", + "\n", + " G_iw[block] << inverse(iOmega_n - Sigma_iw[block])\n", + " G_old = G_tau.copy()\n", + " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw)\n", + " #G_tau << make_gf_dlr_imtime(G_iw)\n", + " idx = np.where(G_old[\"up\"].data[:,0,0] == 0.0)[0]\n", + " G_old[\"up\"].data[idx,0,0] = 1.0\n", + " error = np.mean(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]) / G_old[\"up\"].data[:,0,0]))\n", + " # right now the spin blocks are the same / irrelevant. \n", + " iter += 1\n", + " if iter % 20 == 0:\n", + " print(error, iter, params[\"beta\"])\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break\n", + " G_old = G_tau.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0454b32d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "t = np.array([x.real for x in G_tau.mesh.values()])\n", + "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"]))\n", + "oplot(G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G(\\tau)$\")\n", + "plt.plot(t, Gconformal, label = r\"$G_{conformal}(\\tau)$\", color = \"red\")\n", + "plt.ylim(-0.5,0)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "45fedad2", + "metadata": {}, + "source": [ + "### Exercise 2 \n", + "\n", + "Now that you see the power of DLR, try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. See how much quicker your calculations are compared to Tutorial 1. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba3aecc3", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from triqs.gf import *\n", + "import numpy as np\n", + "from triqs.operators import *\n", + "\n", + "class IPTSolver:\n", + " def __init__(self, params):\n", + " self.params = params\n", + " # Matsubara frequency Green's functions\n", + " iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps =params[\"dlr_err\"], symmetrize = True)\n", + " self.G_iw = BlockGf(mesh=iw_mesh, gf_struct = [('up',1), ('dn',1)] )\n", + " self.G0_iw = self.G_iw.copy() # self.G0 will be set by the user after initialization\n", + " self.Sigma_iw = self.G_iw.copy()\n", + "\n", + " # Imaginary time\n", + " tau_mesh = MeshDLRImTime(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps =params[\"dlr_err\"], symmetrize = True)\n", + " self.G0_tau = BlockGf(mesh=tau_mesh, gf_struct = [('up',1), ('dn',1)] )\n", + " self.G_tau = self.G0_tau.copy()\n", + " self.Sigma_tau = self.G0_tau.copy()\n", + "\n", + " def solve(self):\n", + " error = 1.0\n", + " iter = 0\n", + "\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0287d987", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.5,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"U\" : 3.0, # In the Mott state, U > 4, you run into trouble, but this is also why the IPT tutorial just stops at small iteration number. \n", + " \"t\" : 1.0,\n", + " \"max_iter\": 1000, # small iteration number is ~ 25\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc6182a2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Green Function G composed of 2 blocks: \n", + " Greens Function G_up with mesh DLR imfreq mesh of size 36 with beta = 50, statistic = Fermion, w_max = 10, eps = 1e-08 and target_shape (1, 1): \n", + " \n", + " Greens Function G_dn with mesh DLR imfreq mesh of size 36 with beta = 50, statistic = Fermion, w_max = 10, eps = 1e-08 and target_shape (1, 1): \n", + " " + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S = IPTSolver(params)\n", + "S.G_iw << SemiCircular(2*params[\"t\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d32a671", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 0\n", + "Iteration: 1\n", + "Iteration: 2\n", + "Iteration: 3\n", + "Iteration: 4\n", + "0.0016821665998838229 5\n", + "Iteration: 5\n", + "Iteration: 6\n", + "Iteration: 7\n", + "Iteration: 8\n", + "Iteration: 9\n", + "3.707673734909233e-05 10\n", + "Iteration: 10\n", + "Iteration: 11\n", + "Iteration: 12\n", + "Iteration: 13\n", + "Iteration: 14\n", + "8.68261338822299e-07 15\n", + "Iteration: 15\n", + "Iteration: 16\n", + "Iteration: 17\n", + "Iteration: 18\n", + "Iteration: 19\n", + "2.081733772436832e-08 20\n", + "Iteration: 20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_109476/735204175.py:15: RuntimeWarning: divide by zero encountered in divide\n", + " error = np.mean(np.abs((S.G_tau[\"up\"].real.data[:,0,0] - G_tau_old[\"up\"].real.data[:,0,0]) / G_tau_old[\"up\"].real.data[:,0,0]))\n" + ] + } + ], + "source": [ + "error = 1.0\n", + "iter = 0\n", + "while error > params[\"threshold\"]:\n", + " print(\"Iteration:\", iter)\n", + " for block, g in S.G0_iw:\n", + " g << inverse( iOmega_n - params[\"t\"]**2 * S.G_iw[block] )\n", + " S.G0_tau << make_gf_dlr_imtime(S.G0_iw)\n", + " S.Sigma_tau << (params[\"U\"]**2) * S.G0_tau * S.G0_tau * S.G0_tau\n", + " S.Sigma_iw << make_gf_dlr_imfreq(S.Sigma_tau)\n", + " G_old = S.G_iw.copy()\n", + " S.G_iw << inverse(inverse(S.G0_iw) - S.Sigma_iw)\n", + " S.G_iw << params[\"alpha\"]*S.G_iw+ (1-params[\"alpha\"])*G_old\n", + " G_tau_old = S.G_tau.copy()\n", + " S.G_tau << make_gf_dlr_imtime(S.G_iw)\n", + " error = np.mean(np.abs((S.G_tau[\"up\"].real.data[:,0,0] - G_tau_old[\"up\"].real.data[:,0,0]) / G_tau_old[\"up\"].real.data[:,0,0]))\n", + "\n", + " iter += 1\n", + " if iter % 5 == 0:\n", + " print(error, iter)\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50b5146d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(S.G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65fb461e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(S.G_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8703f85", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(S.Sigma_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$\\Sigma$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fa86573", + "metadata": {}, + "outputs": [], + "source": [ + "G_w = Gf(mesh=MeshReFreq(window = (-5.0,5.0), n_w=1000), target_shape=[1,1])\n", + "G_iw = make_gf_imfreq(S.G_iw[\"up\"], n_iw = 2**14+3)\n", + "G_w.set_from_pade(G_iw, 100, 0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f18b5166", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(-np.imag(G_w)/np.pi, marker = \"o\", markeredgecolor = \"black\", name = r\"$A(\\omega)$\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 71accb35f7aee9cf8a346f62569a189af20adf73 Mon Sep 17 00:00:00 2001 From: Jason Kaye Date: Tue, 29 Jul 2025 12:32:30 -0400 Subject: [PATCH 2/8] edits to DLR Dyson tutorial, exercise 1 solutions --- .../06s-Discrete_Lehman_Representation.ipynb | 353 +++++------------- 1 file changed, 93 insertions(+), 260 deletions(-) diff --git a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb index 3222d42..1e01dc5 100644 --- a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb +++ b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb @@ -5,13 +5,13 @@ "id": "329ad08d", "metadata": {}, "source": [ - "# A DLR DMFT calculation\n", + "# Self-consistent solution of the Dyson equation using the Discrete Lehman Representation\n", "\n", - "The goal of this notebook is to make a more economical DMFT calculation using the Discrete Lehman Representation of Green's functions (DLR). If you are interested in more of the theory behind this method,a good first reference is [(here)](https://doi.org/10.1103/PhysRevB.86.085133), which this tutorial follows closely. \n", + "The goal of this tutorial is to showcase the use of the discrete Lehmann representation (DLR) to solve the Dyson equation self-consistently (i.e., given an expression for the self-energy in terms of the Green's function). The first exercise will implement a simple self-consistent loop for the Sachdev-Ye-Kitaev (SYK) model, and the second exercise will implement a DMFT calculation using the iterated perturbation theory (IPT) approximation. For background on the DLR and its use in TRIQS, we refer to the [TRIQS documentation](https://triqs.github.io/triqs/latest/userguide/python/tutorials/Basics/solutions/01s-Greens_functions.html#Compact-meshes-for-imaginary-time-/-frequency:-DLR-Green%E2%80%99s-function).\n", "\n", - "You will construct first a simple self-consistent loop for the Sachdev-Ye-Kitaev model, and then an IPT calculation with a more compact and economical framework than in Tutorial 1. \n", + " \n", "\n", - "## Discrete Lehman Representation\n", + "" ] }, { @@ -32,19 +32,17 @@ "metadata": {}, "source": [ "### Constructing DLR Green's Functions\n", - "The DLR Green's function is constructed on $r$ Matsubara frequency points which are uniquely determined (independent of $G$) by a error $\\epsilon$ in the accuracy of the representation and a high-energy cutoff. $\\Lambda = \\beta \\omega_{max}$. \n", - "These values are given to TRIQS via the parameters `dlr_error` and `w_max` . In general, these should be convergence criterion. \n", - "Particular care is needed when approximating stochastic data, such as quantum Monte Carlo data, which might include statistical noise.\n", - " For the determinstic Dyson equations solved here, these should be made quite large and small respectively. Here you will see that the representation needs only $\\mathcal{O}(10^2)$ points to converge correctly, compared to $\\mathcal{O}(10^8)$ with a uniform Matsubara grid. \n", "\n", - " The example below shows how to construct a fermionic Green's function in both Matsubara frequencies and imaginary time. " + "We begin by setting various parameters, building a DLR imaginary frequency mesh, and creating Green's function and self-energy containers from this mesh. The DLR parameters are the desired accuracy, `dlr_error`, and the problem bandwidth or frequency cutoff, `w_max`. We also set some physical problem parameters, as well as a maximum number of iterations for the self-consistency, a self-consistency convergence tolerance, and a mixing parameter $\\alpha$." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 86, "id": "f916c67b", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "from triqs.gf import *\n", @@ -57,141 +55,100 @@ "from triqs.plot.mpl_interface import *\n", "import matplotlib.pyplot as plt\n", "import matplotlib as mpl\n", - "import json, sys, os\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c53fb03e", - "metadata": {}, - "outputs": [], - "source": [ + "import json, sys, os\n", + "\n", "params = {\n", - " \"beta\": 50.0,\n", + " \"beta\": 500.0,\n", " \"mu\": 0.0,\n", " \"alpha\" : 0.5,\n", - " \"w_max\": 10.0,\n", + " \"w_max\": 5.0,\n", " \"dlr_err\": 1e-8, \n", " \"J\" : 1.0,\n", " \"max_iter\": 1000,\n", " \"threshold\": 1e-8,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "741f5e46", - "metadata": {}, - "outputs": [], - "source": [ + "}\n", + "\n", "gf_struct =[('up',1), ('dn',1)]\n", "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", - "# careful! does not work without symmetrize=True\n", "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", "G_tau = make_gf_dlr_imtime(G_iw)\n", "Sigma_iw = G_iw.copy()\n", "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" ] }, - { - "cell_type": "markdown", - "id": "cbef9746", - "metadata": {}, - "source": [ - "### A word of caution\n", - "The DLR representation now allows one to evaluate $G(\\tau)$ for any $\\tau$, even if it is not included in the original grid. While these are faithful representations, the current TRIQS implementation does not impose additional properties of Green's functions, such as antiperiodicity. See the below examples for some subtleties in evaluating $G(\\tau)$. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "cef335d7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[-0.50000001+2.1345501e-16j]]\n", - "[[0.00044346+2.40809328e-11j]]\n", - "[[-0.50000001-5.37912629e-16j]]\n", - "[[-0.06406086-4.89547088e-17j]]\n", - "[[-0.06406086-4.89547088e-17j]]\n", - "[[nan+nanj]]\n", - "[[nan+nanj]]\n" - ] - } - ], - "source": [ - "G_iw << SemiCircular(2)\n", - "G_tau << make_gf_dlr_imtime(G_iw)\n", - "G_dlr = make_gf_dlr(G_iw[\"up\"]) # the DLR coefficents \n", - "\n", - "print(G_dlr(0.0)) # evaluating at tau = 0.0 for float\n", - "print(G_dlr(0)) # evaluating at iw_0 for int\n", - "print(G_dlr(50.0)) # evaluating at tau = beta gives density\n", - "print(G_dlr(45.0)) # evaluating at tau = 5.0\n", - "print(G_dlr(-5.0)) # evaluating at tau = -5.0 does not obey G(-tau) = -G(beta - tau)\n", - "print(G_dlr(-150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n", - "print(G_dlr(150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n" - ] - }, { "cell_type": "markdown", "id": "d5547d81", "metadata": {}, "source": [ "### Exercise 1 \n", - "Now we are going to evluate the self-consistent Dyson loop for the $O+1$D (impurity) Sachdev-Ye-Kitaev (SYK) model. The Hamiltonian is given by \n", + "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", - "where the $J_{ijkl}$ couplings between $N$ fermions that are random Gaussian couplings with constant variance $J^2$.\n", - " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its' extensions [(here)](https://doi-org.myaccess.library.utoronto.ca/10.1103/RevModPhys.94.035004). Here we are just interested in the simple form of the self-energy in the large-$N$ limit of the model which is exactly solvable. Here we have (up to some prefactors)\n", + "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", "\\begin{equation}\n", - "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau)\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau).\n", "\\end{equation}\n", - "which has a superficial resemble to the IPT equations (except with the local $G$ rather than the Weiss $\\mathcal{G}_0$). Now it is your turn to write a self-consistent loop to solve for $G$. " + "Combining this self-energy with the Dyson equation yields a self-consistent set of equations. These were solved using the DLR with weighted fixed point iteration in Sec. VII of [(this paper)](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.105.235115). Following that reference, it is your turn to write a self-consistent loop to solve for $G$.\n", + "\n", + "As shown in the paper, as we approach the $\\beta = \\infty$ limit, the result should begin to match the conformal solution of these equations. Try comparing to the conformal solution! We should already have quite good agreement at $\\beta = 1000$.\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 87, "id": "5711f528", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.001559070505714749 5\n", - "1.0349249103620503e-05 10\n", - "1.8579473901673987e-07 15\n" + "Iteration: 1 Error: 0.18620720598844637\n", + "Iteration: 2 Error: 0.09591885627788482\n", + "Iteration: 3 Error: 0.04688903710401063\n", + "Iteration: 4 Error: 0.006693699864808944\n", + "Iteration: 5 Error: 0.0006500289998440656\n", + "Iteration: 6 Error: 0.00015572355093314283\n", + "Iteration: 7 Error: 2.5976909072987497e-05\n", + "Iteration: 8 Error: 7.100638501164602e-06\n", + "Iteration: 9 Error: 1.9008486006680259e-06\n", + "Iteration: 10 Error: 7.498470171729554e-07\n", + "Iteration: 11 Error: 3.250232031917766e-07\n", + "Iteration: 12 Error: 1.5666570055833384e-07\n", + "Iteration: 13 Error: 7.775264952714107e-08\n", + "Iteration: 14 Error: 3.821340015253169e-08\n", + "Iteration: 15 Error: 1.9576569268440893e-08\n", + "Iteration: 16 Error: 9.662122907373015e-09\n" ] } ], "source": [ - "G_iw << SemiCircular(1.0)\n", - "G_tau << make_gf_dlr_imtime(G_iw)\n", + "G_iw << SemiCircular(1.0) # Initial guess for the Green's function \n", + "G_tau << make_gf_dlr_imtime(G_iw) # Initial guess in the imaginary time domain\n", "error = 1.0\n", "iter = 0\n", + "\n", "while error > params[\"threshold\"]:\n", " for block, g in G_tau:\n", - " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2/4 * g.data[:,0,0]**2*np.flip(g.data[:,0,0])\n", - " #Sigma_tau[block].data[:,0,0] = params[\"J\"] * g.data[:,0,0]**3 # works only for particle hole symmetric systems\n", + " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2 * g.data[:,0,0]**2*np.flip(g.data[:,0,0]) # Compute self-energy in imaginary time\n", "\n", - " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) \n", - " for block, g in G_tau:\n", + " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) # Transform self-energy to Matsubara frequency domain \n", "\n", - " G_iw[block] << inverse(iOmega_n - Sigma_iw[block])\n", + " for block, g in G_tau:\n", + " G_iw[block] << inverse(iOmega_n - Sigma_iw[block]) # Solve the Dyson equation to obtain Green's function\n", " G_old = G_tau.copy()\n", - " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw)\n", - " #G_tau << make_gf_dlr_imtime(G_iw)\n", - " error = np.mean(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]) / G_old[\"up\"].data[:,0,0]))\n", - " # right now the spin blocks are the same / irrelevant. \n", + " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw) # Update Green's function via weighted fixed point iteration\n", + " error = np.max(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]))) # Compute absolute error\n", " iter += 1\n", - " if iter % 5 == 0:\n", - " print(error, iter)\n", + "\n", + " # Print iteration number and error\n", + " print(\"Iteration:\", iter, \"Error:\", error)\n", " if iter > params[\"max_iter\"]:\n", " print(\"Maximum number of iterations reached without convergence\")\n", " break" @@ -199,36 +156,15 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 88, "id": "c0669c9e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize = (10,10))\n", - "oplot(G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G(\\tau)$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "f728e5fc", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -238,144 +174,41 @@ } ], "source": [ + "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense grid\n", + "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", + "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", + "\n", "plt.figure(figsize = (10,10))\n", - "oplot(Sigma_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$\\Sigma$\")\n", - "plt.xlim(-20,20)\n", + "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", + "oplot(G_tau[\"up\"].real, marker = \"o\", markeredgecolor = \"black\", label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR nodes)\")\n", + "plt.plot(t, Gconformal, label = r\"$G_c(\\tau)$\", color = \"red\", linestyle = \"dashed\")\n", + "plt.ylim(-0.5,0)\n", + "plt.ylabel(\"\")\n", + "plt.legend(loc=\"upper left\")\n", "plt.show()" ] }, { "cell_type": "markdown", - "id": "1b42178d", - "metadata": {}, - "source": [ - "### Optional Exercise 1b\n", - "To really see the power of DLR, try converging these equations down to lower $T$. To do this, take a higher $T$ solution as a guess and continue lowering $T$. Steps of $\\beta = 50$ should be slow enough, although you can optimize this with your $\\alpha$ mixing parameter. As you approach the $\\beta = \\infty$ limit, your result should begin to match the conformal solution to these equations. Try comparing!\n", - "\\begin{equation}\n", - "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", - "\\end{equation}" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1f5c2940", - "metadata": {}, - "outputs": [], - "source": [ - "params = {\n", - " \"beta\": 50.0,\n", - " \"mu\": 0.0,\n", - " \"alpha\" : 0.80,\n", - " \"w_max\": 20.0,\n", - " \"dlr_err\": 1e-10, \n", - " \"J\" : 1.0,\n", - " \"max_iter\": 1000,\n", - " \"threshold\": 1e-8,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "0ac25f3a", - "metadata": {}, - "outputs": [], - "source": [ - "betas = np.array([50.0,100.0, 150.0, 250.0, 350.0,400.0,450.0 ,500.0])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "aaf1d1d6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.00018642980121496007 20 50.0\n", - "1.0551719818406181e-06 40 50.0\n", - "0.0010133481924638882 20 100.0\n", - "9.020256563906696e-06 40 100.0\n", - "9.256213401949465e-08 60 100.0\n", - "1.2355223139904116e-05 20 150.0\n", - "5.130730897831215e-08 40 150.0\n", - "1.3878098026234743e-05 20 250.0\n", - "5.989698240910868e-08 40 250.0\n", - "9.581600005583062e-06 20 350.0\n", - "4.130081612291154e-08 40 350.0\n", - "4.113186540783512e-06 20 400.0\n", - "1.7995074533369348e-08 40 400.0\n", - "3.6162068025034036e-06 20 450.0\n", - "1.608034789948581e-08 40 450.0\n", - "3.390955130622913e-06 20 500.0\n", - "1.43680989989107e-08 40 500.0\n" - ] - } - ], + "id": "f76bdb41-bb7f-4aea-8061-ec627d77e4dd", + "metadata": { + "tags": [] + }, "source": [ - "for i, beta in enumerate(betas):\n", - " gf_struct =[('up',1), ('dn',1)]\n", - " params[\"beta\"] = beta\n", - " \n", - " iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", - " # careful! does not work without symmetrize=True\n", - "\n", - " G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", - " G_tau = make_gf_dlr_imtime(G_iw)\n", - "\n", - " if i == 0:\n", - " G_iw << SemiCircular(2)\n", - " if i > 1:\n", - " tau = np.array([x.real for x in G_tau.mesh.values()], dtype=np.float64)\n", - " old_tau = np.array([x.real for x in G_old.mesh.values()], dtype=np.float64)\n", - " old_beta = np.max(old_tau)\n", - " tau_prime = tau*old_beta/params[\"beta\"]\n", - " G_dlr = make_gf_dlr(G_old)\n", - " for block, g in G_tau:\n", - " g.data[:,0,0] = np.array([G_dlr[\"up\"](t)[0,0] for t in tau_prime])\n", - " G_iw << make_gf_dlr_imfreq(G_tau)\n", - " G_tau << make_gf_dlr_imtime(G_iw)\n", - " Sigma_iw = G_iw.copy()\n", - " Sigma_tau = make_gf_dlr_imtime(Sigma_iw)\n", - " error = 1.0\n", - " iter = 0\n", - " while error > params[\"threshold\"]:\n", - " for block, g in G_tau:\n", - " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2/4 * g.data[:,0,0]**2*np.flip(g.data[:,0,0])\n", - " #Sigma_tau[block].data[:,0,0] = params[\"J\"] * g.data[:,0,0]**3 # works only for particle hole symmetric systems\n", - "\n", - " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) \n", - " for block, g in G_tau:\n", - "\n", - " G_iw[block] << inverse(iOmega_n - Sigma_iw[block])\n", - " G_old = G_tau.copy()\n", - " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw)\n", - " #G_tau << make_gf_dlr_imtime(G_iw)\n", - " idx = np.where(G_old[\"up\"].data[:,0,0] == 0.0)[0]\n", - " G_old[\"up\"].data[idx,0,0] = 1.0\n", - " error = np.mean(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]) / G_old[\"up\"].data[:,0,0]))\n", - " # right now the spin blocks are the same / irrelevant. \n", - " iter += 1\n", - " if iter % 20 == 0:\n", - " print(error, iter, params[\"beta\"])\n", - " if iter > params[\"max_iter\"]:\n", - " print(\"Maximum number of iterations reached without convergence\")\n", - " break\n", - " G_old = G_tau.copy()" + "Note that in this case, the Green's function is purely real. We observe a slight discrepancy with the conformal solution at the endpoints (which is expected---see the reference). You can experiment with increasing $\\beta$ (it might be necessary to increase the mixing parameter $\\alpha$ in order to converge), and should observe even closer agreement with the conformal solution. We can also plot the self-energy in Matsubara frequency, which is purely imaginary:" ] }, { "cell_type": "code", - "execution_count": null, - "id": "0454b32d", - "metadata": {}, + "execution_count": 79, + "id": "f728e5fc", + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -385,12 +218,12 @@ } ], "source": [ + "Sigma_iw_dense = make_gf_imfreq(Sigma_iw[\"up\"], n_iw = 5000)\n", + "\n", "plt.figure(figsize = (10,10))\n", - "t = np.array([x.real for x in G_tau.mesh.values()])\n", - "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"]))\n", - "oplot(G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G(\\tau)$\")\n", - "plt.plot(t, Gconformal, label = r\"$G_{conformal}(\\tau)$\", color = \"red\")\n", - "plt.ylim(-0.5,0)\n", + "oplot(Sigma_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $\\Sigma(i \\omega_n)$ (DLR)\")\n", + "plt.xlim(-30,30)\n", + "plt.ylabel(\"\")\n", "plt.show()" ] }, @@ -401,7 +234,7 @@ "source": [ "### Exercise 2 \n", "\n", - "Now that you see the power of DLR, try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. See how much quicker your calculations are compared to Tutorial 1. \n" + "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1.\n" ] }, { @@ -663,9 +496,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "triqskernel", "language": "python", - "name": "python3" + "name": "triqskernel" }, "language_info": { "codemirror_mode": { @@ -677,7 +510,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.13" } }, "nbformat": 4, From 515f4d2a6e9d1833f3ac90463b96ed42939f68a2 Mon Sep 17 00:00:00 2001 From: Andrew Hardy Date: Tue, 29 Jul 2025 13:53:46 -0400 Subject: [PATCH 3/8] data --- .../06-Discrete_Lehman_Representation.ipynb | 149 ++---- .../06s-Discrete_Lehman_Representation.ipynb | 430 ++++++++++++++++-- 2 files changed, 422 insertions(+), 157 deletions(-) diff --git a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb index f680c95..c0fc001 100644 --- a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb +++ b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb @@ -5,13 +5,13 @@ "id": "329ad08d", "metadata": {}, "source": [ - "# A DLR DMFT calculation\n", + "# Self-consistent solution of the Dyson equation using the Discrete Lehman Representation\n", "\n", - "The goal of this notebook is to make a more economical DMFT calculation using the Discrete Lehman Representation of Green's functions (DLR). If you are interested in more of the theory behind this method,a good first reference is [(here)](https://doi.org/10.1103/PhysRevB.86.085133), which this tutorial follows closely. \n", + "The goal of this tutorial is to showcase the use of the discrete Lehmann representation (DLR) to solve the Dyson equation self-consistently (i.e., given an expression for the self-energy in terms of the Green's function). The first exercise will implement a simple self-consistent loop for the Sachdev-Ye-Kitaev (SYK) model, and the second exercise will implement a DMFT calculation using the iterated perturbation theory (IPT) approximation. For background on the DLR and its use in TRIQS, we refer to the [TRIQS documentation](https://triqs.github.io/triqs/latest/userguide/python/tutorials/Basics/solutions/01s-Greens_functions.html#Compact-meshes-for-imaginary-time-/-frequency:-DLR-Green%E2%80%99s-function).\n", "\n", - "You will construct first a simple self-consistent loop for the Sachdev-Ye-Kitaev model, and then an IPT calculation with a more compact and economical framework than in Tutorial 1. \n", + " \n", "\n", - "## Discrete Lehman Representation\n", + "" ] }, { @@ -32,138 +32,50 @@ "metadata": {}, "source": [ "### Constructing DLR Green's Functions\n", - "The DLR Green's function is constructed on $r$ Matsubara frequency points which are uniquely determined (independent of $G$) by a error $\\epsilon$ in the accuracy of the representation and a high-energy cutoff. $\\Lambda = \\beta \\omega_{max}$. \n", - "These values are given to TRIQS via the parameters `dlr_error` and `w_max` . In general, these should be convergence criterion. \n", - "Particular care is needed when approximating stochastic data, such as quantum Monte Carlo data, which might include statistical noise.\n", - " For the determinstic Dyson equations solved here, these should be made quite large and small respectively. Here you will see that the representation needs only $\\mathcal{O}(10^2)$ points to converge correctly, compared to $\\mathcal{O}(10^8)$ with a uniform Matsubara grid. \n", "\n", - " The example below shows how to construct a fermionic Green's function in both Matsubara frequencies and imaginary time. " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f916c67b", - "metadata": {}, - "outputs": [], - "source": [ - "from triqs.gf import *\n", - "from triqs.gf.tools import *\n", - "from triqs.operators import *\n", - "from triqs.gf.block_gf import *\n", - "from triqs.gf.descriptors import Function\n", - "import h5\n", - "import numpy as np\n", - "from triqs.plot.mpl_interface import *\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib as mpl\n", - "import json, sys, os\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c53fb03e", - "metadata": {}, - "outputs": [], - "source": [ - "params = {\n", - " \"beta\": 50.0,\n", - " \"mu\": 0.0,\n", - " \"alpha\" : 0.5,\n", - " \"w_max\": 10.0,\n", - " \"dlr_err\": 1e-8, \n", - " \"J\" : 1.0,\n", - " \"max_iter\": 1000,\n", - " \"threshold\": 1e-8,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "741f5e46", - "metadata": {}, - "outputs": [], - "source": [ - "gf_struct =[('up',1), ('dn',1)]\n", - "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", - "# careful! does not work without symmetrize=True\n", - "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", - "G_tau = make_gf_dlr_imtime(G_iw)\n", - "Sigma_iw = G_iw.copy()\n", - "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" + "We begin by setting various parameters, building a DLR imaginary frequency mesh, and creating Green's function and self-energy containers from this mesh. The DLR parameters are the desired accuracy, `dlr_error`, and the problem bandwidth or frequency cutoff, `w_max`. We also set some physical problem parameters, as well as a maximum number of iterations for the self-consistency, a self-consistency convergence tolerance, and a mixing parameter $\\alpha$." ] }, { "cell_type": "markdown", - "id": "cbef9746", - "metadata": {}, - "source": [ - "### A word of caution\n", - "The DLR representation now allows one to evaluate $G(\\tau)$ for any $\\tau$, even if it is not included in the original grid. While these are faithful representations, the current TRIQS implementation does not impose additional properties of Green's functions, such as antiperiodicity. See the below examples for some subtleties in evaluating $G(\\tau)$. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cef335d7", + "id": "d5547d81", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[-0.50000001+2.1345501e-16j]]\n", - "[[0.00044346+2.40809328e-11j]]\n", - "[[-0.50000001-5.37912629e-16j]]\n", - "[[-0.06406086-4.89547088e-17j]]\n", - "[[-0.06406086-4.89547088e-17j]]\n", - "[[nan+nanj]]\n", - "[[nan+nanj]]\n" - ] - } - ], "source": [ - "G_iw << SemiCircular(2)\n", - "G_tau << make_gf_dlr_imtime(G_iw)\n", - "G_dlr = make_gf_dlr(G_iw[\"up\"]) # the DLR coefficents \n", + "### Exercise 1 \n", + "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", + "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", + "\\begin{equation}\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau).\n", + "\\end{equation}\n", + "Combining this self-energy with the Dyson equation yields a self-consistent set of equations. These were solved using the DLR with weighted fixed point iteration in Sec. VII of [(this paper)](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.105.235115). Following that reference, it is your turn to write a self-consistent loop to solve for $G$.\n", "\n", - "print(G_dlr(0.0)) # evaluating at tau = 0.0 for float\n", - "print(G_dlr(0)) # evaluating at iw_0 for int\n", - "print(G_dlr(50.0)) # evaluating at tau = beta gives density\n", - "print(G_dlr(45.0)) # evaluating at tau = 5.0\n", - "print(G_dlr(-5.0)) # evaluating at tau = -5.0 does not obey G(-tau) = -G(beta - tau)\n", - "print(G_dlr(-150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n", - "print(G_dlr(150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n" + "As shown in the paper, as we approach the $\\beta = \\infty$ limit, the result should begin to match the conformal solution of these equations. Try comparing to the conformal solution! We should already have quite good agreement at $\\beta = 1000$.\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" ] }, { "cell_type": "markdown", - "id": "d5547d81", - "metadata": {}, + "id": "f76bdb41-bb7f-4aea-8061-ec627d77e4dd", + "metadata": { + "tags": [] + }, "source": [ - "### Exercise 1 \n", - "Now we are going to evluate the self-consistent Dyson loop for the $O+1$D (impurity) Sachdev-Ye-Kitaev (SYK) model. The Hamiltonian is given by \n", - "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", - "where the $J_{ijkl}$ couplings between $N$ fermions that are random Gaussian couplings with constant variance $J^2$.\n", - " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its' extensions [(here)](https://doi-org.myaccess.library.utoronto.ca/10.1103/RevModPhys.94.035004). Here we are just interested in the simple form of the self-energy in the large-$N$ limit of the model which is exactly solvable. Here we have (up to some prefactors)\n", - "\\begin{equation}\n", - "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau)\n", - "\\end{equation}\n", - "which has a superficial resemble to the IPT equations (except with the local $G$ rather than the Weiss $\\mathcal{G}_0$). Now it is your turn to write a self-consistent loop to solve for $G$. " + "Note that in this case, the Green's function is purely real. We observe a slight discrepancy with the conformal solution at the endpoints (which is expected---see the reference). You can experiment with increasing $\\beta$ (it might be necessary to increase the mixing parameter $\\alpha$ in order to converge), and should observe even closer agreement with the conformal solution. We can also plot the self-energy in Matsubara frequency, which is purely imaginary:" ] }, { "cell_type": "markdown", - "id": "1b42178d", + "id": "da1cf458", "metadata": {}, "source": [ "### Optional Exercise 1b\n", - "To really see the power of DLR, try converging these equations down to lower $T$. To do this, take a higher $T$ solution as a guess and continue lowering $T$. Steps of $\\beta = 10, 20$ should be slow enough. As you approach the $\\beta = \\infty$ limit, your result should begin to match the conformal solution to these equations. Try comparing!\n", - "\\begin{equation}\n", - "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", - "\\end{equation}" + "\n", + "For more complicated systems, one often need to take a higher $T$ solution as a guess and continue lowering $T$. Here, one can try approaching the $\\beta = \\infty$ limit through `cooling' your solution. See if your result will also begin to match the conformal solution to these equations at lower temperatures. Here steps of $\\Delta \\beta = 100$ or so may work, although it may need to be much smaller for more complicated problems.\n", + "HINT: Ask yourself, how do you evaluate DLR data to a new mesh at a larger $\\beta$? " ] }, { @@ -173,7 +85,8 @@ "source": [ "### Exercise 2 \n", "\n", - "Now that you see the power of DLR, try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. See how much quicker your calculations are compared to Tutorial 1. \n" + "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. How can you give a Pad\\'e approximate of $A(\\omega)$ after evaluating on the DLR grid?\n", + "\n" ] } ], diff --git a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb index 1e01dc5..84c0021 100644 --- a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb +++ b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 81, "id": "f916c67b", "metadata": { "tags": [] @@ -58,9 +58,9 @@ "import json, sys, os\n", "\n", "params = {\n", - " \"beta\": 500.0,\n", + " \"beta\": 1000.0,\n", " \"mu\": 0.0,\n", - " \"alpha\" : 0.5,\n", + " \"alpha\" : 0.75,\n", " \"w_max\": 5.0,\n", " \"dlr_err\": 1e-8, \n", " \"J\" : 1.0,\n", @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 82, "id": "5711f528", "metadata": { "tags": [] @@ -109,22 +109,39 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration: 1 Error: 0.18620720598844637\n", - "Iteration: 2 Error: 0.09591885627788482\n", - "Iteration: 3 Error: 0.04688903710401063\n", - "Iteration: 4 Error: 0.006693699864808944\n", - "Iteration: 5 Error: 0.0006500289998440656\n", - "Iteration: 6 Error: 0.00015572355093314283\n", - "Iteration: 7 Error: 2.5976909072987497e-05\n", - "Iteration: 8 Error: 7.100638501164602e-06\n", - "Iteration: 9 Error: 1.9008486006680259e-06\n", - "Iteration: 10 Error: 7.498470171729554e-07\n", - "Iteration: 11 Error: 3.250232031917766e-07\n", - "Iteration: 12 Error: 1.5666570055833384e-07\n", - "Iteration: 13 Error: 7.775264952714107e-08\n", - "Iteration: 14 Error: 3.821340015253169e-08\n", - "Iteration: 15 Error: 1.9576569268440893e-08\n", - "Iteration: 16 Error: 9.662122907373015e-09\n" + "Iteration: 1 Error: 0.09365042856328878\n", + "Iteration: 2 Error: 0.02389091857123847\n", + "Iteration: 3 Error: 0.017721420560846274\n", + "Iteration: 4 Error: 0.01225291280723799\n", + "Iteration: 5 Error: 0.0069780870343561854\n", + "Iteration: 6 Error: 0.003097888019241102\n", + "Iteration: 7 Error: 0.0011871083057315088\n", + "Iteration: 8 Error: 0.00045291431501309765\n", + "Iteration: 9 Error: 0.00020867659064766064\n", + "Iteration: 10 Error: 0.0001221937305567189\n", + "Iteration: 11 Error: 7.29518263504203e-05\n", + "Iteration: 12 Error: 4.423836621747501e-05\n", + "Iteration: 13 Error: 2.7150527487307397e-05\n", + "Iteration: 14 Error: 1.681698909905549e-05\n", + "Iteration: 15 Error: 1.0655920737845381e-05\n", + "Iteration: 16 Error: 6.883502771559691e-06\n", + "Iteration: 17 Error: 4.471739081024495e-06\n", + "Iteration: 18 Error: 2.9197014490001116e-06\n", + "Iteration: 19 Error: 1.9151486686519448e-06\n", + "Iteration: 20 Error: 1.2615741423749327e-06\n", + "Iteration: 21 Error: 8.343275527122884e-07\n", + "Iteration: 22 Error: 5.538040310781867e-07\n", + "Iteration: 23 Error: 3.6886194437757425e-07\n", + "Iteration: 24 Error: 2.4646771973335646e-07\n", + "Iteration: 25 Error: 1.6517766920909338e-07\n", + "Iteration: 26 Error: 1.1100690316956374e-07\n", + "Iteration: 27 Error: 7.485517372618489e-08\n", + "Iteration: 28 Error: 5.154431514942104e-08\n", + "Iteration: 29 Error: 3.558213140797406e-08\n", + "Iteration: 30 Error: 2.462116999168984e-08\n", + "Iteration: 31 Error: 1.7074547720152822e-08\n", + "Iteration: 32 Error: 1.1865782800768443e-08\n", + "Iteration: 33 Error: 8.262231621092297e-09\n" ] } ], @@ -156,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 83, "id": "c0669c9e", "metadata": { "tags": [] @@ -164,7 +181,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -200,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 84, "id": "f728e5fc", "metadata": { "tags": [] @@ -208,7 +225,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -227,6 +244,341 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "da1cf458", + "metadata": {}, + "source": [ + "### Optional Exercise 1b\n", + "\n", + "For more complicated systems, one often need to take a higher $T$ solution as a guess and continue lowering $T$. Here, one can try approaching the $\\beta = \\infty$ limit through `cooling' your solution. See if your result will also begin to match the conformal solution to these equations at lower temperatures. Here steps of $\\Delta \\beta = 100$ or so may work, although it may need to be much smaller for more complicated problems.\n", + "HINT: Ask yourself, how do you evaluate DLR data to a new mesh at a larger $\\beta$? " + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "1e11d3ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 1 Error: 0.08341268718616413\n", + "Iteration: 2 Error: 0.020624876522001317\n", + "Iteration: 3 Error: 0.008508362270219227\n", + "Iteration: 4 Error: 0.004128924998232253\n", + "Iteration: 5 Error: 0.0021405145220456667\n", + "Iteration: 6 Error: 0.001158800199871024\n", + "Iteration: 7 Error: 0.000641626565325959\n", + "Iteration: 8 Error: 0.0003685756237916671\n", + "Iteration: 9 Error: 0.00021545130661626555\n", + "Iteration: 10 Error: 0.0001272547545787539\n", + "Iteration: 11 Error: 7.583129203281302e-05\n", + "Iteration: 12 Error: 4.614611609260466e-05\n", + "Iteration: 13 Error: 2.849274306693239e-05\n", + "Iteration: 14 Error: 1.7729165843860528e-05\n", + "Iteration: 15 Error: 1.1111730505442008e-05\n", + "Iteration: 16 Error: 7.011361329745114e-06\n", + "Iteration: 17 Error: 4.492548279555475e-06\n", + "Iteration: 18 Error: 2.9235559191875815e-06\n", + "Iteration: 19 Error: 1.9132391210208155e-06\n", + "Iteration: 20 Error: 1.2584982634900044e-06\n", + "Iteration: 21 Error: 8.316886299097881e-07\n", + "Iteration: 22 Error: 5.519602330750217e-07\n", + "Iteration: 23 Error: 3.67725420280518e-07\n", + "Iteration: 24 Error: 2.464355425280118e-07\n", + "Iteration: 25 Error: 1.6722670742597145e-07\n", + "Iteration: 26 Error: 1.1382290099337666e-07\n", + "Iteration: 27 Error: 7.769105281330013e-08\n", + "Iteration: 28 Error: 5.3166422320227724e-08\n", + "Iteration: 29 Error: 3.6470967634816276e-08\n", + "Iteration: 30 Error: 2.5074259502044782e-08\n", + "Iteration: 31 Error: 1.7274895236507604e-08\n", + "Iteration: 32 Error: 1.1924811138541713e-08\n", + "Iteration: 33 Error: 8.25099566448273e-09\n", + "Iteration: 1 Error: 0.12500000000000008\n", + "Iteration: 2 Error: 0.09374268479504305\n", + "Iteration: 3 Error: 0.07029982706555932\n", + "Iteration: 4 Error: 0.05271881593527766\n", + "Iteration: 5 Error: 0.03953437914427471\n", + "Iteration: 6 Error: 0.029647238002360188\n", + "Iteration: 7 Error: 0.022232826927764515\n", + "Iteration: 8 Error: 0.016672733664746586\n", + "Iteration: 9 Error: 0.012503190846815504\n", + "Iteration: 10 Error: 0.009376416675704047\n", + "Iteration: 11 Error: 0.007031611962522333\n", + "Iteration: 12 Error: 0.005273206364277305\n", + "Iteration: 13 Error: 0.003954543887726314\n", + "Iteration: 14 Error: 0.0029656484625291135\n", + "Iteration: 15 Error: 0.0022240495310055786\n", + "Iteration: 16 Error: 0.001667902409725086\n", + "Iteration: 17 Error: 0.0012508294622221028\n", + "Iteration: 18 Error: 0.0009380516473309064\n", + "Iteration: 19 Error: 0.0007034876659879896\n", + "Iteration: 20 Error: 0.0005275786694697304\n", + "Iteration: 21 Error: 0.0003956570385001412\n", + "Iteration: 22 Error: 0.0002967231435098694\n", + "Iteration: 23 Error: 0.0002225280395184992\n", + "Iteration: 24 Error: 0.00016688557566552076\n", + "Iteration: 25 Error: 0.00012515654005063048\n", + "Iteration: 26 Error: 9.386181291004547e-05\n", + "Iteration: 27 Error: 7.039226320310066e-05\n", + "Iteration: 28 Error: 5.27911936727965e-05\n", + "Iteration: 29 Error: 3.959119081126117e-05\n", + "Iteration: 30 Error: 2.9691773912432495e-05\n", + "Iteration: 31 Error: 2.2267640184592263e-05\n", + "Iteration: 32 Error: 1.6699854564594663e-05\n", + "Iteration: 33 Error: 1.2524246393086358e-05\n", + "Iteration: 34 Error: 9.392710038524932e-06\n", + "Iteration: 35 Error: 7.04418261737727e-06\n", + "Iteration: 36 Error: 5.282878921153422e-06\n", + "Iteration: 37 Error: 3.9619687978165175e-06\n", + "Iteration: 38 Error: 2.9713360494287855e-06\n", + "Iteration: 39 Error: 2.2283982342719e-06\n", + "Iteration: 40 Error: 1.67122197769487e-06\n", + "Iteration: 41 Error: 1.2533597895103554e-06\n", + "Iteration: 42 Error: 9.399779175023326e-07\n", + "Iteration: 43 Error: 7.049524243796235e-07\n", + "Iteration: 44 Error: 5.286913668522963e-07\n", + "Iteration: 45 Error: 3.965015349383094e-07\n", + "Iteration: 46 Error: 2.973635697123278e-07\n", + "Iteration: 47 Error: 2.230133577807436e-07\n", + "Iteration: 48 Error: 1.6725311269283338e-07\n", + "Iteration: 49 Error: 1.2543471639148152e-07\n", + "Iteration: 50 Error: 9.407224277335757e-08\n", + "Iteration: 51 Error: 7.055136824751784e-08\n", + "Iteration: 52 Error: 5.2911439230030055e-08\n", + "Iteration: 53 Error: 3.968203116100355e-08\n", + "Iteration: 54 Error: 2.9760374220533237e-08\n", + "Iteration: 55 Error: 2.2319427639416745e-08\n", + "Iteration: 56 Error: 1.673893779141622e-08\n", + "Iteration: 57 Error: 1.2553733164111236e-08\n", + "Iteration: 58 Error: 9.414950652431031e-09\n", + "Iteration: 1 Error: 0.03865133722137276\n", + "Iteration: 2 Error: 0.018614955093191582\n", + "Iteration: 3 Error: 0.008498943194396369\n", + "Iteration: 4 Error: 0.004151449709067723\n", + "Iteration: 5 Error: 0.002240788215737144\n", + "Iteration: 6 Error: 0.001293947788542249\n", + "Iteration: 7 Error: 0.0007925613454448088\n", + "Iteration: 8 Error: 0.0004953228320832004\n", + "Iteration: 9 Error: 0.0003210956323461134\n", + "Iteration: 10 Error: 0.00021225572469663057\n", + "Iteration: 11 Error: 0.0001415735015715125\n", + "Iteration: 12 Error: 9.512449446208437e-05\n", + "Iteration: 13 Error: 6.455228776103272e-05\n", + "Iteration: 14 Error: 4.460059330685384e-05\n", + "Iteration: 15 Error: 3.094499174544074e-05\n", + "Iteration: 16 Error: 2.154868335302318e-05\n", + "Iteration: 17 Error: 1.5053500964090638e-05\n", + "Iteration: 18 Error: 1.0545842114184634e-05\n", + "Iteration: 19 Error: 7.406607352045125e-06\n", + "Iteration: 20 Error: 5.21362632549538e-06\n", + "Iteration: 21 Error: 3.6774582602983052e-06\n", + "Iteration: 22 Error: 2.616369032926169e-06\n", + "Iteration: 23 Error: 1.8739124810207564e-06\n", + "Iteration: 24 Error: 1.3440995595415117e-06\n", + "Iteration: 25 Error: 9.653734329151398e-07\n", + "Iteration: 26 Error: 6.942194530901169e-07\n", + "Iteration: 27 Error: 4.998002282041725e-07\n", + "Iteration: 28 Error: 3.60212917827063e-07\n", + "Iteration: 29 Error: 2.5986861618143564e-07\n", + "Iteration: 30 Error: 1.8765139586651713e-07\n", + "Iteration: 31 Error: 1.356212078751362e-07\n", + "Iteration: 32 Error: 9.809752998801713e-08\n", + "Iteration: 33 Error: 7.101042281965064e-08\n", + "Iteration: 34 Error: 5.143993836442817e-08\n", + "Iteration: 35 Error: 3.728854836015927e-08\n", + "Iteration: 36 Error: 2.7047743322849982e-08\n", + "Iteration: 37 Error: 1.963144463656974e-08\n", + "Iteration: 38 Error: 1.425690926426526e-08\n", + "Iteration: 39 Error: 1.036073915550162e-08\n", + "Iteration: 40 Error: 7.575591487452016e-09\n", + "Iteration: 1 Error: 0.04950059352786962\n", + "Iteration: 2 Error: 0.025248973882357445\n", + "Iteration: 3 Error: 0.011473791465799965\n", + "Iteration: 4 Error: 0.005313178543824293\n", + "Iteration: 5 Error: 0.002757186074631768\n", + "Iteration: 6 Error: 0.0015559584947200111\n", + "Iteration: 7 Error: 0.0009248106659895394\n", + "Iteration: 8 Error: 0.0005824927695655124\n", + "Iteration: 9 Error: 0.00037319900752935675\n", + "Iteration: 10 Error: 0.00024221618128461575\n", + "Iteration: 11 Error: 0.00016043382508967863\n", + "Iteration: 12 Error: 0.0001089946293926225\n", + "Iteration: 13 Error: 7.451134044267338e-05\n", + "Iteration: 14 Error: 5.120451625922895e-05\n", + "Iteration: 15 Error: 3.534504724617138e-05\n", + "Iteration: 16 Error: 2.4491624533884426e-05\n", + "Iteration: 17 Error: 1.7027984772877147e-05\n", + "Iteration: 18 Error: 1.1873853164257042e-05\n", + "Iteration: 19 Error: 8.37383540425174e-06\n", + "Iteration: 20 Error: 5.944932320756102e-06\n", + "Iteration: 21 Error: 4.228969607944499e-06\n", + "Iteration: 22 Error: 3.0137481726311144e-06\n", + "Iteration: 23 Error: 2.151269131889233e-06\n", + "Iteration: 24 Error: 1.537933679740533e-06\n", + "Iteration: 25 Error: 1.1009884164914219e-06\n", + "Iteration: 26 Error: 7.891937878201638e-07\n", + "Iteration: 27 Error: 5.663685399004414e-07\n", + "Iteration: 28 Error: 4.069044469701133e-07\n", + "Iteration: 29 Error: 2.926380206491608e-07\n", + "Iteration: 30 Error: 2.1066118766066566e-07\n", + "Iteration: 31 Error: 1.517843925546991e-07\n", + "Iteration: 32 Error: 1.0945468148504389e-07\n", + "Iteration: 33 Error: 7.900879789302095e-08\n", + "Iteration: 34 Error: 5.749939963051176e-08\n", + "Iteration: 35 Error: 4.18731599949318e-08\n", + "Iteration: 36 Error: 3.0512465332144245e-08\n", + "Iteration: 37 Error: 2.2247119479956723e-08\n", + "Iteration: 38 Error: 1.622976275594823e-08\n", + "Iteration: 39 Error: 1.184623521499617e-08\n", + "Iteration: 40 Error: 8.651016181193683e-09\n", + "Iteration: 1 Error: 0.03858572871602911\n", + "Iteration: 2 Error: 0.018631616234846216\n", + "Iteration: 3 Error: 0.008507043829109107\n", + "Iteration: 4 Error: 0.004159257050476817\n", + "Iteration: 5 Error: 0.00223808803552622\n", + "Iteration: 6 Error: 0.0012953692386858395\n", + "Iteration: 7 Error: 0.0007925729104725776\n", + "Iteration: 8 Error: 0.0004987279893959307\n", + "Iteration: 9 Error: 0.00032272680760186967\n", + "Iteration: 10 Error: 0.0002113128620092053\n", + "Iteration: 11 Error: 0.00013959161172860668\n", + "Iteration: 12 Error: 9.326699329209598e-05\n", + "Iteration: 13 Error: 6.423044244679987e-05\n", + "Iteration: 14 Error: 4.4458567711402885e-05\n", + "Iteration: 15 Error: 3.08945608828437e-05\n", + "Iteration: 16 Error: 2.1550619385857228e-05\n", + "Iteration: 17 Error: 1.5077894533699343e-05\n", + "Iteration: 18 Error: 1.0580522993630659e-05\n", + "Iteration: 19 Error: 7.442226793941131e-06\n", + "Iteration: 20 Error: 5.24719866717982e-06\n", + "Iteration: 21 Error: 3.7067069223462035e-06\n", + "Iteration: 22 Error: 2.623555249381404e-06\n", + "Iteration: 23 Error: 1.859886041122305e-06\n", + "Iteration: 24 Error: 1.3275314988403508e-06\n", + "Iteration: 25 Error: 9.553516664984052e-07\n", + "Iteration: 26 Error: 6.883872163965243e-07\n", + "Iteration: 27 Error: 4.965583414451302e-07\n", + "Iteration: 28 Error: 3.5857492275415126e-07\n", + "Iteration: 29 Error: 2.591776572247184e-07\n", + "Iteration: 30 Error: 1.8750993552307804e-07\n", + "Iteration: 31 Error: 1.357720081363034e-07\n", + "Iteration: 32 Error: 9.839072057094e-08\n", + "Iteration: 33 Error: 7.135377072531313e-08\n", + "Iteration: 34 Error: 5.1784002585986144e-08\n", + "Iteration: 35 Error: 3.760619338155635e-08\n", + "Iteration: 36 Error: 2.7327763163498275e-08\n", + "Iteration: 37 Error: 1.987033337869093e-08\n", + "Iteration: 38 Error: 1.4456322805500577e-08\n", + "Iteration: 39 Error: 1.0523065085976668e-08\n", + "Iteration: 40 Error: 7.663961631987348e-09\n" + ] + } + ], + "source": [ + "params = {\n", + " \"beta\": 500.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.75,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-12, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}\n", + "\n", + "gf_struct =[('up',1), ('dn',1)]\n", + "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + "G_tau = make_gf_dlr_imtime(G_iw)\n", + "Sigma_iw = G_iw.copy()\n", + "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)\n", + "betas = np.array([50.0, 100.0, 200.0, 500.0, 1000.0]) # Different beta values for testing\n", + "\n", + "for i, beta in enumerate(betas):\n", + " gf_struct =[('up',1), ('dn',1)]\n", + " params[\"beta\"] = beta\n", + " \n", + " iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + "\n", + " G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + " G_tau = make_gf_dlr_imtime(G_iw)\n", + " Sigma_iw = G_iw.copy()\n", + " Sigma_tau = make_gf_dlr_imtime(Sigma_iw)\n", + " if i == 0:\n", + " G_iw << SemiCircular(1.0)\n", + " if i > 1:\n", + " tau = np.array([x.real for x in G_tau.mesh.values()], dtype=np.float64)\n", + " old_tau = np.array([x.real for x in G_old.mesh.values()], dtype=np.float64)\n", + " old_beta = np.max(old_tau)\n", + " tau_prime = tau*old_beta/params[\"beta\"]\n", + " G_dlr = make_gf_dlr(G_old)\n", + " for block, g in G_tau:\n", + " g.data[:,0,0] = np.array([G_dlr[\"up\"](t)[0,0] for t in tau_prime])\n", + " G_iw << make_gf_dlr_imfreq(G_tau)\n", + "\n", + " G_tau << make_gf_dlr_imtime(G_iw) # Initial guess in the imaginary time domain\n", + " error = 1.0\n", + " iter = 0\n", + "\n", + " while error > params[\"threshold\"]:\n", + " tau = np.array([x.real for x in G_tau.mesh.values()], dtype=np.float64) \n", + " for block, g in G_tau:\n", + " G_dlr = make_gf_dlr(g)\n", + " Sigma_tau[block].data[:,0,0] = np.array([G_dlr(t)[0,0]**2*G_dlr(params[\"beta\"]-t)[0,0] for t in tau]) # Compute self-energy in imaginary time\n", + "\n", + " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) # Transform self-energy to Matsubara frequency domain \n", + "\n", + " for block, g in G_tau:\n", + " G_iw[block] << inverse(iOmega_n - Sigma_iw[block]) # Solve the Dyson equation to obtain Green's function\n", + " G_old = G_tau.copy()\n", + " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw) # Update Green's function via weighted fixed point iteration\n", + " error = np.max(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]))) # Compute absolute error\n", + " iter += 1\n", + "\n", + " # Print iteration number and error\n", + " print(\"Iteration:\", iter, \"Error:\", error)\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "5e260dfb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense grid\n", + "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", + "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", + "\n", + "plt.figure(figsize = (10,10))\n", + "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", + "oplot(G_tau[\"up\"].real, marker = \"o\", markeredgecolor = \"black\", label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR nodes)\")\n", + "plt.plot(t, Gconformal, label = r\"$G_c(\\tau)$\", color = \"red\", linestyle = \"dashed\")\n", + "plt.ylim(-0.5,0)\n", + "plt.ylabel(\"\")\n", + "plt.legend(loc=\"upper left\")\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "id": "45fedad2", @@ -234,12 +586,12 @@ "source": [ "### Exercise 2 \n", "\n", - "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1.\n" + "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. How can you give a Pad\\'e approximate of $A(\\omega)$ after evaluating on the DLR grid?\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 87, "id": "ba3aecc3", "metadata": {}, "outputs": [], @@ -274,7 +626,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "id": "0287d987", "metadata": {}, "outputs": [], @@ -294,7 +646,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 89, "id": "bc6182a2", "metadata": {}, "outputs": [ @@ -308,7 +660,7 @@ " " ] }, - "execution_count": 116, + "execution_count": 89, "metadata": {}, "output_type": "execute_result" } @@ -320,7 +672,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 90, "id": "4d32a671", "metadata": {}, "outputs": [ @@ -359,7 +711,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_109476/735204175.py:15: RuntimeWarning: divide by zero encountered in divide\n", + "/tmp/ipykernel_29847/735204175.py:15: RuntimeWarning: divide by zero encountered in divide\n", " error = np.mean(np.abs((S.G_tau[\"up\"].real.data[:,0,0] - G_tau_old[\"up\"].real.data[:,0,0]) / G_tau_old[\"up\"].real.data[:,0,0]))\n" ] } @@ -391,7 +743,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 91, "id": "50b5146d", "metadata": {}, "outputs": [ @@ -414,7 +766,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "id": "65fb461e", "metadata": {}, "outputs": [ @@ -437,7 +789,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 93, "id": "e8703f85", "metadata": {}, "outputs": [ @@ -460,7 +812,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "id": "1fa86573", "metadata": {}, "outputs": [], @@ -472,7 +824,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 95, "id": "f18b5166", "metadata": {}, "outputs": [ @@ -496,9 +848,9 @@ ], "metadata": { "kernelspec": { - "display_name": "triqskernel", + "display_name": "Python 3", "language": "python", - "name": "triqskernel" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -510,7 +862,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.12" } }, "nbformat": 4, From f22d790f491d2ec8f4fa133296462d4f1926c6c6 Mon Sep 17 00:00:00 2001 From: Jason Kaye Date: Wed, 30 Jul 2025 18:25:08 -0400 Subject: [PATCH 4/8] minor edits dlr exercise 2 --- .../06s-Discrete_Lehman_Representation.ipynb | 625 +++++++++--------- 1 file changed, 322 insertions(+), 303 deletions(-) diff --git a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb index 84c0021..228de37 100644 --- a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb +++ b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 100, "id": "f916c67b", "metadata": { "tags": [] @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 101, "id": "5711f528", "metadata": { "tags": [] @@ -109,39 +109,39 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration: 1 Error: 0.09365042856328878\n", - "Iteration: 2 Error: 0.02389091857123847\n", - "Iteration: 3 Error: 0.017721420560846274\n", - "Iteration: 4 Error: 0.01225291280723799\n", - "Iteration: 5 Error: 0.0069780870343561854\n", - "Iteration: 6 Error: 0.003097888019241102\n", - "Iteration: 7 Error: 0.0011871083057315088\n", - "Iteration: 8 Error: 0.00045291431501309765\n", - "Iteration: 9 Error: 0.00020867659064766064\n", - "Iteration: 10 Error: 0.0001221937305567189\n", - "Iteration: 11 Error: 7.29518263504203e-05\n", - "Iteration: 12 Error: 4.423836621747501e-05\n", - "Iteration: 13 Error: 2.7150527487307397e-05\n", - "Iteration: 14 Error: 1.681698909905549e-05\n", - "Iteration: 15 Error: 1.0655920737845381e-05\n", - "Iteration: 16 Error: 6.883502771559691e-06\n", - "Iteration: 17 Error: 4.471739081024495e-06\n", - "Iteration: 18 Error: 2.9197014490001116e-06\n", - "Iteration: 19 Error: 1.9151486686519448e-06\n", - "Iteration: 20 Error: 1.2615741423749327e-06\n", - "Iteration: 21 Error: 8.343275527122884e-07\n", - "Iteration: 22 Error: 5.538040310781867e-07\n", - "Iteration: 23 Error: 3.6886194437757425e-07\n", - "Iteration: 24 Error: 2.4646771973335646e-07\n", - "Iteration: 25 Error: 1.6517766920909338e-07\n", - "Iteration: 26 Error: 1.1100690316956374e-07\n", - "Iteration: 27 Error: 7.485517372618489e-08\n", - "Iteration: 28 Error: 5.154431514942104e-08\n", - "Iteration: 29 Error: 3.558213140797406e-08\n", - "Iteration: 30 Error: 2.462116999168984e-08\n", - "Iteration: 31 Error: 1.7074547720152822e-08\n", - "Iteration: 32 Error: 1.1865782800768443e-08\n", - "Iteration: 33 Error: 8.262231621092297e-09\n" + "Iteration: 1 Error: 0.09365042856331773\n", + "Iteration: 2 Error: 0.023890918571245603\n", + "Iteration: 3 Error: 0.01772142056085254\n", + "Iteration: 4 Error: 0.012252912807243714\n", + "Iteration: 5 Error: 0.006978087034360904\n", + "Iteration: 6 Error: 0.0030978880192437525\n", + "Iteration: 7 Error: 0.001187108305732671\n", + "Iteration: 8 Error: 0.000452914315013514\n", + "Iteration: 9 Error: 0.0002086765906473831\n", + "Iteration: 10 Error: 0.00012219373055782912\n", + "Iteration: 11 Error: 7.295182635136399e-05\n", + "Iteration: 12 Error: 4.4238366217141945e-05\n", + "Iteration: 13 Error: 2.7150527487362908e-05\n", + "Iteration: 14 Error: 1.6816989099333046e-05\n", + "Iteration: 15 Error: 1.0655920738511515e-05\n", + "Iteration: 16 Error: 6.883502771670713e-06\n", + "Iteration: 17 Error: 4.471739080247339e-06\n", + "Iteration: 18 Error: 2.919701448056422e-06\n", + "Iteration: 19 Error: 1.9151486679303e-06\n", + "Iteration: 20 Error: 1.2615741412647097e-06\n", + "Iteration: 21 Error: 8.343275522681992e-07\n", + "Iteration: 22 Error: 5.538040315222759e-07\n", + "Iteration: 23 Error: 3.6886194482166346e-07\n", + "Iteration: 24 Error: 2.4646772006642337e-07\n", + "Iteration: 25 Error: 1.6517766893153762e-07\n", + "Iteration: 26 Error: 1.1100690222587417e-07\n", + "Iteration: 27 Error: 7.485517272698416e-08\n", + "Iteration: 28 Error: 5.154431464982068e-08\n", + "Iteration: 29 Error: 3.5582131185929455e-08\n", + "Iteration: 30 Error: 2.4621169880667537e-08\n", + "Iteration: 31 Error: 1.7074547498108217e-08\n", + "Iteration: 32 Error: 1.1865782356679233e-08\n", + "Iteration: 33 Error: 8.262231676603449e-09\n" ] } ], @@ -173,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 102, "id": "c0669c9e", "metadata": { "tags": [] @@ -181,7 +181,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -191,9 +191,9 @@ } ], "source": [ - "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense grid\n", - "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", - "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", + "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense imaginary time grid\n", + "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", + "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", "\n", "plt.figure(figsize = (10,10))\n", "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", @@ -217,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 103, "id": "f728e5fc", "metadata": { "tags": [] @@ -225,7 +225,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -235,7 +235,7 @@ } ], "source": [ - "Sigma_iw_dense = make_gf_imfreq(Sigma_iw[\"up\"], n_iw = 5000)\n", + "Sigma_iw_dense = make_gf_imfreq(Sigma_iw[\"up\"], n_iw = 5000) # Obtain DLR expansion on dense Matsubara frequency grid\n", "\n", "plt.figure(figsize = (10,10))\n", "oplot(Sigma_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $\\Sigma(i \\omega_n)$ (DLR)\")\n", @@ -257,225 +257,227 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 104, "id": "1e11d3ed", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Iteration: 1 Error: 0.08341268718616413\n", - "Iteration: 2 Error: 0.020624876522001317\n", + "Iteration: 1 Error: 0.08341268718616414\n", + "Iteration: 2 Error: 0.020624876522001262\n", "Iteration: 3 Error: 0.008508362270219227\n", "Iteration: 4 Error: 0.004128924998232253\n", - "Iteration: 5 Error: 0.0021405145220456667\n", - "Iteration: 6 Error: 0.001158800199871024\n", + "Iteration: 5 Error: 0.002140514522045611\n", + "Iteration: 6 Error: 0.0011588001998710795\n", "Iteration: 7 Error: 0.000641626565325959\n", "Iteration: 8 Error: 0.0003685756237916671\n", - "Iteration: 9 Error: 0.00021545130661626555\n", - "Iteration: 10 Error: 0.0001272547545787539\n", + "Iteration: 9 Error: 0.00021545130661632106\n", + "Iteration: 10 Error: 0.00012725475457886493\n", "Iteration: 11 Error: 7.583129203281302e-05\n", - "Iteration: 12 Error: 4.614611609260466e-05\n", - "Iteration: 13 Error: 2.849274306693239e-05\n", - "Iteration: 14 Error: 1.7729165843860528e-05\n", - "Iteration: 15 Error: 1.1111730505442008e-05\n", - "Iteration: 16 Error: 7.011361329745114e-06\n", - "Iteration: 17 Error: 4.492548279555475e-06\n", + "Iteration: 12 Error: 4.614611609254915e-05\n", + "Iteration: 13 Error: 2.8492743066987902e-05\n", + "Iteration: 14 Error: 1.772916584391604e-05\n", + "Iteration: 15 Error: 1.1111730505386497e-05\n", + "Iteration: 16 Error: 7.011361329800625e-06\n", + "Iteration: 17 Error: 4.492548279610986e-06\n", "Iteration: 18 Error: 2.9235559191875815e-06\n", "Iteration: 19 Error: 1.9132391210208155e-06\n", "Iteration: 20 Error: 1.2584982634900044e-06\n", "Iteration: 21 Error: 8.316886299097881e-07\n", - "Iteration: 22 Error: 5.519602330750217e-07\n", + "Iteration: 22 Error: 5.519602330195106e-07\n", "Iteration: 23 Error: 3.67725420280518e-07\n", "Iteration: 24 Error: 2.464355425280118e-07\n", - "Iteration: 25 Error: 1.6722670742597145e-07\n", - "Iteration: 26 Error: 1.1382290099337666e-07\n", - "Iteration: 27 Error: 7.769105281330013e-08\n", + "Iteration: 25 Error: 1.672267073704603e-07\n", + "Iteration: 26 Error: 1.1382290110439897e-07\n", + "Iteration: 27 Error: 7.769105275778898e-08\n", "Iteration: 28 Error: 5.3166422320227724e-08\n", - "Iteration: 29 Error: 3.6470967634816276e-08\n", + "Iteration: 29 Error: 3.6470967579305125e-08\n", "Iteration: 30 Error: 2.5074259502044782e-08\n", - "Iteration: 31 Error: 1.7274895236507604e-08\n", + "Iteration: 31 Error: 1.7274895292018755e-08\n", "Iteration: 32 Error: 1.1924811138541713e-08\n", "Iteration: 33 Error: 8.25099566448273e-09\n", "Iteration: 1 Error: 0.12500000000000008\n", - "Iteration: 2 Error: 0.09374268479504305\n", - "Iteration: 3 Error: 0.07029982706555932\n", - "Iteration: 4 Error: 0.05271881593527766\n", + "Iteration: 2 Error: 0.09374268479504318\n", + "Iteration: 3 Error: 0.07029982706555926\n", + "Iteration: 4 Error: 0.05271881593527811\n", "Iteration: 5 Error: 0.03953437914427471\n", - "Iteration: 6 Error: 0.029647238002360188\n", - "Iteration: 7 Error: 0.022232826927764515\n", - "Iteration: 8 Error: 0.016672733664746586\n", - "Iteration: 9 Error: 0.012503190846815504\n", - "Iteration: 10 Error: 0.009376416675704047\n", - "Iteration: 11 Error: 0.007031611962522333\n", - "Iteration: 12 Error: 0.005273206364277305\n", - "Iteration: 13 Error: 0.003954543887726314\n", - "Iteration: 14 Error: 0.0029656484625291135\n", - "Iteration: 15 Error: 0.0022240495310055786\n", - "Iteration: 16 Error: 0.001667902409725086\n", - "Iteration: 17 Error: 0.0012508294622221028\n", - "Iteration: 18 Error: 0.0009380516473309064\n", + "Iteration: 6 Error: 0.0296472380023598\n", + "Iteration: 7 Error: 0.02223282692776435\n", + "Iteration: 8 Error: 0.016672733664746753\n", + "Iteration: 9 Error: 0.01250319084681556\n", + "Iteration: 10 Error: 0.00937641667570377\n", + "Iteration: 11 Error: 0.007031611962521944\n", + "Iteration: 12 Error: 0.005273206364277583\n", + "Iteration: 13 Error: 0.003954543887726147\n", + "Iteration: 14 Error: 0.002965648462529502\n", + "Iteration: 15 Error: 0.002224049531005301\n", + "Iteration: 16 Error: 0.0016679024097254747\n", + "Iteration: 17 Error: 0.0012508294622219363\n", + "Iteration: 18 Error: 0.0009380516473310729\n", "Iteration: 19 Error: 0.0007034876659879896\n", "Iteration: 20 Error: 0.0005275786694697304\n", - "Iteration: 21 Error: 0.0003956570385001412\n", - "Iteration: 22 Error: 0.0002967231435098694\n", - "Iteration: 23 Error: 0.0002225280395184992\n", + "Iteration: 21 Error: 0.0003956570385000857\n", + "Iteration: 22 Error: 0.00029672314351020246\n", + "Iteration: 23 Error: 0.0002225280395184437\n", "Iteration: 24 Error: 0.00016688557566552076\n", - "Iteration: 25 Error: 0.00012515654005063048\n", - "Iteration: 26 Error: 9.386181291004547e-05\n", + "Iteration: 25 Error: 0.00012515654005057497\n", + "Iteration: 26 Error: 9.38618129101565e-05\n", "Iteration: 27 Error: 7.039226320310066e-05\n", - "Iteration: 28 Error: 5.27911936727965e-05\n", - "Iteration: 29 Error: 3.959119081126117e-05\n", - "Iteration: 30 Error: 2.9691773912432495e-05\n", - "Iteration: 31 Error: 2.2267640184592263e-05\n", - "Iteration: 32 Error: 1.6699854564594663e-05\n", - "Iteration: 33 Error: 1.2524246393086358e-05\n", - "Iteration: 34 Error: 9.392710038524932e-06\n", - "Iteration: 35 Error: 7.04418261737727e-06\n", - "Iteration: 36 Error: 5.282878921153422e-06\n", - "Iteration: 37 Error: 3.9619687978165175e-06\n", - "Iteration: 38 Error: 2.9713360494287855e-06\n", - "Iteration: 39 Error: 2.2283982342719e-06\n", - "Iteration: 40 Error: 1.67122197769487e-06\n", - "Iteration: 41 Error: 1.2533597895103554e-06\n", - "Iteration: 42 Error: 9.399779175023326e-07\n", - "Iteration: 43 Error: 7.049524243796235e-07\n", - "Iteration: 44 Error: 5.286913668522963e-07\n", - "Iteration: 45 Error: 3.965015349383094e-07\n", - "Iteration: 46 Error: 2.973635697123278e-07\n", - "Iteration: 47 Error: 2.230133577807436e-07\n", - "Iteration: 48 Error: 1.6725311269283338e-07\n", + "Iteration: 28 Error: 5.2791193673074055e-05\n", + "Iteration: 29 Error: 3.959119081103912e-05\n", + "Iteration: 30 Error: 2.9691773912376984e-05\n", + "Iteration: 31 Error: 2.2267640184647775e-05\n", + "Iteration: 32 Error: 1.669985456442813e-05\n", + "Iteration: 33 Error: 1.2524246393363914e-05\n", + "Iteration: 34 Error: 9.392710038247376e-06\n", + "Iteration: 35 Error: 7.044182616988692e-06\n", + "Iteration: 36 Error: 5.282878921430978e-06\n", + "Iteration: 37 Error: 3.9619687982050955e-06\n", + "Iteration: 38 Error: 2.971336049595319e-06\n", + "Iteration: 39 Error: 2.228398234216389e-06\n", + "Iteration: 40 Error: 1.6712219777503812e-06\n", + "Iteration: 41 Error: 1.2533597891772885e-06\n", + "Iteration: 42 Error: 9.399779175578438e-07\n", + "Iteration: 43 Error: 7.049524244351346e-07\n", + "Iteration: 44 Error: 5.286913672408744e-07\n", + "Iteration: 45 Error: 3.9650153488279827e-07\n", + "Iteration: 46 Error: 2.9736356965681665e-07\n", + "Iteration: 47 Error: 2.23013357558699e-07\n", + "Iteration: 48 Error: 1.6725311263732223e-07\n", "Iteration: 49 Error: 1.2543471639148152e-07\n", - "Iteration: 50 Error: 9.407224277335757e-08\n", - "Iteration: 51 Error: 7.055136824751784e-08\n", - "Iteration: 52 Error: 5.2911439230030055e-08\n", - "Iteration: 53 Error: 3.968203116100355e-08\n", - "Iteration: 54 Error: 2.9760374220533237e-08\n", + "Iteration: 50 Error: 9.407224282886872e-08\n", + "Iteration: 51 Error: 7.05513684140513e-08\n", + "Iteration: 52 Error: 5.291143939656351e-08\n", + "Iteration: 53 Error: 3.9682030883447794e-08\n", + "Iteration: 54 Error: 2.976037438706669e-08\n", "Iteration: 55 Error: 2.2319427639416745e-08\n", - "Iteration: 56 Error: 1.673893779141622e-08\n", - "Iteration: 57 Error: 1.2553733164111236e-08\n", - "Iteration: 58 Error: 9.414950652431031e-09\n", + "Iteration: 56 Error: 1.673893773590507e-08\n", + "Iteration: 57 Error: 1.2553733053088934e-08\n", + "Iteration: 58 Error: 9.414950485897577e-09\n", "Iteration: 1 Error: 0.03865133722137276\n", "Iteration: 2 Error: 0.018614955093191582\n", - "Iteration: 3 Error: 0.008498943194396369\n", - "Iteration: 4 Error: 0.004151449709067723\n", - "Iteration: 5 Error: 0.002240788215737144\n", - "Iteration: 6 Error: 0.001293947788542249\n", + "Iteration: 3 Error: 0.00849894319439648\n", + "Iteration: 4 Error: 0.004151449709067834\n", + "Iteration: 5 Error: 0.0022407882157367\n", + "Iteration: 6 Error: 0.001293947788542471\n", "Iteration: 7 Error: 0.0007925613454448088\n", - "Iteration: 8 Error: 0.0004953228320832004\n", + "Iteration: 8 Error: 0.0004953228320831449\n", "Iteration: 9 Error: 0.0003210956323461134\n", - "Iteration: 10 Error: 0.00021225572469663057\n", - "Iteration: 11 Error: 0.0001415735015715125\n", + "Iteration: 10 Error: 0.00021225572469640852\n", + "Iteration: 11 Error: 0.00014157350157173454\n", "Iteration: 12 Error: 9.512449446208437e-05\n", - "Iteration: 13 Error: 6.455228776103272e-05\n", + "Iteration: 13 Error: 6.455228776086619e-05\n", "Iteration: 14 Error: 4.460059330685384e-05\n", - "Iteration: 15 Error: 3.094499174544074e-05\n", - "Iteration: 16 Error: 2.154868335302318e-05\n", - "Iteration: 17 Error: 1.5053500964090638e-05\n", - "Iteration: 18 Error: 1.0545842114184634e-05\n", - "Iteration: 19 Error: 7.406607352045125e-06\n", - "Iteration: 20 Error: 5.21362632549538e-06\n", - "Iteration: 21 Error: 3.6774582602983052e-06\n", - "Iteration: 22 Error: 2.616369032926169e-06\n", - "Iteration: 23 Error: 1.8739124810207564e-06\n", - "Iteration: 24 Error: 1.3440995595415117e-06\n", - "Iteration: 25 Error: 9.653734329151398e-07\n", + "Iteration: 15 Error: 3.094499174538523e-05\n", + "Iteration: 16 Error: 2.154868335307869e-05\n", + "Iteration: 17 Error: 1.5053500964035127e-05\n", + "Iteration: 18 Error: 1.0545842114351167e-05\n", + "Iteration: 19 Error: 7.406607351878591e-06\n", + "Iteration: 20 Error: 5.213626325606402e-06\n", + "Iteration: 21 Error: 3.677458260187283e-06\n", + "Iteration: 22 Error: 2.6163690330927025e-06\n", + "Iteration: 23 Error: 1.8739124811317787e-06\n", + "Iteration: 24 Error: 1.344099559652534e-06\n", + "Iteration: 25 Error: 9.653734328041175e-07\n", "Iteration: 26 Error: 6.942194530901169e-07\n", - "Iteration: 27 Error: 4.998002282041725e-07\n", - "Iteration: 28 Error: 3.60212917827063e-07\n", - "Iteration: 29 Error: 2.5986861618143564e-07\n", + "Iteration: 27 Error: 4.998002283707059e-07\n", + "Iteration: 28 Error: 3.602129177160407e-07\n", + "Iteration: 29 Error: 2.598686162369468e-07\n", "Iteration: 30 Error: 1.8765139586651713e-07\n", - "Iteration: 31 Error: 1.356212078751362e-07\n", - "Iteration: 32 Error: 9.809752998801713e-08\n", - "Iteration: 33 Error: 7.101042281965064e-08\n", - "Iteration: 34 Error: 5.143993836442817e-08\n", - "Iteration: 35 Error: 3.728854836015927e-08\n", - "Iteration: 36 Error: 2.7047743322849982e-08\n", - "Iteration: 37 Error: 1.963144463656974e-08\n", - "Iteration: 38 Error: 1.425690926426526e-08\n", - "Iteration: 39 Error: 1.036073915550162e-08\n", - "Iteration: 40 Error: 7.575591487452016e-09\n", - "Iteration: 1 Error: 0.04950059352786962\n", - "Iteration: 2 Error: 0.025248973882357445\n", + "Iteration: 31 Error: 1.35621207431047e-07\n", + "Iteration: 32 Error: 9.809753021006173e-08\n", + "Iteration: 33 Error: 7.101042270862834e-08\n", + "Iteration: 34 Error: 5.1439938419939324e-08\n", + "Iteration: 35 Error: 3.728854830464812e-08\n", + "Iteration: 36 Error: 2.7047743489383436e-08\n", + "Iteration: 37 Error: 1.9631444303502832e-08\n", + "Iteration: 38 Error: 1.425690965284332e-08\n", + "Iteration: 39 Error: 1.0360738822434712e-08\n", + "Iteration: 40 Error: 7.575591098873957e-09\n", + "Iteration: 1 Error: 0.049500593527869674\n", + "Iteration: 2 Error: 0.025248973882357584\n", "Iteration: 3 Error: 0.011473791465799965\n", "Iteration: 4 Error: 0.005313178543824293\n", - "Iteration: 5 Error: 0.002757186074631768\n", - "Iteration: 6 Error: 0.0015559584947200111\n", - "Iteration: 7 Error: 0.0009248106659895394\n", - "Iteration: 8 Error: 0.0005824927695655124\n", - "Iteration: 9 Error: 0.00037319900752935675\n", - "Iteration: 10 Error: 0.00024221618128461575\n", - "Iteration: 11 Error: 0.00016043382508967863\n", - "Iteration: 12 Error: 0.0001089946293926225\n", - "Iteration: 13 Error: 7.451134044267338e-05\n", - "Iteration: 14 Error: 5.120451625922895e-05\n", - "Iteration: 15 Error: 3.534504724617138e-05\n", - "Iteration: 16 Error: 2.4491624533884426e-05\n", - "Iteration: 17 Error: 1.7027984772877147e-05\n", - "Iteration: 18 Error: 1.1873853164257042e-05\n", - "Iteration: 19 Error: 8.37383540425174e-06\n", - "Iteration: 20 Error: 5.944932320756102e-06\n", + "Iteration: 5 Error: 0.002757186074631879\n", + "Iteration: 6 Error: 0.001555958494719345\n", + "Iteration: 7 Error: 0.000924810665990039\n", + "Iteration: 8 Error: 0.000582492769565679\n", + "Iteration: 9 Error: 0.00037319900752930124\n", + "Iteration: 10 Error: 0.00024221618128450473\n", + "Iteration: 11 Error: 0.00016043382508984516\n", + "Iteration: 12 Error: 0.00010899462939217841\n", + "Iteration: 13 Error: 7.451134044311747e-05\n", + "Iteration: 14 Error: 5.120451625861833e-05\n", + "Iteration: 15 Error: 3.534504724711507e-05\n", + "Iteration: 16 Error: 2.4491624533329315e-05\n", + "Iteration: 17 Error: 1.702798477343226e-05\n", + "Iteration: 18 Error: 1.1873853163590908e-05\n", + "Iteration: 19 Error: 8.37383540475134e-06\n", + "Iteration: 20 Error: 5.944932320423035e-06\n", "Iteration: 21 Error: 4.228969607944499e-06\n", - "Iteration: 22 Error: 3.0137481726311144e-06\n", - "Iteration: 23 Error: 2.151269131889233e-06\n", - "Iteration: 24 Error: 1.537933679740533e-06\n", - "Iteration: 25 Error: 1.1009884164914219e-06\n", - "Iteration: 26 Error: 7.891937878201638e-07\n", - "Iteration: 27 Error: 5.663685399004414e-07\n", - "Iteration: 28 Error: 4.069044469701133e-07\n", - "Iteration: 29 Error: 2.926380206491608e-07\n", - "Iteration: 30 Error: 2.1066118766066566e-07\n", - "Iteration: 31 Error: 1.517843925546991e-07\n", - "Iteration: 32 Error: 1.0945468148504389e-07\n", - "Iteration: 33 Error: 7.900879789302095e-08\n", - "Iteration: 34 Error: 5.749939963051176e-08\n", - "Iteration: 35 Error: 4.18731599949318e-08\n", - "Iteration: 36 Error: 3.0512465332144245e-08\n", - "Iteration: 37 Error: 2.2247119479956723e-08\n", - "Iteration: 38 Error: 1.622976275594823e-08\n", - "Iteration: 39 Error: 1.184623521499617e-08\n", - "Iteration: 40 Error: 8.651016181193683e-09\n", - "Iteration: 1 Error: 0.03858572871602911\n", - "Iteration: 2 Error: 0.018631616234846216\n", - "Iteration: 3 Error: 0.008507043829109107\n", + "Iteration: 22 Error: 3.0137481727421367e-06\n", + "Iteration: 23 Error: 2.1512691321667887e-06\n", + "Iteration: 24 Error: 1.5379336796295107e-06\n", + "Iteration: 25 Error: 1.100988416158355e-06\n", + "Iteration: 26 Error: 7.89193787875675e-07\n", + "Iteration: 27 Error: 5.66368540122486e-07\n", + "Iteration: 28 Error: 4.0690444713664675e-07\n", + "Iteration: 29 Error: 2.926380200385381e-07\n", + "Iteration: 30 Error: 2.1066118827128832e-07\n", + "Iteration: 31 Error: 1.517843921106099e-07\n", + "Iteration: 32 Error: 1.0945468209566656e-07\n", + "Iteration: 33 Error: 7.900879739342059e-08\n", + "Iteration: 34 Error: 5.749939974153406e-08\n", + "Iteration: 35 Error: 4.187316093862137e-08\n", + "Iteration: 36 Error: 3.051246461049928e-08\n", + "Iteration: 37 Error: 2.224711975751248e-08\n", + "Iteration: 38 Error: 1.6229762700437078e-08\n", + "Iteration: 39 Error: 1.1846234659884658e-08\n", + "Iteration: 40 Error: 8.651016625282892e-09\n", + "Iteration: 1 Error: 0.038585728716029\n", + "Iteration: 2 Error: 0.018631616234846382\n", + "Iteration: 3 Error: 0.008507043829109329\n", "Iteration: 4 Error: 0.004159257050476817\n", - "Iteration: 5 Error: 0.00223808803552622\n", - "Iteration: 6 Error: 0.0012953692386858395\n", - "Iteration: 7 Error: 0.0007925729104725776\n", - "Iteration: 8 Error: 0.0004987279893959307\n", - "Iteration: 9 Error: 0.00032272680760186967\n", - "Iteration: 10 Error: 0.0002113128620092053\n", - "Iteration: 11 Error: 0.00013959161172860668\n", - "Iteration: 12 Error: 9.326699329209598e-05\n", - "Iteration: 13 Error: 6.423044244679987e-05\n", - "Iteration: 14 Error: 4.4458567711402885e-05\n", - "Iteration: 15 Error: 3.08945608828437e-05\n", - "Iteration: 16 Error: 2.1550619385857228e-05\n", - "Iteration: 17 Error: 1.5077894533699343e-05\n", - "Iteration: 18 Error: 1.0580522993630659e-05\n", - "Iteration: 19 Error: 7.442226793941131e-06\n", - "Iteration: 20 Error: 5.24719866717982e-06\n", - "Iteration: 21 Error: 3.7067069223462035e-06\n", - "Iteration: 22 Error: 2.623555249381404e-06\n", - "Iteration: 23 Error: 1.859886041122305e-06\n", - "Iteration: 24 Error: 1.3275314988403508e-06\n", - "Iteration: 25 Error: 9.553516664984052e-07\n", - "Iteration: 26 Error: 6.883872163965243e-07\n", - "Iteration: 27 Error: 4.965583414451302e-07\n", - "Iteration: 28 Error: 3.5857492275415126e-07\n", - "Iteration: 29 Error: 2.591776572247184e-07\n", - "Iteration: 30 Error: 1.8750993552307804e-07\n", - "Iteration: 31 Error: 1.357720081363034e-07\n", - "Iteration: 32 Error: 9.839072057094e-08\n", - "Iteration: 33 Error: 7.135377072531313e-08\n", - "Iteration: 34 Error: 5.1784002585986144e-08\n", - "Iteration: 35 Error: 3.760619338155635e-08\n", - "Iteration: 36 Error: 2.7327763163498275e-08\n", - "Iteration: 37 Error: 1.987033337869093e-08\n", - "Iteration: 38 Error: 1.4456322805500577e-08\n", - "Iteration: 39 Error: 1.0523065085976668e-08\n", - "Iteration: 40 Error: 7.663961631987348e-09\n" + "Iteration: 5 Error: 0.002238088035525221\n", + "Iteration: 6 Error: 0.0012953692386866167\n", + "Iteration: 7 Error: 0.0007925729104717449\n", + "Iteration: 8 Error: 0.0004987279893976515\n", + "Iteration: 9 Error: 0.0003227268075990941\n", + "Iteration: 10 Error: 0.00021131286201181432\n", + "Iteration: 11 Error: 0.00013959161172744095\n", + "Iteration: 12 Error: 9.326699329281762e-05\n", + "Iteration: 13 Error: 6.42304424464113e-05\n", + "Iteration: 14 Error: 4.445856771168044e-05\n", + "Iteration: 15 Error: 3.089456088278819e-05\n", + "Iteration: 16 Error: 2.155061938646785e-05\n", + "Iteration: 17 Error: 1.507789453308872e-05\n", + "Iteration: 18 Error: 1.0580522994463326e-05\n", + "Iteration: 19 Error: 7.442226792275797e-06\n", + "Iteration: 20 Error: 5.24719866862311e-06\n", + "Iteration: 21 Error: 3.706706921069447e-06\n", + "Iteration: 22 Error: 2.6235552509357163e-06\n", + "Iteration: 23 Error: 1.8598860398455486e-06\n", + "Iteration: 24 Error: 1.3275314990623954e-06\n", + "Iteration: 25 Error: 9.55351666775961e-07\n", + "Iteration: 26 Error: 6.883872155083459e-07\n", + "Iteration: 27 Error: 4.965583417781971e-07\n", + "Iteration: 28 Error: 3.5857492264312896e-07\n", + "Iteration: 29 Error: 2.591776576132965e-07\n", + "Iteration: 30 Error: 1.8750993530103344e-07\n", + "Iteration: 31 Error: 1.3577200841385917e-07\n", + "Iteration: 32 Error: 9.839072123707382e-08\n", + "Iteration: 33 Error: 7.135376894895629e-08\n", + "Iteration: 34 Error: 5.178400364069802e-08\n", + "Iteration: 35 Error: 3.7606193048489445e-08\n", + "Iteration: 36 Error: 2.732776288594252e-08\n", + "Iteration: 37 Error: 1.9870334433402803e-08\n", + "Iteration: 38 Error: 1.4456322250389064e-08\n", + "Iteration: 39 Error: 1.0523064530865156e-08\n", + "Iteration: 40 Error: 7.663963463855339e-09\n" ] } ], @@ -540,7 +542,6 @@ " error = np.max(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]))) # Compute absolute error\n", " iter += 1\n", "\n", - " # Print iteration number and error\n", " print(\"Iteration:\", iter, \"Error:\", error)\n", " if iter > params[\"max_iter\"]:\n", " print(\"Maximum number of iterations reached without convergence\")\n", @@ -549,13 +550,15 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 105, "id": "5e260dfb", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -565,9 +568,9 @@ } ], "source": [ - "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense grid\n", - "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", - "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", + "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense imaginary time grid\n", + "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", + "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", "\n", "plt.figure(figsize = (10,10))\n", "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", @@ -586,14 +589,16 @@ "source": [ "### Exercise 2 \n", "\n", - "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. How can you give a Pad\\'e approximate of $A(\\omega)$ after evaluating on the DLR grid?\n" + "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. Then obtain a Padé approximation of the spectral function $A(\\omega)$.\n" ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 106, "id": "ba3aecc3", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "\n", @@ -618,17 +623,16 @@ "\n", " def solve(self):\n", " error = 1.0\n", - " iter = 0\n", - "\n", - " \n", - " \n" + " iter = 0" ] }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 112, "id": "0287d987", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "params = {\n", @@ -639,16 +643,18 @@ " \"dlr_err\": 1e-8, \n", " \"U\" : 3.0, # In the Mott state, U > 4, you run into trouble, but this is also why the IPT tutorial just stops at small iteration number. \n", " \"t\" : 1.0,\n", - " \"max_iter\": 1000, # small iteration number is ~ 25\n", + " \"max_iter\": 1000,\n", " \"threshold\": 1e-8,\n", "}" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 113, "id": "bc6182a2", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { @@ -660,7 +666,7 @@ " " ] }, - "execution_count": 89, + "execution_count": 113, "metadata": {}, "output_type": "execute_result" } @@ -672,47 +678,38 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 114, "id": "4d32a671", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Iteration: 0\n", - "Iteration: 1\n", - "Iteration: 2\n", - "Iteration: 3\n", - "Iteration: 4\n", - "0.0016821665998838229 5\n", - "Iteration: 5\n", - "Iteration: 6\n", - "Iteration: 7\n", - "Iteration: 8\n", - "Iteration: 9\n", - "3.707673734909233e-05 10\n", - "Iteration: 10\n", - "Iteration: 11\n", - "Iteration: 12\n", - "Iteration: 13\n", - "Iteration: 14\n", - "8.68261338822299e-07 15\n", - "Iteration: 15\n", - "Iteration: 16\n", - "Iteration: 17\n", - "Iteration: 18\n", - "Iteration: 19\n", - "2.081733772436832e-08 20\n", - "Iteration: 20\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_29847/735204175.py:15: RuntimeWarning: divide by zero encountered in divide\n", - " error = np.mean(np.abs((S.G_tau[\"up\"].real.data[:,0,0] - G_tau_old[\"up\"].real.data[:,0,0]) / G_tau_old[\"up\"].real.data[:,0,0]))\n" + "Iteration: 1 Error: 0.4994691601105864\n", + "Iteration: 2 Error: 0.013218442183916101\n", + "Iteration: 3 Error: 0.006275825531574575\n", + "Iteration: 4 Error: 0.002993884912959155\n", + "Iteration: 5 Error: 0.0014307653808706133\n", + "Iteration: 6 Error: 0.0006841141729723721\n", + "Iteration: 7 Error: 0.00032711102854793284\n", + "Iteration: 8 Error: 0.0001563808101129327\n", + "Iteration: 9 Error: 7.474213040459254e-05\n", + "Iteration: 10 Error: 3.571384048717263e-05\n", + "Iteration: 11 Error: 1.719079397405343e-05\n", + "Iteration: 12 Error: 8.315824688021056e-06\n", + "Iteration: 13 Error: 4.021901271578088e-06\n", + "Iteration: 14 Error: 1.9448479028350008e-06\n", + "Iteration: 15 Error: 9.403252946849072e-07\n", + "Iteration: 16 Error: 4.545876733930143e-07\n", + "Iteration: 17 Error: 2.197414414872867e-07\n", + "Iteration: 18 Error: 1.0621059087778661e-07\n", + "Iteration: 19 Error: 5.1332351869159965e-08\n", + "Iteration: 20 Error: 2.4807740583998594e-08\n", + "Iteration: 21 Error: 1.1988382841998657e-08\n", + "Iteration: 22 Error: 5.7931588970383554e-09\n" ] } ], @@ -720,7 +717,6 @@ "error = 1.0\n", "iter = 0\n", "while error > params[\"threshold\"]:\n", - " print(\"Iteration:\", iter)\n", " for block, g in S.G0_iw:\n", " g << inverse( iOmega_n - params[\"t\"]**2 * S.G_iw[block] )\n", " S.G0_tau << make_gf_dlr_imtime(S.G0_iw)\n", @@ -731,11 +727,10 @@ " S.G_iw << params[\"alpha\"]*S.G_iw+ (1-params[\"alpha\"])*G_old\n", " G_tau_old = S.G_tau.copy()\n", " S.G_tau << make_gf_dlr_imtime(S.G_iw)\n", - " error = np.mean(np.abs((S.G_tau[\"up\"].real.data[:,0,0] - G_tau_old[\"up\"].real.data[:,0,0]) / G_tau_old[\"up\"].real.data[:,0,0]))\n", - "\n", + " error = np.max(np.abs((S.G_tau[\"up\"].data[:,0,0] - G_tau_old[\"up\"].data[:,0,0]))) # Compute absolute error\n", " iter += 1\n", - " if iter % 5 == 0:\n", - " print(error, iter)\n", + "\n", + " print(\"Iteration:\", iter, \"Error:\", error)\n", " if iter > params[\"max_iter\"]:\n", " print(\"Maximum number of iterations reached without convergence\")\n", " break" @@ -743,13 +738,15 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 116, "id": "50b5146d", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -759,20 +756,27 @@ } ], "source": [ + "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense imaginary time grid\n", + "\n", "plt.figure(figsize = (10,10))\n", - "oplot(S.G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G$\")\n", + "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", + "oplot(G_tau[\"up\"].real, marker = \"o\", markeredgecolor = \"black\", label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR nodes)\")\n", + "plt.ylabel(\"\")\n", + "plt.legend(loc=\"upper right\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 121, "id": "65fb461e", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -782,20 +786,26 @@ } ], "source": [ + "G_iw_dense = make_gf_imfreq(G_iw[\"up\"], n_iw = 5000) # Obtain DLR expansion on dense Matsubara frequency grid\n", + "\n", "plt.figure(figsize = (10,10))\n", - "oplot(S.G_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G$\")\n", + "oplot(G_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $G(i \\omega_n)$ (DLR)\")\n", + "plt.xlim(-30,30)\n", + "plt.ylabel(\"\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 122, "id": "e8703f85", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -805,32 +815,40 @@ } ], "source": [ + "Sigma_iw_dense = make_gf_imfreq(Sigma_iw[\"up\"], n_iw = 5000) # Obtain DLR expansion of self-energy on dense Matsubara frequency grid\n", + "\n", "plt.figure(figsize = (10,10))\n", - "oplot(S.Sigma_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$\\Sigma$\")\n", + "oplot(Sigma_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $\\Sigma(i \\omega_n)$ (DLR)\")\n", + "plt.xlim(-30,30)\n", + "plt.ylabel(\"\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 123, "id": "1fa86573", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "G_w = Gf(mesh=MeshReFreq(window = (-5.0,5.0), n_w=1000), target_shape=[1,1])\n", "G_iw = make_gf_imfreq(S.G_iw[\"up\"], n_iw = 2**14+3)\n", - "G_w.set_from_pade(G_iw, 100, 0.01)" + "G_w.set_from_pade(G_iw, 100, 0.01) # Pade analytic continuation" ] }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 124, "id": "f18b5166", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -841,16 +859,17 @@ ], "source": [ "plt.figure(figsize = (10,10))\n", - "oplot(-np.imag(G_w)/np.pi, marker = \"o\", markeredgecolor = \"black\", name = r\"$A(\\omega)$\")\n", + "oplot(-np.imag(G_w)/np.pi, marker = \"o\", markeredgecolor = \"black\", label = r\"$A(\\omega)$\")\n", + "plt.ylabel(\"\")\n", "plt.show()" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "triqskernel", "language": "python", - "name": "python3" + "name": "triqskernel" }, "language_info": { "codemirror_mode": { @@ -862,7 +881,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.13" } }, "nbformat": 4, From 55367bf6891c58eb46a048bdbeadb56ae18de123 Mon Sep 17 00:00:00 2001 From: Jason Kaye Date: Wed, 30 Jul 2025 18:28:04 -0400 Subject: [PATCH 5/8] make exercise and solution text consistent --- ModelDMFT/06-Discrete_Lehman_Representation.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb index c0fc001..b0c8eb8 100644 --- a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb +++ b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb @@ -85,7 +85,7 @@ "source": [ "### Exercise 2 \n", "\n", - "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. How can you give a Pad\\'e approximate of $A(\\omega)$ after evaluating on the DLR grid?\n", + "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. Then obtain a Padé approximation of the spectral function $A(\\omega)$.\n", "\n" ] } From 277a58c4e4fe8fd3d5338d5978bb74495695d0c0 Mon Sep 17 00:00:00 2001 From: Jason Kaye Date: Wed, 13 Aug 2025 16:33:21 -0400 Subject: [PATCH 6/8] split DLR tutorial into a tutorial and two examples --- Examples/iptdmft_dlr.ipynb | 307 ++++++++++++++++++ .../syk_dlr_cooling.ipynb | 261 +-------------- .../06-Discrete_Lehman_Representation.ipynb | 114 ------- ModelDMFT/06-SYK_DLR.ipynb | 66 ++++ ModelDMFT/solutions/06s-SYK_DLR.ipynb | 253 +++++++++++++++ 5 files changed, 640 insertions(+), 361 deletions(-) create mode 100644 Examples/iptdmft_dlr.ipynb rename ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb => Examples/syk_dlr_cooling.ipynb (71%) delete mode 100644 ModelDMFT/06-Discrete_Lehman_Representation.ipynb create mode 100644 ModelDMFT/06-SYK_DLR.ipynb create mode 100644 ModelDMFT/solutions/06s-SYK_DLR.ipynb diff --git a/Examples/iptdmft_dlr.ipynb b/Examples/iptdmft_dlr.ipynb new file mode 100644 index 0000000..9a39c35 --- /dev/null +++ b/Examples/iptdmft_dlr.ipynb @@ -0,0 +1,307 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "329ad08d", + "metadata": {}, + "source": [ + "# Solution of the IPT-DMFT equations using the Discrete Lehman Representation\n", + "\n", + "This example is similar to Tutorial 1 in the ModelDMFT folder, but uses the discrete Lehmann representation (DLR) to represent the Green's functions and self-energies. Try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. Then obtain a Padé approximation of the spectral function $A(\\omega)$. For more information about the IPT equations, [(here)](https://doi.org/10.1103/PhysRevB.86.085133) is a good first reference, which this example follows closely." + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "ba3aecc3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "\n", + "from triqs.gf import *\n", + "import numpy as np\n", + "from triqs.operators import *\n", + "\n", + "class IPTSolver:\n", + " def __init__(self, params):\n", + " self.params = params\n", + " # Matsubara frequency Green's functions\n", + " iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps =params[\"dlr_err\"], symmetrize = True)\n", + " self.G_iw = BlockGf(mesh=iw_mesh, gf_struct = [('up',1), ('dn',1)] )\n", + " self.G0_iw = self.G_iw.copy() # self.G0 will be set by the user after initialization\n", + " self.Sigma_iw = self.G_iw.copy()\n", + "\n", + " # Imaginary time\n", + " tau_mesh = MeshDLRImTime(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps =params[\"dlr_err\"], symmetrize = True)\n", + " self.G0_tau = BlockGf(mesh=tau_mesh, gf_struct = [('up',1), ('dn',1)] )\n", + " self.G_tau = self.G0_tau.copy()\n", + " self.Sigma_tau = self.G0_tau.copy()\n", + "\n", + " def solve(self):\n", + " error = 1.0\n", + " iter = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "0287d987", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.5,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"U\" : 3.0, # In the Mott state, U > 4, you run into trouble, but this is also why the IPT tutorial just stops at small iteration number. \n", + " \"t\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "bc6182a2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Green Function G composed of 2 blocks: \n", + " Greens Function G_up with mesh DLR imfreq mesh of size 36 with beta = 50, statistic = Fermion, w_max = 10, eps = 1e-08 and target_shape (1, 1): \n", + " \n", + " Greens Function G_dn with mesh DLR imfreq mesh of size 36 with beta = 50, statistic = Fermion, w_max = 10, eps = 1e-08 and target_shape (1, 1): \n", + " " + ] + }, + "execution_count": 113, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S = IPTSolver(params)\n", + "S.G_iw << SemiCircular(2*params[\"t\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "4d32a671", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 1 Error: 0.4994691601105864\n", + "Iteration: 2 Error: 0.013218442183916101\n", + "Iteration: 3 Error: 0.006275825531574575\n", + "Iteration: 4 Error: 0.002993884912959155\n", + "Iteration: 5 Error: 0.0014307653808706133\n", + "Iteration: 6 Error: 0.0006841141729723721\n", + "Iteration: 7 Error: 0.00032711102854793284\n", + "Iteration: 8 Error: 0.0001563808101129327\n", + "Iteration: 9 Error: 7.474213040459254e-05\n", + "Iteration: 10 Error: 3.571384048717263e-05\n", + "Iteration: 11 Error: 1.719079397405343e-05\n", + "Iteration: 12 Error: 8.315824688021056e-06\n", + "Iteration: 13 Error: 4.021901271578088e-06\n", + "Iteration: 14 Error: 1.9448479028350008e-06\n", + "Iteration: 15 Error: 9.403252946849072e-07\n", + "Iteration: 16 Error: 4.545876733930143e-07\n", + "Iteration: 17 Error: 2.197414414872867e-07\n", + "Iteration: 18 Error: 1.0621059087778661e-07\n", + "Iteration: 19 Error: 5.1332351869159965e-08\n", + "Iteration: 20 Error: 2.4807740583998594e-08\n", + "Iteration: 21 Error: 1.1988382841998657e-08\n", + "Iteration: 22 Error: 5.7931588970383554e-09\n" + ] + } + ], + "source": [ + "error = 1.0\n", + "iter = 0\n", + "while error > params[\"threshold\"]:\n", + " for block, g in S.G0_iw:\n", + " g << inverse( iOmega_n - params[\"t\"]**2 * S.G_iw[block] )\n", + " S.G0_tau << make_gf_dlr_imtime(S.G0_iw)\n", + " S.Sigma_tau << (params[\"U\"]**2) * S.G0_tau * S.G0_tau * S.G0_tau\n", + " S.Sigma_iw << make_gf_dlr_imfreq(S.Sigma_tau)\n", + " G_old = S.G_iw.copy()\n", + " S.G_iw << inverse(inverse(S.G0_iw) - S.Sigma_iw)\n", + " S.G_iw << params[\"alpha\"]*S.G_iw+ (1-params[\"alpha\"])*G_old\n", + " G_tau_old = S.G_tau.copy()\n", + " S.G_tau << make_gf_dlr_imtime(S.G_iw)\n", + " error = np.max(np.abs((S.G_tau[\"up\"].data[:,0,0] - G_tau_old[\"up\"].data[:,0,0]))) # Compute absolute error\n", + " iter += 1\n", + "\n", + " print(\"Iteration:\", iter, \"Error:\", error)\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "50b5146d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense imaginary time grid\n", + "\n", + "plt.figure(figsize = (10,10))\n", + "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", + "oplot(G_tau[\"up\"].real, marker = \"o\", markeredgecolor = \"black\", label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR nodes)\")\n", + "plt.ylabel(\"\")\n", + "plt.legend(loc=\"upper right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "65fb461e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G_iw_dense = make_gf_imfreq(G_iw[\"up\"], n_iw = 5000) # Obtain DLR expansion on dense Matsubara frequency grid\n", + "\n", + "plt.figure(figsize = (10,10))\n", + "oplot(G_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $G(i \\omega_n)$ (DLR)\")\n", + "plt.xlim(-30,30)\n", + "plt.ylabel(\"\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "id": "e8703f85", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Sigma_iw_dense = make_gf_imfreq(Sigma_iw[\"up\"], n_iw = 5000) # Obtain DLR expansion of self-energy on dense Matsubara frequency grid\n", + "\n", + "plt.figure(figsize = (10,10))\n", + "oplot(Sigma_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $\\Sigma(i \\omega_n)$ (DLR)\")\n", + "plt.xlim(-30,30)\n", + "plt.ylabel(\"\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "1fa86573", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "G_w = Gf(mesh=MeshReFreq(window = (-5.0,5.0), n_w=1000), target_shape=[1,1])\n", + "G_iw = make_gf_imfreq(S.G_iw[\"up\"], n_iw = 2**14+3)\n", + "G_w.set_from_pade(G_iw, 100, 0.01) # Pade analytic continuation" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "f18b5166", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(-np.imag(G_w)/np.pi, marker = \"o\", markeredgecolor = \"black\", label = r\"$A(\\omega)$\")\n", + "plt.ylabel(\"\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "triqskernel", + "language": "python", + "name": "triqskernel" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb b/Examples/syk_dlr_cooling.ipynb similarity index 71% rename from ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb rename to Examples/syk_dlr_cooling.ipynb index 228de37..0a0ffca 100644 --- a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb +++ b/Examples/syk_dlr_cooling.ipynb @@ -5,254 +5,9 @@ "id": "329ad08d", "metadata": {}, "source": [ - "# Self-consistent solution of the Dyson equation using the Discrete Lehman Representation\n", + "# Self-consistent solution of the SYK equation using the Discrete Lehman Representation, with progressive cooling\n", "\n", - "The goal of this tutorial is to showcase the use of the discrete Lehmann representation (DLR) to solve the Dyson equation self-consistently (i.e., given an expression for the self-energy in terms of the Green's function). The first exercise will implement a simple self-consistent loop for the Sachdev-Ye-Kitaev (SYK) model, and the second exercise will implement a DMFT calculation using the iterated perturbation theory (IPT) approximation. For background on the DLR and its use in TRIQS, we refer to the [TRIQS documentation](https://triqs.github.io/triqs/latest/userguide/python/tutorials/Basics/solutions/01s-Greens_functions.html#Compact-meshes-for-imaginary-time-/-frequency:-DLR-Green%E2%80%99s-function).\n", - "\n", - " \n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "id": "fee0f10b", - "metadata": {}, - "source": [ - "### Constructing DLR Green's Functions\n", - "\n", - "We begin by setting various parameters, building a DLR imaginary frequency mesh, and creating Green's function and self-energy containers from this mesh. The DLR parameters are the desired accuracy, `dlr_error`, and the problem bandwidth or frequency cutoff, `w_max`. We also set some physical problem parameters, as well as a maximum number of iterations for the self-consistency, a self-consistency convergence tolerance, and a mixing parameter $\\alpha$." - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "id": "f916c67b", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from triqs.gf import *\n", - "from triqs.gf.tools import *\n", - "from triqs.operators import *\n", - "from triqs.gf.block_gf import *\n", - "from triqs.gf.descriptors import Function\n", - "import h5\n", - "import numpy as np\n", - "from triqs.plot.mpl_interface import *\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib as mpl\n", - "import json, sys, os\n", - "\n", - "params = {\n", - " \"beta\": 1000.0,\n", - " \"mu\": 0.0,\n", - " \"alpha\" : 0.75,\n", - " \"w_max\": 5.0,\n", - " \"dlr_err\": 1e-8, \n", - " \"J\" : 1.0,\n", - " \"max_iter\": 1000,\n", - " \"threshold\": 1e-8,\n", - "}\n", - "\n", - "gf_struct =[('up',1), ('dn',1)]\n", - "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", - "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", - "G_tau = make_gf_dlr_imtime(G_iw)\n", - "Sigma_iw = G_iw.copy()\n", - "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" - ] - }, - { - "cell_type": "markdown", - "id": "d5547d81", - "metadata": {}, - "source": [ - "### Exercise 1 \n", - "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", - "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", - "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", - " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", - "\\begin{equation}\n", - "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau).\n", - "\\end{equation}\n", - "Combining this self-energy with the Dyson equation yields a self-consistent set of equations. These were solved using the DLR with weighted fixed point iteration in Sec. VII of [(this paper)](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.105.235115). Following that reference, it is your turn to write a self-consistent loop to solve for $G$.\n", - "\n", - "As shown in the paper, as we approach the $\\beta = \\infty$ limit, the result should begin to match the conformal solution of these equations. Try comparing to the conformal solution! We should already have quite good agreement at $\\beta = 1000$.\n", - "\\begin{equation}\n", - "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", - "\\end{equation}" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "id": "5711f528", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration: 1 Error: 0.09365042856331773\n", - "Iteration: 2 Error: 0.023890918571245603\n", - "Iteration: 3 Error: 0.01772142056085254\n", - "Iteration: 4 Error: 0.012252912807243714\n", - "Iteration: 5 Error: 0.006978087034360904\n", - "Iteration: 6 Error: 0.0030978880192437525\n", - "Iteration: 7 Error: 0.001187108305732671\n", - "Iteration: 8 Error: 0.000452914315013514\n", - "Iteration: 9 Error: 0.0002086765906473831\n", - "Iteration: 10 Error: 0.00012219373055782912\n", - "Iteration: 11 Error: 7.295182635136399e-05\n", - "Iteration: 12 Error: 4.4238366217141945e-05\n", - "Iteration: 13 Error: 2.7150527487362908e-05\n", - "Iteration: 14 Error: 1.6816989099333046e-05\n", - "Iteration: 15 Error: 1.0655920738511515e-05\n", - "Iteration: 16 Error: 6.883502771670713e-06\n", - "Iteration: 17 Error: 4.471739080247339e-06\n", - "Iteration: 18 Error: 2.919701448056422e-06\n", - "Iteration: 19 Error: 1.9151486679303e-06\n", - "Iteration: 20 Error: 1.2615741412647097e-06\n", - "Iteration: 21 Error: 8.343275522681992e-07\n", - "Iteration: 22 Error: 5.538040315222759e-07\n", - "Iteration: 23 Error: 3.6886194482166346e-07\n", - "Iteration: 24 Error: 2.4646772006642337e-07\n", - "Iteration: 25 Error: 1.6517766893153762e-07\n", - "Iteration: 26 Error: 1.1100690222587417e-07\n", - "Iteration: 27 Error: 7.485517272698416e-08\n", - "Iteration: 28 Error: 5.154431464982068e-08\n", - "Iteration: 29 Error: 3.5582131185929455e-08\n", - "Iteration: 30 Error: 2.4621169880667537e-08\n", - "Iteration: 31 Error: 1.7074547498108217e-08\n", - "Iteration: 32 Error: 1.1865782356679233e-08\n", - "Iteration: 33 Error: 8.262231676603449e-09\n" - ] - } - ], - "source": [ - "G_iw << SemiCircular(1.0) # Initial guess for the Green's function \n", - "G_tau << make_gf_dlr_imtime(G_iw) # Initial guess in the imaginary time domain\n", - "error = 1.0\n", - "iter = 0\n", - "\n", - "while error > params[\"threshold\"]:\n", - " for block, g in G_tau:\n", - " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2 * g.data[:,0,0]**2*np.flip(g.data[:,0,0]) # Compute self-energy in imaginary time\n", - "\n", - " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) # Transform self-energy to Matsubara frequency domain \n", - "\n", - " for block, g in G_tau:\n", - " G_iw[block] << inverse(iOmega_n - Sigma_iw[block]) # Solve the Dyson equation to obtain Green's function\n", - " G_old = G_tau.copy()\n", - " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw) # Update Green's function via weighted fixed point iteration\n", - " error = np.max(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]))) # Compute absolute error\n", - " iter += 1\n", - "\n", - " # Print iteration number and error\n", - " print(\"Iteration:\", iter, \"Error:\", error)\n", - " if iter > params[\"max_iter\"]:\n", - " print(\"Maximum number of iterations reached without convergence\")\n", - " break" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "id": "c0669c9e", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense imaginary time grid\n", - "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", - "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", - "\n", - "plt.figure(figsize = (10,10))\n", - "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", - "oplot(G_tau[\"up\"].real, marker = \"o\", markeredgecolor = \"black\", label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR nodes)\")\n", - "plt.plot(t, Gconformal, label = r\"$G_c(\\tau)$\", color = \"red\", linestyle = \"dashed\")\n", - "plt.ylim(-0.5,0)\n", - "plt.ylabel(\"\")\n", - "plt.legend(loc=\"upper left\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f76bdb41-bb7f-4aea-8061-ec627d77e4dd", - "metadata": { - "tags": [] - }, - "source": [ - "Note that in this case, the Green's function is purely real. We observe a slight discrepancy with the conformal solution at the endpoints (which is expected---see the reference). You can experiment with increasing $\\beta$ (it might be necessary to increase the mixing parameter $\\alpha$ in order to converge), and should observe even closer agreement with the conformal solution. We can also plot the self-energy in Matsubara frequency, which is purely imaginary:" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "id": "f728e5fc", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Sigma_iw_dense = make_gf_imfreq(Sigma_iw[\"up\"], n_iw = 5000) # Obtain DLR expansion on dense Matsubara frequency grid\n", - "\n", - "plt.figure(figsize = (10,10))\n", - "oplot(Sigma_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $\\Sigma(i \\omega_n)$ (DLR)\")\n", - "plt.xlim(-30,30)\n", - "plt.ylabel(\"\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "da1cf458", - "metadata": {}, - "source": [ - "### Optional Exercise 1b\n", - "\n", - "For more complicated systems, one often need to take a higher $T$ solution as a guess and continue lowering $T$. Here, one can try approaching the $\\beta = \\infty$ limit through `cooling' your solution. See if your result will also begin to match the conformal solution to these equations at lower temperatures. Here steps of $\\Delta \\beta = 100$ or so may work, although it may need to be much smaller for more complicated problems.\n", - "HINT: Ask yourself, how do you evaluate DLR data to a new mesh at a larger $\\beta$? " + "This example is similar to the tutorial \"Self-consistent solution of the SYK equation using the Discrete Lehmann Representation\", but it reaches low temperatures by using the calculation for a larger temperature as an initial guess for the next lowest temperature. While this does not appear to be necessary for the SYK model solves using fixed point iteration with mixing, it can be required in more complicated settings, and it is useful to see how the solution using a DLR grid for one temperature can be interpolated to a DLR grid for a lower temperature. " ] }, { @@ -482,6 +237,18 @@ } ], "source": [ + "from triqs.gf import *\n", + "from triqs.gf.tools import *\n", + "from triqs.operators import *\n", + "from triqs.gf.block_gf import *\n", + "from triqs.gf.descriptors import Function\n", + "import h5\n", + "import numpy as np\n", + "from triqs.plot.mpl_interface import *\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import json, sys, os\n", + "\n", "params = {\n", " \"beta\": 500.0,\n", " \"mu\": 0.0,\n", diff --git a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb deleted file mode 100644 index b0c8eb8..0000000 --- a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb +++ /dev/null @@ -1,114 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "329ad08d", - "metadata": {}, - "source": [ - "# Self-consistent solution of the Dyson equation using the Discrete Lehman Representation\n", - "\n", - "The goal of this tutorial is to showcase the use of the discrete Lehmann representation (DLR) to solve the Dyson equation self-consistently (i.e., given an expression for the self-energy in terms of the Green's function). The first exercise will implement a simple self-consistent loop for the Sachdev-Ye-Kitaev (SYK) model, and the second exercise will implement a DMFT calculation using the iterated perturbation theory (IPT) approximation. For background on the DLR and its use in TRIQS, we refer to the [TRIQS documentation](https://triqs.github.io/triqs/latest/userguide/python/tutorials/Basics/solutions/01s-Greens_functions.html#Compact-meshes-for-imaginary-time-/-frequency:-DLR-Green%E2%80%99s-function).\n", - "\n", - " \n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "id": "fee0f10b", - "metadata": {}, - "source": [ - "### Constructing DLR Green's Functions\n", - "\n", - "We begin by setting various parameters, building a DLR imaginary frequency mesh, and creating Green's function and self-energy containers from this mesh. The DLR parameters are the desired accuracy, `dlr_error`, and the problem bandwidth or frequency cutoff, `w_max`. We also set some physical problem parameters, as well as a maximum number of iterations for the self-consistency, a self-consistency convergence tolerance, and a mixing parameter $\\alpha$." - ] - }, - { - "cell_type": "markdown", - "id": "d5547d81", - "metadata": {}, - "source": [ - "### Exercise 1 \n", - "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", - "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", - "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", - " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", - "\\begin{equation}\n", - "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau).\n", - "\\end{equation}\n", - "Combining this self-energy with the Dyson equation yields a self-consistent set of equations. These were solved using the DLR with weighted fixed point iteration in Sec. VII of [(this paper)](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.105.235115). Following that reference, it is your turn to write a self-consistent loop to solve for $G$.\n", - "\n", - "As shown in the paper, as we approach the $\\beta = \\infty$ limit, the result should begin to match the conformal solution of these equations. Try comparing to the conformal solution! We should already have quite good agreement at $\\beta = 1000$.\n", - "\\begin{equation}\n", - "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", - "\\end{equation}" - ] - }, - { - "cell_type": "markdown", - "id": "f76bdb41-bb7f-4aea-8061-ec627d77e4dd", - "metadata": { - "tags": [] - }, - "source": [ - "Note that in this case, the Green's function is purely real. We observe a slight discrepancy with the conformal solution at the endpoints (which is expected---see the reference). You can experiment with increasing $\\beta$ (it might be necessary to increase the mixing parameter $\\alpha$ in order to converge), and should observe even closer agreement with the conformal solution. We can also plot the self-energy in Matsubara frequency, which is purely imaginary:" - ] - }, - { - "cell_type": "markdown", - "id": "da1cf458", - "metadata": {}, - "source": [ - "### Optional Exercise 1b\n", - "\n", - "For more complicated systems, one often need to take a higher $T$ solution as a guess and continue lowering $T$. Here, one can try approaching the $\\beta = \\infty$ limit through `cooling' your solution. See if your result will also begin to match the conformal solution to these equations at lower temperatures. Here steps of $\\Delta \\beta = 100$ or so may work, although it may need to be much smaller for more complicated problems.\n", - "HINT: Ask yourself, how do you evaluate DLR data to a new mesh at a larger $\\beta$? " - ] - }, - { - "cell_type": "markdown", - "id": "45fedad2", - "metadata": {}, - "source": [ - "### Exercise 2 \n", - "\n", - "Next try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. Check how much quicker your calculations are compared to Tutorial 1. Then obtain a Padé approximation of the spectral function $A(\\omega)$.\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/ModelDMFT/06-SYK_DLR.ipynb b/ModelDMFT/06-SYK_DLR.ipynb new file mode 100644 index 0000000..0f7f357 --- /dev/null +++ b/ModelDMFT/06-SYK_DLR.ipynb @@ -0,0 +1,66 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "329ad08d", + "metadata": {}, + "source": [ + "# Self-consistent solution of the SYK equation using the Discrete Lehmann Representation\n", + "\n", + "The goal of this tutorial is to showcase the use of the discrete Lehmann representation (DLR) to solve the Dyson equation self-consistently (i.e., given an expression for the self-energy in terms of the Green's function), by implementing a simple self-consistent loop for the Sachdev-Ye-Kitaev (SYK) model. For background on the DLR and its use in TRIQS, we refer to the [TRIQS documentation](https://triqs.github.io/triqs/latest/userguide/python/tutorials/Basics/solutions/01s-Greens_functions.html#Compact-meshes-for-imaginary-time-/-frequency:-DLR-Green%E2%80%99s-function). We note that although this is not a DMFT calculation, some of the main steps (Fourier transform between imaginary time and Matsubara frequency, solving the Dyson equation) are similar to those in a DMFT calculation." + ] + }, + { + "cell_type": "markdown", + "id": "fee0f10b", + "metadata": {}, + "source": [ + "### Constructing DLR Green's Functions\n", + "\n", + "We begin by setting various parameters, building a DLR imaginary frequency mesh, and creating Green's function and self-energy containers from this mesh. The DLR parameters are the desired accuracy, `dlr_error`, and the problem bandwidth or frequency cutoff, `w_max`. We also set some physical problem parameters, as well as a maximum number of iterations for the self-consistency, a self-consistency convergence tolerance, and a mixing parameter $\\alpha$." + ] + }, + { + "cell_type": "markdown", + "id": "d5547d81", + "metadata": {}, + "source": [ + "### Exercise 1 \n", + "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", + "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", + "\\begin{equation}\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau).\n", + "\\end{equation}\n", + "Combining this self-energy with the Dyson equation yields a self-consistent set of equations. These were solved using the DLR with weighted fixed point iteration in Sec. VII of [(this paper)](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.105.235115). Following that reference, it is your turn to write a self-consistent loop to solve for $G$.\n", + "\n", + "As shown in the paper, as we approach the $\\beta = \\infty$ limit, the result should begin to match the conformal solution of these equations. Try comparing to the conformal solution! We should already have quite good agreement at $\\beta = 1000$.\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ModelDMFT/solutions/06s-SYK_DLR.ipynb b/ModelDMFT/solutions/06s-SYK_DLR.ipynb new file mode 100644 index 0000000..6a67b55 --- /dev/null +++ b/ModelDMFT/solutions/06s-SYK_DLR.ipynb @@ -0,0 +1,253 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "329ad08d", + "metadata": {}, + "source": [ + "# Self-consistent solution of the SYK equation using the Discrete Lehmann Representation\n", + "\n", + "The goal of this tutorial is to showcase the use of the discrete Lehmann representation (DLR) to solve the Dyson equation self-consistently (i.e., given an expression for the self-energy in terms of the Green's function), by implementing a simple self-consistent loop for the Sachdev-Ye-Kitaev (SYK) model. For background on the DLR and its use in TRIQS, we refer to the [TRIQS documentation](https://triqs.github.io/triqs/latest/userguide/python/tutorials/Basics/solutions/01s-Greens_functions.html#Compact-meshes-for-imaginary-time-/-frequency:-DLR-Green%E2%80%99s-function). We note that although this is not a DMFT calculation, some of the main steps (Fourier transform between imaginary time and Matsubara frequency, solving the Dyson equation) are similar to those in a DMFT calculation." + ] + }, + { + "cell_type": "markdown", + "id": "fee0f10b", + "metadata": {}, + "source": [ + "### Constructing DLR Green's Functions\n", + "\n", + "We begin by setting various parameters, building a DLR imaginary frequency mesh, and creating Green's function and self-energy containers from this mesh. The DLR parameters are the desired accuracy, `dlr_error`, and the problem bandwidth or frequency cutoff, `w_max`. We also set some physical problem parameters, as well as a maximum number of iterations for the self-consistency, a self-consistency convergence tolerance, and a mixing parameter $\\alpha$." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "f916c67b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from triqs.gf import *\n", + "from triqs.gf.tools import *\n", + "from triqs.operators import *\n", + "from triqs.gf.block_gf import *\n", + "from triqs.gf.descriptors import Function\n", + "import h5\n", + "import numpy as np\n", + "from triqs.plot.mpl_interface import *\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import json, sys, os\n", + "\n", + "params = {\n", + " \"beta\": 1000.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.75,\n", + " \"w_max\": 5.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}\n", + "\n", + "gf_struct =[('up',1), ('dn',1)]\n", + "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + "G_tau = make_gf_dlr_imtime(G_iw)\n", + "Sigma_iw = G_iw.copy()\n", + "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" + ] + }, + { + "cell_type": "markdown", + "id": "d5547d81", + "metadata": {}, + "source": [ + "### Exercise 1 \n", + "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", + "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", + "\\begin{equation}\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau).\n", + "\\end{equation}\n", + "Combining this self-energy with the Dyson equation yields a self-consistent set of equations. These were solved using the DLR with weighted fixed point iteration in Sec. VII of [(this paper)](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.105.235115). Following that reference, it is your turn to write a self-consistent loop to solve for $G$.\n", + "\n", + "As shown in the paper, as we approach the $\\beta = \\infty$ limit, the result should begin to match the conformal solution of these equations. Try comparing to the conformal solution! We should already have quite good agreement at $\\beta = 1000$.\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "5711f528", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 1 Error: 0.09365042856331773\n", + "Iteration: 2 Error: 0.023890918571245603\n", + "Iteration: 3 Error: 0.01772142056085254\n", + "Iteration: 4 Error: 0.012252912807243714\n", + "Iteration: 5 Error: 0.006978087034360904\n", + "Iteration: 6 Error: 0.0030978880192437525\n", + "Iteration: 7 Error: 0.001187108305732671\n", + "Iteration: 8 Error: 0.000452914315013514\n", + "Iteration: 9 Error: 0.0002086765906473831\n", + "Iteration: 10 Error: 0.00012219373055782912\n", + "Iteration: 11 Error: 7.295182635136399e-05\n", + "Iteration: 12 Error: 4.4238366217141945e-05\n", + "Iteration: 13 Error: 2.7150527487362908e-05\n", + "Iteration: 14 Error: 1.6816989099333046e-05\n", + "Iteration: 15 Error: 1.0655920738511515e-05\n", + "Iteration: 16 Error: 6.883502771670713e-06\n", + "Iteration: 17 Error: 4.471739080247339e-06\n", + "Iteration: 18 Error: 2.919701448056422e-06\n", + "Iteration: 19 Error: 1.9151486679303e-06\n", + "Iteration: 20 Error: 1.2615741412647097e-06\n", + "Iteration: 21 Error: 8.343275522681992e-07\n", + "Iteration: 22 Error: 5.538040315222759e-07\n", + "Iteration: 23 Error: 3.6886194482166346e-07\n", + "Iteration: 24 Error: 2.4646772006642337e-07\n", + "Iteration: 25 Error: 1.6517766893153762e-07\n", + "Iteration: 26 Error: 1.1100690222587417e-07\n", + "Iteration: 27 Error: 7.485517272698416e-08\n", + "Iteration: 28 Error: 5.154431464982068e-08\n", + "Iteration: 29 Error: 3.5582131185929455e-08\n", + "Iteration: 30 Error: 2.4621169880667537e-08\n", + "Iteration: 31 Error: 1.7074547498108217e-08\n", + "Iteration: 32 Error: 1.1865782356679233e-08\n", + "Iteration: 33 Error: 8.262231676603449e-09\n" + ] + } + ], + "source": [ + "G_iw << SemiCircular(1.0) # Initial guess for the Green's function \n", + "G_tau << make_gf_dlr_imtime(G_iw) # Initial guess in the imaginary time domain\n", + "error = 1.0\n", + "iter = 0\n", + "\n", + "while error > params[\"threshold\"]:\n", + " for block, g in G_tau:\n", + " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2 * g.data[:,0,0]**2*np.flip(g.data[:,0,0]) # Compute self-energy in imaginary time\n", + "\n", + " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) # Transform self-energy to Matsubara frequency domain \n", + "\n", + " for block, g in G_tau:\n", + " G_iw[block] << inverse(iOmega_n - Sigma_iw[block]) # Solve the Dyson equation to obtain Green's function\n", + " G_old = G_tau.copy()\n", + " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw) # Update Green's function via weighted fixed point iteration\n", + " error = np.max(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]))) # Compute absolute error\n", + " iter += 1\n", + "\n", + " # Print iteration number and error\n", + " print(\"Iteration:\", iter, \"Error:\", error)\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "c0669c9e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G_tau_dense = make_gf_imtime(G_tau[\"up\"], n_tau=1000) # Obtain DLR expansion on dense imaginary time grid\n", + "t = np.array([x.real for x in G_tau_dense.mesh.values()])[1:] # Obtain dense grid\n", + "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"])) # Conformal solution\n", + "\n", + "plt.figure(figsize = (10,10))\n", + "oplot(G_tau_dense.real, label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR)\")\n", + "oplot(G_tau[\"up\"].real, marker = \"o\", markeredgecolor = \"black\", label = r\"$\\mathrm{Re}\\, G(\\tau)$ (DLR nodes)\")\n", + "plt.plot(t, Gconformal, label = r\"$G_c(\\tau)$\", color = \"red\", linestyle = \"dashed\")\n", + "plt.ylim(-0.5,0)\n", + "plt.ylabel(\"\")\n", + "plt.legend(loc=\"upper left\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f76bdb41-bb7f-4aea-8061-ec627d77e4dd", + "metadata": { + "tags": [] + }, + "source": [ + "Note that in this case, the Green's function is purely real. We observe a slight discrepancy with the conformal solution at the endpoints (which is expected---see the reference). You can experiment with increasing $\\beta$ (it might be necessary to increase the mixing parameter $\\alpha$ in order to converge), and should observe even closer agreement with the conformal solution. We can also plot the self-energy in Matsubara frequency, which is purely imaginary:" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "f728e5fc", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Sigma_iw_dense = make_gf_imfreq(Sigma_iw[\"up\"], n_iw = 5000) # Obtain DLR expansion on dense Matsubara frequency grid\n", + "\n", + "plt.figure(figsize = (10,10))\n", + "oplot(Sigma_iw_dense.imag, marker = \"o\", markeredgecolor = \"red\", markersize=2, linestyle=\"none\", label = r\"Im $\\Sigma(i \\omega_n)$ (DLR)\")\n", + "plt.xlim(-30,30)\n", + "plt.ylabel(\"\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "triqskernel", + "language": "python", + "name": "triqskernel" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 929e83046da0ae73190db2623c95f04ab47ffdc6 Mon Sep 17 00:00:00 2001 From: Andrew Hardy Date: Tue, 26 Aug 2025 07:26:55 -0400 Subject: [PATCH 7/8] typos in description --- ModelDMFT/06-SYK_DLR.ipynb | 4 ++-- ModelDMFT/solutions/06s-SYK_DLR.ipynb | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ModelDMFT/06-SYK_DLR.ipynb b/ModelDMFT/06-SYK_DLR.ipynb index 0f7f357..2e4b622 100644 --- a/ModelDMFT/06-SYK_DLR.ipynb +++ b/ModelDMFT/06-SYK_DLR.ipynb @@ -26,8 +26,8 @@ "metadata": {}, "source": [ "### Exercise 1 \n", - "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", - "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "We first solve the $0+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", + "$$H = \\frac{1}{(2N)^3/2}\\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", "\\begin{equation}\n", diff --git a/ModelDMFT/solutions/06s-SYK_DLR.ipynb b/ModelDMFT/solutions/06s-SYK_DLR.ipynb index 6a67b55..737d6b5 100644 --- a/ModelDMFT/solutions/06s-SYK_DLR.ipynb +++ b/ModelDMFT/solutions/06s-SYK_DLR.ipynb @@ -66,8 +66,8 @@ "metadata": {}, "source": [ "### Exercise 1 \n", - "We first solve the $O+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", - "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "We first solve the $0+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", + "$$H = \\frac{1}{(2N)^3/2}\\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", "\\begin{equation}\n", From eea808f182e59c28b9fe095f80e05082d2674696 Mon Sep 17 00:00:00 2001 From: Andrew Hardy Date: Tue, 26 Aug 2025 07:30:43 -0400 Subject: [PATCH 8/8] exponent typo --- ModelDMFT/06-SYK_DLR.ipynb | 2 +- ModelDMFT/solutions/06s-SYK_DLR.ipynb | 86 +++++++++++++-------------- 2 files changed, 44 insertions(+), 44 deletions(-) diff --git a/ModelDMFT/06-SYK_DLR.ipynb b/ModelDMFT/06-SYK_DLR.ipynb index 2e4b622..bb9a8fe 100644 --- a/ModelDMFT/06-SYK_DLR.ipynb +++ b/ModelDMFT/06-SYK_DLR.ipynb @@ -27,7 +27,7 @@ "source": [ "### Exercise 1 \n", "We first solve the $0+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", - "$$H = \\frac{1}{(2N)^3/2}\\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "$$H = \\frac{1}{(2N)^{3/2}}\\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", "\\begin{equation}\n", diff --git a/ModelDMFT/solutions/06s-SYK_DLR.ipynb b/ModelDMFT/solutions/06s-SYK_DLR.ipynb index 737d6b5..c7cacc3 100644 --- a/ModelDMFT/solutions/06s-SYK_DLR.ipynb +++ b/ModelDMFT/solutions/06s-SYK_DLR.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 1, "id": "f916c67b", "metadata": { "tags": [] @@ -67,7 +67,7 @@ "source": [ "### Exercise 1 \n", "We first solve the $0+1$-dimensional (impurity) Sachdev-Ye-Kitaev (SYK) model self-consistently. The Hamiltonian is given by \n", - "$$H = \\frac{1}{(2N)^3/2}\\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "$$H = \\frac{1}{(2N)^{3/2}}\\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", "where the $J_{ijkl}$ are random Gaussian couplings between $N$ fermions with constant variance $J^2$.\n", " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its extensions [(here)](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.94.035004). Here we are interested in a simple form of the self-energy in the large-$N$ limit of the model, given by\n", "\\begin{equation}\n", @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 2, "id": "5711f528", "metadata": { "tags": [] @@ -93,39 +93,39 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration: 1 Error: 0.09365042856331773\n", - "Iteration: 2 Error: 0.023890918571245603\n", - "Iteration: 3 Error: 0.01772142056085254\n", - "Iteration: 4 Error: 0.012252912807243714\n", - "Iteration: 5 Error: 0.006978087034360904\n", - "Iteration: 6 Error: 0.0030978880192437525\n", - "Iteration: 7 Error: 0.001187108305732671\n", - "Iteration: 8 Error: 0.000452914315013514\n", - "Iteration: 9 Error: 0.0002086765906473831\n", - "Iteration: 10 Error: 0.00012219373055782912\n", - "Iteration: 11 Error: 7.295182635136399e-05\n", - "Iteration: 12 Error: 4.4238366217141945e-05\n", - "Iteration: 13 Error: 2.7150527487362908e-05\n", - "Iteration: 14 Error: 1.6816989099333046e-05\n", - "Iteration: 15 Error: 1.0655920738511515e-05\n", - "Iteration: 16 Error: 6.883502771670713e-06\n", - "Iteration: 17 Error: 4.471739080247339e-06\n", - "Iteration: 18 Error: 2.919701448056422e-06\n", - "Iteration: 19 Error: 1.9151486679303e-06\n", - "Iteration: 20 Error: 1.2615741412647097e-06\n", - "Iteration: 21 Error: 8.343275522681992e-07\n", - "Iteration: 22 Error: 5.538040315222759e-07\n", - "Iteration: 23 Error: 3.6886194482166346e-07\n", - "Iteration: 24 Error: 2.4646772006642337e-07\n", - "Iteration: 25 Error: 1.6517766893153762e-07\n", - "Iteration: 26 Error: 1.1100690222587417e-07\n", - "Iteration: 27 Error: 7.485517272698416e-08\n", - "Iteration: 28 Error: 5.154431464982068e-08\n", - "Iteration: 29 Error: 3.5582131185929455e-08\n", - "Iteration: 30 Error: 2.4621169880667537e-08\n", - "Iteration: 31 Error: 1.7074547498108217e-08\n", - "Iteration: 32 Error: 1.1865782356679233e-08\n", - "Iteration: 33 Error: 8.262231676603449e-09\n" + "Iteration: 1 Error: 0.09365042856328878\n", + "Iteration: 2 Error: 0.02389091857123847\n", + "Iteration: 3 Error: 0.017721420560846274\n", + "Iteration: 4 Error: 0.01225291280723799\n", + "Iteration: 5 Error: 0.0069780870343561854\n", + "Iteration: 6 Error: 0.003097888019241102\n", + "Iteration: 7 Error: 0.0011871083057315088\n", + "Iteration: 8 Error: 0.00045291431501309765\n", + "Iteration: 9 Error: 0.00020867659064766064\n", + "Iteration: 10 Error: 0.0001221937305567189\n", + "Iteration: 11 Error: 7.29518263504203e-05\n", + "Iteration: 12 Error: 4.423836621747501e-05\n", + "Iteration: 13 Error: 2.7150527487307397e-05\n", + "Iteration: 14 Error: 1.681698909905549e-05\n", + "Iteration: 15 Error: 1.0655920737845381e-05\n", + "Iteration: 16 Error: 6.883502771559691e-06\n", + "Iteration: 17 Error: 4.471739081024495e-06\n", + "Iteration: 18 Error: 2.9197014490001116e-06\n", + "Iteration: 19 Error: 1.9151486686519448e-06\n", + "Iteration: 20 Error: 1.2615741423749327e-06\n", + "Iteration: 21 Error: 8.343275527122884e-07\n", + "Iteration: 22 Error: 5.538040310781867e-07\n", + "Iteration: 23 Error: 3.6886194437757425e-07\n", + "Iteration: 24 Error: 2.4646771973335646e-07\n", + "Iteration: 25 Error: 1.6517766920909338e-07\n", + "Iteration: 26 Error: 1.1100690316956374e-07\n", + "Iteration: 27 Error: 7.485517372618489e-08\n", + "Iteration: 28 Error: 5.154431514942104e-08\n", + "Iteration: 29 Error: 3.558213140797406e-08\n", + "Iteration: 30 Error: 2.462116999168984e-08\n", + "Iteration: 31 Error: 1.7074547720152822e-08\n", + "Iteration: 32 Error: 1.1865782800768443e-08\n", + "Iteration: 33 Error: 8.262231621092297e-09\n" ] } ], @@ -157,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 3, "id": "c0669c9e", "metadata": { "tags": [] @@ -165,7 +165,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0YAAANGCAYAAADZJJ4YAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC2ZklEQVR4nOzdeXhU9dnG8e+ZJZnsYUlIgEBYBWURQUUxiopLXQrGWLGuLdWqtSpa+xZq9yqtFdFaq9aW1taNNka0aHFHg+KGG6DIYoAAWVhC9tnOOe8fkwQiiwSSnMzk/lxXLpwzZyZPhiE+9/yWY9i2bSMiIiIiItKNuZwuQERERERExGkKRiIiIiIi0u0pGImIiIiISLenYCQiIiIiIt2egpGIiIiIiHR7CkYiIiIiItLtKRiJiIiIiEi3p2AkIiIiIiLdnoKRiIiIiIh0ewpGIiIiIiLS7XVKMHrggQfIzc3F5/Nx/PHH89577x3w/P/85z+MGDECn8/H6NGjeeGFFzqjTBERERER6aY6PBgtWLCAW265hV/84hd8+OGHjB07lrPOOovKysp9nv/2229zySWXMGPGDD766COmTZvGtGnTWLlyZUeXKiIiIiIi3ZRh27bdkd/g+OOP59hjj+VPf/oTAJZlkZOTww9/+EN+8pOf7HX+xRdfTH19PYsWLWo5NnHiRI4++mgeeuihjixVRERERES6KU9HPnkwGGT58uXMmjWr5ZjL5WLKlCksW7Zsn49ZtmwZt9xyS6tjZ511FgsXLtzn+YFAgEAg0HLbsix27txJr169MAzj8H8IERERERGJSrZtU1tbS9++fXG5DjxZrkOD0fbt2zFNkz59+rQ63qdPH1avXr3Px5SXl+/z/PLy8n2eP2fOHH71q1+1T8EiIiIiIhJzSktL6d+//wHP6dBg1BlmzZrVaoSpurqaAQMGUFpaSmpqqoOViYiIiIiIk2pqasjJySElJeVrz+3QYNS7d2/cbjcVFRWtjldUVJCVlbXPx2RlZbXp/Pj4eOLj4/c6npqaqmAkIiIiIiIHtcSmQ3eli4uLY/z48bz66qstxyzL4tVXX+WEE07Y52NOOOGEVucDvPzyy/s9X0RERERE5HB1+FS6W265hSuvvJIJEyZw3HHHce+991JfX893vvMdAK644gr69evHnDlzALjppps45ZRTmDt3Lueeey5PPfUUH3zwAX/5y186ulQREREREemmOjwYXXzxxWzbto2f//znlJeXc/TRR7N48eKWDRY2bdrUaoeIE088kSeeeILbb7+d2bNnM2zYMBYuXMioUaM6ulQREREREemmOvw6Rp2tpqaGtLQ0qqur97vGyLZtwuEwpml2cnUinc/tduPxeLR9vYiIiHQ7B5MNmkX9rnRtFQwGKSsro6GhwelSRDpNYmIi2dnZxMXFOV2KiIiISJfUrYKRZVmUlJTgdrvp27cvcXFx+hRdYppt2wSDQbZt20ZJSQnDhg372oubiYiIiHRH3SoYBYNBLMsiJyeHxMREp8sR6RQJCQl4vV42btxIMBjE5/M5XZKIiIhIl9MtPzrWJ+bS3eg9LyIiInJg6pZERERERKTbUzASEREREZFuT8FIRERERES6PQUjERERERHp9hSM5KDt2LGDzMxMNmzYcFDnT58+nblz53bIc3eEttQrIiIiIrFFwSiKXHXVVRiGgWEYeL1eBg0axI9//GP8fv9hPe+KFSu4/PLL6devH/Hx8QwcOJBzzz2XwsLCVufdcccdTJ06ldzc3IN63ttvv5077riD6urqrz13X8/91Z+3T58+nHHGGcyfPx/LslqdN23atP0+98G+bm2pV0RERERii4JRlDn77LMpKyvjyy+/ZN68eTz88MP84he/OOTnKywsZMKECbhcLp566inWrVvH888/z5QpU/j1r3+NbdsANDQ08Le//Y0ZM2Yc9HOPGjWKIUOG8Nhjjx3wvAM9d/PPu2HDBv73v/9x6qmnctNNN3HeeecRDocPupaDed0Otl4RERERiT3dPhjZtk1DMOzIV3PoaIv4+HiysrLIyclh2rRpTJkyhZdffrnlfsuymDNnDoMGDSIhIYGxY8fuNfLT7KOPPuKSSy5hzpw5PProo+Tl5ZGTk8OoUaOYOXMmn3zyCYZhAPDCCy8QHx/PxIkTWx4/derUlpGYr34999xzAJx//vk89dRTB/yZ9vXcX/15+/XrxzHHHMPs2bN59tln+d///sc//vGPdnvdmh1MvSIiIiISezxOF+C0xpDJkT9/0ZHv/dmvzyIx7tD/ClauXMnbb7/NwIEDW47NmTOHxx57jIceeohhw4bx5ptvctlll5GRkcEpp5zS6vEzZ87kpJNO4pZbbtnn8zeHIoDi4mLGjx/f6v758+cTCoWoq6tj2LBhvPDCC4wbNw6A3r17A3Dcccdxxx13EAgEiI+P3+f32ddzH8hpp53G2LFjKSoq4nvf+95BP67Zvl63ZgdTr4iIiIjEnm4fjKLNokWLSE5OJhwOEwgEcLlc/OlPfwIgEAhw55138sorr3DCCScAMHjwYJYuXcrDDz/cKhht3LiRN954gwULFrQca2xsJCsrC9M0Abj++uu56667Ws7v27dvq1p69eoFwLJlyzAMg7y8PJKTk1ud07dvX4LBIOXl5fsMIvt77q8zYsQIPv3004M+/0CvW1vrFREREZHY0+2DUYLXzWe/Psux791Wp556Kg8++CD19fXMmzcPj8fDhRdeCMC6detoaGjgjDPOaPWYYDDYMpLTbMWKFUBkhKSZ1+tl+fLl2LbNmDFjGD58eMt9jY2N+Hy+fdb06aefkpubu1coAkhISAAi64j250DPvT+2bbca0fo6B3rd2lqviIiIiMSebh+MDMM4rOlsnS0pKYmhQ4cCkalsY8eObdm4oK6uDoDnn3+efv36tXrcV6eF1dbWAuDx7P7ZPR4PQ4cOpaSkBL/fz9ixY1vu6927N1VVVfus6dNPP2XMmDH7vG/nzp0AZGRk7PdnOtBz78/nn3/OoEGDDvr8A71uba1XRERERGJPt998IZq5XC5mz57N7bffTmNjI0ceeSTx8fFs2rSJoUOHtvrKyclp9dijjjoKgKVLl+71vCtXrsTlcjFq1KiWY+PGjeOzzz7bZx0bNmzgiCOO2Od9K1eupH///i1rjvblQM+9L6+99horVqzY54jPwfjq69bWekVEREQk9igYRbmLLroIt9vNAw88QEpKCj/60Y+YOXMmjz76KOvXr+fDDz/k/vvv59FHH231uDFjxnD++edz4403Mn/+fL744gs+//xznnzySX7xi18wYsSIlmllAGeddRarVq3a58iOZVls3LiRLVu27LXTXnFxMWeeeeYBf4YDPXcgEKC8vJwtW7bw4YcfcueddzJ16lTOO+88rrjiipbzqqur+fjjj1t9lZaWHtTr1tZ6RURERCT2KBhFOY/Hww033MBdd91FfX09v/nNb/jZz37GnDlzGDlyJGeffTbPP//8Pqed/ec//2HmzJncc889jBs3jokTJ/LHP/6RgoICiouLW507evRojjnmGP7973/v9Tw33ngjb731FkcccUSrYOT3+1m4cCFXX331AX+GAz334sWLyc7OJjc3l7PPPpvXX3+dP/7xjzz77LO43bvXaC1ZsoRx48a1+vrVr3510K9bW+oVERERkdhj2IdyMZ0urKamhrS0NKqrq0lNTW11n9/vp6SkhEGDBrV5sb9E1i7ddtttLVPtvs6DDz7IM888w0svvdTuz90R2lJvtNF7X0RERLqjA2WDr4qeXQfEceeeey5r165ly5Yte61Z2hev18v999/fIc/dEdpSr4iIiIjEFo0YiXQDeu+LiIhId9SWESOtMRIRERERkW5PwUhERERERLo9BSMREREREen2FIxERERERKTbUzASEREREZFuT8FIRERERES6PQUjERERERHp9hSMRERERESk21MwEhERERGRbk/B6BCZpsmSJUt48sknWbJkCaZpOl1Sh9uxYweZmZls2LDhoM6fPn06c+fO7ZDnjmaTJ0/m5ptvbrfna8vrLCIiIiL7pmB0CIqKihg6OJdTTz2Vb3/725x66qkMHZxLUVFRh37fq666CsMwMAwDr9fLoEGD+PGPf4zf7z+s512xYgWXX345/fr1Iz4+noEDB3LuuedSWFjY6rw77riDqVOnkpube1DPe/vtt3PHHXdQXV39tefu67m/+vP26dOHM844g/nz52NZVqvzpk2btt/n7qjXratoy+ssIiIiIvumYNRGRUVFFBQUMNpXwbIZidTOSmHZjERGJ1RQUFDQ4eHo7LPPpqysjC+//JJ58+bx8MMP84tf/OKQn6+wsJAJEybgcrl46qmnWLduHc8//zxTpkzh17/+NbZtA9DQ0MDf/vY3ZsyYcdDPPWrUKIYMGcJjjz12wPMO9NzNP++GDRv43//+x6mnnspNN93EeeedRzgcPuha2vt160oO9nUWERERkf1TMGoD0zS5deZNnDfMw8LpPib295AcZzCxv4eFF/s4b7iHH91yc4dOq4uPjycrK4ucnBymTZvGlClTePnll1vutyyLOXPmMGjQIBISEhg7duxeIz/NPvroIy655BLmzJnDo48+Sl5eHjk5OYwaNYqZM2fyySefYBgGAC+88ALx8fFMnDix5fFTp05tGYn56tdzzz0HwPnnn89TTz11wJ9pX8/91Z+3X79+HHPMMcyePZtnn32W//3vf/zjH/9ot9dtXyZPnsyNN97Ij3/8Y3r27ElWVha//OUvW50TCAS48cYbyczMxOfzcdJJJ/H++++33F9fX88VV1xBcnIy2dnZ+5zydjB/Z4WFhYwePZqEhAR69erFlClTqK+vb7n/YF5nke7CNE1effVVfvazn/Gzn/2MV199tVtMdxYRkcOjYNQGxcXFbNi0mdl5XlxNgaGZyzCYNclLycZSiouLO6WelStX8vbbbxMXF9dybM6cOfzzn//koYceYtWqVcycOZPLLruMN954Y6/Hz5w5k5NOOolbbrlln89v7PEzFhcXM378+Fb3z58/n7KyMtauXQtEAk5ZWRllZWWcc845ABx33HG89957BAKB/f4c+3ruAznttNMYO3bsIY/O7et1259HH32UpKQk3n33Xe666y5+/etftwpUP/7xj3n66ad59NFH+fDDDxk6dChnnXUWO3fuBOC2227jjTfe4Nlnn+Wll15iyZIlfPjhh62+x9f9nZWVlXHJJZfw3e9+l88//5wlS5aQn5/fMpoHB/c6S9fXHdcutreioiKys/pw9plT+O1vf8tvf/tbpkyZQr/sPh0+oh+L9J4UkW7FjjHV1dU2YFdXV+91X2Njo/3ZZ5/ZjY2Nh/TcTzzxhA3YtbNSbPsXqXt91fwkxQbsJ5544nB/jH268sorbbfbbSclJdnx8fE2YLtcLruwsNC2bdv2+/12YmKi/fbbb7d63IwZM+xLLrmk1bENGzbYgL1gwYKWYw0NDXZqaqqdlJRkJyUl2bfddlvLfVOnTrW/+93v7rOut99+2zYMw66trd3rvk8++cQG7A0bNuz359rfc1955ZX21KlT9/mYiy++2B45cuTXntd8/4Fet/055ZRT7JNOOqnVsWOPPdb+v//7P9u2bbuurs72er32448/3nJ/MBi0+/bta9911112bW2tHRcXZ//73/9uuX/Hjh12QkKCfdNNN9m2fXB/Z8uXL//a1/DrXufDfe9Lx3v66aft3AH9baDlK3dAf/vpp592urSo8fTTT9uAbYB9/nC3vWxGol07K8VeNiPRPneY2zYM9Hq2gd6TIhILDpQNvsrT6UksimVnZwOwstJkYv+9X7qVlWar8zrCqaeeyoMPPkh9fT3z5s3D4/Fw4YUXArBu3ToaGho444wzWj0mGAwybty4VsdWrFgBREYamnm9XpYvX45t24wZM4bhw4e33NfY2IjP59tnTZ9++im5ubkkJyfvdV9CQgIQWUe0Pwd67v2xbbvViNbXOdDrdiBjxoxpdTs7O5vKykoA1q9fTygUYtKkSS33e71ejjvuOD7//HPWr19PMBjk+OOPb7m/Z8+eHHHEES23D+bvbOzYsZx++umMHj2as846izPPPJOCggJ69OjRcv7BvM7SdTWvXTxvmIcnZyQyKtPNykqTO5dG1i4WFhaSn5/vWH22bRO2bIIhk1AgSDgQxA4ECYdChNN6ELbBtCzYsgWqqrCCIaxgEDsYwgoEsUJhLNNk53EnEnJ5MC2bxM9W4Nu8CStsYpsmtmVB05+GZbHhtHMIxydg2TaZn7xPj3Wfg2VhmBZYJlhNvboNq75RQGNSCr+67nrO8MD0dIOrBnhwbTJhk8lE4LlcD3+vsvnZ969jS+pRuD1u+nz+KdmrlgNgYEDT7xTD7QKXi42nnEUgMwsDSN24nozVn4Lhwna7MdxuDI8Hl8eF4XZTN3Y8ZkYmHpdBwvZKkjd9ieFx4/J4cHncuN0ejDgvbl88Vv9+uFNTcbsMPOEwnmAAd3wc7oR4vF4vXreBx+3shI6u/p4UEekICkZtkJeXR+6A/ty5tIKFF7tbTaezbJs5b4UYNDCHvLy8DqshKSmJoUOHApGpbGPHjm3ZuKCurg6A559/nn79+rV6XHx8fKvbtbW1AHg8u98CHo+HoUOHUlJSgt/vZ+zYsS339e7dm6qqqn3W9Omnn+4VIJo1TynLyMjY7890oOfen88//5xBgwYd9PkHet0OxOv1trptGEarHfEO18H8nbndbl5++WXefvttXnrpJe6//35++tOf8u6777a8BgfzOndXpmlSXFxMWVkZ2dnZ5OXl4Xa7nS6rxVfXLjb/XomsXXQzbYGfH918E5NPPIVwXT3BmjqCtXUE/EF2DR2JP2wSCJkkL12Cu7wcq9Ef+fL7we/HCPgJY7D4ousImTbBsMWZTz9MTsnneIJB3KEgnlAAdyiINxQE2+bim/9O0LQIhS3mFM7h9DXv4LHCJFl7T6Ma+qOFhN2R3yP3PfcHpn6+97TdZmNueooaX+QDlDsX38+3P3lxv+feuqM35am9Afj5K49z7vLn9nvuT81BfFa/kx2VFZwMfHe7Da+0nlbqAmYAf6KSO+YX4RswhuuXPcuFb/5zv897d2UCH/Q/CoDvfPAsv3j1kf2ee8VFv+LNwZEpwRd/8iK/X3z/fs+9dtosFh8R+UDl/M/e4P7//qHlPguDkNuD3+0h7HLz2/NuZMnYyXjdLo7b+Ck3PfcnTLcHy+PB9HgxvXGYcfGE430sOz2fkqNPIM7tos/2LUx4/TmshATw+TASfLgTEnAl+HAlJRIYOQp78GASvG4Swn5SKsqIS04kLjkRT3IiP7r5xgO/J2+5malTp3apf0vQ9f+9i0jXpmDUBm63m7nz7qOgoIBpC/zMmuRt+RRtzlshFq0JU1h4b6f9Ena5XMyePZtbbrmFb3/72xx55JHEx8ezadMmTjnllAM+9qijIv+zX7p0KdOnT29138qVK3G5XIwaNarl2Lhx4/a769mGDRtanfvV5+rfvz+9e/feby0Heu59ee2111ixYgUzZ8486Mfs6auvW/NoS1sNGTKEuLg43nrrLQYOHAhAKBTi/fff5+abb2bIkCF4vV7effddBgwYAEBVVRVr1qxp+fs52L8zwzCYNGkSkyZN4uc//zkDBw7kmWeeaVkfdjCvc3dUVFTErTNvYsOmzS3Hcgf0Z+68+9r9027Tsmlo8NO4YxeNO6oI7KwmuKsaf9iibOTRNATD1AdMBj39L+LKtmI0NmDUN+Cv2MzdmzZzej8XrqJGuDCx5TldjzawcLOJy9wM2a3/biuTevCNG/7Vcvvfj/+W4zZ/ts/a6r0+vjvo/JbbF328nGNKlu/zXAuD8prdW9m7wiESwvtfu5bqsQnFeXC7DYIpKexMSsd0uwm7PZhNX5bLhe1yc1TfVPzJqXhcBvaQIXxRPwa7aQQGw8B2uSJfhouTj+pLXXrPyDb7u47hQ08jtmFA03PZLgPbMDCAyccOIemzKhYBHwOhUR68rr1HlEOmTdWqMMdmGowY35/e9jF8aG6jebWeDWDbGLaNYZmMPnoomdlZ2Db0aRzOqoqJGHZkRMtlmRimiWFZGJZJv0HZjBuQjmnZpJf3YlPmAFxN9xm2jdsycZsmHiuMKymJ5HgPYcvCR+uw6cIm3gwRb4YACAZCbK8LAuCv2M7gsi/3+3fx755HUmRFftec/OVyZv7nof2e+6vTr+bvE6YCMH7zZzz9+I9b3f8lYLrBdXcY8uJgYuSDGtcum0frTV7eXMqSY/LwZQ/ATkqCpCSM5GR2HX0sDcdMIDneQ7IdImPdZ8T1SCe+V08SeqWT2Cud+Hhvm0b8D1Zn/nsXkdikYNRG+fn5FBYWcuvMmzhx/u5fvoMG5lBYeG+n//K96KKLuO2223jggQf40Y9+xI9+9CNmzpyJZVmcdNJJVFdX89Zbb5GamsqVV17Z8rgxY8Zw/vnnc+ONN9LQ0MCkSZOwLIuPP/6YP/zhD4wYMaJVYDjrrLOYNWsWVVVVraZwQWRXtY0bN7Jlyxb69u2716YNZ5555gF/hgM9dyAQoLy8HNM0qaioYPHixcyZM4fzzjuPK664ouW86upqPv7441aP7dWrFzk5OQf1uh2KpKQkrrvuOm677TZ69uzJgAEDuOuuu2hoaGDGjBkkJyczY8YMbrvtNnr16kVmZiY//elPcbl2T5FJSUn52r+zd999l1dffZUzzzyTzMxM3n33XbZt28bIkSNbnudgXufupi1TgYIhk9raBmotF7X+MDX+EPGvvoxZUYG1swq7qgpq63DV1uCqq6MypScPn389tf4Qtf4w//zz9QzZvomUcJCUr9SxtlcOBd97sOX24sfmM2L7xr0L3mJBjd36mAmurwzSNHriCcTFU5ecxpCMJBLi3Pg8braPHMvK9FSsuHis+Hjsli8fVkICt511BHFuF3EeF2T+gOU7t4EvHrfPh5GQgCvRh9vnw+2LZ9GxxxPndRPndhH/nSPZEQri9cXj9cXj8cXhifNixMWB18uHe34Q9PMDvwef3PPGtSce8Ny79rzx7WMOeO6xwJIlHhbdB08Dy4+P2+d05w9Kw2xcFeYf0yYyefJYuGgscNN+n7fVd71sPLD/3xVzWt06Cdj/5QD+vOcN6ywI3oHlDxAKBDD9QUJ+P+HGIKFAgJm9M7k+KYVQ2MaqGMpnF4zHDASwAsHIn/4AdmMjdqOfieMmMiRnCCHTImWdxfLGb2MEArj8jbgCAVwBP+5gAFcwQMKggYzMTiUQMsnY6aU6IZm4UOsQ7DaBBhv2HCSvt+ix2eJbAJ8ui3zt4d5Jl3Dvl5GNbYZu38Qrf7t+r5+/Li6B+vhEnj5hKk+feTkpPi/Z4XqueOYBrOQU7JRUjLTIl6dHGt70dNzDhuE9cgSpCV5SfB6S4zy49gi/mvonIu1BwegQ5OfnM3Xq1C4xXO/xeLjhhhu46667uO666/jNb35DRkYGc+bM4csvvyQ9Pb1lm+uv+s9//sM999zDPffcww033IDX6+XII4+koKCAa6+9ttW5o0eP5phjjuHf//433//+91vdd+ONN3LNNddwxBFHUFNT0xKM/H4/CxcuZPHixQf8GQ703IsXLyY7OxuPx0OPHj0YO3Ysf/zjH7nyyitbBYwlS5bstY5qxowZ/PWvfz2o1y0pKemANe7P7373OyzL4vLLL6e2tpYJEybw4osvtgS8P/zhD9TV1XH++eeTkpLCrbfeuteFWL/u7yw1NZU333yTe++9l5qaGgYOHMjcuXP5xje+ARz869xRusrUFdu2afQHqd5SQc2mLfzrmmu4pb+Lu/acCrQqzLMemw8TwPzWxWzokUVyYx0p/jo29BnKhZff3fJ8yx74Idl1O/b5vdb0GsCKYy5tue0NBfGFgy23A24vDfGJNPoSqcvIYuLgniTFeUiM97BpynlU1+3CSEzESEpk267t/PeZx7n15DiG9v3K63ZhAh9uDXPWf/ws+O8iTjvnGyS4XCQA6cCre5573YGDxrF73jjxOwc8t5XeBz9l1Ul5eXkMzOnHjoot3FkcYOH0vac731Ec7PDpzm3mcoHPh8vnI/7rzu2fBuOP2O/dx+1547RhcM35+zuVHzd9RUyGv9wMgG1ZvPrC/7jk/PN46Vs+xvVyQ9IeozvpLtadFMd9S4Occ/50eqf1xKivh4YGXPV1JEwYzynDM2gIhunFDrb2zCbB30Cyvx6vFbn2XHKwkeRgI6G6RtZvi1x2oHZ7KSe8sf/pkn8ffz6/mhL5/0NGXRVvPvw9ahKSqU9MoT4phfjSL3g5BU7rAUadDf2bLqVxkYsfP2px3/XXM2nsBHrmZOON8+73+3S0rvL7UkT2zbBt2/7606JHTU0NaWlpVFdXk5qa2uo+v99PSUkJgwYNavNif4msg7nttttaptp9nQcffJBnnnmGl156qd2fW3Y7mNe5o977HTl1xTItqsu3U71hM7VbK/CXVRAsr2SHJ4F3xk1mR12AqoYQs+beQM+qSlLrq0lrrMPF7l9pNX1cpF67x6Yg99RC7b5/5a3tlcO06/9Cis9LaoKHnz/xW9IbawgmpxFOTY18ip2SgistFTs7m5qpF5Ka4CU53kP6lo0kJMbj65lOfI80jPivbXFbmKbJ0MG5jE6oYOHFvr2a+WkL/Kz0Z7F2fYkaqK9RVFTEhRdeiAGcO9zN7JPiW0YO7igO8MI6k8LCpzVy8DU66j1pNvrxb9+Jf3sVjTurqE/tQVWvLGr9YYJby8gqfAK7pgZqanDV1uKuq8FbX0dcQx3/O+YsHp1wPjWNYQZUbNjnSFSL4+LgG02/5+osmFu3uwbDRXVCCtXJadSn9OCjY0/j/W9eTo9ELz19Lo559xV82X1I6JdNak42PQb2JTklsV2m/mmqn4gzDpQNvkojRnLQzj33XNauXcuWLVv2O0VtT16vl/vv3/8C5MN5btmtLa9zezqUqSumZbOzYgdV60up2bgZf+kWzLJytnuTeGP8FHbUB9hRF+Th315K1q4Kepghenzl+37QbyRPXDa45Xaf8k30rd3e6pxdXh+VIT+Den4lZJ8UD5ZNo8dg+vN+pt/8Y07NzyexTwaD+/RmVdoevzBnHnidXivZow/+3K/oamsXo1l+fj5PP/00137/Ghav28GiNbt3aczK7E1h4cNqQA9CR70n3Qk+knL6kpTTd+87j+wDU47e72N/2PQF4G/ws+OmU2mo3E6gYjvLX3yBV//5CPdPjiM+CAzYo64QWKkGtTU2aYDbtujZUE3Phmqo3MR76QN57pOtQGQk6qYH9p5aWRufSHVSOsXHncnLF19P7+Q4eid4OOHN/+Ltl41vQH9SBvan5+Ac0lMT9hmiNNVPJDpoxEikG2jv937LJ8q+it27Vpk21NpY1SZ/eDHIyoZU+v/1NbY3hKms8XPPby4nq6qcpJB/r+db3ndEq2lsSx/8Dv1rtgFQF59ITXI69SnpBNJ6sHPwEXx4/f/RKymOHklxDPzoHZJSEkjql0VyvywS+/Tmjbfe4tRTT2XZjMR9rjVZVhrmxPkNvP7660yePPmwX4/2sK9PkwcNzOHuezp/7WK0a74o6ZIlSwCYPHkykydPVrhso2h5Ty5ZsuSg/r2/+uJLHDP0CGpLy2jcWk6grILKjH6U5I6kqiGIubGUaffOJqF6J8k1VaTVV+Oxdy+wmj/+m/x6yjUAZNTt5P0Hrmj1fSwMdialsSu1J+8efyZvX3Q1Wak+Mn3w/kWT6JFSy+8v9OFKcUHT+iiNCot0vLaMGCkYicQI27apq6sjGAwSFxdHcnJyq/Veh/Per6trZNtna6ms3MW6jIEUv/EGD//flWzPddPLHwlE1Lf+VbIMuOCSO/ENiGzlvmfYafT62JXak7oevfH3yqB66AhWf/8WeifH0ys5jr6l60nL6EHaoP54k9u+/itap6dp/YF0NdHwnuywf++WRWPlDnZt3ELt5jK2+VIpzchhe12AYMlGznjg1yTt2Ebqru2k1+3Es8elHP46YSq/Pf1qAFK/WMqnC3+3+3kNIMWANBekGqzt5WL4m0F+8dACzjxtMgNCdWQOHUBcXPtN6omGv0eRjqKpdCLdTFVVFaWlpQSDuzcAiIuLIycnZ6+d/valuiHEpp0NbNxZT8KTT+Bav474LZtIKd9C7+1lZNbuYJBtsbPvCH56+d3Uf7YSgB67LNi1RyByA6kG4WQX75WaTMmN5+xvjqJPqo+G055me0ZP0gfnkJCWylc3ST9pzxvDDu96TNE6Pc3tdneZESwRiI73ZIf9e3e5SMjKICErg+zjj2Z4qzuHwYwpu2+aJoGKSqrWbaSmpJRhyb35WZ9cKmv8rC5bwlvACakGrtrIRYmpsaEmsuXkwGMjm0E88PwHPL8iwPsPXEHA7WFLam92ZvSlrm8OwQG5uAYPJu7Y8fQYP4Z+6QkkxR9cC6e1TSIHT8FIJMpVVVWxfv160nwGg3u7SPBAYxjK6kKsX7+eIUOG4PP5CIdNVr+yjPpPPsNcs4a4ki9J2bKJirhkvjt1966Fbz50NwOqK/b6Pn5PHHEJ8UwZmUkweST/+i+sneDliAw3pEY++STBAMPg/dIwN89v4PUzj2HyxMg1njiyT2e9JEDX21pfRDqO4//e3W7i+2aT1TebrJMnMhxoXqW4JPFcTvrn3Sy7KIGJfd1QZ0ONBdWRP9c25bWjj8hlUNiPhUG8GaZfVTn9qsphzYct3+aRY6dxx2nfA2Coy8/v/juPxv4DsAcNIn7YENJHHUGfcUeR3jsd0NomkbbSVDqRKGbbNitWrCDBFWJoDwPDBsKADXYcrKuyqQ27GYyLsvKtDLr2WnwbW19DpyK5J8f/4J9kpMQzoGci1y9+hF6mH3tgLnFDB5EyYii9jjoismC6aYpKNE1V0xQSke6jK/57b+vvSzsYZOfaDexcvZ76L9YTXrce98YNJG7ZyHMTzuFfQ/Oo8YcZt2U1zzy272trlaVm8NwZl/CTNxZwUs+dPFsQj6sOSDPAZXS539MiHUlT6URimGXbBMMW4Zpagrt20ScYpJcXjEobmi8G6gIjy012MlRvD2O6Ixdc3JWURvWwsdTn5GIOGUrc8GGkHzWcz07PI7F5PvvXXA8HomuqWjRMBRKR9tEV/7239felERdHr6OG0+uo4Xs9121NX9WNIbZ+NpRPc8OE1q7Hs3EDSWWlZFRuIa2xluyabWzcUMKu7RX8dGoirkob/lofme7c04Wrl4sH4+CnX5Ty9J33Mvnq75DRp0e7bEsuEs00YiTSRdm2TSgQIlRXj9XQgBUMUZHSi0DIwsZm8M4tJAcb936gi8hHHr1cmDZ8VG7Rr08WVTXVDG6aVtdeomXXKhERp3XW78uGreVsW76Cx9/9gJ/eMZvaWSkkl4ThP427Pzz7it+e+l0WnPwthmQkM97TwElbVpF+7NEMnDSenj1T2q02ESdoxEgkypiWRWPIwtxVjVFXi9vvxxv0E2eGiWs6xwZK49OwDQO3YRD0JVJvQG2gkfRkA5/PiPyLdu3+xK8xFPncIy4xAaOutt3rzs/PZ+rUqV1u6oqISFfTWb8vE/tmMbBvFiemeOEOWFlpMvEIL8z2RDZ92GHBdovyjWE++zzM0b5k1mYMpNYf5uPSXeR89gan/vcPAIQNFyW9+7FtwDAajxqF99gJZJwxmdyh/fC6dTF2iT0aMRJpowNti30wwmGTYF09Zm09NDSwNTWDgBnZ5rV/dSU9G2tanR/yeAnF+bB9Pqw+fYiPj8PrNjAMY+81RnvUYds266ps/JaXocOGsWHDBr33RUS6ibasbQqZNht3NrKuso7wwoUc+fhfyCpdR0pj3V7P+/0LZvPayEkMy0zhNKOK4xrKyDzlBAZPOIo4b9tCXldcEyaxRyNGsl87duxg5MiRvPfee+Tm5h7UY6ZPn86xxx7Lrbfe2rHFRYG2bottWjaB+kbCNTVQ34DH34AvFCBxj88jjPgU8MQR53YRTk6hIc4NCYl4khPxJCfh9Xjw7qcewzDIyclh/fr1rKuC7GT22JXOptpvM2RIjuaNi4h0M21Z2+R2wxFZKRyRlQJjroOfXwe2TX3JJra89QF173+I+5OP6fXFKkpyhhMybT4rq+G0t//DycWPAbDLl8znA46gavQ43CeeSJ8zT2HwyFw8+xlZ0jbi0hVpxCgKrVixgrvuuovXXnuN7du3k5WVxahRo/jOd75DQUHBAR97yy23UFtbyyOPPHLQ32/lypWcfPLJlJSUkJaWdrjlR609t8XOTjb2EUCGkJiYRKi6llp3PHVhG3/IIqNuB1l1O1s9l2m4CPoSsBISsXv3xpeUsN//eRxsbV8NbPFxcfRvCmyx8t4XEZG2ae+1TbZts7mqkVVbq3E//BDDnnuKfpu/xGuF9zr3m9c8QMIx4xg/sAcT02zGjhxAWnpSq23EZ+d599hGvDmwaRtxaT9tGTFSMIoyhYWFXHrppUyfPp3vfe975ObmUl1dzcsvv8zf//53Pvnkk/2ODjQ0NJCdnc2LL77IxIkT2/R9jz32WK666ip+8IMftMePEXX2O2XNtLEDNtW1NnEmJBC5qPmG9GxqfEkApIf9ZNbuwEpMxJWUhDc1BXeCr2Xr6/ascX9T/GLhvS8iIoemo6es2YEA5W8vZ9vrS7HfeZdeKz+k5/ZyRt+8ANMV+T6/f+E+pn7+Buv6D+elii/Z1TPALy9PwBW/+0NBbSMuHUHBKEaD0UcffcRxxx3H73//e2655Za97rdt+4BTpgoLC7n++uuprKxsOTZ16lSee+65fZ7/7LPP8s1vfhOAX//617z88ssUFxcf5k8RnWpra/niiy8Y0dtFcpwBARt2Wfvc4Sfk8VLXqw9Gr54kxnmI8zi/QDXa3/siIhJdrNo6vmy0Wb6xig82VHHVbZdy1MZVrU8ygL4uGOiB0+PBZbCsNMyJ8xt4/fXXu9zW6xKdtMboUNTX7/8+txv2bCYPdK7LBQkJX39uUlLb6gNmzpzJSSedtM9QBHztOpLi4mLGjx/f6tj8+fMJhULU1dUxbNgwXnjhBcaNGwdA7969W8477rjjuOOOOwgEAsTHx7e59mhk2zYBf5Bg1S6snTvoSWT9DhC5FkRzKPKC5TUoabDpMWAAPTMz2Xu1kYiISPfhSklmaAoMzUzh4mMHQMEKqj5exatz7qLuP//iijQDV7UNWywIhOGMSJ81KtPNd4DP/vU0Rxx5NNmZ6Y7+HNK9KBg1S07e/33nnAPPP7/7dmYmNDTs+9xTToElS3bfzs2F7dv3Pq+NA3UbN27kjTfeYMGCBS3HGhsbycrKwjQjHfr111/PXXfddcDn6Nu3b6tjvXr1AmDZsmUYhkFeXh7J+3gt+vbtSzAYpLy8nIEDB7ap9mgSDps0VlVjV1cTV1+HLxSgORLbRNYUJccRCUa9XOAFXAYNQZuqBpvMPUOxiIiIRBgGPcaNovf13+Wi//yLEQUJTExxwYbWa5NWlYW5H0ia/yca/vUI7w4dx668U8m48JuMOvXYNu98J9IWCkZRYsWKFUBk5KaZ1+tl+fLl2LbNmDFjGD5876tk76mxsXG/06g+/fRTcnNz9xmKABKaGv6G/QXCKGXbNo0hk5rGMHX+ILlb1pNitZ4fF4iLx0xKpqq2GrPOZGiPptG5+N3PUVZnE9+0rkdERET2LS8vj9wB/blzadM24mPjWu6zbJv7i0Oc50vgrLgEetbs5PjP34HP34G/zGFLWibF516KeeNNTD4ik37p+jBS2peCUbO6vffqb/HVxX97rNHZi+sr60k2bDjkkvZUWxu5OKfHs/uvzOPxMHToUEpKSvD7/YwdOxaIjAzdcMMNbN68mVAoxAsvvMCAAQPo3bs3VVVV+3z+Tz/9lDFjxuz3++/cGdlVLSMjo11+HidZtk1jTR3mjiosf4BNqbt/Jr8nDl84SDApBSM9jfgeacTHRX5p92jalU7bYouIiByar91GvMTkwsIF9LzgAmrf/5DNTy3E/crL5H72If2qK9m4ZScPPrMSgAlpBlfvWsmgK7/FsJED9f9gOWwKRs3asuano849gKOOOgqApUuXMn369Fb3rVy5EpfLxahRowgGg5xzzjk88MADTJ48maqqqpZRjHHjxvHYY4/t8/k3bNjAqFGj9vv9V65cSf/+/VutO4ompmXRsKsWa2cVvroaksKRba1tIC6lFwmJ8aT4vMT3HoonPg7PPn659ujRgyFDhlBaWsrq7a23xR4yZN/XMRIREZHW8vPzKSws5NaZN3Hi/NbbiBcW7t5GPOW48Yw8bjzwG6zaOjY88wJZngwmVMfz4aYq+r39Gmctmkv4D7P4eNAYtk/5Blnf/TZHHXsULpdCkrSdglGUGDNmDOeffz433ngjDQ0NTJo0Ccuy+Pjjj/nDH/7AiBEjSEhIYMGCBUycOLFlJ5c9m/WzzjqLWbNmUVVVtVcTb1kWGzduZMuWLfTt23evT12Ki4s588wzO/znbE+WbVPnDxOqqCSlajspZmj3fRgEEpMgvQfDM1NxeQ7un0KPHj1IT0/f77bYIiIi8vXy8/OZOnXqQW8j7kpJJveKb5ELXAlU1Qf54v5NlH4yjJzStYz78mP4y8fwlzl8lDuarWdNZcAPv8eoIwfo/9Fy0LRddxQJBALcc889PP7443z55Zd4vV6OPPJIzj//fK699lp69uzJ7bffTk5ODt///vf3+RzHH3883/3ud/e6/3//+x/XXHMNVVVV1NTU4NpjSqDf7ycrK4vFixe3+fpHnc22berrGqkOmOwKWpiWTY/GWnKqK7AMIzJFrkcP4nr1wDjIMBQLov29LyIisj/1q9eyYf6TxP93IYNXf4yLSGt7wnV/xzc4l2lH92Pa0dkM7K11wN2RrmMUo8HoYNx///2sWbOG+++/H9M0qa6upmfPni33P//889x2220t0+8OxoMPPsgzzzzDSy+91FFlH9CBLlzaLBAI4q/Yjqe6iqRAI1tTerM9KR2v20V6vJueZiNxPXtgdNOLxXWH976IiIi/ZCObHvwHlR+u4HsnzMAfsgD407O/JzklgeDlV3L8dy4kLXnvS4909IVwxRm6jlE3dtVVV3HxxRczatQovF4vDz74YKtRnnPPPZe1a9eyZcsWcnJyDuo5vV4v999/f0eVfEBVVVWUlpYSDO5e0xMXF0dOTg6paWnU76yB7dtIqq8hbY+Mn2qYpGYkkxTnbgpR7bPWS0RERLou36CBDL/rFwwHPgiEeWlVOa+9sYKzv3gLj23B+y9R+vNbefuMC8i+6TrGnjgKwzAoKiri1pk3sWHT7jVPuQP6M3fefS1rniT2acRIuqyqpl3g0nwG2clGq13gavw2Iz1eEsO71w0FvXGYPXoR36c3rm5yEdqDpfe+iIh0W7bNziVLqbzvQXJefI4kfz0QWW/83sjjeWvSidz2t3mcN8zD7Lzdu+TduTTEojVhCgsLFY6imKbSKRhFPdu2WbFiBQmuEEN7GJFRH9MGt4Ft26yrsukVgHQgkJKGp08m3tQU0ALLfdJ7X0REBOz6ejY98i/Cj/yNIZ99AMDNviTWDwjw7PQEXHv0EZZtM22Bn5X+LNauL9G0uijVlmB0cItMRDpZ85qi7GQDIwjstKDCgrCNYURGkDbbNvWDh5AwfCjetFSFIhERETkgIymJgTdfy5BV71P36UqWnnYO8/31/DQvLhKKVoTghUaosnAZBrMmeSnZWEpxcbHTpUsnUDCSLsnvD9ADSKq2YIcF/qaBzUDkzwQPBIGgZTpWo4iIiESv5NFHUfq9y6gFRmW6wbbh7QC8H4L766CogTFN55aVlTlZqnQSBSPpUkJhk6rSMlI2b2YIYIQAA0g0IMMFSZG3bGM4cn5cXJxTpYqIiEiUy87OBmBlZdMHrWf4YIg7cgX4FWGS5jewCKj7YA3BsOVYndI5umUwirFlVTEhZFps3dXI2rIaUirL8JlhwsAOD9iZLkh3gTcyVc62bcrqbOKbtu6Wr6f3vIiIyN7y8vLIHdCfO5eGsAAGe+CyJLgmCftIDyZwLnD1Pb/k6cnf4tG3NxAIa7ZKrOpWwcjr9QLQ0NDgcCXSLGxa7CzbzhfltWyvCxA2DHal9ybQJ5u6QYMoCcO6apu6oI1pRf5cV2VT7bfpn5Ojq1kfpOb3fPO/AREREQG3283cefexaE2YaQv8LCsNUxuwWRa2mWoajASWTphE2OXmhX5j+cVzqzjt7jd45sNSLEsfOsaabnUdI7fbTXp6OpWVlQAkJiaqsXaIZdnU7qwmbnslieEgvtRMzKQkeifHkdgrA9sw8AE5OTmUl5ezevvubbnjvF5ycrJISEjA7/c790NEAdu2aWhooLKykvT0dO2oIyIi8hX5+fkUFhZy68ybOHH+7usYDRqYw91P38tJ+fn4N2zizK0ma5asZ8uuRtbfPJslDRUk3v17jj/laPWTMaJbbdcNkUaxvLycXbt2dX5xAoC/wQ+7duELBQCwMQinpeNN3/cWirZtEwgEME0Tt9tNfHy8fgG1UXp6OllZWXrdRERE9sM0TYqLiykrKyM7O5u8vLy9PlBsDJr869VVTL/gRFID9fg9cbxw1qUc9cc7OGJwtkOVy4HoOkYH8cObpkkoFNrv/XJoTNNk+fLlVFZWkpmZyfjx41t+qazbWEnJb+7hlLcXEWeFCbtclE05j34//RGuPpkOVx67vF6vRopERETaUc1b71J17Q8ZuPJ9AMpSerHsez9iyh23kJoQ2RjqYIKWdDwFo4P84aV9FRUVcevMm9iwafcwdO6A/txx1z18mXQUp/3gEk7c9CkAJceeTNZfHyBhzCinyhURERE5dLbNjn8+iX3bbfTethWADwaNZdu8P9EQruBHt9y8V080d9595OfnO1Vxt6RgpGDU6YqKiigoKOC8YR5m53kZlelmZaXJHcUhnl8bovfU2Zzr8XL3kr9g3HcvPS+5SBdkFRERkejn97Nh9m/o86d7cJthTpv8Hd5+/a979UR3Lg2xaE2YwsJChaNOpGCkYNSpTNNk6OBcRvsqWDjdF7lytG3DxyEsF3zzM5PXt6XzbPEnTBnaE+LjnS5ZREREpF0F167njX8s5JsP/I4pfXbx7PQEXPU2JEc2gbZsm2kL/Kz0Z7F2fYmm1XWStmSDbrVdt3SM4uJiNmzazOw8byQU1VjwRCM858f1gp9fjXPTULUNz7YvFIpEREQkJsUNG4L3jPH4q7fz07w4XGUW3FcHS/xg2bgMg1mTvJRsLKW4uNjpcmUfutV23dIxysrKABiV6YbPQvBcIwQAN3ByPMMHelqdJyIiIhKLWvVExQEIA28EYZ0JF/gix1FP1FUpGMlhy87OxgfUP9NI8upw5GA/F0xNgAw3K0vDLeeJiIiIxKrmXmdlpcnE032Q6YbnG2GLCQ/XU3l8XKvzpGvRVDo5bNtc2bznctNndRgb4KQ4+E4SZLixbJs5b4UYNDCHvLw8p0sVERER6TB5eXnkDujPnUtDWLYNo71wXTLkuiEEQ5YGeTTOR8++w5wuVfZBwUgOmT9k8pOnP+W2F9bxxuBjKQd+0d/NsuEeasOwrDTMtAV+Fq0Jc/c992qRoYiIiMQ0t9vN3Hn3sWhNpAdaVhqm1mew7NQ4Hu3twgSuCPr598y7eOajzV/7fNK5tCudHJLKXQ3c+MibvLPDxGXAjybnkrP5XW789S9a7dk/aGAOd99zr7alFBERkW5jX9d2HDQwh4cvu4q4Nz/hqhO+h224+O6kQcw6ZwRet8YqOoq261Yw6lCfrdvKtqnfInnXDq6b8QfmXTGRSUN7A7rKs4iIiAjsvycyLZt7X1nD/a+tIz4U4Pr6z/nOvT8m1ed1uuSYpGCkYNRhlixdRc+LL2TM1i8Iur3sfPZ5ss49w+myRERERKLK4k+3Yl9yCd/47E2ePuVbnPD03+jbK9npsmKOrmMkHeLZp99k4DfPYMzWL6hNSiX48isKRSIiIiKH4OzR2Rxz3skAXPjGv1mTdzarSyodrqp704iR7GVfQ79Ff13E5FuuIqNhFzsz+5Ly+it4jxzpdKkiIiIiUW3n/H+R/P0ZxIVDLBt0NJ5nF3Ls6IFantBONJVOweiQ7Wux4JQePSmsrSctHKBiyEgyi1/F0P77IiIiIu2ibvEruKdNJSHQwIf9j+T1G3/An/40p1U/ljugP3Pn3acNrdpIU+nkkBQVFVFQUMBoXwXLZiRSOyuFZTMSGZ5aQzAcYO3AIfT58B2FIhEREZF2lHz2FFyvvkx9YgrHbP6MY378A0bHl7fqx0YnVFBQUEBRUZHT5cYsjRgJEJk+N3RwLqN9FSyc7sNlGC33WbbNDx5tpNjqwyclGzWMKyIiItIBGj9YTsXxx/Hnfga/+07iXv3YtAV+VvqzWLu+RP3YQdKIkbRZcXExGzZtZnaeN/KPcIsJm8MAuAyDK06PY1XpFoqLix2uVERERCQ2vVtXyzDLIv/M+FahCCL92KxJXko2lqof6yAKRgJAWVkZAKMy3bDdhMcb4J8NUBrefXyP80RERESkfZWVlRFmd99FuQn/aYBQZIKX+rGOpWAkAGQ3rRtaUxKCxxqg0YYMFzT9A1xZabY6T0RERETaV3OftbLSBNOGpxrgszA80wi2rX6sg2mNkQCRNUYj+/fn5Z3lDAwCvVzwnURIcmlOq4iIiEgnaFnznVDBwot9uDaakQ+sTbAneplahfqxNtIaI2mzteU1PEgyA4Owww3LT4+j1mOwrDTMtAV+Fq0Jc/c99+ofoYiIiEgHcbvdzJ13H4vWRPqvZW5oPMcHgPFOiIFfhJjzh3vUj3UQBSNhV0OQjy/5PqeXryPg9nBV70wm/NtP6u9qOXF+Ayv9WRQWFmrffBEREZEOlp+fT2FhISsa+3Di/AYS/+tndtN992Kw65PtxNiEry5DU+m6OdOymfG3ZVz++5s5ff371P3jMRIum64rLYuIiIg4yDTN3f1YVhbD7/8LfZ95ip0Jqbz4j0Vc8q08p0uMCm3JBgpG3dzvF6/mwSXrSXTb/G9UiIGXXOB0SSIiIiLyVX4/28cdx6qAl1u+eRsP33wmE3J7Ol1Vl6c1RnJQXv10Cw8uWQ/A7751jEKRiIiISFfl89Gr+DWKfvMwO3wp3PDER+yoCzhdVUxRMOqmKqobCV52Gb/73x+5ZkIW3xzb1+mSREREROQAjN69uaPgaAZnJFFe4+eXD7+MZcXU5C9HeZwuQDqfZdk8d+NvuHrFEkyXG7Nv0OmSREREROQgJMd7eOiCkazIv5wzVr/Nkzn/41KtN2oXCkbdxJ4L+NZ/Vs7MJ+cBsGv2z+h14gkOVyciIiIiB2t4Tk96hbeRGqhn6G0/4PMTXqdi/QptnHWYtPlCN1BUVMStM29iw6bNGMArwGnAl7lDGbz+C3BpRqWIiIhINLHXriUweiy+QCM/T0jiN431LfflDujP3Hn36VIraPMF2UNRUREFBQWM9lWwbEYiDWfGcxoQMOCsDesoWrjQ6RJFREREpI2MYcN4//LLAbjdX89HBT5qZ6WwbEYioxMqKCgooKioyOEqo4tGjGKYaZoMHZzLaF8FC6f7cO2y4cE6CIF1djzTSixW+rNYu75Ew60iIiIiUcQ0TYYOGsjTO7ZyTIMNuW64IhEMA8u2mbbArz4PjRhJk+LiYjZs2szsPC8uw4CdFngNGOjGdVwcsyZ5KdlYSnFxsdOlioiIiEgbFBcXs6F0C8a58ZFdAzaY8EkIAJdhqM87BNp8IYaVlZUBMCqz6VOCIR64IRmCNhhGy/Hm80REREQkOjT3b8OGemGyDe8EIcFouV99XttpxCiGZWdnA7Cy0tx9MMGANFer483niYiIiEh0aNXnnRAHP0iGI7wt96vPazsFoxiWl5fHwAH9+ei/fqxVQdhjOZll28x5K8SggTnk5WnvexEREZFokpeXR+6A/ty5NIRlAL7do0Xq8w6NglEMc7vdfLvgGq6qtHAV+vns3SC1AZtlpWGmLfCzaE2Yu++5t1svyBMRERGJRm63m7nz7mPRmkhft6w0TK3fYt1rfpbOq2PRFyH1eW2kNUYxbGd9kONfeZME4G1vHJNeDMCLAQAGDcyhsPBe7W8vIiIiEqXy8/MpLCzk1pk3ceL8zfQF1gJDgZ+ffZn6vDbSdt0x7JE/P8eMH0zDhU347bdZGgjoisgiIiIiMcY0TYqLiykrK+OohYsY8+8n+LJHX8rfXs6JI7KcLs9RbckGCkYxqrzaz6pjT+X0te9Qedb5ZC5+zumSRERERKSj1dZS338gSTVV/Ony2fzg0d9iGMbXPy5G6TpGwsIHCzl97TuYLjcZ997ldDkiIiIi0hlSUrBuuw2Aqc/9jaWrtjpcUPRQMIpBpTsbGPnIvQDsvHA6xogRzhYkIiIiIp0m5ZabqO3Rm5zqClb+9l5ibIJYh1EwikF/efNL/jnuHL4YOoaMOb9yuhwRERER6UyJiTB7NgBTX/gHb2jU6KAoGMWYbbUB/v1BKa8OPZ4di1+FIUOcLklEREREOlnKDdex8pRzuOW8W/hz8Uany4kK2q47RjTvRvLw4uVUbwpy/AmTOGFwL6fLEhEREREn+Hz0fvZplt/1GsGS7Tyy4L8kW3XanfgAFIxiQFFREbfOvIkNmzbze2AI8J/X+vBMvz9r/3oRERGRbiorzcdI/2pe+tscrqne3nI8d0B/5s67T33iV2gqXZQrKiqioKCA0b4K3r80gdvc8Ftgavx2CgoKKCoqcrpEEREREXFAUVER79xzK0+4drAzx0XtrBSWzUhkdEKF+sR90HWMophpmgwdnMtoXwULp/twLQ3CawHo68Kakci0fwdY6c9i7foSDZeKiIiIdCPNfeIp7nL+vjGMYQHXJkEfN5ZtM22Bv1v0ibqOUTdRXFzMhk2bmZ3nxWUDHwQjdxwXh8vlYtYkLyUbSykuLna0ThERERHpXM194rWnxWGMaFo9836kV3QZhvrEfVAwimJlZWUAjMp0w+ow1NiQZMBR3t3H9zhPRERERLqHVn3isXGRg5+GIGDvPo76xD0pGEWx7OxsAFZWmi2fADDeCx5j9/E9zhMRERGR7qFVnzjQDb1dEAI+Ce0+jvrEPSkYRbG8vDxyB/Tnr68FYUPkzc0xkU8ELNtmzlshBg3MIS8vz8EqRURERKSzNfeJdy4NYcHuUaMPgliWpT5xHxSMopjb7eYPc+/l9ZIwL6ca7BjoptZnsKw0zLQFfhatCXP3PffG9II6EREREdmb2+1m7rz7WLQm0he+18vA9gLbLG77R6P6xH1QMIpyfcaeTO202Ux19aL3RpPU39Vy4vwGVvqzKCws1P70IiIiIt1Ufn4+hYWFrGjsw/GPNTIvBPcAL+xK44mn/q0+8St0gdcoV7h8M4lHnMjVl32LM3pVUVZWpisai4iIiAgQCUdTp06luLiYLVu2MueNchrSh5I8YoLTpXU5CkZRrMYfIuHxf3FUr4F869gTGTtgrNMliYiIiEgX43a7mTx5MgBbe6/mgdfXs/CjLZw3pq+zhXUxCkZR7MX3vuTnL/6ZxFAA++ZTYEAPp0sSERERkS5s2ugsPv770+R8WMrOgrH0TIpzuqQuQ2uMoljZk0UkhgJUZ/fHGKvRIhERERE5sGE7N/P4gtuZ9erfeHnpZ06X06UoGEWpqvogQ5a8ELlRcBEYhrMFiYiIiEjXN2oUO4aMIM4KU/nYf5yupktRMIpSry0v4bR17wOQduWlDlcjIiIiItEi/uKLABjxzitU1PgdrqbrUDCKUuVPPk1COEB1dg4cc4zT5YiIiIhIlEi+5FsAnFzyEa+/v97haroOBaMoVN0QYnDTNDrrIk2jExEREZE2OOoodvXPJd4Msb3wWaer6TIUjKLQK6vKGLNlDQA9rvi2w9WIiIiISFQxDOwLLgAg940XqfGHHC6oa1AwikIvra7k5Gv/ylPzntQ0OhERERFpsx6XTQdg8I5SXv+8wuFqugYFoygTDFu8tW4HpsvNyAvP1jQ6EREREWm7CRP4+58Xcs5Vf+SlzyudrqZLUDCKIqZp8siC/1Lx4SvEVX7OkVnJTpckIiIiItHI5WLceadg2xbPL36Ffz32OEuWLME0Tacrc4zH6QLk4BQVFXHrzJvwbtrMB8BCYPgr9zL33j+Sn5/vcHUiIiIiEm3Wvfsq2x65Fv+u7Vzxr8ix3AH9mTvvvm7ZX2rEKAoUFRVRUFDAaF8FLx3vZSBwVV8XoxMrKSgooKioyOkSRURERCSKFBUV8a2LCnjB3EEgHuquT2LZjERGJ1R02/6yw4LRzp07ufTSS0lNTSU9PZ0ZM2ZQV1d3wMf85S9/YfLkyaSmpmIYBrt27eqo8qKGaZrcOvMmzhvmYeF0H7nbLADSRnlZeLGP84Z7+NEtN3frYU8REREROXgt/eVwL6ekGXgDkLTJZGJ/T7fuLzssGF166aWsWrWKl19+mUWLFvHmm29yzTXXHPAxDQ0NnH322cyePbujyoo6xcXFbNi0mdl5XlwhYEPTG3SYB5dhMGuSl5KNpRQXFztap4iIiIhEhz37S2OoN3JwfRigW/eXHbLG6PPPP2fx4sW8//77TJgwAYD777+fc845h7vvvpu+ffvu83E333wzAEuWLOmIsqJSWVkZAKMy3bDZBAtINaCXa/fxPc4TERERETmQVv0lwBLgyzBYNriMbttfdsiI0bJly0hPT28JRQBTpkzB5XLx7rvvtuv3CgQC1NTUtPqKJdnZ2QCsrDRhQyTJk+tp2aZ7ZaXZ6jwRERERkQNp1V/2dYMPCABbzN3H6X79ZYcEo/LycjIzM1sd83g89OzZk/Ly8nb9XnPmzCEtLa3lKycnp12f32l5eXnkDujPnUtD2M3T6AZGUrxl28x5K8SggTnk5eU5WKWIiIiIRIs9+0vLAAY3TSL70uzW/WWbgtFPfvITDMM44Nfq1as7qtZ9mjVrFtXV1S1fpaWlnfr9O5rb7WbuvPtYtCbMc7U2DekGdX3dLCsNM22Bn0Vrwtx9z7243W6nSxURERGRKLBnfzltgZ8v0yIzkXatCXXr/rJNa4xuvfVWrrrqqgOeM3jwYLKysqisbH0F3XA4zM6dO8nKympzkQcSHx9PfHx8uz5nV5Ofn883br6Li+f/nkD1dni4HoBBA3MoLLy3W+4zLyIiIiKHLj8/n8LCQm6deRPnL9vMX4DFWy3ez86isPD+btlftikYZWRkkJGR8bXnnXDCCezatYvly5czfvx4AF577TUsy+L4448/tEq7Mdu22dF7HH2u+Ru3jbXp5WogOzubvLy8bpfkRURERKR95OfnM3XqVIqLi7n/hQ9YsjnEFdPOJj9/nNOlOaJDdqUbOXIkZ599NldffTUPPfQQoVCIG264genTp7fsSLdlyxZOP/10/vnPf3LccccBkbVJ5eXlrFu3DoAVK1aQkpLCgAED6NmzZ0eUGhU2VzWStn411b37M+Oi80iIUxgSERERkcPndruZPHkyocyRvPPPD1heWu10SY7psOsYPf7444wYMYLTTz+dc845h5NOOom//OUvLfeHQiG++OILGhoaWo499NBDjBs3jquvvhqAk08+mXHjxvHcc891VJlR4f3Pt/Dcozfz8byLSdhe4XQ5IiIiIhJjJgzsQUqgnqRPP2JHXcDpchxh2LZtO11Ee6qpqSEtLY3q6mpSU1OdLqdd/Pk3f+f6n3+Xuh69Sd5R2bJVt4iIiIhIu1i5EnPMWGrik3jv/S84a1RsbNXdlmzQYSNG0n6Md98DoPGYYxWKRERERKT9DR+O5fHQw1/Ll8s+droaRygYdXG7GoIMWLcCgOSTJzlcjYiIiIjEpLg4akaMAiC87B2Hi3GGglEX9+nmao7eugaABAUjEREREekgromR3aN7rvwI04qp1TYHRcGoi1v3yRr61W7DMlwwYYLT5YiIiIhIjEo75SQAjtq8mnWVdQ5X0/kUjLq4huJlAOwaNAySkx2uRkRERERilevEEwA4sqKEFevKHa6m8ykYdWG2bfOKO4Pfn3Iltd/5ntPliIiIiEgsy82lPq0ncVaYbUvfdbqaTtchF3iV9lFW7efj+N6sOPFb3PR/ZzldjoiIiIjEMsNg47U388RH5WwIJXGd0/V0Mo0YdWErtkSuPHxEnxR8XrfD1YiIiIhIrEv7yY94bNw5vNMYTyBsOl1Op1Iw6sLWf1HKOauXkueqdroUEREREekG+qb5SEvwErZs1lZ0rw0YNJWuCwu/9TZ/fvZ3VH0yDH54ntPliIiIiEiMM2ybc4JbsD75iNWlRzKqX5rTJXUaBaMuzLfqUwDCY8Y6XImIiIiIdBe/nPdD4hvrefDc02HiIKfL6TSaStdF1fhD9C9ZDUDy8bp+kYiIiIh0ApeLmiOOBMD88EOHi+lcCkZd1OqyWo6q/BKABAUjEREREekkrnHjAEhdvRLbth2upvMoGHVRa9eXMXBX04W1xoxxthgRERER6TZSJ0Y+lM8tK6Gs2u9wNZ1HwagLMk2Tz/79FAA1yamYPXs6XJGIiIiIdBfeMaMBGFaxnj898ihLlizBNGN/624Foy6mqKiIoYNz2fzIbwFYXlfD0MG5FBUVOVyZiIiIiHQHz61dC0B2Yw1//vF1nHrqqd2iH1Uw6kKKioooKChgtK+CGy9JoPECH9lnxjM6oYKCgoKYfzOKiIiIiLOKioqYduWVbGvau3rr5Yksm5HYLfpRw46xFVU1NTWkpaVRXV1Namqq0+UcNNM0GTo4l9G+ChZO9+EyjJb7LNtm2gI/K/1ZrF1fgtvtdrBSEREREYlFrfrRsW5c8S7o74Z4I2r70bZkA40YdRHFxcVs2LSZ2XneVqEIwGUYzJrkpWRjKcXFxQ5VKCIiIiKxrFU/emQcDPFAfKQv7Q79qIJRF1FWVgbAqEw3hGxYGoA1IWga0BuV6W51noiIiIhIe2rVj+5DrPejCkZdRHZ2NgArK03YZsGrAXjWD02jRysrzVbniYiIiIi0p1b9aNCGFSEoDrTcH+v9qIJRF5GXl0fugP7cuTSEta1pO8SMyF+PZdvMeSvEoIE55OXlOViliIiIiMSqVv2oaUNRI7wWgIDdLfpRBaMuwu12M3fefSxaE+bfbwYBCKa7WFYaZtoCP4vWhLn7nnujZqGbiIiIiESXPfvRac8GCPoixz/9LNQt+lEFoy4kPz+ffz7xFEatF4DbPwlx4vwGVvqzKCwsJD8/3+EKRURERCSW5efnU1hYyIrGPrzvjxy74zl/t+hHtV13F7NiczXWsRMYW76O4pkzMb/5TfLy8mI2mYuIiIhI12OaJutPO5Phb77GfePP5oZ3F0VlP6rtuqPYxh11DKqK7PSR993vMnny5Kh8E4qIiIhI9HK73eSccjIA/QIhQpbDBXUCBaMupqJkC6mB+siNwYOdLUZEREREui3fkUcAMLCqjE07GxyupuN5nC5AWlvrd3Hulfdy7SAv5ycmOl2OiIiIiHRTxvDhAORWbeXjHQ0M75PicEUdS8GoiympDrEqayjW1KOdLkVEREREurMRI3jgtj/yn13xXLaj3ulqOpym0nUxG3dEhikH9NRokYiIiIg4KDGR+tPOYEPPfi09aizTiFEX4g+Z5C39L6mBegbtGgQDejhdkoiIiIh0YwN7RT6s39gN1hhpxKgL2bSzgUs/foGfvfZX0tatdrocEREREenmjipZyY1vPUn20ledLqXDKRh1IRt3NNCvehsAxqBBDlcjIiIiIt3dwOVLuWXp4xz90ZuEzdjes1vBqAvZvHUHGQ27IjcGDnS0FhERERGRpGFDAOhbXcnWXX6Hq+lYCkZdSP3aLwEI+hKgh9YXiYiIiIizXINyAehXXcnmXbG9zkjBqAsJl2wAoCG7PxiGs8WIiIiIiDTNYupXs42tVY0OF9OxFIy6EHdpKQDh/jkOVyIiIiIiAuRE+tKEcICqjVsdLqZjKRh1IQllmwFw5eY6W4iIiIiICEB8PHU9MwDwr/vS4WI6lq5j1EX4QyZ/PPqbPDvwWB6febrT5YiIiIiIAODvl0Pyzm3YGzc6XUqHUjDqIsqq/dT4klk/cAQpY0c5XY6IiIiICACld8zl4udWEzdwMDc6XUwH0lS6LmLrrshitr7pCRjaeEFEREREuoj0E45lfa8cNtZb2LbtdDkdRiNGXcTW7bX87NVH8A0ZBIGJEB/vdEkiIiIiImSn+QBoCJpUN4ZIT4xzuKKOoWDURdR8uZEZHzxL+GMPPDHX6XJERERERADwVZbzf+//G38gzJZdJ8VsMNJUui7CXxJZzNbQqw+49NciIiIiIl3Ejh1c99o/ueLDRWzd5Xe6mg6jDrwLME2T7e8tBWBXUjKmaTpckYiIiIhIk759AejVWMOzTz7OkiVLYrJfVTByWFFREUMH57L9ub8C8O6XXzB0cC5FRUUOVyYiIiIiAkVvvEGw6b+f++2tnHrqqTHZryoYOaioqIiCggJG+yr4yZjIcq+TjvQwOqGCgoKCmHuziYiIiEh0KSoqouCii9jVtDPB6isSWTYjMSb7VcOOsT33ampqSEtLo7q6mtTUVKfL2S/TNBk6OJfRvgoWTvfhetYPn4Tg9HisSXFMW+BnpT+LtetLcLvdTpcrIiIiIt3Mnv3qs/UmxhYLvpUAI71Yth0V/WpbsoFGjBxSXFzMhk2bmZ3nxWUYUGtF7kg2cBkGsyZ5KdlYSnFxsbOFioiIiEi3tGe/aqQ0xYbayJhKLPar2q7bIWVlZQCMymxK1/kJUGNDqtHqePN5IiIiIiKdqVW/mhLpUVs+zCf2+lWNGDkkOzsbgJWVTTt6JLkg2x35c4/jzeeJiIiIiHSmVv3qifHwgyTIi2+5P9b6Va0xckjLnM2EChZe7ItMp2sSLXM2RURERCR2xUK/qjVGUcDtdjN33n0sWhPmysca2VrYgP+tAMtKw0xb4GfRmjB333Nvl32TiYiIiEhs27NfnbbAz7LSMLUBO2b7VQUjB+Xn51NYWMi2nSn0XRVm6ysBTpzfwEp/FoWFheTn5ztdooiIiIh0Y8396sb6DF6c38Bff1cbs/2qNl9wWH5+PqUvfw4P3Q4DBvH6o/PJy8uLmeQtIiIiItEtPz+fqZMm4c7KAqDqvn/xix9cEnP9qkaMuoC4ym0AJI8cxeTJk2PuTSYiIiIi0c2dmUnYExlTyenVPyb7VQWjLsC3rRwAd/++DlciIiIiIrIPhkFDz0wAQqWbHS6mYygYOSxsWiTv2gFAfP9+DlcjIiIiIrJvwd6RYGRtjY3rFn2VgpHDdtQH6dFQDUBi3yyHqxERERER2Tc7o3fkP7Zvd7aQDqJg5LDKmgC9GmoAcPXJdLgaEREREZF9c2dGelX3jtgMRtqVzmHb6vz8X/5PmZgY4v5TTnG6HBERERGRfYrL7hP5c1cVtm1j7HHB11igYOSwnfUhtiX3pHp4BqSnO12OiIiIiMg+eWbezGkNR1CZ3JOLAmFSfV6nS2pXmkrnsKr6IAA9EmPrjSUiIiIiscWXO4Dy7IHUxSe29LCxRMHIYQ3lFdz+6iOcu/gxp0sRERERETmgHolxAOyMwWCkqXRO27yZ733wLA3regFzna5GRERERGTfKir44ZJ/sqO6gaqrJjhdTbtTMHKYVVEJQLBnLxIdrkVEREREZL/q6pj+4qM0eOP5X/09TlfT7jSVzmHG9sjFXcM9ezlciYiIiIjIAfSOXMcoMRSgZme1w8W0PwUjh3l2RoJR8xtNRERERKRLSk3F9EQmnPnLKhwupv0pGDksflckGLl1cVcRERER6coMg8a0ngCEK7c5XEz7UzBykGXZJFRXAeDN6uNwNSIiIiIiBxZsWv5hVygYSTuq9Yfp0RCZnxmfrWAkIiIiIl2b2RSMjB0KRtKOqhqC/OzM68m/+gG80y92uhwRERERkQPrnQGAu3mdfAzRdt0O2tkQZGdiGon9sqCPRoxEREREpGur/tkvuajv2YSzsrje6WLamYKRg6qarhjcfAVhEREREZGuLHnEcDb0LMUdNrBtG8MwnC6p3WgqnYOq6oP89LW/cvmSJ6Cx0elyREREREQOKD3RC4Bp2dT4ww5X0740YuSgum07ufr9hfA+wFyHqxEREREROTDf+rXMeusxyuNTqKqfTFqC1+mS2o2CkYMatkUWrYW9cXgSEhyuRkRERETka2zcyPeXPsWqzMHsbAiSS5LTFbUbTaVzUHDbTgACyakOVyIiIiIichDS0wFIDdSzqyHobC3tTMHIQeGdkWAUTlEwEhEREZEo0ByM/HXsqFMwknZi79oFgJmW5mwhIiIiIiIHoykYpQQaqNGIkbQH0zSp/+JTAGqwMU3T4YpERERERL5G0wf6LmzeXfgUS5YsiZk+VsHIAUVFRQwdnEvVq48D8M6Kjxk6OJeioiKHKxMRERER2b+iF16g+SIzL867nVNPPTVm+lgFo05WVFREQUEBo30VXHZZAg0zEhlR4GN0QgUFBQUx8aYSERERkdjT3Mc2uiO3P/9uIstmJMZMH2vYtm07XUR7qqmpIS0tjerqalJTu9amBqZpMnRwLqN9FSyc7sO1x5WCLdtm2gI/K/1ZrF1fgtvtdrBSEREREZHdWvWxp3pxeQ1Ic4HH6NJ9bFuygUaMOlFxcTEbNm1mdp63VSgCcBkGsyZ5KdlYSnFxsUMVioiIiIjsrVUfm+WBXm7wRPrZWOljdYHXTlRWVgbAqMymFP1xEGpsGOGBTHfL8ebzRERERES6gr362K+IhT5WI0adKDs7G4CVlU07d3wSgtcDUGm1Ot58noiIiIhIV9Cqj10Tgtf8UBJuuT8W+lgFo06Ul5dH7oD+3Lk0hGXb4G9a3uWLzM2c81aIQQNzyMvLc7ZQEREREZE97NnH2mvCUByEjZFgFCt9rIJRJ3K73cyddx+L1oSZ+pQff10kGK2oNpm2wM+iNWHuvufeLrVgTURERERkzz726ZLI6FCw3mZZaThm+lgFo06Wn59PYWEhH9T2prEpGF20KMBKfxaFhYXk5+c7XKGIiIiIyN6a+9h1ZjIAT3wQ4sT5DTHTx2rzBQfk5+dTnzmGtLzhgM38p5/m+KlTozphi4iIiEjsy8/Pxywvhx/8gMw+Qyma/wDfPOv0mOhjFYwcEqquw0VkxOjEc86BGHgziYiIiEjsc/fqBUDPOB8Zx54YE6EINJXOMaEdOwAIe+PA53O4GhERERGRg5SeDkBqoJ5af/jA50YRjRg5pCyhJ2d/536uHN2LS5wuRkRERETkYDUHI389XzaGnK2lHSkYOWSXCaszB1E3fqTTpYiIiIiIHLyjjmLW//2Vt6ps/i+GRow0lc4hzcOOqQnKpiIiIiISRZKT2TZyDJt6ZFPrj50RIwUjh2R8sYIfvL2AIe+87nQpIiIiIiJtkuLzAsTUGiMFI4cM/OJjbiv+FwP/94zTpYiIiIiItMmZLz3JLW/+i2BlpdOltBsFI4e46usjf6amOFyJiIiIiEjbnPL0I9y4bAFGWbnTpbQbBSOHuBoiwcijYCQiIiIiUSacmAxAqLra4Uraj4KRA0KhMFRuAqC8ugrTNB2uSERERETk4JlJSQBseed1lixZEhP9rIJRJysqKmLYkEG41iwD4B//foqhg3MpKipyuDIRERERka9XVFTE2o3rAVj//KOceuqpMdHPKhh1oqKiIgoKChiTUMG0QW4ArpnoZXRCBQUFBVH/ZhIRERGR2Nbcz7q9kd3oHj/Xx7IZiTHRzxq2bdtOF9GeampqSEtLo7q6mtTUVKfLaWGaJkMH5zLaV8HC6T5cTzbC2jB804d1tJdpC/ys9Gexdn0Jbrfb6XJFRERERFrZs5991mNjfBaGs31wfByWbXfJfrYt2UAjRp2kuLiYDZs2MzvPi8sw4Kx4uCoRhnpwGQazJnkp2VhKcXGx06WKiIiIiOxlz37WiDMiB4ORMZZY6Gc9ThfQXZSVlQEwKrMpPfdyQ6/d9zcfbz5PRERERKQradXPnmTAhDhIM1ruj/Z+ViNGnSQ7OxuAlZX73rGj+XjzeSIiIiIiXUmrfraXG/q5IXl3nIj2flZrjDpJy5zMhAoWXuzD9X4IbGC0ByvB6JJzMkVEREREmu3Vzxq7R4u0xkgOmtvtZu68+1i0JszUp/yEX/XDYj8ffRlm2gI/i9aEufuee7vMm0hEREREZE979rM//GcjG19opPGjIMtKY6OfVTDqRPn5+RQWFvJedS8IRo6d+3QkWRcWFpKfn+9sgSIiIiIiB9Dcz8bVpjDw/RDFz/k5cX5DTPSz2nyhk+Xn51ORMBTPOWMBWLBoESeefXbUJmsRERER6V7y8/OZCnDhhfTokc38h//CFfnfiPp+VsHIAXZdQ8t/5519NkT5m0hEREREuhd303qdFHccR004MepDEWgqnSPCNbUAhOLiFYpEREREJPokJQGQGPJTHww7XEz7UDBygFlbB0A4IdHhSkREREREDkFTMEoIBWgI7PtyNNFGwcgBdl1kxCickORwJSIiIiIih2DPEaNAbIwYaY2RA0oyBnDxJXP4Xt4gznC6GBERERGRttpjxKg+EHK4mPahYOSAKncC7w4YzSUTj3a6FBERERGRtuvVi0d+9jD/K6nh9BgZMdJUOgc0NC1QS4jTxgsiIiIiEoW8XrYeO4kP+42kLmQ5XU27UDByQFbJai7/cBHZHy5zuhQRERERkUOS4I18yO8PafMFOURHfr6c37z8EP2eedLpUkREREREDsm415/je+8V4dpW6XQp7ULByAGexnoAjKRkhysRERERETk0Ex+9j9tfn0/i1s1Ol9IuFIwcENfYAIA7NcXhSkREREREDo3VdE1Ou77B4Urah4JRJ7NtG2+gEQCPgpGIiIiIRCkrISHyHw31zhbSThSMOlkgbJEYbApGaakOVyMiIiIicmjsxMi1jIx6BSM5BPWBMIlBPwBejRiJiIiISJSymy7y6mrQVDo5BA1Bk6SmESNXijZfEBEREZEo1RSM3I0KRnIIGkMmd51yJTd9+1cwebLT5YiIiIiIHBIjxoKRx+kCupuGoMnKrKFUpSdATo7T5YiIiIiIHJK662/gJtdItvfL5QdOF9MONGLUyWobA/g3fUrNyiUsWbIE04yNKwWLiIiISPdijx7Ny24PH5esjIm+VsGoExUVFXHx5GOY8uRsxj3+Gy449VSGDs6lqKjI6dJERERERA5aUVERJx8zkoonZ1O+8C5OjYG+VsGokxQVFVFQUMD4lG38PR7+Cbx+oY/RCRUUFBRE9ZtIRERERLqP5r72fFcF6yfF0XBJAstmJEZ9X2vYtm07XUR7qqmpIS0tjerqalJTu8Z1gkzTZOjgXEb7Klg43YfrzloIAzclY6UZTFvgZ6U/i7XrS3C73U6XKyIiIiKyT6362lwXrpcCMMoDFyZi2XaX62vbkg00YtQJiouL2bBpM7PzvJEXPNx0hwdchsGsSV5KNpZSXFzsYJUiIiIiIgfWqq/1GpGDTb1ttPe1CkadoKysDIBRmW7Yc02ax9h9fI/zRERERES6olZ9rbfpYGj3BLRo7msVjDpBdnY2ACsrTQjtcUfTm2llpdnqPBERERGRrqhVX9v0If+e/W0097UKRp0gLy+P3AH9uXNpCCtkRQ4agAss22bOWyEGDcwhLy/P0TpFRERERA6kVV/bfEXUcGTEKNr7WgWjTuB2u5k77z4WrQnz/WcCANgeWLbZZNoCP4vWhLn7nnu7xAI1EREREZH92bOv/fnSIABmEJaVhqO+r1Uw6iT5+fkUFhayuK4H04CCEJw4v4GV/iwKCwvJz893ukQRERERka/V3Nd+HuoJwIbtVkz0tdquu5P94PEPePr5l5k6PJFLJo8lLy8vKhO1iIiIiHRv5rZt/Pq7s/h0Ry0TvnsRP/nOBV2ur21LNvAc8F5pd0ETfAPGcMo3RjP5+AFOlyMiIiIickjcGRlszL+Gj77YxrePHtPlQlFbaSpdJ0usLGPqqtfp/9Eyp0sRERERETksPk8kDPnDlsOVHD6NGHWy/utWcduiuVSVjodrL3a6HBERERGRQxMMcsJ7L5GyvoLAN45wuprDpmDUyVz+RgBsX4LDlYiIiIiIHIZAgCv/NBuAh384w+FiDl+HTqXbuXMnl156KampqaSnpzNjxgzq6uoOeP4Pf/hDjjjiCBISEhgwYAA33ngj1dXVHVlmp3L5/ZH/SFAwEhEREZEotkc/a9bXO1hI++jQYHTppZeyatUqXn75ZRYtWsSbb77JNddcs9/zt27dytatW7n77rtZuXIl//jHP1i8eDEzZkR/Am3mCigYiYiIiEgM8HgwPZEJaGZDo8PFHL4Om0r3+eefs3jxYt5//30mTJgAwP33388555zD3XffTd++ffd6zKhRo3j66adbbg8ZMoQ77riDyy67jHA4jMcT/TP/3E1T6YykRIcrERERERE5POE4H+5wHVZ9g9OlHLYOGzFatmwZ6enpLaEIYMqUKbhcLt59992Dfp7mPcf3F4oCgQA1NTWtvroydyAAgJGoYCQiIiIi0c2M9wFgxcCIUYcFo/LycjIzM1sd83g89OzZk/Ly8oN6ju3bt/Ob3/zmgNPv5syZQ1paWstXTk7OYdXd0TxNU+lcCT6HKxEREREROTzNwYjGbjhi9JOf/ATDMA74tXr16sMurKamhnPPPZcjjzySX/7yl/s9b9asWVRXV7d8lZaWHvb37kgLR+Rx83m3Err4EqdLERERERE5LFZ8fOTPRr/DlRy+Ni/aufXWW7nqqqsOeM7gwYPJysqisrKy1fFwOMzOnTvJyso64ONra2s5++yzSUlJ4ZlnnsHr9e733Pj4eOKb/kK6upBpsSpjEKsyBvGr4493uhwRERERkcPy6Y2zeeqNNbgyBzhdymFrczDKyMggIyPja8874YQT2LVrF8uXL2f8+PEAvPbaa1iWxfEHCAU1NTWcddZZxMfH89xzz+Hzxc6Us8AeVwSO93bohoAiIiIiIh2u6vSzeb6yDyckpDtdymHrsO585MiRnH322Vx99dW89957vPXWW9xwww1Mnz69ZUe6LVu2MGLECN577z0gEorOPPNM6uvr+dvf/kZNTQ3l5eWUl5djmmZHldpp/CGTo7d+wRlr3yF+8yanyxEREREROSzxnkic8Iejv1fv0P2vH3/8cW644QZOP/10XC4XF154IX/84x9b7g+FQnzxxRc0NEQWa3344YctO9YNHTq01XOVlJSQm5vbkeV2uEDY4pp3n+acNW/DaVnwgx84XZKIiIiIyCHLWPUR56xeit97tNOlHLYODUY9e/bkiSee2O/9ubm52Lbdcnvy5Mmtbscaf8gkzgxFbkTJuigRERERkf0Z9PC9/Pm1l7g77kfAxU6Xc1i00KUTBUIWcWY4ciOG1k6JiIiISPdkNG3XbTRdqzOaKRh1In/YJD4cjNzQiJGIiIiIRDmj6dqcrqCCkbRBIGQR3zyVTiNGIiIiIhLlDF/kw35XIOhwJYdPwagTBU1La4xEREREJGa4EhIAcIcUjKQNQmGL+LCCkYiIiIjEBlfTiJE7HIz6TdQ6dFc6aS1oWszNu4xxCWGuHj7c6XJERERERA6Lq2l5SHwoSNiy8boNhys6dApGnSgYtnhhxEnUDO3N1dnZTpcjIiIiInJ4LryQ2z4LsKb3QC4OW3jd0TshTcGoEwXDFgBxnuh9w4iIiIiINPMefxz/GbMdiPS6SVG8WkTBqBMFTIuTv1zOaCMT/KO1M52IiIiIRDW3y8BlgGVHlo1EMwWjThQMW8wv/BUe24IffhP69nW6JBERERGRQ7d5M6dvWM42bzLB8KlOV3NYNKerE4UCoUgoAu1KJyIiIiLR76WXeOSpX/DDt58iEI7uESMFo05kNvp331AwEhEREZFo19TTxoVDLevpo5WCUSey/ApGIiIiIhJDmoORGSIU5WuMFIw6UXMwslwu8Gh5l4iIiIhEuaZgFG8Go37zBQWjTmQ3TaUzvXFgRO/Fr0REREREgJZdluM1lU7awvTvEYxERERERKJdy1S6cNQHI83n6kRVSen8Ysr3mTIqmzynixEREREROVx7rDGK9l3pFIw6iWmarCr5gqUJqTQMHs6Jponb7Xa6LBERERGRQ2YOGMCfJxfwWXUD/d9ZyhkjL4jaHtewbdt2uoj2VFNTQ1paGtXV1aSmpjpdDgBFRUXcOvMmNmza3HIsd0B/5s67j/z8fAcrExERERE5NNHQ47YlG2iNUQcrKiqioKCA0b4K3rssgfrLEvjkAh+jEyooKCigqKjI6RJFRERERNpkzx532YxEamelsGxGYlT3uBox6kCmaTJ0cC6jfRUsnO7DtS4MTzRClgvrmiSmLfCz0p/F2vUlUTvkKCIiIiLdS6se96J4XFssMIHBHizb7lI9rkaMuoji4mI2bNrM7DwvLsOA5vVobgOXYTBrkpeSjaUUFxc7WqeIiIiIyMFq1eP6gX80wL8awLajusdVMOpAZWVlAIzKbErKZtMdTTebjzefJyIiIiLS1bXqcd17XJuzaRAgWntcBaMOlJ2dDcDKyqZE9JVg1Hy8+TwRERERka6uVY+750y5pmAUrT2uglEHysvLI3dAf+5cGsKybTCblnO5wbJt5rwVYtDAHPLydFUjEREREYkOrXpc1x7bFZjR3eMqGHUgt9vN3Hn3sWhNmGkL/KzfHonRO4MwbYGfRWvC3H3PvY4vShMREREROVitetz/+FuOv78pHNU9roJRB8vPz6ewsJAVjX2Y+1YQgFc3maz0Z1FYWNhl9ngXERERETlYLT2uP4tQ07ELnmyM6h5X23V3EtM0ufCCW5mw9kNOOj+PvDm/jroULSIiIiKyJ9M0CScmEh8McuNNc5g397Yu1eO2JRt4Oqmmbs/tdrNu3Df4+MgzuOxHk7vUG0ZERERE5FC43W7eu/pHvPJZBcmjT4zqHldT6TpRyIysMfLsua2hiIiIiEgUW33J9/jbcRdQk5DsdCmHRcGoE/WqquSo8nX4KsudLkVEREREpF143JFI0TwIEK0UjDqJZdlc9uEinn/0ZpLvv9fpckRERERE2kXvkjWM27IaT12t06UcFgWjThKyLDxm5GJXRnycw9WIiIiIiLSPk35yLc889iOyN65xupTDomDUSUKmjdcKA+COj3e4GhERERGR9mHHeSP/EQg6W8hhUjDqJGHTIs6M7PJuxGnESERERERig+2N9LZGOPQ1Z3ZtCkadJGTaeM3IiJFLU+lEREREJEbY3qYRo6CCkRyEkGnhsZrXGGkqnYiIiIjEiKbZUEZIU+nkIIRNm7imESOaU7WIiIiISLRrnkoXiu4RI4/TBXQXIcti8fAT2JrRj2uOPdbpckRERERE2keMjBgpGHWSkGmxaOTJvJMcxzUTJzpdjoiIiIhIu6i64CLmm334Imuw06UcFgWjThI2bQA8Ls1eFBEREZHYUXvht/hjWT+y03xOl3JYFIw6Sci06L+rnJywB+rqIDnZ6ZJERERERA6b1x354D/UNBAQrRSMOknItLl30VwmbPkcJqXCBRc4XZKIiIiIyGHzba/giG0bCIV7OV3KYdG8rk4SNq2W6xihC7yKiIiISIzo/Yc7eXH+DUxb/j+nSzksCkadJGTZxJlNWxhqu24RERERiRHN1+h0hcMOV3J4FIw6SXiPC7xqxEhEREREYoUrLvKhvzsc3dt1Kxh1kpCm0omIiIhIDGoeMfKYYUwrejdgUDDqJCHTxmMpGImIiIhIbGkeMfKaYUKm5XA1h07BqJOELYu45hEjrTESERERkRjhahox8lphwlE8YqTtujtJKGzz+NHf4KgkizMzM50uR0RERESkXbiaZkN5zTChsAXxDhd0iBSMOknIsrjvpG9z5pF9ODM72+lyRERERETahevEE3jo+AtZ0Wcok63onUqnYNRJwk1XAm6+MrCIiIiISCwwTj2Ve073EzQtfmpqKp18jZBp0b+6gt673GCa4HY7XZKIiIiISLvwuA2CJlG9+YKCUScJmTZvPvQ9XNhQUA59+jhdkoiIiIjI4aurI7e6gu1hg1AUjxhpXlcnMYOhSCgC8CiPioiIiEiM+Pe/eeGPV3Hni38iHMVrjBSMOokZDO2+oWAkIiIiIrGiqbf1WiahsEaM5GuYYQUjEREREYlBTb2t2zIJacRIvo6154iRLvAqIiIiIrGiKRh5LLNlJ+ZopGDUSSxNpRMRERGRWNT0ob/HMqN6VzoFo07SvMbINgxw6WUXERERkRixx4hRNAcjDV10Er/byz/Hncsx/VMZ5XQxIiIiIiLtZY81RtE8lU7BqJPUJiTz8zOvY/Y5IxSMRERERCR25Oay+JR8PjJSGRfFmy8oGHWS5vTs1jQ6EREREYklI0fy6LdvY9mXO/hjFI8YqUvvJHYoRM+GahIbap0uRURERESkXXncBgCWFb3BSCNGnaT35i/58P5LaXysN+zc5nQ5IiIiIiLtIxSiR+1OMuqqCCsYydcKhwGwPW6HCxERERERaUeffMIfZ57DlpQMll75gdPVHDJNpesEpmmyY90KAIKmiWmaDlckIiIiItI+TCMyjc4dbODT99+O2l5XwaiDFRUVMXRwLu//6y4Atu/cztDBuRQVFTlcmYiIiIjI4SkqKuKc884FwBWo584fXBK1va6CUQcqKiqioKCA0b4K/npOPAD90gxGJ1RQUFAQlW8YERERERHY3esO9u0AIMMHy2YkRm2va9i2Hb0rpPahpqaGtLQ0qqurSU1NdawO0zQZOjiX0b4KFk734dpgwj8bIMOFdV0S0xb4WenPYu36EtxurTsSERERkejRqtc9Mw7Xn+ohDpiVimXbXabXbUs20IhRBykuLmbDps3MzvPiMgxovtaVC1yGwaxJXko2llJcXOxonSIiIiIibdWq123aqru5343WXle70nWQsrIyAEZlNiXkZAPGeiHVaHW8+TwRERERkWjRqtcNNE1As3bfH429rkaMOkh2djYAKyubduXo44ZpCXCar9Xx5vNERERERKJFq17Xa8DR3sggQJNo7HW1xqiDtMy7TKhg4cW+yHS6Jl1p3qWIiIiISFtFS6+rNUZdgNvtZu68+1i0Jsy0BX7e2Riits7inY0hpi3ws2hNmLvvuVehSERERESizld73WWlYWoDNstKw1Hb6yoYdaD8/HwKCwtZ0diH+//RSMrcOmr+0chKfxaFhYXk5+c7XaKIiIiIyCFp6XUbMjljfgP9f1fLifMborbX1VS6TmCaJj+fchl3LHmKTUePp98H70ZVehYRERER2R/T78edkADA9bc/wP2//H6X6XU1la6LcbvdJPXsB0B674wu80YRERERETlc7ri4lv8eOHx01Pa6CkadxAiHI//h1Q7pIiIiIhJDXC4sVyRWWKGww8UcOgWjTmKYkS0LDY/3a84UEREREYkudtMokR1WMJKv4QqHIv+hESMRERERiTGWu6nHDYWcLeQwKBh1ElfLiJGCkYiIiIjElpYRIwUj+Tpf9sjmheEnEjpmvNOliIiIiIi0K6tpuUg0T6XT8EUneXnYRF4YfDzvXHu606WIiIiIiLSr0pPP5LN15TTG+Zwu5ZApGHWSsBW5XJTbZThciYiIiIhI+3rvp7/np8+s5Mz0Pk6XcsgUjDqBZdlgWYCBR8FIRERERGJMc49rNg0GRCOtMeoEYcvm/954lA13nU/i7bOcLkdEREREpF25DQO3ZWKGTadLOWQKRp3AtGzcVvOudNF5JWARERERkf0566LTWP+HqQxZ87HTpRwyBaNOELYsPE3ByKXtukVEREQkxtjNPW5Y23XLAURGjCwAXF6vw9WIiIiIiLSz5llRUbxdt4JRJwhbdsuIkeHViJGIiIiIxBbb3TxipDVGcgCt1hhpxEhEREREYk3TVDrD1IiRHEBkxKjpTaI1RiIiIiISa5qDUUhrjOQATNPmi4xciodMgMGDnS5HRERERKR9NQejKJ5Kp+GLTmDaNn85/kKePOViVuSf5XQ5IiIiIiLtqnb88by3I8y2lJ5Ol3LIFIw6gdm0I13zFYFFRERERGJJ+W0/5eqUZQzqneR0KYdMU+k6QdiyAXC79HKLiIiISOxxNw0AhJsGBKKROvVOEDZtHlg4h+Jfnw//+IfT5YiIiIiItKvmYGSatsOVHDoFo05gWjYJoQAJIT9EcYoWEREREdmXgdd9hy/unsY5773gdCmHTMGoE4QtG7fdFIjcbmeLERERERFpZy7TJN4M49J1jORATMvGZSkYiYiIiEhsMjxNPa4Zvdt1Kxh1grBlacRIRERERGKW0dTjGgpGciCmptKJiIiISCxrHjGyFIzkAMKWjdEcjLRlt4iIiIjEGMMduTxqNI8Y6QKvncA0bT7LHExSvJejMjOdLkdEREREpF21rDGK4h2YFYw6Qdiy+eUZ1zJhYA8KTz7R6XJERERERNqVPXIkbw0cw5aUDCzLxtV0XaNoomDUCUwrcqErdxS+QUREREREvk7olh9xae0YAOZaNnFR2PdqwUsnCDcNKSoYiYiIiEgs8uzR54ajdDqdRow6gWnZLHjiJ4zctQWOWAgnn+x0SSIiIiIi7WbPAYDm2VLRRiNGncC0bNIba0itrYJw9F4NWERERERkX7w/u51P7r2YH771ZNTuv6Bg1AlsG9yWrmMkIiIiIrHJaGwkLVBPYiiAZWvESPbDtG1cusCriIiIiMSo5u26XbaFqWAk+2NaNm4FIxERERGJUYYnsnWB2zKxtMZI9seybVzNydmll1xEREREYkzTh/9ujRjJgViWjUtrjEREREQkVjX1uIZtE6UDRtquuzOYNqzOzMXq1Yuc5GSnyxERERERaV9Ns6LcthW1U+kUjDqBZdnMKPgFF4zrx7wRI5wuR0RERESkfQ0YwMf9RrA5LTNqr2OkYNQJQuEw/k2fsqZxBUv67CIvLw+3ptSJiIiISIwwr7qKC4p3ULdzOwOWvknO+WdGXb9r2HaUro7aj5qaGtLS0qiuriY1NdXpcigqKuL71/+A7RXlLcdyB/Rn7rz7yM/Pd7AyEREREZHDV1RUxK0zb2LDps0tx7pKv9uWbKDNFzpQUVERBQUFTEzbQX26gZlm8OG3fIxOqKCgoICioiKnSxQREREROWTN/e5oXwXLZiRSOyuFZTMSo7Lf1YhRBzFNk6GDcxntq2DhdB+uObUQAn6YjNXDYNoCPyv9WaxdXxJ1w4wiIiIiIq363eEuXG8EYYQHzknAsu0u0e9qxKgLKC4uZsOmzczO8+IyDGiOny5wGQazJnkp2VhKcXGxo3WKiIiIiByKVv1uCKi1oTHS9EZjv6tg1EHKysoAGJXZlI6bLmOEQavjzeeJiIiIiESTVv2uq6nJtXbfH239roJRB8nOzgZgZaUZObDHiNGex5vPExERERGJJq363aZcxB6LdKKt31Uw6iB5eXnkDujPnUtDWLa9+01igGXbzHkrxKCBOeTl5Tlap4iIiIjIoWjV7xpNzW7TH9HY7yoYdRC3283cefexaE2YaU82thx/f6vJtAV+Fq0Jc/c992rjBRERERGJSnv2uw98EAYgHLZZVhqOyn5XwagD5efnU1hYyDtVvVgJfA6c8WQjK/1ZFBYWOr6vu4iIiIjI4WjudzeFIju+vbjO5MT5DVHZ73qcLiDW5efn87ExlCn/eZ7TBsSx8Ozx5OXlRU1yFhERERE5kPz8fKa6XKydcT0VKX24/45fct3086Ku31Uw6gwuF74BY5hw2lAmTz7C6WpERERERNqVe9o0frihJ6vLa/nXccdFXSgCTaXrFKbVtJ978zaGIiIiIiIxxmVEet3m3jfaaMSoE3jra3nlkWvpsSAB1qwCr9fpkkRERERE2pW7aRDAshWMZD+MUJihOzfDTsClQToRERERiTEvv8xDv53Bhz1zsa74j9PVHBIFo05gm+buGwpGIiIiIhJr6uvpV1lKhSeRbVE6YqQuvRM0ByPL5QJD64xEREREJMY0bbbgsi2sKF1jpGDUCVpGjAy93CIiIiISg5qCkduyMDViJPvVPGLk1sstIiIiIjGoabmIy7aJ0gEjBaNOEY4EI9sVffu5i4iIiIh8rRiYSqfNFzpBGIPNqZmk9EghzeliRERERETa255T6aI0GGnEqBNs65XFSdfN5/kFrzldioiIiIhI+0tKojKjH2WpvaN2jZFGjDpB83CilhiJiIiISEw6/nhm3fUMr66u5HcaMZL9ab76r6GtukVEREQkRrlckV43SnORRow6Q0bZRp57dDYZSwfA0ledLkdEREREpN25mwYBNJVO9iuusYEx5etotOqcLkVEREREpP2tXs3sn13Kt41ESr5Z5HQ1h6RDp9Lt3LmTSy+9lNTUVNLT05kxYwZ1dQcOB9///vcZMmQICQkJZGRkMHXqVFavXt2RZXa45gu82m5t1y0iIiIiMcjvZ8DGLzhi+0btSrcvl156KatWreLll19m0aJFvPnmm1xzzTUHfMz48eP5+9//zueff86LL76IbduceeaZmE3hIhoZzbUbWtIlIiIiIjGo+TpGltWyvj7adNhUus8//5zFixfz/vvvM2HCBADuv/9+zjnnHO6++2769u27z8ftGZxyc3P57W9/y9ixY9mwYQNDhgzpqHI7lqURIxERERGJYa7IAIDLjt5g1GFDGMuWLSM9Pb0lFAFMmTIFl8vFu+++e1DP8f/t3Xl4lOW9//HPzGQHksiagEBAViW0CIosUShUFGvBGBVFC0q1VqkbRwVb2/PTWqy7tdqWeqr1iMKRjoiUalFQI0Y2QYwiKLJEIEGJJGyBzDz3749kxgQCEpo7D8/k/bquuYSZJ+QbvC/9fq5727t3r5555hl16dJFHTt2rPOZAwcOqLy8vNbrhBOqnjEiGAEAACAWRS54NY7Cjsu1HCdrwai4uFht27at9V5cXJxatmyp4uLio37tU089pebNm6t58+b617/+pYULFyohIaHOZ6dPn660tLTo60gBylVO1egwfpbSAQAAIAbFwFK6enfqU6dOlc/nO+rrPz0sYfz48Vq1apXefvtt9ejRQ5deeqkqKirqfHbatGkqKyuLvoqKiv6j721DyOfX1ylpCp3U0u1SAAAAgIZXY8bI8ejhC/XeYzRlyhRNnDjxqM907dpVGRkZ2rFjR633Q6GQSktLlZGRcdSvj8z+dO/eXWeddZZOOukkvfzyy7r88ssPezYxMVGJiYn1/TEa1Udd+2rAL2bq2avP0DC3iwEAAAAaWkKCdqe3Uqnim849Rm3atFGbNm2+87lBgwZp165dWrlypfr37y9JWrRokRzH0cCBA4/5+xljZIzRgQMH6lvqCSNyZGGg+jZgAAAAIKacfLIefPYtPVewWTd5dMbI2qaX3r1767zzztO1116rZcuWacmSJZo8ebLGjRsXPZFu69at6tWrl5YtWyZJ+uKLLzR9+nStXLlSW7Zs0XvvvadLLrlEycnJGj16tK1SrYuss4zcBgwAAADEGn91r+vVGSOrpwHMnDlTvXr10ogRIzR69GgNHTpUM2bMiH5eWVmpdevWad++fZKkpKQk5efna/To0erWrZsuu+wytWjRQu+9995hBzl4Se8NazR75p3qes9Ut0sBAAAArIgGI4+eSmftHiNJatmypV544YUjfp6VlSVTI1G2b99eCxYssFmSK9J3f6OBX36s3Wubu10KAAAA0PDKynT11Ct1wa79WjjkJberOS5WgxGqVV/wKj/3GAEAACAGOY46frJKHSW9Hgq5Xc1x4WKdRmAi84ncYwQAAIBYFPh2AsBxvLmWjk69EfjC1TNGccwYAQAAIAbVnABgxghH4qveR+VjxggAAACxqMaMkeG4bhxJdDqRYAQAAIBYVKPPdSKrpTyGTr0ROPJpX3yiTGKS26UAAAAADa9GMDIe3WPEqXSNYH7fH+j5bjl647az1cLtYgAAAICG5vfrYEozVYQlJ8xSOhyBU73OMnLpFQAAABBTAgH9bcGH6nvLbO1tlup2NceFYNQIIvvPCEYAAACIVYHqXtcxzBjhCAavX6ZnXvqNTnrkAbdLAQAAAKzw+6uCUdijp9Kxx6gRZOwq0fAvVmr/Rx3cLgUAAACwYtR/Xa0exWV6tcvDbpdyXAhGjYF7jAAAABDj2q94VyeHw/rngQNul3Jc6NQbgS9yZGGAv24AAADEJuOr6nWN8eZx3XTqlhljvp0x8vHXDQAAgBhVvTrKcFw36uIYycdSOgAAAMQ4U30As3HC7hZynOjULQs7Rv7IkYUspQMAAECsql4dxQWvqJNjjHyKLKXjHiMAAADEJhNZHcWMEeriGKP/OWOssu6cr8pn/+52OQAAAIAVJhCnSn9AxuHwBdSh5gVXfvYYAQAAIEa9nv+Jut/+ira1OdntUo4LnbplNS/+DfhZSgcAAIDYFOl1HW9uMeKCV9uMMRq17j39eO3b8nfaLN1wg9slAQAAAA0uMgVgjDeTETNGlhkjddtZpAvWLZH/gw/cLgcAAACwIvvuWzUj+Fu1+rrY7VKOC8HIspqn0ok9RgAAAIhRbfLf1Lmfva+k/XvcLuW40Klb5hhF7zHyBQIuVwMAAABYEj2um1PpUAdjjPymenBwjxEAAABiVPQeI/YYoS6OkXyRscFSOgAAAMSqyCQAM0aoi5GRLzJjRDACAABArIrOGBGMUAfHSP7I4QsspQMAAECsigSjMMEIdaisDOn+Ttk65Ue36e0LLlA4HHa7JAAAAKDBRXaPfL12qd566y3P9b0EI4uCwaDOPr23ts6+W1/Mf0TDRo1St65ZCgaDbpcGAAAANJhgMKhTnZASJL3w2jMaPny45/pegpElwWBQeXl5+n7KDhVMStHuaS1UMClF2cklysvL89QgAQAAAI4k0vdmt/ha70xKUblH+16fMR49T+8IysvLlZaWprKyMqWmprpSQzgcVreuWcpOKtHccUnyF4akDSGpe5ycU+M0dnaFCisy9NmGjQpwtxEAAAA86rC+t8aeescY1/ve+mQDZowsyM/P16YtX+qunPiqwbEtLH1YKW0Ly+/zadqQeG3cXKT8/Hy3SwUAAACOW62+940DUnCf9FXV3iKv9b0EIwu2b98uSerTtjoVR+bkqgN05P3IcwAAAIAX1ep714ekj0LS3m8XpHmp7yUYWZCZmSlJKtxRfRLHIcEo8n7kOQAAAMCLavW9kVV0NTbqeKnvJRhZkJOTo6xOJ+t371bKMUaKbOPyVa21nL6kUl06d1ROTo67hQIAAAD/gZp9rzkkGHmt7yUYWRAIBPTwo49r/vqQxs6uUPGeqtFRtNvR2NkVmr8+pIceeYyDFwAAAOBpNfveTbuqLnbdd9CooCjkub6XYGRJbm6u5syZow/2tFFwbUiS9PTqkAorMjRnzhzl5ua6XCEAAADwn4v0vXtNnCRp7Oz9Gvy3fZ7rewlGFuXm5uqf732kZt3OlCRNnDhRn23Y6JnBAQAAAByL3Nxcde15miTp5LMv0+LFiz3X98a5XUCs8/n9+v2Ft2t2sk8L7jpP8sA0IgAAAFBfPn/VJqO0rGwNGzbM3WKOA8HIMmOkfQnJKmuRLDVr5nY5AAAAgBWbZ8/TpX9+T81aprldynFhKZ1lTvWJdH7+pgEAABDL0tNUntRclX5vzr14s2oPcYyUW/imckq/kPqFpR/+0O2SAAAAgAbnq77IyBjzHU+emJjHsMwYo8Gb1+iiglekVavcLgcAAACwouVTj2v6v/6gHlvXu13KcSEYWWYk+UzVme6spwMAAECsav7vBbp8zb/Vflex26UcFzp1yxzHyB+ZTiQYAQAAIFZFel2HpXSog2P0bTDy+dwtBgAAALClOhj5CEaoizFGPjFjBAAAgNjmi0wCOGF3CzlOdOqW1ZoxIhgBAAAgVlX3uh49lI5gZJuR+fbwBZbSAQAAIFZFltJFel+PIRhZ5hjp7nNv0NW/ni1ddZXb5QAAAAB2eDwYccGrZY4xKk1J09et06S0NLfLAQAAAKwom/E/OueRxdrXrIUedLuY40Awsixy8y+r6AAAABDT2rRVSYvWCvi92fgSjCxzHOmSNQs1eMUO6cwE6cwz3S4JAAAAaHDRQ+k8evoCe4wsM5LO/axAF735ovTRR26XAwAAAFiR/Nyz+vUbM9Tvy7Vul3JcCEaWOcZwXDcAAABiXuKCf+qalfPU46vN0e0kXkKnbpkxRn6O6wYAAECsq54E8MvI8V4uIhjZ5hjJFxkYzBgBAAAgRvkC1cHIGE/uM6JTt8wYfTtjRDACAABArKpxj5EHcxHByDbHGPnYYwQAAIBYFwhIknzMGKEujjHyiz1GAAAAiG2+6l7Xb4wnZ4y4x8gyY6Q7zr9FOZlJun/0aLfLAQAAAOzwe3uPEcHIMscYbU1rq60dWktpaW6XAwAAAFgR+v0D+mHqcO1MSdOtBCMcKrq9iGV0AAAAiGH+Dh20sWUHSZL3YhHByDrHGF364b81eO0+aVALqXdvt0sCAAAAGlzNeYDIocxewuELlhkjXfrRQo2d97S0bp3b5QAAAABW+F9+Wf/1znMauOUj9hjhcI4x3GMEAACAmOf/53xNLvg/7U1I9mQwolO3zDFVJ3NI4rhuAAAAxCxfrXuMXC7mOBCMLDMyim4/Y8YIAAAAsSp6j5FT3QN7C526ZbVmjAhGAAAAiFXVva7Poxe80qlbZoxhKR0AAABin8cveCUYWeY4Rj5mjAAAABDrokvpvLnHiFPpLDOSbr7wvzQqq4VuHzjQ7XIAAAAAO6JL6RwZD84YEYwsc4z0eetOOq1beyktze1yAAAAADvuvFMXHeitLxNTdZH3chHByLZIWvazvwgAAACxrGNHrc88RXsPhtljhMM5xuiyD1/XD+Y9KxUVuV0OAAAAYE1kMsCLe4wIRpY5Rrpu2cu68IXHpU2b3C4HAAAAsOPNN3Vd/osavGm1J2eMWEpnmTFVG9AkcSodAAAAYtdrr+kXi/+u+DNzuccIh3O4xwgAAABNQY17jLx4Kh3ByDJjjHziHiMAAADEuOg9Rg57jHA4x+jbGSOCEQAAAGJV5B4jyZN7jOjULXOM+XaPEUvpAAAAEKuiS+kcghEOV3X4QvVvmDECAABArKqeBPAZ48nDFziVzjJjjCaPuVM/7tlSV/fo4XY5AAAAgB3RpXQEI9TBMdKqDr30vb5ZUosWbpcDAAAA2HHNNbq+pJU+VjP90YPJiGBkWWR9JduLAAAAENM6d1Zhlz768pv97DHC4YykSz/8t85c8KK0c6fb5QAAAADW+KtnA7wXi5gxss4xRne+/axavVYuTb5catXK7ZIAAACAhrdihfKW/EPLkjJkzCC3q6k3ZowsM9xjBAAAgKbgjTd007wndeHad7jgFYdzHCM/9xgBAAAg1kXvMTJyPJiMCEaWOabq9l9JzBgBAAAgdlVPAvjlMGOEwxkZ+SIzRgQjAAAAxKpIr2uMjAePX6BTt6zWHiOW0gEAACBW1VhK58HTuglGtjnGyCcOXwAAAECMiyylM8aT9xhxXLdljjG6fuxdyu2bobHt2rldDgAAAGBH9SSAT8aTe4wIRpY5Rnqna3/1P6uHlJLidjkAAACAHWPG6O5PK7W8IlF3MmOEQ0WvMGJ7EQAAAGJZ585a3XugPt1aJg+evcAeI5vC4bA2f7RMF77+pFo+/ZDCu3e7XRIAAABgRTgcVunnq7T3k7f1wdJ3FQ6H3S6pXghGlgSDQXXrmqUX//unemz1vzR+1gyd1bungsGg26UBAAAADSoYDOrcjh106h9uUr9XH9R/TbxY3bpmear3JRhZEAwGlZeXp+ykEhVMSlGg+v3eSV8pLy/PUwMEAAAAOJpI73tR+Gv9VdKC7nEqmJSi7OQST/W+PmM8uDPqKMrLy5WWlqaysjKlpqY2+vcPh8Pq1jVL2UklmjsuqSp53lO1hM6Z0kxj5x9UYUWGPtuwUYFA4Kh/FgAAAHAiq9X79vTL/+oBqUecdHmKHGM0dnaFq71vfbIBM0YNLD8/X5u2fKm7cuLl9/lqbTzz+32aNiReGzcXKT8/370iAQAAgAZwWO8rRftfv89bvS/BqIFt375dktSnbR2J2OeLvh95DgAAAPCqWr1vHacwe6n3JRg1sMzMTElS4Y7qUzhqLlT0fft+5DkAAADAq2r1vpFgVGOnjpd6X4JRA8vJyVFWp5P1u3cr5RhTKxg5Mpq+pFJdOndUTk6Oe0UCAAAADaBW7xt5s7r/dYy3el+CUQMLBAJ6+NHHNX99SGNnV6hga0j7xyZp3fAEXfxyheavD+mhRx7j4AUAAAB4Xs3e99GllZKkUFgqKKrqhb3U+xKMLMjNzdWcOXP00f52GvzsfqXMrVCvxQf14YFMzZkzR7m5uW6XCAAAADSISO/7D18bXSTpnE1hDf7bPhVWZHiq9+W4bovC4bAuuvtpFRRu0HXnna57fnaJJ9IyAAAAUF/hcFjnT5uhVZ9u1OQLztCvfprreu/Lcd0niEAgoA7d+uoyn0/nf1MqIhEAAABiVSAQUPve/dXs1HN0av+zXA9F9RXndgGxLq6iQk/Me0CaJ+n2n0oeGyAAAADAMdmyRYMKXlOozC9j+rpdTb0RjCzzfXs+BwAAABC7li3Tz/76G33/5NO0ST9xu5p6YymdZcapsYXLV8etVwAAAECMcTx4igHByDLHEIwAAADQBFT3uj6Z2j2wRxCMLKs1JghGAAAAiFWRYGSYMUIdjFNjjxHBCAAAADHOJ3PI7IA3EIws8+CYAAAAAOqvxiSAF2eMOJXOsv2JSZoy+lZdeVYn9WPGCAAAALEqupTOm3uMCEaWHYhL0D+yR2j4mH4EIwAAAMSu/v313A2/1RtfhXWO93IRS+lsi0wj+kQoAgAAQAzr2FErc0brna79ZTw4Y0Qwsizu4EH94PNlapf/htulAAAAAFb5q1dIeTAXsZTOtpS9ZXr6H/fIBH3SjVe5XQ4AAABgR3Gxspcv1rZtB+SYXm5XU2/MGFkWDcvsLwIAAEAsW7FC1zx8m6a99Td5cMKIYGSdF88qBAAAAP4DXlxKRzCyrmpUGGaMAAAAEMuix3VLxoNzRgQj26LH0hGMAAAAEMMiwUiGGSMc7tsxQTACAABA7PN5MRWJYGSdzzhulwAAAADYV2OFlBfvMeK4bsv2JLfQr374c105OEveO7QQAAAAOEbRpXTePHyBYGTZvsQUPX/6BRox7gyCEQAAAGLXaacp+LO79XpJWKe5XctxYCmdZdETOdhiBAAAgFjWsaOWn3uJXu852JMzRgQjy+IOHtCgzWuUvrzA7VIAAAAAqyLbjLx4XDdL6SxLLyvVs7PuUviVFOnKvW6XAwAAANixc6e6rS7Q6VvLZUx3t6upN2aMrPNeWgYAAADqbdUqXXPPz3Tf6096sgMmGNnmsMcIAAAATYwHNxkRjCzzVedl4yMZAQAAIIZFjus2XtxhRDCyLzJjxJQRAAAAYln0HiPjxQkjgpFt3x7XTTACAABA7PMZb55KRzCyzXtjAgAAAKi/GhMBXpwx4rhuy3Y1S9Pvhl2ty4d2Uxe3iwEAAABsqbmUzuVSjgfByLLdyc01Y+DF+sHVZxGMAAAAELu6ddPrk+7U68UH1daDyYildJZx9AIAAACahJNP1rKxP1GwzwhPzhkRjCxLOHhA39u2Ts0+XuN2KQAAAIBV0ckA7+UiltLZ1vabEj33v1MUevUk6ZtSt8sBAAAA7CgvV8e1H6hP8U4ZdXW7mnqzOmNUWlqq8ePHKzU1Venp6Zo0aZL27NlzTF9rjNH5558vn8+nuXPn2izTLsdxuwIAAADAvjVrNOGOq/T4qw/KePBYOqvBaPz48fr444+1cOFCzZ8/X++8846uu+66Y/raxx57TL6YuPuHe4wAAADQdPiMNy94tbaUbu3atXrttde0fPlyDRgwQJL0xBNPaPTo0XrooYfUvn37I37t6tWr9fDDD2vFihXKzMy0VWLjcKpGhSEYAQAAIJZ5/LhuazNGBQUFSk9Pj4YiSRo5cqT8fr+WLl16xK/bt2+frrjiCj355JPKyMj4zu9z4MABlZeX13qdWJgxAgAAQBMQCUbGmxe8WgtGxcXFatu2ba334uLi1LJlSxUXFx/x62699VYNHjxYY8aMOabvM336dKWlpUVfHTt2/I/qbmjRQUEwAgAAQCyrNWPkvWRU72A0depU+Xy+o74+/fTT4ypm3rx5WrRokR577LFj/ppp06aprKws+ioqKjqu722NF+MyAAAAUF81JgK82ALXe4/RlClTNHHixKM+07VrV2VkZGjHjh213g+FQiotLT3iErlFixZpw4YNSk9Pr/X+xRdfrJycHL311luHfU1iYqISExPr8yM0qm+apevRIVfosmG9dORdVQAAAEBs8HkxFek4glGbNm3Upk2b73xu0KBB2rVrl1auXKn+/ftLqgo+juNo4MCBdX7N1KlT9dOf/rTWe9nZ2Xr00Ud14YUX1rfUE0Jp85P0+NArNOL6IQQjAAAAxK6OHZU/4Rb9e1uF/B4MR9ZOpevdu7fOO+88XXvttfrzn/+syspKTZ48WePGjYueSLd161aNGDFCzz33nM4880xlZGTUOZvUqVMndenSxVapVkW3GIk9RgAAAIhhHTpo2RXX638Xfa6fuF3LcbB6j9HMmTPVq1cvjRgxQqNHj9bQoUM1Y8aM6OeVlZVat26d9u3bZ7MMVyUcPKAeX21S4hefuV0KAAAAYFVkKsCDE0b2ZowkqWXLlnrhhReO+HlWVtZ33orrxVtza+r01Rb9798mq/KfmVLxNrfLAQAAAOzYt09tvvhU3b/aKqNObldTb1ZnjKBv4zIr6QAAABDLPvlEV/18rJ6Z89+enDEiGFkUDoe198v1kqSDBw8qHA67XBEAAABgWeigCvMX6K233vJU/0swsiQYDKpb1yxtmfeYJKm0dKe6dc1SMBh0tzAAAADAgkWLF0uSzL4yzXt0qoYPH+6p/pdgZEEwGFReXp6yk0r0zI+r7lhq28yn7OQS5eXleWZwAAAAAMciGAzq9jvukCS1TfFp97QWKpiU4qn+12e8frrBIcrLy5WWlqaysjKlpqY2+vcPh8Pq1jVL2UklmjsuSf5tjvT0XinNJ+fm5ho7u0KFFRn6bMNGBQKBRq8PAAAAaEiR/neMivXYlpDUwifd1kKS5Bjjav9bn2zAjFEDy8/P16YtX+qunHj5fbVPXPD7fJo2JF4bNxcpPz/fpQoBAACAhhPpf685/fADr73U/1o9rrsp2r59uySpT9vqNNzcJw1OkJJ8td6PPAcAAAB4WaSv7dayes7lkPVoXul/mTFqYJmZmZKkwh3VJ3Ck+aUfJkk5ibXejzwHAAAAeFmkr12730hDE6SBCbU+90r/yx6jBhbdY5RcormXJdVaTuf2GksAAACgoZ3I/S97jFwUCAT08KOPa/76kMbOrtD7Gyu1pySslZ8e1NjZFZq/PqSHHnmMUAQAAICYULP/HTOrQgVFIe0+YFRQFPJU/8uMkSXBYFBTbr1ZGVu+VIGkzyWd27mjHnrkMeXm5rpWFwAAAGDD3NmzNf3Gyfpq59faWP1eF5f73/pkA4KRReFwWJf+6Bf6x2t/0u6MTKV8WXTCJ2UAAADguBQWStnZ+iqxmSZc90vdkTtIOTk5rva/9ckGnEpnUSAQUEpGN0lSUnIKoQgAAAAxzxeIU88h52vYsO+7XUq9sMfINuNU/fOQO40AAACAmFLd7/qMkRcXpRGMLIsOCYIRAAAAYlkkGOmwq4w8gWBkmxdHBQAAAFBftWaMXK7lOBCMbGMpHQAAAJqCGv2uB3MRwci2kuat9Fy/C7Qv71K3SwEAAACs88mbe4w4lc6yzS3b69fn/lwj7vyB0twuBgAAALClZUt9fMlEvV20hxkj1KF6VLCQDgAAADGtbVstv/nXeuCciZ5cS0cwsiwufFCt9u6Sf1ep26UAAAAAVvmq9xkZDyYjgpFlpxd9opV/vFKtRp/rdikAAACAPaGQUr4uVtvdOzmVDnVgKR0AAACagk2bdMmYQXrj6Z8TjFAHjusGAABAE+KTYSkdjoJgBAAAgFgWueBVYsYIh4sOCoIRAAAAYlkkGBkvzhcRjKzzeTEuAwAAAPVVYyLAiy0wwcgiY4x80dMXmDECAABA7Kvqf72XjAhGFhkjlTRvqZf6jFTlBRe6XQ4AAABgT3QpnTdnjOLcLiCWGUnr22Tp9gtu0chf/VDJbhcEAAAA2NKihTaMGaf3tpR7cL6IGSOrTI2ozEo6AAAAxLRWrbTylw/o7nNvqNUHewXByCIjKeCElXJwv3z7K9wuBwAAALCrejLAe7GIYGSVMVLOxg/0yaOXqNkPh7tdDgAAAGCP4yhhd5lSK/Z4co8RwcgiIxMJzSylAwAAQGzbtk1jf5CtFU9cyYwRaqudlElGAAAAiH0+GfYY4XDRC179BCMAAADEMI8vkSIYWWSMuOAVAAAATUP0HiPDHiPUZjy5uhIAAAA4DpFgJG/2wQQji4ypuvlXknzMGAEAAKCJYMYItRhJJc1ban7PoXKG/8DtcgAAAAB7PL6ULs7tAmKZMUYfZXbX5LFT9em95/GXDQAAgNiVnKwvzxurFVu+8eRSOnp1i2oOB1bSAQAAIKalpWnV/U/qlhdXaaD3chHByCZjFF1g6fPg4AAAAADqIzIZ4MXWlz1GNhlp1PoCbXrgQsUNO8ftagAAAAB7jJG/slLx4UrJ8V40IhhZZGSi9xhxKh0AAABi2s6dGj0gS589dJFkHLerqTeCkUVVx3VXp2U/wQgAAABNhAePpSMYWWRUdcEVAAAAEPNqrJDyXiwiGFkVCoVU+fVmSVJZWZnC4bDLFQEAAACW1AhGRcsX6q233vJU/0swsiQYDOqM7B4qW/KiJGn1mjXq1jVLwWDQ5coAAACAhvfq/PnRX6/8+70aPny4p/pfgpEFwWBQeXl5+l7yDt03PEGSdHqGX9nJJcrLy/PM4AAAAACORTAY1IQJE6K//+aO5iqYlOKp/tdnjAd3Rh1FeXm50tLSVFZWptTU1Eb//uFwWN26Zik7qURzxyXJvyUsLTkotfXLGZGosbMrVFiRoc82bFQgEGj0+gAAAICGFOl/z4ov1osbQlVv/qqFFPDJMcbV/rc+2YAZowaWn5+vTVu+1F058fL7fFLnOOmKFGlkkvw+n6YNidfGzUXKz893u1QAAADgPxbpf28dGi/1jKt6VfNS/xv33Y+gPrZv3y5J6tO27jQceT/yHAAAAOBlkb721PZx0rj4wz73Sv/LjFEDy8zMlCQV7qj7BI7I+5HnAAAAAC+Llf6XPUYNLLrHKLlEcy9Lkv/jkPTKfqlLnJzLk9ljBAAAgJhyWP9b49hu9hg1YYFAQA8/+rjmrw9p7OwKffZ1WApJu/Y6Gju7QvPXh/TQI48RigAAABATIv3v4nWVcu7ZLeeecu3e46igKOSp/pdgZEFubq7mzJmj1Xvb6v+9fVCStGybo8KKDM2ZM0e5ubkuVwgAAAA0nNzcXD3//POKk+Q3UsbDezT4b/s81f+ylM6izV/v1oMXTtIf339JpQMGKO3990/4pAwAAAAcl717pebNJUlnjZuq+382Sjk5Oa72v/XJBpxKZ5HfH1B8q46SpJatWkmEIgAAAMSqGnuLMr5/joYNG+ZeLceBpXSW+RRTE3IAAABA3WoEI58HW2CCkUXG1BgUNQYKAAAAEMu8uFmHYGSRkdFXzdK1rHNfqW9ft8sBAAAA7Kk1EeC4VsbxYo+RRcZI73Ttrw96D1Th/xvldjkAAACAPYGAdg0+Rx9tLVPYg/MvBCOLoqvoXK0CAAAAaATx8frkuTm66q9L1S0x2e1q6s17Uc5Doiehk4wAAADQBPiqG18v3ghEMLLISBrz8WK988Cl0vjxbpcDAAAAWBXZZuS9WEQwssoYKSl0UCftL5fKy90uBwAAALAnHNaA73fVmscuU/O9u92upt7YY2RVjazMcd0AAACIcXG7y5UqyWe8dyodM0YWVd1jFNlnRDACAABADKvZ77LHCDUZ1Th3gWAEAACAJoLDF1CLB8cDAAAAcHxqTAR4sQ8mGFlkZOQTS+kAAADQBNTqd9ljhBqMkXampOnjDj2l7t3dLgcAAABoHI73pow4lc4iY6TXewzWB/2Ha/kvR7pdDgAAAGDVntPP0Lri3Qr5Am6XUm8EI4tM9TI6FtEBAACgKfh87r918ZNL1KFZstul1BtL6SzipG4AAAA0JZG2l1PpcJjcwjc198Hx0g03uF0KAAAAYFVkQsB7sYhgZJUxUvMD+5S5a4f09ddulwMAAABY1eusbC198ic6qbzU7VLqjT1GFlUd112N9XQAAACIcfElxWoXCsnvhN0upd6YMbLIGMnnwfWVAAAAwPEw0bV03uuBCUYW1RoOzBgBAACgqSAYoSZjjHziaDoAAAA0EdU9r/diEcHIKiPJ58VRAQAAABwPltKhLsZI3yS30Ma2naWTT3a7HAAAAKBxeDAYcSqdVUYv9/mBPjjnR3r79uFuFwMAAABYdeDUPtq4tVSVfu/FDO9V7CGRoMzuIgAAADQFRf9arNGPvqOTUuLdLqXeWEpnUWQC0cfBCwAAAGgCIl2v9xbSEYysMka6ZM1CPfvgBGnqVLfLAQAAAKzy8NkLBCObjDFK379bnXdskbZtc7scAAAAwKqOI4Zq8Yxr1W5Xidul1Bt7jCwyEvcYAQAAoMmI3/iFuuzdo0A45HYp9caMkUW1phAJRgAAAIh11T2vF+/yJBhZZGS+nTECAAAAmgoPbjIiGNlkaqRlZowAAAAQ66p7XkMwQk3sMQIAAECT4vPugd0EI4uMkXYnNlNxywypdWu3ywEAAAAah/dyEafS2WRk9Hy/0Vpx/mV67Zaz3S4HAAAAsCrUpYu2bilRpd978y8EI4tMdBUdy+gAAAAQ+0oWLdHwBxYrMc57wch7FXtI9NwFV6sAAAAAGkdkPsCDK+kIRjYZY3Tph//W4w9fK913n9vlAAAAAFb5PJyMCEYWGUnt9uxU96J10ubNbpcDAAAAWNX6wvO04JlfqOM329wupd7YY2RTzaTMPiMAAADEuLi1n+jUnV8rofKg26XUGzNGFhmZb/cXEYwAAAAQ67jHCHUxRvJ58NZfAAAA4HhEY5EHe2CCkUWGpXQAAABoSjh8AXUxknyKXmbkai0AAACAbSYajLyXjAhGFhljtC8+SWXN06UWLdwuBwAAALDKF/2n94IRp9JZZCTNGHixVlwyScEbhrhdDgAAAGCV066dvtpXqZAvIGPMt/caeQDByCITXUXnnQEBAAAAHK+y95Zp4G/fkFR9EJmH2mCW0llVlYw8NB4AAACA41ZzQsBri+kIRhaFQmHlLv4f3XXPFfrsF79QOBx2uyQAAADAGiccVsWWNdr7ydt6a/FiT/W/BCNLgsGgrh19plote1mnF2/Wgj/+Ud26ZikYDLpdGgAAANDggsGgVmS0VPDFu9Ty1Qc1cuQIT/W/BCMLgsGg8vLyNKDF15r4vaptXJeeFqfs5BLl5eV5ZnAAAAAAxyLS//avrNBgSasmpqhgUoqn+l+f8eK1tEdRXl6utLQ0lZWVKTU1tdG/fzgcVreuWcpOKtHccUnyLzogvXtQGpggZ1Sixs6uUGFFhj7bsFGBQKDR6wMAAAAaUs3+95XikHzlRrq2mdQ+IMcYV/vf+mQDZowaWH5+vjZt+VJ35cTL7/PV2nXm9/k0bUi8Nm4uUn5+vntFAgAAAA2kZv976Cl0Xup/CUYNbPv27ZKkPm0PScPVgyTyfuQ5AAAAwMvq7H9rTA54pf8lGDWwzMxMSVLhjuoTOA5ZqBh5P/IcAAAA4GWH9b+H8Er/SzBqYDk5OcrqdLJ+926lHGOkgKR4SQHJMUbTl1SqS+eOysnJcbtUAAAA4D9Ws/81kaV01ccYeKn/JRg1sEAgoIcffVzz14c0ZlaFCrrHafeUFiroGaexsys0f31IDz3yGAcvAAAAICbU7H837TcKJUh7Q1JBUchT/S+n0lkSDAZ1w+TJKqmxlrJL54566JHHlJub61pdAAAAgA3BYFC33XKzNhd9GX3P7f63PtmAYGTRS8s36xePvqBuzUP67RU5ysnJOeGTMgAAAHC89lYc1CnXPKzwnm/098nnatSI4a72v/XJBnGNVFOT5PcHNOGb7brioxX63lkdpGHD3C4JAAAAsCYQCCipU19J0tCzz/HUpAB7jCwykrrtLNL3CgukdevcLgcAAACwKv6nk/S/s36l7l9tltfWpTFjZJExRr7IiDj0tisAAAAgxvjfW6KczZ8r9cDew66tOdExY2RRrbFAMAIAAECsq+55fTIyHktGBCObjEQcAgAAQJNRYzLAa0vpCEYWGbGUDgAAAE2Pz3htvohgZJUxVdOIkghGAAAAiH3RpXRV++29hGBkEXuMAAAA0KREghEzRqjJGOn/jfyZrv37cum3v3W7HAAAAMAqX3y8Kv1Vdxd5bMKI47ptiuRk5ooAAADQJKxZo+5T/ylJnEqHb3HuAgAAAJqaaO/rrVxEMLIpHA4rd/H/aPx/T9THv/61wuGw2yUBAAAA1oTDYVVsXqO9n7ytd/Pf8VT/SzCyJBgM6o68oeq27GWd/cXHmnPvverWNUvBYNDt0gAAAIAGFwwG9Vx6uv704l3KfPVBXfyjUZ7qfwlGFgSDQeXl5enM1K+V26tqG9ekfnHKTi5RXl6eZwYHAAAAcCwi/e/wg3s0VtLSy5NVMCnFU/2vz3jtgPHvUF5errS0NJWVlSk1NbXRv384HFa3rlnKTirR3HFJ8v+zQlpZKZ2TKOecBI2dXaHCigx9tmGjAoFAo9cHAAAANKSa/e8ru8Ly7XCkq1KkrnFyjHG1/61PNmDGqIHl5+dr05YvdVdOvPyHnLrg9/k0bUi8Nm4uUn5+vksVAgAAAA2nZv976KFjXup/CUYNbPv27ZKkPm0PScPVgyTyfuQ5AAAAwMvq7H9rrEnzSv9LMGpgmZmZkqTCHdUncByyUDHyfuQ5AAAAwMsO638P4ZX+l2DUwHJycpTV6WT97t1KOTW3b/kkxxhNX1KpLp07Kicnx70iAQAAgAZSs/81h9xh5KX+l2DUwAKBgB5+9HHNXx/SmFkVej87TrunNNf7nfwaO7tC89eH9NAjj3HwAgAAAGJCzf73i28cSdK+SqOCopCn+l9OpbMkGAzq+htu1FclxdH3unTuqIceeUy5ubmu1QUAAADYEAwGNfWWm7SpaKtCqpo0crv/rU82IBhZ9Kc3PtUvpz+sjvG7dfV5Z+mGG25QQkKCqzUBAAAAthw8eFCdfvQL7du5TbdcNFS/uuNWV/tfjus+AQSDQf3myuG6aNHTuu312Xrj1lvVs/spnrjcCgAAAKivYDCont1PUcnCGdr9wXzde/dUT/W/VoNRaWmpxo8fr9TUVKWnp2vSpEnas2fPUb9m2LBh8vl8tV7XX3+9zTIbXOTm34FpOzW9e0ATJD01IN5TN/8CAAAAxyrS/96/Z5u+6hrQ3qtTVDApxVP9r9WldOeff762b9+uv/zlL6qsrNTVV1+tM844Qy+88MIRv2bYsGHq0aOH7rnnnuh7KSkpx7wszu2ldDVv/p07Lkn+eRXS6kppRKKcIQmu3vwLAAAANLSa/e8re8LybXOky5OlHvFyjHG1/z0hltKtXbtWr732mp5++mkNHDhQQ4cO1RNPPKFZs2Zp27ZtR/3alJQUZWRkRF9u7xWqj5o3//oPufrXSzf/AgAAAMeiZv/rO+QzL/W/cbb+4IKCAqWnp2vAgAHR90aOHCm/36+lS5fqoosuOuLXzpw5U88//7wyMjJ04YUX6u6771ZKSkqdzx44cEAHDhyI/r6srExSVTp0w4YNGyRJndL8Kj9gpHD1hFzYSAeMOqX5o8+dfvrprtQIAAAANJRa/W9kMdrBqt438n7kucbufyOZ4JgWyRlL7rvvPtOjR4/D3m/Tpo156qmnjvh1f/nLX8xrr71m1qxZY55//nnToUMHc9FFFx3x+d/85jdGVacB8uLFixcvXrx48eLFi9dhr6Kiou/ML/WeMZo6dap+//vfH/WZtWvX1vePjbruuuuiv87OzlZmZqZGjBihDRs26JRTTjns+WnTpum2226L/t5xHJWWlqpVq1by+Q6dzGt85eXl6tixo4qKijy1JBDuYLygvhgzqC/GDOqLMYP6OpHGjDFGu3fvVvv27b/z2XoHoylTpmjixIlHfaZr167KyMjQjh07ar0fCoVUWlqqjIyMY/5+AwcOlCR9/vnndQajxMREJSYm1novPT39mP/8xpKamur6wIB3MF5QX4wZ1BdjBvXFmEF9nShjJi0t7Zieq3cwatOmjdq0afOdzw0aNEi7du3SypUr1b9/f0nSokWL5DhONOwci9WrV0uSMjMz61sqAAAAABwTa6fS9e7dW+edd56uvfZaLVu2TEuWLNHkyZM1bty46FTW1q1b1atXLy1btkxS1Yase++9VytXrtSmTZs0b948/eQnP9HZZ5+tvn372ioVAAAAQBNn9YLXmTNnqlevXhoxYoRGjx6toUOHasaMGdHPKysrtW7dOu3bt0+SlJCQoDfeeEPnnnuuevXqpSlTpujiiy/Wq6++arNMqxITE/Wb3/zmsOV+QF0YL6gvxgzqizGD+mLMoL68OmasXvAKAAAAAF5gdcYIAAAAALyAYAQAAACgySMYAQAAAGjyCEYAAAAAmjyCkUVPPvmksrKylJSUpIEDB0aPJUfTMn36dJ1xxhlq0aKF2rZtq7Fjx2rdunW1nqmoqNCNN96oVq1aqXnz5rr44otVUlJS65ktW7boggsuUEpKitq2bavbb79doVCoMX8UuOT++++Xz+fTLbfcEn2PMYNDbd26VVdeeaVatWql5ORkZWdna8WKFdHPjTH69a9/rczMTCUnJ2vkyJH67LPPav0ZpaWlGj9+vFJTU5Wenq5JkyZpz549jf2joBGEw2Hdfffd6tKli5KTk3XKKafo3nvvVc0zuRgzTds777yjCy+8UO3bt5fP59PcuXNrfd5Q42PNmjXKyclRUlKSOnbsqAceeMD2j3ZkBlbMmjXLJCQkmL/97W/m448/Ntdee61JT083JSUlbpeGRjZq1CjzzDPPmMLCQrN69WozevRo06lTJ7Nnz57oM9dff73p2LGjefPNN82KFSvMWWedZQYPHhz9PBQKmT59+piRI0eaVatWmQULFpjWrVubadOmufEjoREtW7bMZGVlmb59+5qbb745+j5jBjWVlpaazp07m4kTJ5qlS5eaL774wrz++uvm888/jz5z//33m7S0NDN37lzz4Ycfmh//+MemS5cuZv/+/dFnzjvvPPO9733PvP/++yY/P99069bNXH755W78SLDsvvvuM61atTLz5883GzduNC+99JJp3ry5efzxx6PPMGaatgULFphf/vKXJhgMGknm5ZdfrvV5Q4yPsrIy065dOzN+/HhTWFhoXnzxRZOcnGz+8pe/NNaPWQvByJIzzzzT3HjjjdHfh8Nh0759ezN9+nQXq8KJYMeOHUaSefvtt40xxuzatcvEx8ebl156KfrM2rVrjSRTUFBgjKn6j5Pf7zfFxcXRZ/70pz+Z1NRUc+DAgcb9AdBodu/ebbp3724WLlxozjnnnGgwYszgUHfeeacZOnToET93HMdkZGSYBx98MPrerl27TGJionnxxReNMcZ88sknRpJZvnx59Jl//etfxufzma1bt9orHq644IILzDXXXFPrvdzcXDN+/HhjDGMGtR0ajBpqfDz11FPmpJNOqvX/pTvvvNP07NnT8k9UN5bSWXDw4EGtXLlSI0eOjL7n9/s1cuRIFRQUuFgZTgRlZWWSpJYtW0qSVq5cqcrKylrjpVevXurUqVN0vBQUFCg7O1vt2rWLPjNq1CiVl5fr448/bsTq0ZhuvPFGXXDBBbXGhsSYweHmzZunAQMG6JJLLlHbtm3Vr18//fWvf41+vnHjRhUXF9caM2lpaRo4cGCtMZOenq4BAwZEnxk5cqT8fr+WLl3aeD8MGsXgwYP15ptvav369ZKkDz/8UO+++67OP/98SYwZHF1DjY+CggKdffbZSkhIiD4zatQorVu3Tt98800j/TTfimv079gEfP311wqHw7UaEklq166dPv30U5eqwonAcRzdcsstGjJkiPr06SNJKi4uVkJCgtLT02s9265dOxUXF0efqWs8RT5D7Jk1a5Y++OADLV++/LDPGDM41BdffKE//elPuu2223TXXXdp+fLluummm5SQkKAJEyZE/53XNSZqjpm2bdvW+jwuLk4tW7ZkzMSgqVOnqry8XL169VIgEFA4HNZ9992n8ePHSxJjBkfVUOOjuLhYXbp0OezPiHx20kknWan/SAhGQCO68cYbVVhYqHfffdftUnACKyoq0s0336yFCxcqKSnJ7XLgAY7jaMCAAfrd734nSerXr58KCwv15z//WRMmTHC5OpyI/u///k8zZ87UCy+8oNNOO02rV6/WLbfcovbt2zNm0GSxlM6C1q1bKxAIHHZCVElJiTIyMlyqCm6bPHmy5s+fr8WLF+vkk0+Ovp+RkaGDBw9q165dtZ6vOV4yMjLqHE+RzxBbVq5cqR07duj0009XXFyc4uLi9Pbbb+sPf/iD4uLi1K5dO8YMasnMzNSpp55a673evXtry5Ytkr79d360/y9lZGRox44dtT4PhUIqLS1lzMSg22+/XVOnTtW4ceOUnZ2tq666SrfeequmT58uiTGDo2uo8XGi/b+KYGRBQkKC+vfvrzfffDP6nuM4evPNNzVo0CAXK4MbjDGaPHmyXn75ZS1atOiwKeP+/fsrPj6+1nhZt26dtmzZEh0vgwYN0kcffVTrPzALFy5UamrqYc0QvG/EiBH66KOPtHr16uhrwIABGj9+fPTXjBnUNGTIkMOuAVi/fr06d+4sSerSpYsyMjJqjZny8nItXbq01pjZtWuXVq5cGX1m0aJFchxHAwcObISfAo1p37598vtrt4GBQECO40hizODoGmp8DBo0SO+8844qKyujzyxcuFA9e/Zs9GV0kjiu25ZZs2aZxMRE8+yzz5pPPvnEXHfddSY9Pb3WCVFoGn7+85+btLQ089Zbb5nt27dHX/v27Ys+c/3115tOnTqZRYsWmRUrVphBgwaZQYMGRT+PHL187rnnmtWrV5vXXnvNtGnThqOXm5Cap9IZw5hBbcuWLTNxcXHmvvvuM5999pmZOXOmSUlJMc8//3z0mfvvv9+kp6ebV155xaxZs8aMGTOmzqN1+/XrZ5YuXWreffdd0717d45ejlETJkwwHTp0iB7XHQwGTevWrc0dd9wRfYYx07Tt3r3brFq1yqxatcpIMo888ohZtWqV2bx5szGmYcbHrl27TLt27cxVV11lCgsLzaxZs0xKSgrHdceiJ554wnTq1MkkJCSYM88807z//vtulwQXSKrz9cwzz0Sf2b9/v7nhhhvMSSedZFJSUsxFF11ktm/fXuvP2bRpkzn//PNNcnKyad26tZkyZYqprKxs5J8Gbjk0GDFmcKhXX33V9OnTxyQmJppevXqZGTNm1PrccRxz9913m3bt2pnExEQzYsQIs27dulrP7Ny501x++eWmefPmJjU11Vx99dVm9+7djfljoJGUl5ebm2++2XTq1MkkJSWZrl27ml/+8pe1jk1mzDRtixcvrrN/mTBhgjGm4cbHhx9+aIYOHWoSExNNhw4dzP33399YP+JhfMbUuOIYAAAAAJog9hgBAAAAaPIIRgAAAACaPIIRAAAAgCaPYAQAAACgySMYAQAAAGjyCEYAAAAAmjyCEQAAAIAmj2AEAAAAoMkjGAEAAABo8ghGAAAAAJo8ghEAAACAJo9gBACIKWPGjJHP56vzNW/ePLfLAwCcoHzGGON2EQAANJSdO3eqsrJSe/bsUffu3bVgwQL169dPktS6dWvFxcW5XCEA4EREMAIAxKSCggINGTJE5eXlat68udvlAABOcCylAwDEpDVr1igrK4tQBAA4JgQjAEBMWrNmjfr27et2GQAAjyAYAQBi0qZNm9SzZ0+3ywAAeATBCAAQkxzH0ebNm7V161axnRYA8F0IRgCAmHTTTTdpyZIl6tmzJ8EIAPCdOJUOAAAAQJPHjBEAAACAJo9gBAAAAKDJIxgBAAAAaPIIRgAAAACaPIIRAAAAgCaPYAQAAACgySMYAQAAAGjyCEYAAAAAmjyCEQAAAIAmj2AEAAAAoMkjGAEAAABo8v4/UvEpg6IyXyoAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -201,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 4, "id": "f728e5fc", "metadata": { "tags": [] @@ -209,7 +209,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAANBCAYAAAD9Rh/7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABrUklEQVR4nO3dfXyU9Z3v//fMJBOSQEZIAkFBYG0LUdQiogLqQrcFtTbxtFBZt1jOoax0qy1oz3ogPVV7RGp3j73zhrZC2boWLVrM9PyUit1ErYB3JVoV3K4VUCQSA85AgNxMrt8fM3Mxk0zur2uumblez8djHpm55pprPtGR8c33+/18PYZhGAIAAAAADJnX6QIAAAAAIFcQsAAAAADAIgQsAAAAALAIAQsAAAAALELAAgAAAACLELAAAAAAwCIELAAAAACwSJ7TBTihs7NTH3zwgUaMGCGPx+N0OQAAAAAcYhiGjh49qtNPP11e79DHn1wZsD744AONHz/e6TIAAAAAZIj33ntP48aNG/J1XBmwRowYISn6D7GkpMThagAAAAA4JRwOa/z48WZGGCpXBqz4tMCSkhICFgAAAADLlg7R5AIAAAAALELAAgAAAACLELAAAAAAwCKuXIMFAACAzBCJRNTe3u50Gchxfr/fkhbs/UHAAgAAQNoZhqHGxkZ9/PHHTpcCF/B6vZo0aZL8fr/t70XAAgAAQNrFw9Xo0aNVVFRkWQc3oKvOzk598MEHOnjwoM4880zbP2sELAAAAKRVJBIxw1VpaanT5cAFysvL9cEHH6ijo0P5+fm2vhdNLgAAAJBW8TVXRUVFDlcCt4hPDYxEIra/FwELAAAAjmBaINIlnZ81AhYAAAAAWISABQAAAAAWIWABAAAAgEUIWAAAAECWaG5u1ujRo7V3717z2A033KDrrrvO0vdZsGCB7rnnnkHXlG4DqdduBCwAAABgAJYsWaJrrrnG8mt6PJ5utzlz5iSdt3btWn3hC1/QxIkTk4794he/sLSe7373u1qzZo3C4XCf56aqKfH3yc/P15gxY/S5z31OGzZsUGdnZ9J5vf2zTLxOXl6ezjzzTH3961/XkSNHBl2v3QhYAAAAgMOuu+465efn6/7779fBgwfN229/+1vznBMnTmj9+vX62te+lvTaUaNGqbi42NJ6zjvvPE2cOFEPP/xwr+f1VJMkXXHFFTp48KD27t2rp556SnPnztW3vvUtXX311ero6Oh3LYnXefDBB/W73/1O//RP/zSoetOBgAUAAAAM0pw5c3TTTTdpxYoVGjlypMaMGaOf//znamlp0X//7/9dI0aM0FlnnaWnnnqq1+vMmzdPGzZs0C233KL//M//VEVFhSoqKjRq1CjznKeeekp5eXmaOXOmeWzv3r3yeDzat2+feezGG2/UpZdemvJ9Jk6cqDVr1vTrd6uqqtKmTZt6PSdVTXEFBQWqqKjQGWecoQsuuECrV69WbW2tnnrqKW3cuLFfNSReZ9y4cZo3b56uvfZaPf3004OqNx0IWAAAAMhuwaC0cmX0pwP+7d/+TWVlZXrppZd000036etf/7oWLlyoWbNm6U9/+pPmz5+vxYsX6/jx471e5ytf+Yr+z//5P6qqqtLrr7/e7fnnnntOF154YdKxhoYGnXbaaZowYYIk6a233tIDDzygu+++O+V7VFZWqqGhoV+/10UXXaSXXnpJra2tPZ6TqqbefOYzn9H555+fNDI3EH/961+1detW5efnD6redCBgAQAAIHsFg1J1tZo2PCRVVzsSss4//3x95zvf0Sc/+UmtWrVKhYWFKisr07Jly/TJT35S3/3ud9Xc3JwyNHV1yy236Atf+IKuvPJKnThxIum5vXv36vTTT0869tprr+n88883H//Lv/yLZsyYodmzZ6e8/qhRo/Thhx/26/c644wz1NraqsbGxh7PSVVTX6ZMmTKghhj/7//9Pw0fPlyFhYU666yz9NZbb+nWW28dVL3pQMACAABA9qqrU1NJqWYs36imklKpvj7tJZx33nnmfZ/Pp9LSUp177rnmsTFjxkiSDh061Oe1Dhw4oN///ve6/vrrVVhYmPTciRMnNGzYsKRjDQ0NZsDq6OjQ448/ri996Uvm8zfccIPWr19vPj569Gi/12vF37+3kbdUNfXFMAx5PJ5+nz937lw1NDToxRdf1E033aT58+frpptuGlS96UDAAgAAQPaaO1fl4Wa9vG6JysPNUpeue+nQdbpavHNe4mNJSd3zUuno6NC1116ryspK3Xnnnd2eLysr69Y977XXXtOnP/1pSdI777yjo0ePmuGus7NTmzdv1vDhw83zX3/9dVVWVpqPr7zySt1222265JJLNGHCBL311lvmc4cPH5YklZeX91hzqpr6snv3bk2aNKnf5xcXF+sTn/iEzjvvPP3kJz9Ra2ur7rjjjm7n9afedCBgAQAAIHtVVUm1tSpfer1UWxt9nKVuvfVW/dd//ZceeeQR+Xy+bs9PmzYtKQCFw2Ht3bvXHMH6+OOPJckMVL///e915MgR+f1+SdJLL72kffv2JbVFf+ONNzRp0iTt3LlTy5Yt0+9+97uk58aNG6eysrIea+5aU1/+4z/+Q3/+85+TRtkG6rbbbtO//uu/6oMPPkg63p960yHP0XcHAAAAhqqqKquDlSQ98cQT+uEPf6iHH35YHo/HXEfk8/nMEZn58+dr1apVOnLkiEaOHKnXXntNPp9P55xzjiRpwoQJ8ng82rRpk4qLi3XLLbfoqquuUm1trSZOnKgbbrhBn/nMZ3T55ZdLkkKhkPLz87VkyRJJkt/vVyAQMGt6/vnnNW/evF7r7lpTovh6qEgkog8//FBbt27V2rVrdfXVV+v66683zwuFQt0ab4waNUpnnnlmyvecM2eOzjnnHN1111269957B1RvOjCCBQAAADjsiSeekGEYuu666zR27FjzNmPGDPOcc889VxdeeKF+85vfSIpOD5wyZYoKCgokSRUVFVqzZo3+/d//XVdeeaVuvvlmrV27Vs8++6wuvfRSTZ48WZs3bzav98Ybb+iiiy5KehwPaydPntSWLVu0bNmyXuvuWlOirVu3auzYsZo4caKuuOIK1dXV6Sc/+Ylqa2uTRujq6+s1bdq0pNt3v/vdXt/35ptv1i9+8Qu99957A6o3HTyGYRhOF5Fu4XBYgUBAoVBIJSUlTpcDAADgKidPntS7776rSZMmDbhBgts9+eST+va3v6033nhDXu/Qxkp+9rOf6aOPPlJNTY2k6HS/uro6nXbaabrvvvtUW1ubcr8pO2sarL7q7e0zZ3U2YIogAAAAkCWuuuoq/eUvf9GBAwc0fvz4IV3rzTff1Gc/+1lJ0QYbx44d02mnnSYp2rjjpz/9adprGqyB1Gs3RrAYwQIAAEgrRrCQbukcwWINFgAAAABYhIAFAAAAABYhYAEAAACARQhYAAAAAGARAhYAwB0WLpTy8yWfT5o92+lqAEhyYa81OCSdnzUCFgAg9y1cKD32mNTRoc7OTmn7dkIW4KD8/HxJ0vHjxx2uBG7R1tYmSUkbHNuFfbAAALlvyxZ1Kvq3ioY8kgxpxw6HiwLcy+fz6bTTTtOhQ4ckSUVFRfJ4PA5XhVzV2dmppqYmFRUVKS/P/vhDwAIA5L5IxJyy0enxymdEJKYmAY6qqKiQJDNkAXbyer0688wz0xLkCVgAgNxWU5P08Hj+MAXaWhwqBkCcx+PR2LFjNXr0aLW3tztdDnKc3++X15ue1VEELABAbrvvPnXIozwZCvmLFWhrUbvHp3wjIgWDUlWV0xUCrubz+dKyLgZIF5pcAAByW0uL8hSdDhgfuWr3xf5+cc0ap6oCAOQoAhYAILfFpoR0JHzlGfEp+Pv2OVAQACCXEbAAAK7gUYqmFiUl6S8EAJDTCFgAgNwVDEqxvU86PSm+8kaOTHNBAIBcR8ACAOSuO+9Ue6pgBQCATfjWAQDkrn37lG90djt8tKDYgWIAAG5AwAIA5K5Y6+dWb160LXtenkL+Yv1/ky9VyF8sxTY6BQDAKuyDBQDIXcePS5K88QYXXq8CbS36+9d+r6KOVmnqVAeLAwDkIkawAAA5r90b+/vEzuh0QbNN+xtvOFMQACBnEbAAALmrqEiSlB/pSDpsrsFqbEx3RQCAHEfAAgDkrlAo+tOTcIg1WAAAGxGwAAC5KRg012CZUwT9fgXaWlS1+zkF2lpYgwUAsBwBCwCQm+68Uy15BZISpgiec46aRozSqvk36nh+AWuwAACWI2ABAHLTvn0q7mjVsfxh0RbtRUXSd76j8qOH9eCWOyVD0VGuYNDpSgEAOYSABQDITbE9sLxGrEV7ICBVVUkzZkiSwsNijS7Wr3eiOgBAjiJgAQByUyQiScrvjE0PjLVoV0VFcqMLAAAsRMACAOSm2AiW2eDCG/vKO/dcGl0AAGxDwAIA5KaeRrCOH1fTiFGaceNDahoxSjpxwqECAQC5iIAFAMhNXUewSkqiP+fOVfnRw3rrRwtVfvSwNGeOM/UBAHISAQsAkHuCQengQUkJI1gjRyad0uIvTHdVAAAXIGABAHLPgw+qNTZy1eaLjWBVVER/1tUpVDhCwcmXKVQ4Qqqvd6ZGAEBOImABAHLP7t0qiI1ceWJd2rV0afRnUZECJ45Gm1ycOCoVMpIFALAOAQsAkHvCYUnSSV+eijpaT+2BJUnHjytUOFzByssVKhxOkwsAgKUIWACA3BNraNHpiTa60OjRp54rKlLgxLHYCNYxRrAAAJYiYAEAcpbZ4CIRbdoBADYiYAEAck9siqDZ4CL2WBJt2gEAtiJgAQByT2wPLLPBhbf71x1t2gEAdiBgAQByz/HjkhKmCHZ2nnqurk5NJaWa8U+/UlNJKW3aAQCWImABAHJLMCiFQpKk9theWJow4dTzc+eqPNwcnSIYbmaKIADAUgQsAEBuufNOhfzFkqT8SGwEq6am22lMEQQA2IGABQDILfv2KdDWoiPDhivfiCTvgSUxRRAAYCsCFgAgt8T2wCroaI8+TtwDS2KKIADAVgQsAEBOSrkHVgKmCAIA7EDAAgDklt72wJKYIggAsBUBCwCQW2JTBM09sGKPTbEpgi+vW8IUQQCA5QhYAICc1OMUwaoqafVqlZ91prR6dXIDDAAAhoiABQDILU1NknqZIhgMSnfdpaZ39kt33RV9DACARQhYAIDckbDJsDlFMHGTYenUGqzlG1mDBQCwHAELAJA7+rPJMG3aAQA2ImABAHJHX5sMJ6BNOwDADgQsAEDu8PkkJWwyXFTU/RzatAMAbETAAgDkjkhEUkIHwc7O7ufQph0AYCMCFgAgd8T2vGr35iU9TkKbdgCAjQhYAICc0+MeWBJt2gEAtiJgAQByR2zPqx73wJJo0w4AsBUBCwCQO2JNLsw9sFJNEWQNFgDARnlOFwAAgCWCQengQUkJUwRHjux+XlWVVFur8vr6aLhiDRYAwEIELABAbnjwQbV681TQ2aE2X57yOyNSRUXqc+Ohqq4u+TEAAENk+xTB+++/X5MmTdKwYcM0ffp0Pf/88z2ee/DgQV133XWaPHmyvF6vVqxY0e2cjRs3yuPxdLudPHnSxt8CAJDxGhtVEBu5MqcILl2a+txgUKquVtOGh6TqahpdAAAsY2vAevTRR7VixQrV1NRo165duuyyy3TllVdq//79Kc9vbW1VeXm5ampqdP755/d43ZKSEh08eDDpNmzYMLt+DQBANjhyRJJ00penoo5WaezYnkemaHQBALCJrQHrnnvu0dKlS/W1r31NlZWV+tGPfqTx48frgQceSHn+xIkT9eMf/1jXX3+9AoFAj9f1eDyqqKhIugEAXC7WMTDijTa6SLnJcByNLgAANrEtYLW1tenVV1/VvHnzko7PmzdP27dvH9K1jx07pgkTJmjcuHG6+uqrtWvXrl7Pb21tVTgcTroBAHJMrGNgrx0E49hsGABgE9sC1kcffaRIJKIxY8YkHR8zZowaGxsHfd0pU6Zo48aNCgaD2rRpk4YNG6bZs2frL3/5S4+vWbt2rQKBgHkbP378oN8fAJDZet1kOI7NhgEANrG9yYXH40l6bBhGt2MDcckll+grX/mKzj//fF122WX6zW9+o0996lP66U9/2uNrVq1apVAoZN7ee++9Qb8/ACBD9WeT4TjWYAEAbGJbwCorK5PP5+s2WnXo0KFuo1pD4fV6NWPGjF5HsAoKClRSUpJ0AwDkmPZ2SQlTBL29fMWxBgsAYBPbApbf79f06dO1bdu2pOPbtm3TrFmzLHsfwzDU0NCgsWPHWnZNAECWCQbNLoLmFMHCwp7Pj282vPR6qbaWNVgAAMvYutHwzTffrMWLF+vCCy/UzJkz9fOf/1z79+/X8uXLJUWn7h04cEC/+tWvzNc0NDRIijayaGpqUkNDg/x+v84++2xJ0h133KFLLrlEn/zkJxUOh/WTn/xEDQ0Nuu++++z8VQAAmezBB9WSV6Dijla1e2ObDC9a1PfrDKPvcwAAGABbA9a1116r5uZmfe9739PBgwc1depUPfnkk5owYYKk6MbCXffEmjZtmnn/1Vdf1a9//WtNmDBBe/fulSR9/PHH+sd//Ec1NjYqEAho2rRpeu6553TRRRfZ+asAADLZ7t0q7mjVsfxhGt5+Uho5Ulqzpufz4xsNl5Sq/Ec/YhQLAGAZj2G476/vwuGwAoGAQqEQ67EAIBeMGSMdOqSW/AIVt7dGH/fWsXblSjVteEgzlm+MrsNaer10zz3pqxcAkDGszga2dxEEAMB2vujmwv1qcCHR5AIAYBtbpwgCAJAWkYikhAYXnZ29nx9vclFfHw1XTA8EAFiEgAUAyH4lJdKhQ6caXPRnikdVFcEKAGA5pggCAHKGOYLVH8GgtHJl9CcAABYhYAEAst8HH0iS2nyxiRnhcO/nx7sIbnhIqq4mZAEALEPAAgBkt5oa6fhxSQlNLmLbgfSork5NJaWasXyjmkpKpfp6W0sEALgHAQsAkN02bVLIXyxJyo/EpgjW1PT+GroIAgBsQpMLAEB28/kUaGtRyF+sQFuLNHZs380r6CIIALAJAQsAkBOKOk5G7wwf3r8X0EUQAGADpggCALJbrKFFvxtcxNFFEABgAwIWACC7+XySEhpcePvx1UYXQQCATQhYAIDsFolIStgDq7Oz79fQRRAAYBMCFgAgu8VGsNq9sSmC/RnBoosgAMAmNLkAAGS3UEjSAEew6CIIALAJAQsAkL0SNhlu9+YpvzPS9ybDcXQRBADYgCmCAIDsNZhNhuPoIggAsAEBCwCQvU6eNDcZzjci0siR/RuVoosgAMAmBCwAQPaKdRA0Nxn2+/v3OroIAgBsQsACAGSvwXQQlOgiCACwDU0uAADZazB7YEl0EQQA2IaABQDIXgkjWPmdkf6PYEl0EQQA2IIpggCA7DWYPbAAALARAQsAkJ267IElqf97YAEAYBMCFgAgOw1lDyyJfbAAALYgYAEAstNg98CS2AcLAGAbAhYAIDsNdg8siX2wAAC2IWABALLTYPfAktgHCwBgG9q0AwCy02D3wJLYBwsAYBsCFgAgOw1lDyyJfbAAALZgiiAAIDuxBxYAIAMRsAAA2Yc9sAAAGYqABQDIPuvXD20PLIl9sAAAtiBgAQCyT9c9sIqKBraein2wAAA2IWABALJPUVH0R3tsD6xAYGCvZx8sAIBNCFgAgOwTa9EuT+zxQBtcsA8WAMAmtGkHAGQfK1q0sw8WAMAGBCwAQPaJdRA0W7THHg8I+2ABAGzAFEEAQPY5cUJSQot2AAAyBAELAJBdamqktjZJCS3aJ092sCAAAE4hYAEAskvCHlimge6BJbEPFgDAFgQsAEB2GeoeWBL7YAEAbEPAAgBkl6HugSWxDxYAwDYELABAdol3DPR0eTwQ7IMFALAJ7ZcAAFnJ3ANrMNgHCwBgEwIWACC7dEQ7B5odBGNTBgeMfbAAADZgiiAAIHvU1EgtLdH78SmChYWOlQMAQFcELABA9li/Xi15BZISNhletMjBggAASEbAAgBkj5MnVdzRqpa8AhV1tEp+v7RmjdNVAQBgImABALJHbL2VP77+qrTUwWIAAOiOgAUAyB5WtGiPCwallSvZZBgAYCkCFgAge7S3R3/E11/FHg9YMChVV6tpw0NSdTUhCwBgGQIWACB7dG3Rnp8/uOvU1amppFQzlm9UU0mpVF9vTX0AANcjYAEAskNNjdTWlnxs8uTBXWvuXJWHm/XyuiUqDzdHNxsGAMACbDQMAMgO69cr5C9WoK3l1LGamsFdq6pKqq1VeX19NFyx4TAAwCIewzAMp4tIt3A4rEAgoFAopJKSEqfLAQD0R3GxdPz4qZDl90utrU5XBQDIclZnA6YIAgCySlH7yeidPCZhAAAyDwELAAAAACxCwAIAZIeuHQMH20EQAAAbEbAAANkh1qLdVFTkTB0AAPSCgAUAyHw1NVJLrHugJ3assNCxcgAA6AkBCwCQ+davV0tegSSp3RtrbrFokYMFAQCQGgELAJD5jh5VcUerWvIKVNTRGu0guGbN0K4ZDEorV0Z/AgBgEQIWACBr+COxdVh+/9AuFAxK1dVq2vCQVF1NyAIAWIaABQBwn7o6NZWUasbyjWoqKZXq652uCACQIwhYAIDM19Zm7fXmzlV5uFkvr1ui8nCzNGeOtdcHALhWntMFAADQq5qa7i3aR4wY2jWrqqTaWpXX10fDVVXV0K4HAEAMAQsAkNliHQSLO1pPHVu6dOjXraoiWAEALMcUQQBAZkvoIJhvRKzpIAgAgE0IWACArGBZB0EAAGxEwAIAAAAAixCwAACZzeoOggAA2IiABQDIXHZ0EAQAwEYELABA5op1EExiRQdBAABsQsACAGQuOggCALIMAQsAkPFs6SAYDEorV0Z/AgBgEQIWAMB9gkGpulpNGx6SqqsJWQAAyxCwAACZy64OgnV1aiop1YzlG9VUUirV19vzPgAA1yFgAQAyU6oOgvn51lx77lyVh5v18rolKg83S3PmWHNdAIDr5TldAAAAKa1fr3aPV/lG56ljkydbc+2qKqm2VuX19dFwVVVlzXUBAK5HwAIAZKajR5PDlRQd1bJKVRXBCgBgOaYIAgAyWoe80Rbtfj+BCACQ8QhYAIDMFFt/ZXg80cd5TLoAAGQ+AhYAIPMEg/Z1EAQAwEYELABA5rnzTkXkST42YoQztQAAMAAELABA5vnP/5RPRvKxpUudqQUAgAEgYAEAMs+JE5IUa9Mekbxeac0ah4sCAKBvBCwAQObpjLdnj00T9PJ1BQDIDrZ/Y91///2aNGmShg0bpunTp+v555/v8dyDBw/quuuu0+TJk+X1erVixYqU5z3++OM6++yzVVBQoLPPPltbtmyxqXoAgCMikeTHBCwAQJaw9Rvr0Ucf1YoVK1RTU6Ndu3bpsssu05VXXqn9+/enPL+1tVXl5eWqqanR+eefn/KcHTt26Nprr9XixYv12muvafHixfryl7+sF1980c5fBQCQLgsXSkZ0/ZU3vtHwyJEOFgQAQP95DMMw+j5tcC6++GJdcMEFeuCBB8xjlZWVuuaaa7R27dpeXztnzhx9+tOf1o9+9KOk49dee63C4bCeeuop89gVV1yhkSNHatOmTf2qKxwOKxAIKBQKqaSkpP+/EADAfsXFammLqLijVe0eX3QN1urV1q/BCgalujpp7lw2MAYAF7M6G9g2gtXW1qZXX31V8+bNSzo+b948bd++fdDX3bFjR7drzp8/v9drtra2KhwOJ90AABmqo0PFHa1qySuwr8FFMChVV6tpw0NSdXX0MQAAFrAtYH300UeKRCIaM2ZM0vExY8aosbFx0NdtbGwc8DXXrl2rQCBg3saPHz/o9wcApMewjthGw/n51l+8rk5NJaWasXyjmkpKpfp6698DAOBKtq8a9niSN4o0DKPbMbuvuWrVKoVCIfP23nvvDen9AQA2am+XJHV6Yl9RXRteWGHuXJWHm/XyuiUqDzdLc+ZY/x4AAFfKs+vCZWVl8vl83UaWDh061G0EaiAqKioGfM2CggIVFBQM+j0BAGlSU2M2uDD5/da/T1WVVFur8vr6aLhiDRYAwCK2jWD5/X5Nnz5d27ZtSzq+bds2zZo1a9DXnTlzZrdrPv3000O6JgAgQ6xfr/bYyJXZQXDqVHveq6pKuucewhUAwFK2jWBJ0s0336zFixfrwgsv1MyZM/Xzn/9c+/fv1/LlyyVFp+4dOHBAv/rVr8zXNDQ0SJKOHTumpqYmNTQ0yO/36+yzz5Ykfetb39Lll1+uu+++W9XV1aqtrdUzzzyjP/7xj3b+KgCAdDhyRPmxYNXp8cpnRKKjWgAAZAlb27RL0Y2Gf/CDH+jgwYOaOnWqfvjDH+ryyy+XJC1ZskR79+5VfcLi4lRrqSZMmKC9e/eajx977DF95zvf0V//+ledddZZWrNmjb74xS/2uybatANAhsrPlzo61CGv8tQZ7SBoxxosAABirM4GtgesTETAAoAM5fVKhnFq/6u8PLPpBQAAdsiafbAAABiQhAYX5vorOxpcAABgIwIWACAz3HefTnqjS4PNFu1XXeVgQQAADBwBCwCQGY4e1bDODp305kWnB0rS5s3O1gQAwAARsAAAmSE2PdAXXxrs5SsKAJB9+PYCADgvGOy+/irP1p1EAACwBQELAOC8W25RRF226Rg50plaAAAYAgIWAMB5+/fLp+gIltngYulSBwsCAGBwCFgAAOd1RqcFtnu80QYXHo+0Zo3DRQEAMHAELACA8yLRroHeeIMLj6eXkwEAyFwELACAsxI2GDanB6arg2AwKK1cGf0JAIAFCFgAAGetX6+OWIMLs4PgpEn2v28wKFVXq2nDQ1J1NSELAGAJAhYAwFlHjigv1uDC9K//av/71tWpqaRUM5ZvVFNJqVRfb/97AgByHgELAOCs9nZJUoe80U6CHo9UVWX/+86dq/Jws15et0Tl4WZpzhz73xMAkPPYxREA4JyEDYYNj0cylL4GF1VVUm2tyuvro+EqHaEOAJDzPIZhGH2fllvC4bACgYBCoZBKSkqcLgcA3OuTn1Tkv/5LPkkReaIjWIGA9PHHTlcGAHAJq7MBUwQBAM7Zu1e+rse+8Q0nKgEAwBIELACAczo6JEU3GPbFG12wwTAAIIsRsAAAzkhoi25uMJyu/a8AALAJ32QAAGfccosiXY+NGOFEJQAAWIaABQBwBuuvAAA5iIAFAHAG668AADmIgAUASL9U66/Stf8VAAA2ImABANIv1fqr/HwnKgEAwFIELABA+qVaf1VV5UQlAABYioAFAEi/2PqrDnlOrb/avNnBggAAsAYBCwCQXjU15l1z1RX7XwEAcgTfaACA9LrvPva/AgDkLAIWACC9jh5l/ysAQM4iYAEA0quzU5IUSVx/xf5XAIAcQcACAKTPwoXdj7H+CgCQQ/hWAwCkzxNPqM3T5avnkkucqQUAABsQsAAA6dPRIb/RqTaP99T0wBdecK6eYFBauTL6EwAACxCwAADpkRBifIbhYCExwaBUXa2mDQ9J1dWELACAJQhYAID0uOUWsz27Jz565fc7Vo7q6tRUUqoZyzeqqaRUqq93rhYAQM4gYAEA0uOvfzXbsxvxLYarqhwrR3PnqjzcrJfXLVF5uFmaM8e5WgAAOSPP6QIAAC4Ra8/eIY/y4iNYmzc7V09VlVRbq/L6+mi4cjLsAQByBgELAGC/hPbsHvOOJ+WpaVVVRbACAFiKKYIAAPsltGc311/NnOlgQQAA2IOABQCwX0J7dvOLx8n27AAA2ISABQCwV8L0wIxozw4AgI0IWAAAez3xRPf27GPHOlYOAAB2ImABAOzV0WG2ZzetW+dEJQAA2I6ABQCwT02NeTeihC8dOvcBAHIUAQsAYJ8f/zhhemBMUZFDxQAAYD8CFgDAPi0t3acHrljhQCEAAKQHAQsAYI+k6YGeU184a9Y4Ug4AAOlAwAIA2OP//t/u3QOZHggAyHEELACAPVpbmR4IAHAdAhYAwHoJmwszPRAA4CYELACA9bZsMacHetlcGADgIgQsAID1IhFzeqARP8bmwgAAFyBgAQCsVVlp3mVzYQCA2xCwAADW2rNHbZ7o14v5JTNrlmPlAACQTgQsAIB1gkFJkt/oVJvHK0/8+AsvOFYSAADpRMACAFhnyRJ1xu7mG7F7Hk+PpwMAkGsIWAAA6xw5Yn6xmM0tZs50qBgAANKPgAUAsEbS3lcJXzBMDwQAuAgBCwBgjccfT9j7KqaoyKFiAABwBgELADB0waBkGN33vlqxwpl6AABwiMcwDKPv03JLOBxWIBBQKBRSSUmJ0+UAQPYbNUqdsfVXEckMWnLfVwwAIMtYnQ0YwQIADF1Ccwv2vgIAuBkBCwAwNLNnm3cjUnbtfRUMSitXmvt3AQAwVAQsAMDQbN/evbmF3+9QMQMQDErV1Wra8JBUXU3IAgBYgoAFABi8mhpJCWuu4r797bSXMmB1dWoqKdWM5RvVVFIq1dc7XREAIAcQsAAAg3f33eboVacSpgeuWeNMPQMxd67Kw816ed0SlYebpTlznK4IAJAD8pwuAACQpYJBKRIxR6/McLVggUMFDVBVlVRbq/L6+mi4qqpyuiIAQA6gTTtt2gFgcIYPV2dLC63ZAQBZjTbtAIDMEAtXEq3ZAQCII2ABAAaustK8m3Wt2QEAsBEBCwAwcHv2qCN21/wiOeMMh4oBACBzELAAAAMTG73Kk9ShhNGr9993qCAAADIHAQsAMDB79pit2c3GFsXFDhUDAEBmIWABAPovNnrVbWPhX/867aUAAJCJCFgAgP5LGL0yFJseWFDAHlIAAMQQsAAA/dPT6NVvfpP2UgAAyFQELABA/6QavcrLY/QKAIAEBCwAQN9KSyWlGL16/PG0lwIAQCYjYAEAehcMSocPdx+9Gj6c0SsAALogYAEAevfFL8pQdPQqooR9r44edawkAAAyFQELANCzmhopEjFDlfmlccYZDhUEAEBmI2ABAHp2110yYneTRq/ef9+ZegAAyHAELABAarNnS1L30aspU5yoBgCArEDAAgCktn272dgiafRq925n6gEAIAsQsAAA3Y0YIelUW3bzy2LBAieqAQAgaxCwAADJgkHp2DFz9KpTsdErj0favNm5ugAAyAIELABAsupqsy27lDA18IknHCkHAIBsQsACAJwybpykU6HK3FR41Cg2FQYAoB9sD1j333+/Jk2apGHDhmn69Ol6/vnnez3/2Wef1fTp0zVs2DD9zd/8jdatW5f0/MaNG+XxeLrdTp48aeevAQC5LxiUDhxI3diiudmZmgAAyDK2BqxHH31UK1asUE1NjXbt2qXLLrtMV155pfbv35/y/HfffVdXXXWVLrvsMu3atUurV6/WN7/5TT3++ONJ55WUlOjgwYNJt2HDhtn5qwBA7usyNZDGFgAADJzHMAyj79MG5+KLL9YFF1ygBx54wDxWWVmpa665RmvXru12/q233qpgMKjdCS2Aly9frtdee007duyQFB3BWrFihT7++ONB1xUOhxUIBBQKhVRSUjLo6wBAzqislPbsMR+aUwPz86W2NqeqAgDAdlZnA9tGsNra2vTqq69q3rx5ScfnzZun7du3p3zNjh07up0/f/58vfLKK2pvbzePHTt2TBMmTNC4ceN09dVXa9euXb3W0traqnA4nHQDAMQEg9KePeqMPUyaGki4AgBgQGwLWB999JEikYjGjBmTdHzMmDFqbGxM+ZrGxsaU53d0dOijjz6SJE2ZMkUbN25UMBjUpk2bNGzYMM2ePVt/+ctfeqxl7dq1CgQC5m38+PFD/O0AIIfEpgbGvxDML4ZZs5ypBwCALGZ7kwuPx5P02DCMbsf6Oj/x+CWXXKKvfOUrOv/883XZZZfpN7/5jT71qU/ppz/9aY/XXLVqlUKhkHl77733BvvrAEBuiW0oHP+T19zzyuuVXnjBoaIAAMheeXZduKysTD6fr9to1aFDh7qNUsVVVFSkPD8vL0+lpaUpX+P1ejVjxoxeR7AKCgpUUFAwwN8AAHJcTY25obBPMn9KkiKRHl8GAAB6ZtsIlt/v1/Tp07Vt27ak49u2bdOsHqadzJw5s9v5Tz/9tC688ELl5+enfI1hGGpoaNDYsWOtKRwA3OKuu+gaCACAxWydInjzzTfrwQcf1IYNG7R7926tXLlS+/fv1/LlyyVFp+5df/315vnLly/Xvn37dPPNN2v37t3asGGD1q9fr29/+9vmOXfccYd+//vf669//asaGhq0dOlSNTQ0mNcEAPRDbNp1tw2F8/OlzZsdKgoAgOxn2xRBSbr22mvV3Nys733vezp48KCmTp2qJ598UhMmTJAkHTx4MGlPrEmTJunJJ5/UypUrdd999+n000/XT37yE33pS18yz/n444/1j//4j2psbFQgENC0adP03HPP6aKLLrLzVwGA3FFYKEmppwbSNRAAgCGxdR+sTMU+WABca/Zsafv21OHKfV8HAABkzz5YAIAMEwxK27ez7goAABsRsADALWL7XbHuCgAA+xCwAMANujS1iCTcZ90VAADWIWABQK6Lhav4zlasuwIAwD4ELADIZb5olEoMVeYf/LW1DhQEAEBuI2ABQK7Ky5M6O9WpU+HKXHe1YIFUVeVYaQAA5CoCFgDkosJCKRKRoVN/0Jvh6owzaGoBAIBNCFgAkGtGjJBOnuy5Y+D77ztWGgAAuY6ABQC5ZMQI6dix1OHK66VjIAAANiNgAUCuKC3tOVxJUiSS8mWuFgxKK1dGfwIAYAECFgDkgtJS6fDhpEDVmXCfduwpBINSdbWaNjwkVVcTsgAAliBgAUC2KyxMGa7MP+AJV6nV1amppFQzlm9UU0mpVF/vdEUAgBxAwAKAbJaX162hBeGqn+bOVXm4WS+vW6LycLM0Z47TFQEAckCe0wUAAAbJE41UieEqcUNhwlUfqqqk2lqV19dHwxX7ggEALEDAAoBslCJcJW4oTLjqp6oqghUAwFJMEQSAbJMiXCVuKEy4AgDAOQQsAMgWNTVmuErsEJjUip1wBQCAo5giCADZINaGXUpeZ2WGq/x8NhEGACADELAAINMlTAlMXGdlhqtRo6TmZkdKAwAAyZgiCACZrMt6K5+iI1iKPdaCBYQrAAAyCCNYAJCJKiulPXsk0YYdAIBsQsACgEzjMVtWdFtvRbgCACCzMUUQADJFQpdAQ700syBcAQCQsRjBAoBMkJcnRaKrq7qut/IpYb3V5s1OVQgAAPqBESwAcFJ81CoSMUetEve3SpoSSLgCACDjMYIFAE7x+aTOTknJo1aJj9nfCgCA7MIIFgCkW2VldNSqs9Pc2yqxS6CUMCWQcAUAQFZhBAsA0iUYlKqrzYfxUaoepwQCAICsQ8ACgHTw+6X2dkkyR63iYSqpkcWsWdILLzhRIQAAsAABCwDsVFoqHT4sKRqspO5rrXyS5PWaXQQBAED2Yg0WANghvs4qIVx1nQ6o+OPVqwlXAADkCEawAMBKCxdKjz1mPux1OuCoUVJzc7orBAAANiJgAYAVZs+Wtm83H/Y6HVCiiQUAADmKKYIAMBSzZ0enAsbClaE+pgMuWEC4AgAghzGCBQCDUVkp7dljPkwKUQnHzKB1xhnS+++nrTwAAOAMAhYADERCV0ApdbBinRUAAO5FwAKA/kjYx0pKHaw6FZ137ZOkYcOkEyfSVh4AAMgMrMECgJ7U1ETXV3k8SZsEd11j1Rn76ZWiwcowCFcAALgUI1gA0NWIEdKxY0mHeltj5ZWk4cOlo0fTUh4AAMhcjGABgBTdvyo+WhULV/HRqoh66Qo4alR0xIpwBQAAxAgWALfrsrZK6j5albiPFV0BAQBAbxjBAuA+paU9rq3qVPJoVSThZR5JWr06OmJFuAIAACkwggXAHcaNkw4c6Ha462hV4jRAj2KjV/n5Ulub3RUCAIAcwAgWgNw1btypkaqEcNXT2qpuo1WzZkVHqwhXAACgnxjBApBbumwEHGck3O9pbRWjVQAAYKgYwQKQ/fz+UyNVCeHKUPd9q7p2ApS6rK0iXAEAgCFgBAtA9lm4UHrssZRPpRqpSnwuaa3VlCnS7t2WlwcAANyLgAUgO6Ropx43oFBFe3UAAGAjpggCyEwjRpya9pfQTl1KnvqX2Kiix+l/Z5wRnf5He3UAAGAzAhaAzJDY8c/jkY4dS3q6p/VUiY0q4szpf4QqAACQZgQsAM7oOkLVZY+qvkapIkqW1KjCMFhbBQAAHMEaLADp4fVGg08Puj6TuJaqazt18xgt1QEAQIZhBAuA9UpLk0enPJ5u4cpQz9P+Uq2lUvz4ggWnRqkIVwAAIMMwggVgaCorpT17+jzN6HI/1d/uJI5QSaKVOgAAyDoELAD9V1qatJFvT7qOPHXq1DQ/KXmEqlugoo06AADIYkwRBJCaz9d9ml+KcNV1ql+q6X4+dW9KodhzmjXr1JQ/Ov4BAIAsxwgW4HaFhdLJk/06NVWLiq4b+yae261RhdcrRVJFLQAAgNzACBbgFn5/9xEpj6fHcNWfkamemlFI6r4XlWEQrgAAQM4jYAG5ZPbs1CHK45Ha21O+JFWQ6rrvVL/C1KhRyWGKvagAAIALMUUQyDazZ0vbtw/4ZamCUdfmE3HxNVOpnqMRBQAAQM8IWEAmGsC6qEQ9bePbW5CKv67rWirWTAEAAAwcUwQBJ4wY0fNUvl7WRUmpp/T1tkYq3sUv/tpUum3gy5opAACAQSFgAVarqek9PHk80rFjvV5iMCEqPgLV2ct1PZK0enX3IGUY0ubNg/+dAQAAIIkpgsDAVFZKe/YM+TI9jSTFn+vrbz46eznHK0nDh0tHjw6iMgAAAAwFAQuQBt04IpXewlP8+d4CVGK3vp72mCJEAQAAZCamCCJ3BYN9T9WL3/oZrnqbutefKXwenfqPrq8g5pGkWbNST+czDMIVAABABmIEC9nF7+9xP6eh6CvsxPU0otRVTy3Ou11r1izphRf6eVUAAABkOgIWnFNaKh0+bNvl+xuapP4Hp/h1+zrfJ0n5+VJb2wCuDAAAgGxHwMLQ2RyUEtkVmqTeG0d0u+6oUVJz8wDfAQAAALmOgIUon0/q7K3Bt/UGEpaknjfL7U1/purF0TgCAAAAQ0XAygUOhKNEAw1KcQMdYUrcLLe/r/VJ0X8+HR0DfDcAAABg4Ogi6BSfr/8d7vq6WRCu+tMdb7Bd83rbFHcw4azXzXJT3QhXAAAASBNGsPpSUyPddZfTVfRqsCNIcYOZepeqhoGOSCn+mjPOkN5/f4gVAAAAAM5zd8AKBBx766GGojgrwpFPA1urlIpHkqZMkXbvHmI1AAAAQPZyd8DqB6uCUCIrQlGcFeEofh15vVIkMuSaAAAAALdydcCKryHqzWCmvfXFqlCUeD2r1mIBAAAAGDxXB6zEZgu9sTIMxRGKAAAAgNzj6oDVX7T6BgAAANAf7m7THgrR6hsAAACAZdwdsAAAAADAQgQsAAAAALAIAQsAAAAALELAAgAAAACLELAAAAAAwCIELAAAAACwCAELAAAAACxCwAIAAAAAi9gesO6//35NmjRJw4YN0/Tp0/X888/3ev6zzz6r6dOna9iwYfqbv/kbrVu3rts5jz/+uM4++2wVFBTo7LPP1pYtW+wqHwAAAAD6zdaA9eijj2rFihWqqanRrl27dNlll+nKK6/U/v37U57/7rvv6qqrrtJll12mXbt2afXq1frmN7+pxx9/3Dxnx44duvbaa7V48WK99tprWrx4sb785S/rxRdftPNXAQAAAIA+eQzDMOy6+MUXX6wLLrhADzzwgHmssrJS11xzjdauXdvt/FtvvVXBYFC7d+82jy1fvlyvvfaaduzYIUm69tprFQ6H9dRTT5nnXHHFFRo5cqQ2bdrUr7rC4bACgYBCoZBKSkoG++sBAAAAyHJWZwPbRrDa2tr06quvat68eUnH582bp+3bt6d8zY4dO7qdP3/+fL3yyitqb2/v9ZyerilJra2tCofDSTcAAAAAsJptAeujjz5SJBLRmDFjko6PGTNGjY2NKV/T2NiY8vyOjg599NFHvZ7T0zUlae3atQoEAuZt/Pjxg/mVAAAAAKBXtje58Hg8SY8Nw+h2rK/zux4f6DVXrVqlUChk3t57771+1w8AAAAA/ZVn14XLysrk8/m6jSwdOnSo2whUXEVFRcrz8/LyVFpa2us5PV1TkgoKClRQUDCYXwMAAAAA+s22ESy/36/p06dr27ZtSce3bdumWbNmpXzNzJkzu53/9NNP68ILL1R+fn6v5/R0TQAAAABIF9tGsCTp5ptv1uLFi3XhhRdq5syZ+vnPf679+/dr+fLlkqJT9w4cOKBf/epXkqIdA++9917dfPPNWrZsmXbs2KH169cndQf81re+pcsvv1x33323qqurVVtbq2eeeUZ//OMf7fxVAAAAAKBPtgasa6+9Vs3Nzfre976ngwcPaurUqXryySc1YcIESdLBgweT9sSaNGmSnnzySa1cuVL33XefTj/9dP3kJz/Rl770JfOcWbNm6ZFHHtF3vvMd/e///b911lln6dFHH9XFF19s568CAAAAAH2ydR+sTMU+WAAAAACkLNoHCwAAAADchoAFAAAAABYhYAEAAACARQhYAAAAAGARAhYAAAAAWISABQAAAAAWIWABAAAAgEUIWAAAAABgkTynCwAAAACAAfP5pM5Op6vohhEsAAAAAPaaPVvyeKy9ZWC4khjBAgAAANCT0lLp8GGnq0jJsOg6HxUGpBMhi65GwAIAAAByV4ZMo7MqDMV1SvJZdK0yC8OVRMACAAAAMltenhSJOPLWVgUjj0XXiYuHK8OGaw8Va7AAAACAdKisHNxaoyGEK2OIN49FNyk66mQ1jyTV1kqGMfhbiBEsAAAAwHl+v9TebvvbDHYUyappdFaNEnklafhw6ehRC66WuRjBAgAAACSppmZgI0sDDFeDGUGKaPCjRr7Y64fKI0lTpgxtlCh+y/FwJTGCBQAAgFw3YoR07Jjllx3oyNJgRoGGutbIJ2V0S/NcxAgWAAAAslN/91bqZ7iye2Qp/h6DMaS1RoSrtGIECwAAAJln4ULpsccsuVR/Q81ARogGO7LkkVyxDsnNGMECAABA+pWW9j7q1I9wZXUnPGnga5Y8krR6NeuQYGIECwAAANabPVvavn3QL+/PqNNARo76O9Lkk6T8fKmtbQBXB04hYAEAAGBwxo2TDhwY1Ev7ClD9DU+d6t+ULLMT3u7d/bwyMDgELAAAAPRskCNRVgSoiPrex8krScOGSSdO9KcswHYELAAAAAyqlXlvIao/AaqvaXtM10M2oskFAACAm4wYMaBW5oNtHiFFp+/1pl8b2BKukGUIWAAAALlo4UJLgtRQ9nUyp+/1FqBYE4UcwxRBAACAbDeA6X2pApGh3v/WvbdGEh5JOuMM6f33+/X+QK4jYAEAAGST0lLp8OE+TxtIkEocjUq1JsorsTku0E9MEQQAAMhUs2d3n+KXIlz1d2qfN+H8VDySNGsWm+MCQ8AIFgAAQKbIy5MikV5PSRWOeurE11ObczNIvfDCgMoD0DdGsAAAAJxQU9N9dKpLuOrvyFT83K58Us9NJghXgC0IWAAAAOnQNVDddVe3U4YSpnpsec4GvEBaMUUQAADADsGgVF3d49NdQ1KnUk/nS9XBzwxTtDgHMg4BCwAAwCqFhdLJkymf6hqouq6b8iWcl/gcHfyA7MIUQQAAgMHq2uUvIVz1Nd1Pijah6MojSbW1dPADshQjWAAAAAPRy6a+iaNUqTr7de3q55Mkn0/q6LCsPADOImABAAD0pYf26YmBKtUaqpSBKj9famuzukIAGYKABQAAkIrPJ3V2djvc0yhVqjVUjFAB7sMaLAAAgLi8vFPrqRLCVU9rqaToyFUijyQtWHBq/RThCnAVRrAAAIC79dD5Lz5SlWrqX+IolVeKbubLflMAxAgWAABwo8rKXjv/RXRqlCpx6l9ct019CVcAYghYAADAPXy+aKjas8c8NKBQtXr1qVDFJr8AUmCKIAAAyG3jxkkHDiQdSjX9L1WTCnNPqqoqm4sEkCsIWAAAIDel6AIYD1ZJXf5EqAJgHaYIAgCA3DF7drcugKmmAMaPx3Xr/Ee4AjBIjGABAIDs18s0wMTRqsSNfz2SNGqU1NycjgoBuAQBCwAAZK8RI6Rjx8yHPbVWj08B9EmS1ytFIumqEIDLMEUQAABkn8LC6DTAWLjquglw1y6AHkk644zo9D/CFQAbEbAAAED2iAer2N5VXYOVFB29ijMbVhiG9P776awUgEsxRRAAAGS+FFMBDSX/TXE8aHkladgwNv8F4AhGsAAAQOYqLe02FbBTCUFKPUwDJFwBcAgBCwAAZJ7KymiwOnxYUnKb9ZTBatYspgECyAgELAAAkDlqaqLBas8eSckjVikbV8SD1QsvpLtSAEiJNVgAACAz+HxJmwNL3TcGNh8vWCBt3pzuCgGgTwQsAADgrNLSpKmA0qlQFT9mBqtZsxitApDRmCIIAACcEQx2W2fVdcRK6tK8gnAFIMMxggUAANKvsDBpL6tOnVpjFYnd90jSqFFSc7MTFQLAoDCCBQAA0ifexOLkyaRNghMbWPik6DmGQbgCkHUIWAAAID38fumuuyT1MR1w9Wqz2QUAZBumCAIAAPt5olGqaxOLpOmAZ5zBPlYAsh4jWAAAwD7xDYOVetQqPjWQTYIB5AoCFgAAsEeXDYMTR60UfzxlSjRcAUCOIGABAABrxduvKxqsIupl1Gr37rSXBwB2ImABAADrVFZK1dWSkjsEMmoFwC1ocgEAAKyRlydFIt32teo2agUAOYwRLAAAMHQejxmuuu5r5ZEkn49wBcAVCFgAAGBounQJlLpMCVywQOroSH9dAOAApggCAIDBCQa7rbeSkqcHMmoFwG0YwQIAAAO3cKEZrrp2CfRK0VEtwhUAF2IECwAADExlpbRnT8pmFh5JGj5cOnrUqeoAwFGMYAEAgP4rLTXDVcpmFrNmEa4AuBoBCwAA9M+IEdLhwz03s6itlV54wZHSACBTMEUQAOBewaBUVyfNnStVVTldTWYrLJROnuwWrmhmAQDJGMECALhTrANe04aHos0agkGnK8pcfj/hCgD6iYAFAHCnujo1lZRqxvKNaioplerrna4oMxUWSu3ttGEHgH4iYAEA3GnuXJWHm/XyuiUqDzdLc+Y4XVHmKS3tNnLVqYT/eSBcAUA3rMECALhTVZVUW6vy+vpouGINVrLKym4NLcw9riTCFQD0gIAFAHCvqiqCVSoLFya1YpeUdJ9wBQA9Y4ogAAA4JRiUHnus27RAwhUA9A8BCwAAnFJd3a1bINMCAaD/CFgAACDKE41VtGIHgMEjYAEAADNcRWIPCVcAMDgELAAA3K6wUFJyqDL/B6G21oGCACB7EbAAAHCz2bOlkyeTNg8212AtWECXRQAYIAIWAABuFQxK27cn7W9lhqszzpA2b3asNADIVgQsAADcqkvHQPO+zye9/75jZQFANiNgAQDgRr7ohMDEjoHmXlcdHQ4UBAC5gYAFAIDbVFZKnZ10DAQAG9gasI4cOaLFixcrEAgoEAho8eLF+vjjj3t9jWEYuv3223X66aersLBQc+bM0Ztvvpl0zpw5c+TxeJJuixYtsvE3AQAgRwSD0p49MpSiY+Dq1c7UBAA5xNaAdd1116mhoUFbt27V1q1b1dDQoMWLF/f6mh/84Ae65557dO+99+rll19WRUWFPve5z+no0aNJ5y1btkwHDx40bz/72c/s/FUAAMgNPa27GjVKWrPGsbIAIFfk2XXh3bt3a+vWrdq5c6cuvvhiSdIvfvELzZw5U2+//bYmT57c7TWGYehHP/qRampq9MUvflGS9G//9m8aM2aMfv3rX+uGG24wzy0qKlJFRYVd5QMAkHtGjJB0Klx1KvY3rR6P1NzsUFEAkFtsG8HasWOHAoGAGa4k6ZJLLlEgEND27dtTvubdd99VY2Oj5s2bZx4rKCjQ3/7t33Z7zcMPP6yysjKdc845+va3v91thCtRa2urwuFw0g0AAFepqZGOHUtad2X+T0BnpzM1AUAOsm0Eq7GxUaNHj+52fPTo0WpsbOzxNZI0ZsyYpONjxozRvn37zMf/8A//oEmTJqmiokJvvPGGVq1apddee03btm1Led21a9fqjjvuGOyvAgBA9rvrLtZdAUAaDHgE6/bbb+/WYKLr7ZVXXpEkeTyebq83DCPl8URdn+/6mmXLlumzn/2spk6dqkWLFumxxx7TM888oz/96U8pr7dq1SqFQiHz9t577w301wYAIHt1mRporrsaNox1VwBgsQGPYN144419duybOHGiXn/9dX344Yfdnmtqauo2QhUXX1PV2NiosWPHmscPHTrU42sk6YILLlB+fr7+8pe/6IILLuj2fEFBgQoKCnqtGQCAnJQwNdCnLi3ZT5xwrCwAyFUDDlhlZWUqKyvr87yZM2cqFArppZde0kUXXSRJevHFFxUKhTRr1qyUr4lP+9u2bZumTZsmSWpra9Ozzz6ru+++u8f3evPNN9Xe3p4UygAAgJgaCABpZluTi8rKSl1xxRVatmyZdu7cqZ07d2rZsmW6+uqrkzoITpkyRVu2bJEUnRq4YsUK3XXXXdqyZYveeOMNLVmyREVFRbruuuskSe+8846+973v6ZVXXtHevXv15JNPauHChZo2bZpmz55t168DAED2qayUlGJq4PDhTA0EAJvY1uRCinb6++Y3v2l2BayqqtK9996bdM7bb7+tUChkPv7nf/5nnThxQv/0T/+kI0eO6OKLL9bTTz+tEbH5436/X3/4wx/04x//WMeOHdP48eP1+c9/Xrfddpt8Pp8AAEDMnj2ppwb20nkXADA0HsMwDKeLSLdwOKxAIKBQKKSSkhKnywEAwHp+v9Tebj40R68WLJA2b3aqKgDIOFZnA9umCAIAAIcsXCi1t5t7XpnhKj+fcAUANiNgAQCQax57zGxsEdGpNVhqa3OsJABwCwIWAAC5JNbwKR6qzC/6KVOcqAYAXIeABQBALtm+3ZwamDR6tXu3M/UAgMsQsAAAyBXjxklKsefVggVOVAMArkTAAgAgVxw4YI5edSo2euXx0NgCANKIgAUAQC4oLZV0avTKnBr4xBMOFAMA7kXAAgAgFxw+rI7YXbMt+6hRUlWVczUBgAsRsAAAyHYjRkiS8iR1KGH0qrnZoYIAwL0IWAAAZLNgUDp2zBy9ik8R1BlnOFQQALgbAQsAgGz25S/LUIrRq/ffd6wkAHAzAhYAANkqGJRaW81QZY5esakwADiGgAUAQLa67joZsbtsKgwAmYGABQBAtmppMUOV+YXO6BUAOIqABQBANho3zrzL6BUAZA4CFgAA2ejAAbNzoPllTudAAHAcAQsAgGxTWSmJzoEAkIkIWAAAZJs9exSJ3TU7B44c6VAxAIBEBCwAALLJ7NmSEoJV3MaN6a4EAJACAQsA4F7BoLRyZfRntti+3Ry9MhSbHpiXJ1VVOVcTAMBEwAIAuFMwKFVXq2nDQ1J1dXaErJoaSSlGr/75n9NeCgAgNQIWAMCd6urUVFKqGcs3qqmkVKqvd7qivv3f/2uOXnUqobnFmjXO1AMA6IaABQBwp7lzVR5u1svrlqg83CzNmeN0RX1rbTVHr8xwtWCBQ8UAAFLJc7oAAAAcUVUl1daqvL4+Gq4yfQ1TrDW7FN1Y2JwmuHmzE9UAAHpAwAIAuFdVVeYHq7g9e9Sh6Bc3GwsDQOZiiiAAAJku1tyCjYUBIPMRsAAAyHQJzS3MqYF+v0PFAAB6Q8ACACDTJTS3MH37205UAgDoAwELAIBMltTcwkNrdgDIcAQsAAAy2Z49ao/FKq+M6LEpUxwsCADQGwIWAACZKhiUJOXLUHvi6NXu3Y6VBADoHQELAIBMtXy5OmN38+KjVx5Pj6cDAJxHwAIAIFMdPGh+URvxYzNnOlQMAKA/CFgAAGSi2N5XkhRRwhf2Cy84UQ0AoJ8IWAAAZKKEva/MSYHsfQUAGY+ABQBAJkrY+8oMWOx9BQAZj4AFAECmWbjQvMveVwCQXQhYAABkmieeMKcHmntfjR3rWDkAgP4jYAEAkGk6OszpgWb3wHXrHCoGADAQBCwAADJJ0vTAhC/qqionqgEADBABCwCATJIwPdBce1VU5FAxAICBImABAJBJEqYHmlascKAQAMBgELAAAMgUPW0uTPdAAMgaBCwAADLFj3/cfXpgIOBQMQCAwSBgAQCQKVpaEroHxiLWN77hWDkAgIEjYAEAkAmSpgd65Is3aGd6IABkFQIWAACZIGl6YCxc0T0QALIOAQsAgEyQMD3QRPdAAMg6BCwAgHsFg9LKldGfGSIiD90DASCLEbAAAO4UDErV1Wra8JBUXe1syJo927xrTg/08hUNANmIP70BAO5UV6emklLNWL5RTSWlUn29c7Xs3Kk2T/Qr2eweeMklztUDABg0AhYAwJ3mzlV5uFkvr1ui8nCzNGeOc7V0dspvdKrN4z3VPfCFF5yrBwAwaHlOFwAAgCOqqqTaWpXX10fDVVWVM3UktGfPMzqjdzyeHk4GAGQ6j2EYhtNFpFs4HFYgEFAoFFJJSYnT5QAA3Gz4cEViHQTN/a/GjpU++MDpygDAFazOBkwRBADASQnt2c0GF+vWOVYOAGBoCFgAAGSADnlPfSk7NV0RADBkBCwAAJyS0J7dq9j6K7/foWIAAFYgYAEA4JSdO3XSG+03ZbZnZ/QKALIaAQsAAKd0dmpYZ4dOevNOtWffvNnZmgAAQ0LAAgDAYf7Ojugd2rMDQNYjYAEA4ISE9Vfm9MD8fIeKAQBYhYAFAIATEtZfmVh/BQBZj4AFAIATWH8FADmJgAUAQLoFg+Zdc/2Vl69kAMgF/GkOAEC63XKLIrG75vqrESMcKwcAYB0CFgAA6bZ3r3xdj33jG05UAgCwGAELAIB064hOC2z3eE+tv1qzxsGCAABWIWABAJBOCeuvvEYsXLH+CgByBn+iAwCQTgnrr0ysvwKAnEHAAgAgnVh/BQA5jYAFAEA6RaLjV6y/AoDcRMACALhXMCitXJm0Lsp2sXVX5vorjyd97w0AsB0BCwDgTsGgVF2tpg0PSdXV6QlZNTXdj+Xn2/++AIC0IWABANyprk5NJaWasXyjmkpKpfp6+9/zvvt00puXfKyqyv73BQCkDQELAOBOc+eqPNysl9ctUXm4WZozx/73PHpUwzo7dNKbd2r91ebN9r8vACBt8vo+BQCAHFRVJdXWqry+Phqu0jGS1NkpSfKx/goAchYBCwDgXlVV6Zuil7TBcDRoydetYTsAIMsxRRAAgHS45RZ1qMuI1aRJztQCALANAQsAgHTYu1d58XVXcf/6r87UAgCwDQELAIB0iK2/ao03uPB46CAIADmIgAUAQDrEAlZeZyT6mPVXAJCTCFgAANht4cLux/z+9NcBALAdAQsAALs9+aS5wXCnJ/bVe9VVDhYEALALAQsAALu1tZkbDOcbsSmCbDAMADmJgAUAQJrkx9df5bENJQDkKgIWAAB2i0SDlTk9EACQs/iTHgAAO9XUSEZ0/yuvEe0kSIMLAMhdtgasI0eOaPHixQoEAgoEAlq8eLE+/vjjXl/z29/+VvPnz1dZWZk8Ho8aGhq6ndPa2qqbbrpJZWVlKi4uVlVVld5//317fgkAAIbivvtocAEALmJrwLruuuvU0NCgrVu3auvWrWpoaNDixYt7fU1LS4tmz56t73//+z2es2LFCm3ZskWPPPKI/vjHP+rYsWO6+uqrFYlNwQAAIGO0tNDgAgBcxGMYsXkLFtu9e7fOPvts7dy5UxdffLEkaefOnZo5c6b27NmjyZMn9/r6vXv3atKkSdq1a5c+/elPm8dDoZDKy8v10EMP6dprr5UkffDBBxo/fryefPJJzZ8/v8/awuGwAoGAQqGQSkpKBv9LAgCyWzAo1dVJc+dKVVX2vEd+vtTRoXaPLxqw8vKk9nZ73gsAMGBWZwPbRrB27NihQCBghitJuuSSSxQIBLR9+/ZBX/fVV19Ve3u75s2bZx47/fTTNXXq1B6v29raqnA4nHQDALhcMChVV6tpw0NSdXX0sR1isyvM9VcAgJxmW8BqbGzU6NGjux0fPXq0Ghsbh3Rdv9+vkSNHJh0fM2ZMj9ddu3atuQ4sEAho/Pjxg35/AECOqKtTU0mpZizfqKaSUqm+3vr3SGhwYa6/Ki62/n0AABljwAHr9ttvl8fj6fX2yiuvSJI8Hk+31xuGkfL4UPV23VWrVikUCpm39957z/L3BwBkmblzVR5u1svrlqg83CzNmWP9e9x3n1ryCiQljGB94xvWvw8AIGMMeKfDG2+8UYsWLer1nIkTJ+r111/Xhx9+2O25pqYmjRkzZqBva6qoqFBbW5uOHDmSNIp16NAhzZo1K+VrCgoKVFBQMOj3BADkoKoqqbZW5fX10XBlxxqslhYVd3SoJa9AxR2tkscjrVlj/fsAADLGgANWWVmZysrK+jxv5syZCoVCeumll3TRRRdJkl588UWFQqEeg1B/TJ8+Xfn5+dq2bZu+/OUvS5IOHjyoN954Qz/4wQ8GfV0AgAtVVdnX3EKSvNGJIv5IR/Rxfr597wUAyAi2rcGqrKzUFVdcoWXLlmnnzp3auXOnli1bpquvvjqpg+CUKVO0ZcsW8/Hhw4fV0NCgt956S5L09ttvq6GhwVxfFQgEtHTpUt1yyy36wx/+oF27dukrX/mKzj33XH32s5+169cBAGDgOqLBypweaMMUeQBAZrF1H6yHH35Y5557rubNm6d58+bpvPPO00MPPZR0zttvv61QKGQ+DgaDmjZtmj7/+c9LkhYtWqRp06Zp3bp15jk//OEPdc011+jLX/6yZs+eraKiIv3ud7+Tz+ez89cBAKD/amqkzmiwMhtc8D0FADnPtn2wMhn7YAEAbFdRoZNNzRrWmbAH1oIFbDIMABkma/bBAgDA1Y4e1bDODp305kXDlddLuAIAFyBgAQBgh9j6K198oggNLgDAFQhYAADYIbb+yhSJOFMHACCtCFgAANiha8Dy8pULAG7An/YAAFgtoYOg2aJ95EgHCwIApAsBCwAAq61fr5a8AkkJLdqXLnWwIABAuhCwAADuFQxKK1dGf1rp6FEVd7SqJa8g2kEwL09as8ba9wAAZCQCFgDAnYJBqbpaTRsekqqrrQ1ZsQ6C/kj0JxsMA4B7ELAAAO5UV6emklLNWL5RTSWlUn29ddeOBSwTHQQBwDUIWAAAd5o7V+XhZr28bonKw83SnDnWXDcY7N5B0O+35toAgIyX53QBAAA4oqpKqq1VeX19NFxVVVlz3TvvVLvHq3yj81QHwalTrbk2ACDjEbAAAO5VVWVdsIr7z/9UfixYdXq88hmRaNt2AIArMEUQAAArtbdLklq9edEOgn6/9SEOAJCxCFgAANjAaxjRO3lMFgEANyFgAQBgpa4dBAEArkLAAgDAKsGg1NaWfCw/35laAACOIGABAGCVWAfBJJMnO1MLAMARBCwAAKyS0EHQRAdBAHAVAhYAAFahgyAAuB4BCwDgXsGgtHJl9KeF6CAIAO5FwAIAuFMwKFVXq2nDQ1J1teUhCwDgTgQsAIA71dWpqaRUM5ZvVFNJqVRfP/Rr0qIdAFyPgAUAcKe5c1UebtbL65aoPNwszZkztOulatE+YsTQrgkAyDpMDgcAuFNVlVRbq/L6+mi4GmozijvvVEtegYo7Wk8dW7p0aNcEAGQdj2HEV+K6RzgcViAQUCgUUklJidPlAABywWmnSaGQjuUP0/D2k9EOgq2tfb4MAOAsq7MBUwQBALBCrEU7HQQBwN0IWAAAWCg/QqMLAHAzAhYAAFaggyAAQAQsAACGLlUHwfx8Z2oBADiKgAUAwFA9+KDaPV2+UidPdqYWAICjCFgAAPcKBqWVK6M/h2L3buUbncnHamqGdk0AQFYiYAEA3CkYlKqr1bThIam6emghq6lJknTSl6d8IyIVFQ19Xy0AQFYiYAEA3KmuTk0lpZqxfKOaSkql+vrBXyvWor3T47OmNgBA1iJgAQDcae5clYeb9fK6JSoPN0tz5gz+WrGGFmaLdhpcAIBrsQsiAMCdqqqk2lqV19dHw9VQpvR5u/x9ZVHRUCoDAGQxAhYAwL2qqoa+VioYlI4cid73SDIkdXb29goAQA5jiiAAAENx551mi/Z2b+zvLSdMcLAgAICTCFgAAAzFvn1mi3ZzDRYt2gHAtQhYAAAMhS/aObDVG2vRPnIkLdoBwMUIWAAADMXx45Ikr4zoY9ZfAYCrEbAAAO4WDEorVw5+o+HYHljm+qvYYwCAOxGwAADuFQxK1dVq2vCQVF09+JAl9sACAEQRsAAA7lVXp6aSUs1YvlFNJaVSff3AXh8MmlMETaNHW1YeACD7ELAAAO41d67Kw816ed0SlYeboxsOD8Sdd6o1PjXQEztWWWllhQCALMNGwwAA96qqkmprVV5fHw1XA+3+t2+fCjqjUwPbvXnK74xIS5daXiYAIHsQsAAA7lZVNfi26gkt2os6WmnRDgBgiiAAAIMWiUhKaNHu9ztYDAAgExCwAAAYrNgIltmi3cvXKgC4Hd8EAAAMVqyDYH5sHVa3joIAANchYAEA3G0oGw133WQYAOB6BCwAgHsNZaPhhD2wzE2G2QMLAFyPgAUAcK+hbDTMHlgAgBQIWAAA9xrKRsNd9sCSxB5YAAD2wQIAuNhQNhpmDywAQAoELACAuw12o2H2wAIApMAUQQAABoM9sAAAKfBtAADAYMRGsMw9sDo7HSwGAJApCFgAAHcb7D5YXffAYgQLACACFgDAzQa7D1YwKB05IilhBKuw0KYiAQDZhIAFAHCvwe6DdeedaskrkJQwgrVokT01AgCyCgELAOBeg90Ha98+FXe06lj+sGiL9qIiac0aW0sFAGQH2rQDANxrsPtgxToIeo1Yi/ZAwJbyAADZh4AFAHC3weyDRQdBAEAPmCIIAMBAsQcWAKAHfCMAANxtMG3aGcECAPSAgAUAcK/BtmlnDywAQA/4RgAAuNdg2rSzBxYAoBcELACAew2mTTt7YAEAeuExjHiPWfcIh8MKBAIKhUIqKSlxuhwAgJOCwejIVX/btI8ZIx06pGP5wzS8/WR0D6yWFrurBADYxOpsQJt2AIC7DbRNO3tgAQB6wRRBAAAGgg6CAIBeELAAAO420Dbt7IEFAOgF3woAAPcaTJt2RrAAAL0gYAEA3GswbdoZwQIA9IJvBQCAew2mTXsoJIkRLABAanQRBAC4V1WVVFur8v62aa+pkY4flxQdwcrvjEgTJtheJgAgexCwAADuNpA27Zs2KeQvVqCtRfmR2AhWTY19tQEAsg5TBAEA7jaQLoI+nwJtLQr5i5VvRKSxYwe2hxYAIOcRsAAA7jWYLoKSijpORu8MH25jcQCAbETAAgC410C7CIbDkqQ2X17SYwAA4ghYAAD3GmgXwViLdo8Re0yLdgBAFzS5AAC410C7CLLJMACgD/zVGwAAhtH3OVL3TYZLSmwqCACQrQhYAAD3GkiTi2BQOnhQUsII1siRaSgSAJBNCFgAAPcaSJOLBx9Ua2zkymxyUVFhf40AgKxCwAIAuNdAmlzs3q2C2MiV2eRi6VLbSwQAZBeaXAAA3GsgTS5iLdlP+vJU1NEqBQJsMgwA6MbWEawjR45o8eLFCgQCCgQCWrx4sT7++ONeX/Pb3/5W8+fPV1lZmTwejxoaGrqdM2fOHHk8nqTbokWL7PklAAC5rz9NLmINLTo90UYXGj3axoIAANnK1oB13XXXqaGhQVu3btXWrVvV0NCgxYsX9/qalpYWzZ49W9///vd7PW/ZsmU6ePCgefvZz35mZekAADcYSJOLGLPBBQAAKdg2RXD37t3aunWrdu7cqYsvvliS9Itf/EIzZ87U22+/rcmTJ6d8XTyA7d27t9frFxUVqYLFxQCAoUhocvHyuiXRqYI9TfuLTRFs8+UpvzNiPgYAIJFtI1g7duxQIBAww5UkXXLJJQoEAtq+ffuQr//www+rrKxM55xzjr797W/r6NGjPZ7b2tqqcDicdAMAYEBNLmJTBM0GF+yBBQBIwbYRrMbGRo1OMT999OjRamxsHNK1/+Ef/kGTJk1SRUWF3njjDa1atUqvvfaatm3blvL8tWvX6o477hjSewIActBAmly0tEhiiiAAoHcDHsG6/fbbuzWY6Hp75ZVXJEkej6fb6w3DSHl8IJYtW6bPfvazmjp1qhYtWqTHHntMzzzzjP70pz+lPH/VqlUKhULm7b333hvS+wMAckxfTS4SNhk298CKRGwuCgCQjQY8gnXjjTf22bFv4sSJev311/Xhhx92e66pqUljxowZ6Nv26oILLlB+fr7+8pe/6IILLuj2fEFBgQoKCix9TwBADog3uSgpVfmPfiTV1qYexXrwQbXkFai4o/XUFEG61wIAUhhwwCorK1NZWVmf582cOVOhUEgvvfSSLrroIknSiy++qFAopFmzZg280l68+eabam9v19ixYy29LgAgx/W3ycXu3SruaNWx/GEa3n5SGjlSWrMm7eUCADKfbU0uKisrdcUVV2jZsmXauXOndu7cqWXLlunqq69O6iA4ZcoUbdmyxXx8+PBhNTQ06K233pIkvf3222poaDDXbb3zzjv63ve+p1deeUV79+7Vk08+qYULF2ratGmaPXu2Xb8OACAX9bfJRaw5kkex4Su/Pz31AQCyjq37YD388MM699xzNW/ePM2bN0/nnXeeHnrooaRz3n77bYVCIfNxMBjUtGnT9PnPf16StGjRIk2bNk3r1q2TJPn9fv3hD3/Q/PnzNXnyZH3zm9/UvHnz9Mwzz8jn89n56wAAck1VlbR6tcrPOlNavbrnJhex7xdzeqDX1q9PAEAW8xhGf7avzy3hcFiBQEChUEgltNkFAPdKXIMVbu55DdaYMdKhQ2r3+qJ7YI0ZIw2xIy4AIDNYnQ34KzgAgHslrMFqKimV6utTnxf7wm335iU9BgCgKwIWAMC9BrLRsNgDCwDQNwIWAMC9+rsGK9bkwtwDK/YYAICuCFgAAPcKBqW77lLTO/ulu+6KPk6lvV1SQpMLpggCAHpAwAIAuFd/1mDV1EhHjkhKmCJYWZm+GgEAWYWABQBwr/6swdq0SSF/saSEJhdLl6avRgBAViFgAQDcqz9rsHw+BdpaFPIXq6ijVRo7tue1WgAA1yNgAQDcq79rsCQVdZyM3hk+PE3FAQCyEQELAOBe/VmDRQdBAMAAELAAAO4VW4P12k+vi67BKizsfk6sYyAdBAEA/UHAAgC4V2wNVuDEUTWNGNXrNEE2GQYA9AcBCwDgbsePR6cJfv3fUk8TZIogAGAACFgAAHfrq1U7mwwDAAaAgAUAcLfeWrWzyTAAYIAIWAAAd+utVTubDAMABoiABQBwt7o6hQpHKPjJ2QoVjkheg3XyZPImwyNHsskwAKBXBCwAgLsVFSlw4qiqdj+nwImjya3aI5HoKfFNhv1+BwoEAGQTAhYAwN2OH1fTiFGaceND0VbtJ06cei7W0MKcHkiDCwBAHwhYAAB3mztX5UcP660fLVT50cPduwiKPbAAAP1HwAIAQFKLv7D7QfbAAgAMEAELAOBudXXRjYb/6VfdNxr2+SSxBxYAoP8IWAAAd4ttNPzWjxYmbzQcDEoHD0pKmCI4cqQzNQIAsgYBCwAApZgi+OCDao01tzCnCFZUpLkqAEC2IWABANwtvg/W5MuS98HavVsFsZErc4ogmwwDAPpAwAIAuFtP+2DFGlqc9OVFNxkOBNhkGADQJwIWAMDdjh9XqHC4gpWXK1Q4/NQ+WLGGFp2eaKMLjR7tUIEAgGxCwAIAuFtRkQInjsVGsI6dGsGKYQ8sAMBAELAAAO7W0wgWe2ABAAaBgAUAcLeeRrC67oHl5SsTANA3vi0AAO7W0wjW8eOSEqYIdnY6VCAAIJsQsAAA7pZqBCsYlEIhSVJ7bC+seNMLAAB6Q8ACALhbqhGshE2GzRGsykoHiwQAZIs8pwsAAMBRsRGsv3/t99H9rgoLkzYZbvfmKb8zwibDAIB+YQQLAOBuf/6zJCk8rDj6+I03pKYmSQmbDBcVsckwAKBfCFgAANcL+Yv1/02+VCF/cdJxc5Ph/HwHqgIAZCMCFgDA3c49V4G2Fv39a79XoK1Fmjo1OmIlKT8SW38VewwAQF8IWAAAd4tNEWzNi41SPfOMFIlE73ti59CiHQDQTwQsAIDrhfzFGnnymJqKTpNeeql7i3Y2GQYA9BPfGAAAd/va1xRoa1HIX6xg5eU6mZcvtbZKSmjRXljoYIEAgGxCwAIAuFtVlbRggbkOa1hHu1ryCiQljGAtWuRggQCAbELAAgCgy4hVcUerWvIKoi3a8/KkNWucrA4AkEUIWAAA7N4tKWHESpI/3kHQ73eiIgBAliJgAQAQDkuSDE8f5wEA0AcCFgAAJSWSEkatAAAYJAIWAAAx3s5I94MjRqS/EABA1iJgAQDQ1CQp+qUY7yBoWro0/fUAALIWAQsAgBiPTnUQzDdio1l0EAQADAABCwCAT31KiZMDh3W0OVYKACC7EbAAAPjOd+ST1Nn1uJevSQDAwPDNAQBAVZXk83X/UrzkEieqAQBkMQIWAACS1NEh5edLknwypFmzpBdecLgoAEC2yev7FAAAXKKNtVcAgKFhBAsAAAAALELAAgAAAACLELAAAAAAwCIELAAAAACwCAELAAAAACxCwAIAAAAAixCwAAAAAMAiBCwAAAAAsAgBCwAAAAAsQsACAAAAAIsQsAAAAADAIgQsAAAAALAIAQsAAAAALELAAgAAAACLELAAAAAAwCIELAAAAACwCAELAAAAACxCwAIAAAAAixCwAAAAAMAiBCwAAAAAsAgBCwAAAAAsQsACAAAAAIsQsAAAAADAIgQsAAAAALAIAQsAAAAALELAAgAAAACLELAAAAAAwCIELAAAAACwCAELAAAAACxCwAIAAAAAi+Q5XYATDMOQJIXDYYcrAQAAAOCkeCaIZ4ShcmXAam5uliSNHz/e4UoAAAAAZILm5mYFAoEhX8eVAWvUqFGSpP3791vyDxHZKRwOa/z48XrvvfdUUlLidDlwAJ8B8BkAnwHwGUAoFNKZZ55pZoShcmXA8nqjS88CgQD/IUElJSV8DlyOzwD4DIDPAPgMIJ4RhnwdS64CAAAAACBgAQAAAIBVXBmwCgoKdNttt6mgoMDpUuAgPgfgMwA+A+AzAD4DsPoz4DGs6kcIAAAAAC7nyhEsAAAAALADAQsAAAAALELAAgAAAACLELAAAAAAwCIELAAAAACwiOsCVlVVlc4880wNGzZMY8eO1eLFi/XBBx8knbN//3594QtfUHFxscrKyvTNb35TbW1tDlUMK+3du1dLly7VpEmTVFhYqLPOOku33XZbt3+/fAZy25o1azRr1iwVFRXptNNOS3kOn4Hcd//992vSpEkaNmyYpk+frueff97pkmCj5557Tl/4whd0+umny+Px6Iknnkh63jAM3X777Tr99NNVWFioOXPm6M0333SmWFhu7dq1mjFjhkaMGKHRo0frmmuu0dtvv510Dp+B3PfAAw/ovPPOU0lJiUpKSjRz5kw99dRT5vNWfQZcF7Dmzp2r3/zmN3r77bf1+OOP65133tGCBQvM5yORiD7/+c+rpaVFf/zjH/XII4/o8ccf1y233OJg1bDKnj171NnZqZ/97Gd688039cMf/lDr1q3T6tWrzXP4DOS+trY2LVy4UF//+tdTPs9nIPc9+uijWrFihWpqarRr1y5ddtlluvLKK7V//36nS4NNWlpadP755+vee+9N+fwPfvAD3XPPPbr33nv18ssvq6KiQp/73Od09OjRNFcKOzz77LP6xje+oZ07d2rbtm3q6OjQvHnz1NLSYp7DZyD3jRs3Tt///vf1yiuv6JVXXtFnPvMZVVdXmyHKss+A4XK1tbWGx+Mx2traDMMwjCeffNLwer3GgQMHzHM2bdpkFBQUGKFQyKkyYaMf/OAHxqRJk8zHfAbc45e//KURCAS6HeczkPsuuugiY/ny5UnHpkyZYvyv//W/HKoI6STJ2LJli/m4s7PTqKioML7//e+bx06ePGkEAgFj3bp1DlQIux06dMiQZDz77LOGYfAZcLORI0caDz74oKWfAdeNYCU6fPiwHn74Yc2aNUv5+fmSpB07dmjq1Kk6/fTTzfPmz5+v1tZWvfrqq06VChuFQiGNGjXKfMxnAHwGcltbW5teffVVzZs3L+n4vHnztH37doeqgpPeffddNTY2Jn0mCgoK9Ld/+7d8JnJUKBSSJPP7n8+A+0QiET3yyCNqaWnRzJkzLf0MuDJg3XrrrSouLlZpaan279+v2tpa87nGxkaNGTMm6fyRI0fK7/ersbEx3aXCZu+8845++tOfavny5eYxPgPgM5DbPvroI0UikW7/jseMGcO/X5eK/3vnM+EOhmHo5ptv1qWXXqqpU6dK4jPgJn/+8581fPhwFRQUaPny5dqyZYvOPvtsSz8DORGwbr/9dnk8nl5vr7zyinn+//yf/1O7du3S008/LZ/Pp+uvv16GYZjPezyebu9hGEbK48gMA/0MSNIHH3ygK664QgsXLtTXvva1pOf4DGSfwXwGesNnIPd1/XfJv1/wmXCHG2+8Ua+//ro2bdrU7Tk+A7lv8uTJamho0M6dO/X1r39dX/3qV/XWW2+Zz1vxGcizpFKH3XjjjVq0aFGv50ycONG8X1ZWprKyMn3qU59SZWWlxo8fr507d2rmzJmqqKjQiy++mPTaI0eOqL29vVuiReYY6Gfggw8+0Ny5czVz5kz9/Oc/TzqPz0B2GuhnoDd8BnJbWVmZfD5ft7+RPHToEP9+XaqiokJSdBRj7Nix5nE+E7nnpptuUjAY1HPPPadx48aZx/kMuIff79cnPvEJSdKFF16ol19+WT/+8Y916623SrLmM5ATASsemAYjPnLV2toqSZo5c6bWrFmjgwcPmv9wn376aRUUFGj69OnWFAzLDeQzcODAAc2dO1fTp0/XL3/5S3m9yQO5fAay01D+HOiKz0Bu8/v9mj59urZt26b/9t/+m3l827Ztqq6udrAyOGXSpEmqqKjQtm3bNG3aNEnRtXrPPvus7r77boergxUMw9BNN92kLVu2qL6+XpMmTUp6ns+AexmGodbWVms/A1Z038gWL774ovHTn/7U2LVrl7F3717jP/7jP4xLL73UOOuss4yTJ08ahmEYHR0dxtSpU42/+7u/M/70pz8ZzzzzjDFu3DjjxhtvdLh6WOHAgQPGJz7xCeMzn/mM8f777xsHDx40b3F8BnLfvn37jF27dhl33HGHMXz4cGPXrl3Grl27jKNHjxqGwWfADR555BEjPz/fWL9+vfHWW28ZK1asMIqLi429e/c6XRpscvToUfO/dUnGPffcY+zatcvYt2+fYRiG8f3vf98IBALGb3/7W+PPf/6z8fd///fG2LFjjXA47HDlsMLXv/51IxAIGPX19Unf/cePHzfP4TOQ+1atWmU899xzxrvvvmu8/vrrxurVqw2v12s8/fTThmFY9xlwVcB6/fXXjblz5xqjRo0yCgoKjIkTJxrLly833n///aTz9u3bZ3z+8583CgsLjVGjRhk33nijGcCQ3X75y18aklLeEvEZyG1f/epXU34G6urqzHP4DOS+++67z5gwYYLh9/uNCy64wGzXjNxUV1eX8r/7r371q4ZhRNt033bbbUZFRYVRUFBgXH755caf//xnZ4uGZXr67v/lL39pnsNnIPf9j//xP8w/98vLy42/+7u/M8OVYVj3GfAYRkJ3BwAAAADAoOVEF0EAAAAAyAQELAAAAACwCAELAAAAACxCwAIAAAAAixCwAAAAAMAiBCwAAAAAsAgBCwAAAAAsQsACAAAAAIsQsAAAAADAIgQsAEDOu/HGG3XppZemfG7ixIlas2ZNmisCAOSqPKcLAADATm+99ZYeeOABPffccymfr6ysVENDQ3qLAgDkLEawAAA57V/+5V80Y8YMzZ49O+Xzo0aN0ocffpjmqgAAuYqABQDIWR0dHXr88cf1pS99yTx2ww03aP369ebjo0ePqri42InyAAA5iIAFAMhZ77zzjo4ePapzzz1XktTZ2anNmzdr+PDh5jmvv/66KisrJUlXXnmlbrvtNl1yySWaMGGC3nrrLUfqBgBkLwIWACBnffzxx5JkBqrf//73OnLkiPx+vyTppZde0r59+3TNNddIkt544w1NmjRJO3fu1LJly/S73/3OibIBAFmMJhcAgJw1YcIEeTwebdq0ScXFxbrlllt01VVXqba2VhMnTtQNN9ygz3zmM7r88ssVCoWUn5+vJUuWSJL8fr8CgYCzvwAAIOswggUAyFkVFRVas2aN/v3f/11XXnmlbr75Zq1du1bPPvusLr30Uk2ePFmbN2+WFB29uuiii8zXvvHGGzrnnHOcKh0AkKU8hmEYThcBAIDTfvazn+mjjz5STU2NJGnatGmqq6vTaaed5mxhAICswggWAACS3nzzTbMZRkdHh44dO0a4AgAMGCNYAAAAAGARRrAAAAAAwCIELAAAAACwCAELAAAAACxCwAIAAAAAixCwAAAAAMAiBCwAAAAAsAgBCwAAAAAsQsACAAAAAIsQsAAAAADAIgQsAAAAALAIAQsAAAAALPL/A8O6Pgab2ip8AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -231,9 +231,9 @@ ], "metadata": { "kernelspec": { - "display_name": "triqskernel", + "display_name": "Python 3", "language": "python", - "name": "triqskernel" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -245,7 +245,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.12" } }, "nbformat": 4,