FullClassicalHubbard.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import sys\n",
    "sys.path.append('./src')\n",
    "# Importing standard Qiskit libraries and configuring account\n",
    "#from qiskit import QuantumCircuit, execute, Aer, IBMQ\n",
    "#from qiskit.compiler import transpile, assemble\n",
    "#from qiskit.tools.jupyter import *\n",
    "#from qiskit.visualization import *\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import numpy as np\n",
    "import ClassicalHubbardEvolutionChain as chc\n",
    "import FullClassicalHubbardEvolutionChain as fhc\n",
    "\n",
    "import random as rand\n",
    "import scipy.linalg as la\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0. ...  0.  0.  0.]\n",
      " [ 0.  0. -1. ...  0.  0.  0.]\n",
      " [ 0. -1.  0. ...  0.  0.  0.]\n",
      " ...\n",
      " [ 0.  0.  0. ...  2. -1.  0.]\n",
      " [ 0.  0.  0. ... -1.  2.  0.]\n",
      " [ 0.  0.  0. ...  0.  0.  2.]]\n"
     ]
    }
   ],
   "source": [
    "numsites = 3\n",
    "states_list = fhc.get_states(numsites)\n",
    "hamil = fhc.get_hamiltonian(states_list, 1.0, 2.0)\n",
    "print(hamil)\n",
    "eigval, eigvec = la.eig(hamil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 4 is different from 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_13108/2344664767.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     42\u001b[0m     \u001b[0mH4_trot\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtensordot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mI\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtensordot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mI\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mYY\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdelta\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxes\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxes\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     43\u001b[0m     \u001b[0mH_trot\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mH3_trot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mH4_trot\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 44\u001b[1;33m     \u001b[0mH_trot\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mH2_trot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mH_trot\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     45\u001b[0m     \u001b[0mH_trot\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mH1_trot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mH_trot\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     46\u001b[0m     \u001b[0mH_trot\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mH0_trot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mH_trot\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 4 is different from 2)"
     ]
    }
   ],
   "source": [
    "#Attempt to get trotter error\n",
    "\n",
    "def XX(theta):\n",
    "    theta2 = theta / 2\n",
    "    cos = np.cos(theta2)\n",
    "    isin = 1j * np.sin(theta2)\n",
    "    return np.array([[cos, 0, 0, -isin], [0, cos, -isin, 0], [0, -isin, cos, 0], [-isin, 0, 0, cos]])\n",
    "\n",
    "def YY(theta):\n",
    "    cos = np.cos(theta / 2)\n",
    "    isin = 1j * np.sin(theta / 2)\n",
    "    return np.array([[cos, 0, 0, isin], [0, cos, -isin, 0], [0, -isin, cos, 0], [isin, 0, 0, cos]]) \n",
    "\n",
    "def ZZ(theta):\n",
    "    itheta2 = 1j * float(theta) / 2\n",
    "    return np.array(\n",
    "        [\n",
    "            [np.exp(-itheta2), 0, 0, 0],\n",
    "            [0, np.exp(itheta2), 0, 0],\n",
    "            [0, 0, np.exp(itheta2), 0],\n",
    "            [0, 0, 0, np.exp(-itheta2)],\n",
    "        ])\n",
    "\n",
    "def Z(theta):\n",
    "    itheta2 = 1j * float(theta)/2\n",
    "    return np.array([np.exp(-itheta2), 0], [0, np.exp(itehta2)])\n",
    "    \n",
    "t = 6.0\n",
    "trotter_steps = np.arange(2,50,2)\n",
    "U_over_t = 2.0\n",
    "I = np.array([[1., 0.], [0., 1.]])\n",
    "X = np.array([[0., 1.], [1., 0.]])\n",
    "Y = np.array([[0., -1.j], [1.j, 0.]])\n",
    "Z = np.array([[1., 0.],[0., -1.]])\n",
    "\n",
    "for N in trotter_steps:\n",
    "    delta = t/N\n",
    "    H0_trot = np.tensordot(I, np.tensordot(ZZ(delta), I, axes=0), axes=0)\n",
    "    H1_trot = np.tensordot(XX(delta), np.tensordot(I, I, axes=0), axes=0)\n",
    "    H2_trot = np.tensordot(YY(delta), np.tensordot(I, I, axes=0), axes=0)\n",
    "    H3_trot = np.tensordot(I, np.tensordot(I, XX(delta), axes=0), axes=0)\n",
    "    H4_trot = np.tensordot(I, np.tensordot(I, YY(delta), axes=0), axes=0)\n",
    "    \n",
    "    H_trot = np.matmul(H3_trot, H4_trot)\n",
    "    H_trot = np.matmul(H2_trot, H_trot)\n",
    "    H_trot = np.matmul(H1_trot, H_trot)\n",
    "    H_trot = np.matmul(H0_trot, H_trot)\n",
    "    \n",
    "    for step in range(N):\n",
    "        H_trot = np.matmul(H_trot, H_trot)\n",
    "    \n",
    "    H0 = np.tensordot(I, np.tensordot(Z, np.tensordot(Z, I, axes=0), axes=0), axes=0)\n",
    "    H1 = np.tensordot(X, np.tensordot(X, np.tensordot(I, I, axes=0), axes=0), axes=0)\n",
    "    H2 = np.tensordot(Y, np.tensordot(Y, np.tensordot(I, I, axes=0), axes=0), axes=0)\n",
    "    H3 = np.tensordot(I, np.tensordot(I, np.tensordot(X, X, axes=0), axes=0), axes=0)\n",
    "    H4 = np.tensordot(I, np.tensordot(I, np.tensordot(Y, Y, axes=0), axes=0), axes=0)\n",
    "    H = H0 + H1 + H2 + H3 + H4\n",
    "    true_unitary = np.expm(-1j*H*t)\n",
    "    \n",
    "    diff = np.linalg.norm(true_unitary - H_trot)\n",
    "    print(\"Trotter Steps: \", N, \"  Error: \",diff)\n",
    "    \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3.00000000e+00+0.j  1.00000000e+00+0.j  1.00000000e+00+0.j\n",
      " -1.00000000e+00+0.j  1.00000000e+00+0.j -1.00000000e+00+0.j\n",
      " -1.23606798e+00+0.j  1.15861935e-17+0.j  3.23606798e+00+0.j\n",
      "  3.00000000e+00+0.j  1.00000000e+00+0.j  2.00000000e+00+0.j\n",
      "  0.00000000e+00+0.j  0.00000000e+00+0.j  0.00000000e+00+0.j\n",
      "  2.00000000e+00+0.j]\n"
     ]
    }
   ],
   "source": [
    "print(eigval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, (-0.00983435222107347+0.0013193953970894764j), 0j, (0.009817818428368446+0.09801659541892288j), (-0.009900553773458835+0.0006593662648672717j), 0j, 0j, 0j, 0j, (0.009817818428368473+0.09801659541892312j), 0j, (0.9801988924530836+0.0013187325297345435j), (0.009817818428368473+0.09801659541892312j), 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, (-0.009900553773458845+0.0006593662648672722j), 0j, (0.009817818428368466+0.09801659541892307j), (-0.00983435222107349+0.0013193953970894795j), 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j]\n",
      "[[0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]\n",
      " [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]\n",
      " [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]\n",
      " ...\n",
      " [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]\n",
      " [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]\n",
      " [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "./src\\FullClassicalHubbardEvolutionChain.py:239: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  evolve[t] = np.dot(np.conj(wfk),wfk)\n",
      "./src\\FullClassicalHubbardEvolutionChain.py:240: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  energies[t] = wfk_energy(wfk, hamiltonian)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1719e6e9288>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJQAAAI/CAYAAAAhoYNSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA1uklEQVR4nO3df7CfdX3n/debEwzWwNISjor8lAbNT0/tIQxguaNsom6dpuq2wHLvhCojDLWuOOZueq+z5e7ATVx01Z2FOm61g4UWrF1dBhUqyJ1lQ6CcxANKYipQaqKppGYSkxr5ET73H/lKT5JD8r1Iwonp4zFzJt/ruj7XdX2uM3PG9sl1Xd9qrQUAAAAA+nXERE8AAAAAgJ8vghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdTJroCRwIU6dObaeeeupETwMAAADgsLFy5cp/bK0dP962wyIonXrqqRkZGZnoaQAAAAAcNqrq719om0feAAAAAOhEUAIAAACgE0EJAAAAgE4Oi3coAQAAAOzumWeeyfr16/PTn/50oqdySDvqqKNy4okn5sgjj+x7H0EJAAAAOCytX78+Rx99dE499dRU1URP55DUWsuPfvSjrF+/Pqeddlrf+3nkDQAAADgs/fSnP81xxx0nJu1FVeW4447rfBeXoAQAAAActsSkfXsxvyNBCQAAAIBOBCUAAAAAOhGUAAAAAA6ia665JjNnzsycOXMyNDSUBx54IElyzjnnJEk2b96cG264ofNx3/Oe92RwcDCzZs3a67gtW7Zk1apV3Se+F4ISAAAAwEGyYsWK3H777Vm1alUefvjh3HXXXTnppJOSJPfdd1+SFx+ULrnkktxxxx17HbNly5a89a1vzTnnnJOvfe1r3S/gBQhKAAAAAAfJhg0bMnXq1EyePDlJMnXq1JxwwglJkilTpiRJlixZksceeyxDQ0NZvHhxkuSmm27K3LlzMzQ0lMsuuyw7duzY49jnnXdefumXfmmv57/00ktz9tln5y1veUs+8pGP5Hvf+94BuS5BCQAAAOAgWbBgQdatW5czzjgjV1xxRZYtW7bHmKVLl+b000/P6OhorrvuuqxZsya33nprli9fntHR0QwMDOTmm29+Uef//Oc/n4svvjiDg4NZvnx5Tj755P29pCTJpANyFAAAAIBD2KlLvnJQjvvE0l/f6/YpU6Zk5cqVuffee3PPPffkggsuyNKlS3PJJZe84D533313Vq5cmTPPPDNJsn379gwODr6o+b385S9//vNRRx31oo4xHkEJAAAA4CAaGBjIvHnzMm/evMyePTs33njjXoNSay2LFi3Ktdde+9JNsiNBCQAAADjs7etOooNl7dq1OeKIIzJt2rQkyejoaE455ZRdxhx99NHZunXr88vnn39+Fi5cmCuvvDKDg4PZtGlTtm7dusd+E8k7lAAAAAAOkm3btmXRokWZMWNG5syZk9WrV+eqq67aZcxxxx2Xc889N7NmzcrixYszY8aMXH311VmwYEHmzJmT+fPnZ8OGDXsc+6KLLsrZZ5+dtWvX5sQTT8xnP/vZl+iqkmqtvWQnO1iGh4fbyMjIRE8DAAAAOISsWbMm06dPn+hp/FwY73dVVStba8PjjXeHEgAAAACd9BWUquptVbW2qh6tqiXjbH99Va2oqqeq6sNj1r+uqkbH/Py4qj7Y23ZVVX1/zLZ/M2a/P+ida21VvfUAXCcAAAAAB8g+X8pdVQNJrk8yP8n6JA9W1W2ttdVjhm1K8oEkvzl239ba2iRDY47z/SRfGjPkE621j+12vhlJLkwyM8kJSe6qqjNaazs6XRkAAAAAB0U/dyjNTfJoa+3x1trTSW5JsnDsgNbak621B5M8s5fjnJ/ksdba3+/jfAuT3NJae6q19ndJHu3NAQAAAIBDQD9B6TVJ1o1ZXt9b19WFSf5it3Xvr6qHq+pzVfWLB/h8AAAAABwE/QSlGmddp6+Gq6qXJfmNJH85ZvUfJzk9Ox+J25Dk413OV1Xvq6qRqhrZuHFjl+kAAAAAsB/6CUrrk5w0ZvnEJD/oeJ63J1nVWvvhz1a01n7YWtvRWnsuyX/PPz/W1tf5Wmufaa0Nt9aGjz/++I7TAQAAAODF6icoPZhkWlWd1rvT6MIkt3U8z0XZ7XG3qnr1mMV3Jvl27/NtSS6sqslVdVqSaUn+puP5AAAAAA4J11xzTWbOnJk5c+ZkaGgoDzzwQJLknHPOSZJs3rw5N9xwQ+fjvuc978ng4GBmzZq113FbtmzJQw891H3ie7HPoNRaezbJ+5PcmWRNki+01h6pqsur6vIkqapXVdX6JB9K8pGqWl9Vx/S2/UJ2fkPc/9jt0P+5qr5VVQ8neXOSK3vneyTJF5KsTnJHkt/1DW8AAADAz6MVK1bk9ttvz6pVq/Lwww/nrrvuykkn7Xww67777kvy4oPSJZdckjvuuGOf47773e/mE5/4ROfj782kfga11r6a5Ku7rfv0mM//kJ2Ppo2370+SHDfO+n+/l/Ndk+SafuYGAAAAcKjasGFDpk6dmsmTJydJpk6d+vy2KVOmZNu2bVmyZEkee+yxDA0NZf78+bnuuuty00035b/+1/+ap59+OmeddVZuuOGGDAwM7HLs8847L0888cRLeTnP6+eRNwAAAABehAULFmTdunU544wzcsUVV2TZsmV7jFm6dGlOP/30jI6O5rrrrsuaNWty6623Zvny5RkdHc3AwEBuvvnmCZj9C+vrDiUAAACAn3enLvnKC277f985O//urJOTJH/+wPfyf3/pWy849omlv973OadMmZKVK1fm3nvvzT333JMLLrggS5cuzSWXXPKC+9x9991ZuXJlzjzzzCTJ9u3bMzg42Pc5XwqCEgAAAMBBNDAwkHnz5mXevHmZPXt2brzxxr0GpdZaFi1alGuvvXa/z71ixYrnH5UbGRnJ7Nmzn3/8bn8ISgAAAMC/CP3eWfTvzjr5+buV9tfatWtzxBFHZNq0aUmS0dHRnHLKKbuMOfroo7N169bnl88///wsXLgwV155ZQYHB7Np06Zs3bp1j/368eUvfznLli3LT37yk1x66aW5884788pXvnL/LireoQQAAABw0Gzbti2LFi3KjBkzMmfOnKxevTpXXXXVLmOOO+64nHvuuZk1a1YWL16cGTNm5Oqrr86CBQsyZ86czJ8/Pxs2bNjj2BdddFHOPvvsrF27NieeeGI++9nP7jHmox/9aN70pjdl+/bt+cpXvnJAYlKSVGvtgBxoIg0PD7eRkZGJngYAAABwCFmzZk2mT58+0dM4JOzYsWOPb4kba7zfVVWtbK0NjzfeHUoAAAAAh7m9xaQXQ1ACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAADqJrrrkmM2fOzJw5czI0NJQHHnggSXLOOeckSTZv3pwbbrih0zHXrVuXN7/5zZk+fXpmzpyZT33qUy84dsuWLVm1atWLv4BxCEoAAAAAB8mKFSty++23Z9WqVXn44Ydz11135aSTTkqS3HfffUleXFCaNGlSPv7xj2fNmjW5//77c/3112f16tV7jNuyZUve+ta35pxzzsnXvva1/b+gHkEJAAAA4CDZsGFDpk6dmsmTJydJpk6dmhNOOCFJMmXKlCTJkiVL8thjj2VoaCiLFy9Oktx0002ZO3duhoaGctlll2XHjh27HPfVr3513vjGNyZJjj766EyfPj3f//739zj/pZdemrPPPjtvectb8pGPfCTf+973Dsh1CUoAAAAAB8mCBQuybt26nHHGGbniiiuybNmyPcYsXbo0p59+ekZHR3PddddlzZo1ufXWW7N8+fKMjo5mYGAgN9988wue44knnsg3v/nNnHXWWXts+/znP5+LL744g4ODWb58eU4++eQDcl2TDshRAAAAAA5lV/2rg3TcLXvdPGXKlKxcuTL33ntv7rnnnlxwwQVZunRpLrnkkhfc5+67787KlStz5plnJkm2b9+ewcHBccdu27Yt7373u/PJT34yxxxzzB7bX/7ylz//+aijjurjgvojKAEAAAAcRAMDA5k3b17mzZuX2bNn58Ybb9xrUGqtZdGiRbn22mv3etxnnnkm7373u3PxxRfnXe961wGe9d4JSgAAAMDhbx93Eh0sa9euzRFHHJFp06YlSUZHR3PKKafsMuboo4/O1q1bn18+//zzs3Dhwlx55ZUZHBzMpk2bsnXr1l32a63lve99b6ZPn54PfehDL83FjOEdSgAAAAAHybZt27Jo0aLMmDEjc+bMyerVq3PVVVftMua4447Lueeem1mzZmXx4sWZMWNGrr766ixYsCBz5szJ/Pnzs2HDhl32Wb58ef7sz/4s3/jGNzI0NJShoaF89atffcmuq1prL9nJDpbh4eE2MjIy0dMAAAAADiFr1qzJ9OnTJ3oaPxfG+11V1crW2vB4492hBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAABxE11xzTWbOnJk5c+ZkaGgoDzzwQJLknHPOSZJs3rw5N9xwQ6djrlu3Lm9+85szffr0zJw5M5/61KdecOyWLVvy0EMPvfgLGIegBAAAAHCQrFixIrfffntWrVqVhx9+OHfddVdOOumkJMl9992X5MUFpUmTJuXjH/941qxZk/vvvz/XX399Vq9ePe7Y7373u/nEJz6xfxeyG0EJAAAA4CDZsGFDpk6dmsmTJydJpk6dmhNOOCFJMmXKlCTJkiVL8thjj2VoaCiLFy9Oktx0002ZO3duhoaGctlll2XHjh27HPfVr3513vjGNyZJjj766EyfPj3f//73X6rLEpQAAAAADpYFCxZk3bp1OeOMM3LFFVdk2bJle4xZunRpTj/99IyOjua6667LmjVrcuutt2b58uUZHR3NwMBAbr755hc8xxNPPJFvfvObOeussw7mpexi0kt2JgAAAICJdNW/euFt7/hkMvw7Oz+P/Gly+wf3cpwtfZ9yypQpWblyZe69997cc889ueCCC7J06dJccsklL7jP3XffnZUrV+bMM89Mkmzfvj2Dg4Pjjt22bVve/e5355Of/GSOOeaYvue1vwQlAAAAgINoYGAg8+bNy7x58zJ79uzceOONew1KrbUsWrQo11577V6P+8wzz+Td7353Lr744rzrXe8ad8yKFSsyMDCQJBkZGcns2bOff/xufwhKAAAAwL8M/d5ZNPw7/3y30n5au3ZtjjjiiEybNi1JMjo6mlNOOWWXMUcffXS2bt36/PL555+fhQsX5sorr8zg4GA2bdqUrVu37rJfay3vfe97M3369HzoQx96wfN/+ctfzrJly/KTn/wkl156ae6888688pWv3O/r8g4lAAAAgINk27ZtWbRoUWbMmJE5c+Zk9erVueqqq3YZc9xxx+Xcc8/NrFmzsnjx4syYMSNXX311FixYkDlz5mT+/PnZsGHDLvssX748f/Znf5ZvfOMbGRoaytDQUL761a/ucf6PfvSjedOb3pTt27fnK1/5ygGJSUlSrbUDcqCJNDw83EZGRiZ6GgAAAMAhZM2aNZk+ffpET+OQsGPHjucffRvPeL+rqlrZWhseb7w7lAAAAAAOc3uLSS+GoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAAAcRNdcc01mzpyZOXPmZGhoKA888ECS5JxzzkmSbN68OTfccEOnY/70pz/N3Llz84Y3vCEzZ87MH/7hH77g2C1btmTVqlUv/gLGISgBAAAAHCQrVqzI7bffnlWrVuXhhx/OXXfdlZNOOilJct999yV5cUFp8uTJ+cY3vpGHHnooo6OjueOOO3L//ffvMW7Lli1561vfmnPOOSdf+9rX9v+CegQlAAAAgINkw4YNmTp1aiZPnpwkmTp1ak444YQkyZQpU5IkS5YsyWOPPZahoaEsXrw4SXLTTTdl7ty5GRoaymWXXZYdO3bsctyqen7/Z555Js8880yqao/zX3rppTn77LPzlre8JR/5yEfyve9974Bcl6AEAAAAcJAsWLAg69atyxlnnJErrrgiy5Yt22PM0qVLc/rpp2d0dDTXXXdd1qxZk1tvvTXLly/P6OhoBgYGcvPNN++x344dOzI0NJTBwcHMnz8/Z5111h5jPv/5z+fiiy/O4OBgli9fnpNPPvmAXNekA3IUAAAAgEPY7BtnH5TjfmvRt/a6fcqUKVm5cmXuvffe3HPPPbnggguydOnSXHLJJS+4z913352VK1fmzDPPTJJs3749g4ODe4wbGBjI6OhoNm/enHe+85359re/nVmzZu0y5uUvf/nzn4866qgOV7Z3ghIAAADAQTQwMJB58+Zl3rx5mT17dm688ca9BqXWWhYtWpRrr722r+Mfe+yxmTdvXu644449gtLBIigBAAAAh7193Ul0sKxduzZHHHFEpk2bliQZHR3NKaecssuYo48+Olu3bn1++fzzz8/ChQtz5ZVXZnBwMJs2bcrWrVt32W/jxo058sgjc+yxx2b79u2566678vu///svzUVFUAIAAAA4aLZt25bf+73fy+bNmzNp0qT88i//cj7zmc/sMua4447Lueeem1mzZuXtb397rrvuulx99dVZsGBBnnvuuRx55JG5/vrrdwlKGzZsyKJFi7Jjx44899xz+e3f/u284x3veMmuq1prL9nJDpbh4eE2MjIy0dMAAAAADiFr1qzJ9OnTJ3oaPxfG+11V1crW2vB4433LGwAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAHAQXXPNNZk5c2bmzJmToaGhPPDAA0mSc845J0myefPm3HDDDZ2O+dOf/jRz587NG97whsycOTN/+Id/+IJjt2zZkoceeujFX8A4BCUAAACAg2TFihW5/fbbs2rVqjz88MO56667ctJJJyVJ7rvvviQvLihNnjw53/jGN/LQQw9ldHQ0d9xxR+6///5xx373u9/NJz7xif27kN30FZSq6m1VtbaqHq2qJeNsf31Vraiqp6rqw2PWv66qRsf8/LiqPtjbdl1VfaeqHq6qL1XVsb31p1bV9jH7fPrAXCoAAADAS2vDhg2ZOnVqJk+enCSZOnVqTjjhhCTJlClTkiRLlizJY489lqGhoSxevDhJctNNN2Xu3LkZGhrKZZddlh07duxy3Kp6fv9nnnkmzzzzTKrqpbqsfQelqhpIcn2StyeZkeSiqpqx27BNST6Q5GNjV7bW1rbWhlprQ0l+NclPknypt/nrSWa11uYk+dskfzBm18d+tl9r7fLulwUAAAAw8RYsWJB169bljDPOyBVXXJFly5btMWbp0qU5/fTTMzo6muuuuy5r1qzJrbfemuXLl2d0dDQDAwO5+eab99hvx44dGRoayuDgYObPn5+zzjrrpbikJMmkPsbMTfJoa+3xJKmqW5IsTLL6ZwNaa08mebKqfn0vxzk/O0PR3/f2+esx2+5P8m87zh0AAACgb7NvnP2C2/7T2f8pv3XGbyVJ/vJv/zJ/tOKPXnDstxZ9q+9zTpkyJStXrsy9996be+65JxdccEGWLl2aSy655AX3ufvuu7Ny5cqceeaZSZLt27dncHBwj3EDAwMZHR3N5s2b8853vjPf/va3M2vWrL7ntj/6CUqvSbJuzPL6JC8meV2Y5C9eYNt7ktw6Zvm0qvpmkh8n+Uhr7d4XcT4AAACACTcwMJB58+Zl3rx5mT17dm688ca9BqXWWhYtWpRrr722r+Mfe+yxmTdvXu644449gtKKFSsyMDCQJBkZGcns2bOff/xuf/QTlMZ7AK91OUlVvSzJb2TXx9p+tu0/Jnk2yc/u3dqQ5OTW2o+q6leTfLmqZrbWfrzbfu9L8r4kOfnkk7tMBwAAAPgXqN87i37rjN96/m6l/bV27docccQRmTZtWpJkdHQ0p5xyyi5jjj766GzduvX55fPPPz8LFy7MlVdemcHBwWzatClbt27dZb+NGzfmyCOPzLHHHpvt27fnrrvuyu///u/vcf4vf/nLWbZsWX7yk5/k0ksvzZ133plXvvKV+31d/byUe32Sk8Ysn5jkBx3P8/Ykq1prPxy7sqoWJXlHkotbay1JWmtPtdZ+1Pu8MsljSc7Y/YCttc+01oZba8PHH398x+kAAAAAHHzbtm3LokWLMmPGjMyZMyerV6/OVVddtcuY4447Lueee25mzZqVxYsXZ8aMGbn66quzYMGCzJkzJ/Pnz8+GDRt22WfDhg1585vfnDlz5uTMM8/M/Pnz8453vGOP83/0ox/Nm970pmzfvj1f+cpXDkhMSpLqdZwXHlA1KTtfmn1+ku8neTDJv2utPTLO2KuSbGutfWy39bckubO19qdj1r0tyX9J8n+01jaOWX98kk2ttR1V9dok9yaZ3Vrb9EJzHB4ebiMjI/u6VgAAAOBfkDVr1mT69OkTPY1Dwo4dO55/9G084/2uqmpla214vPH7fOSttfZsVb0/yZ1JBpJ8rrX2SFVd3tv+6ap6VZKRJMckea6qPphkRmvtx1X1C0nmJ7lst0P/tySTk3y997V29/e+0e28JH9UVc8m2ZHk8r3FJAAAAAD2bm8x6cXo5x1Kaa19NclXd1v36TGf/yE7H4Ubb9+fJDlunPW//ALj/yrJX/UzLwAAAABeev28QwkAAAAAnicoAQAAAIetfb07mhf3OxKUAAAAgMPSUUcdlR/96Eei0l601vKjH/0oRx11VKf9+nqHEgAAAMDPmxNPPDHr16/Pxo0b9z34X7CjjjoqJ5447quxX5CgBAAAAByWjjzyyJx22mkTPY3DkkfeAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOukrKFXV26pqbVU9WlVLxtn++qpaUVVPVdWHx6x/XVWNjvn5cVV9sLftl6rq61X13d6/vzhmvz/onWttVb31AFwnAAAAAAfIPoNSVQ0kuT7J25PMSHJRVc3YbdimJB9I8rGxK1tra1trQ621oSS/muQnSb7U27wkyd2ttWlJ7u4tp3fsC5PMTPK2JDf05gAAAADAIaCfO5TmJnm0tfZ4a+3pJLckWTh2QGvtydbag0me2ctxzk/yWGvt73vLC5Pc2Pt8Y5LfHLP+ltbaU621v0vyaG8OAAAAABwC+glKr0mybszy+t66ri5M8hdjll/ZWtuQJL1/Bw/w+QAAAAA4CPoJSjXOutblJFX1siS/keQvD9T5qup9VTVSVSMbN27sMh0AAAAA9kM/QWl9kpPGLJ+Y5Acdz/P2JKtaaz8cs+6HVfXqJOn9+2SX87XWPtNaG26tDR9//PEdpwMAAADAi9VPUHowybSqOq13p9GFSW7reJ6LsuvjbukdY1Hv86Ik/3PM+guranJVnZZkWpK/6Xg+AAAAAA6SSfsa0Fp7tqren+TOJANJPtdae6SqLu9t/3RVvSrJSJJjkjxXVR9MMqO19uOq+oUk85Ncttuhlyb5QlW9N8n3kvxW73iPVNUXkqxO8myS322t7TgA1woAAADAAVCtdXod0iFpeHi4jYyMTPQ0AAAAAA4bVbWytTY83rZ+HnkDAAAAgOcJSgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnfQVlKrqbVW1tqoeraol42x/fVWtqKqnqurDu207tqq+WFXfqao1VXV2b/2tVTXa+3miqkZ760+tqu1jtn36AFwnAAAAAAfIpH0NqKqBJNcnmZ9kfZIHq+q21trqMcM2JflAkt8c5xCfSnJHa+3fVtXLkvxCkrTWLhhzjo8n2TJmn8daa0PdLgUAAACAl0I/dyjNTfJoa+3x1trTSW5JsnDsgNbak621B5M8M3Z9VR2T5Lwkn+2Ne7q1tnm3MZXkt5P8xYu9CAAAAABeOv0EpdckWTdmeX1vXT9em2Rjkj+tqm9W1Z9U1St2G/NrSX7YWvvumHWn9cYvq6pf6/NcAAAAALwE+glKNc661ufxJyV5Y5I/bq39SpJ/SrL7O5guyq53J21IcnJv/IeS/HnvTqddJ1X1vqoaqaqRjRs39jkdAAAAAPZXP0FpfZKTxiyfmOQHfR5/fZL1rbUHestfzM7AlCSpqklJ3pXk1p+ta6091Vr7Ue/zyiSPJTlj9wO31j7TWhturQ0ff/zxfU4HAAAAgP3VT1B6MMm0qjqt91LtC5Pc1s/BW2v/kGRdVb2ut+r8JGNf5v2vk3yntbb+Zyuq6vjei8BTVa9NMi3J4/2cDwAAAICDb5/f8tZae7aq3p/kziQDST7XWnukqi7vbf90Vb0qyUiSY5I8V1UfTDKjtfbjJL+X5OZejHo8ye+MOfyF2fNl3Ocl+aOqejbJjiSXt9Y27c9FAgAAAHDgVGv9vg7p0DU8PNxGRkYmehoAAAAAh42qWtlaGx5vWz+PvAEAAADA8wQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhk0kRPgH82+8bZEz0FAAAA4AD41qJvTfQUDip3KAEAAADQiTuUDiGHe70EAAAADg/uUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADoRlAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6EZQAAAAA6ERQAgAAAKATQQkAAACATgQlAAAAADrpKyhV1duqam1VPVpVS8bZ/vqqWlFVT1XVh3fbdmxVfbGqvlNVa6rq7N76q6rq+1U12vv5N2P2+YPeudZW1Vv39yIBAAAAOHAm7WtAVQ0kuT7J/CTrkzxYVbe11laPGbYpyQeS/OY4h/hUkjtaa/+2ql6W5BfGbPtEa+1ju51vRpILk8xMckKSu6rqjNbajv4vCwAAAICDpZ87lOYmebS19nhr7ekktyRZOHZAa+3J1tqDSZ4Zu76qjklyXpLP9sY93VrbvI/zLUxyS2vtqdba3yV5tDcHAAAAAA4B/QSl1yRZN2Z5fW9dP16bZGOSP62qb1bVn1TVK8Zsf39VPVxVn6uqXzwA5wMAAADgIOsnKNU461qfx5+U5I1J/ri19itJ/inJz97B9MdJTk8ylGRDko93OV9Vva+qRqpqZOPGjX1OBwAAAID91U9QWp/kpDHLJyb5QZ/HX59kfWvtgd7yF7MzMKW19sPW2o7W2nNJ/nv++bG2vs7XWvtMa224tTZ8/PHH9zkdAAAAAPZXP0HpwSTTquq03ku1L0xyWz8Hb639Q5J1VfW63qrzk6xOkqp69Zih70zy7d7n25JcWFWTq+q0JNOS/E0/5wMAAADg4Nvnt7y11p6tqvcnuTPJQJLPtdYeqarLe9s/XVWvSjKS5Jgkz1XVB5PMaK39OMnvJbm5F6MeT/I7vUP/56oays7H2Z5IclnveI9U1ReyMzw9m+R3fcMbAAAAwKGjWuv3dUiHruHh4TYyMjLR0wAAAAA4bFTVytba8Hjb+nnkDQAAAACeJygBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQSV9BqareVlVrq+rRqloyzvbXV9WKqnqqqj6827Zjq+qLVfWdqlpTVWf31l/XW/dwVX2pqo7trT+1qrZX1Wjv59MH4DoBAAAAOED2GZSqaiDJ9UnenmRGkouqasZuwzYl+UCSj41ziE8luaO19vokb0iyprf+60lmtdbmJPnbJH8wZp/HWmtDvZ/Lu1wQAAAAAAdXP3cozU3yaGvt8dba00luSbJw7IDW2pOttQeTPDN2fVUdk+S8JJ/tjXu6tba59/mvW2vP9oben+TE/bkQAAAAAF4a/QSl1yRZN2Z5fW9dP16bZGOSP62qb1bVn1TVK8YZ954kXxuzfFpv/LKq+rU+zwUAAADAS6CfoFTjrGt9Hn9Skjcm+ePW2q8k+acku7yDqar+Y5Jnk9zcW7Uhycm98R9K8ue9O52y237vq6qRqhrZuHFjn9MBAAAAYH/1E5TWJzlpzPKJSX7Q5/HXJ1nfWnugt/zF7AxMSZKqWpTkHUkubq21JGmtPdVa+1Hv88okjyU5Y/cDt9Y+01obbq0NH3/88X1OBwAAAID91U9QejDJtKo6rapeluTCJLf1c/DW2j8kWVdVr+utOj/J6mTnN8cl+f0kv9Fa+8nP9qmq43svAk9VvTbJtCSP93k9AAAAABxkk/Y1oLX2bFW9P8mdSQaSfK619khVXd7b/umqelWSkSTHJHmuqj6YZEZr7cdJfi/Jzb0Y9XiS3+kd+r8lmZzk61WVJPf3vtHtvCR/VFXPJtmR5PLW2qYDdsUAAAAA7JfqPWn2c214eLiNjIxM9DQAAAAADhtVtbK1Njzetn4eeQMAAACA5wlKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACd9BWUquptVbW2qh6tqiXjbH99Va2oqqeq6sO7bTu2qr5YVd+pqjVVdXZv/S9V1der6ru9f39xzD5/0DvX2qp66/5eJAAAAAAHzj6DUlUNJLk+yduTzEhyUVXN2G3YpiQfSPKxcQ7xqSR3tNZen+QNSdb01i9JcndrbVqSu3vL6R37wiQzk7wtyQ29OQAAAABwCOjnDqW5SR5trT3eWns6yS1JFo4d0Fp7srX2YJJnxq6vqmOSnJfks71xT7fWNvc2L0xyY+/zjUl+c8z6W1prT7XW/i7Jo705AAAAAHAI6CcovSbJujHL63vr+vHaJBuT/GlVfbOq/qSqXtHb9srW2oYk6f07eADOBwAAAMBB1k9QqnHWtT6PPynJG5P8cWvtV5L8U3qPtu3v+arqfVU1UlUjGzdu7HM6AAAAAOyvfoLS+iQnjVk+MckP+jz++iTrW2sP9Ja/mJ2BKUl+WFWvTpLev092OV9r7TOtteHW2vDxxx/f53QAAAAA2F/9BKUHk0yrqtOq6mXZ+cLs2/o5eGvtH5Ksq6rX9Vadn2R17/NtSRb1Pi9K8j/HrL+wqiZX1WlJpiX5m37OBwAAAMDBN2lfA1prz1bV+5PcmWQgyedaa49U1eW97Z+uqlclGUlyTJLnquqDSWa01n6c5PeS3NyLUY8n+Z3eoZcm+UJVvTfJ95L8Vu94j1TVF7IzPD2b5HdbazsO2BUDAAAAsF+qtX5fh3ToGh4ebiMjIxM9DQAAAIDDRlWtbK0Nj7etn0feAAAAAOB5ghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCeCEgAAAACdCEoAAAAAdCIoAQAAANCJoAQAAABAJ4ISAAAAAJ0ISgAAAAB0IigBAAAA0ImgBAAAAEAnghIAAAAAnQhKAAAAAHQiKAEAAADQiaAEAAAAQCd9BaWqeltVra2qR6tqyTjbX19VK6rqqar68G7bnqiqb1XVaFWNjFl/a2/daG/MaG/9qVW1fcy2T+/nNQIAAABwAE3a14CqGkhyfZL5SdYnebCqbmutrR4zbFOSDyT5zRc4zJtba/84dkVr7YIx5/h4ki1jNj/WWhvq5wIAAAAAeGn1c4fS3CSPttYeb609neSWJAvHDmitPdlaezDJM10nUFWV5LeT/EXXfQEAAAB46fUTlF6TZN2Y5fW9df1qSf66qlZW1fvG2f5rSX7YWvvumHWnVdU3q2pZVf1ah3MBAAAAcJDt85G3JDXOutbhHOe21n5QVYNJvl5V32mt/a8x2y/KrncnbUhycmvtR1X1q0m+XFUzW2s/3mVSO+PUzwLVtqpa22FOh7KpSf5xn6MAfyvQP38v0B9/K9AffyvQv5/3v5dTXmhDP0FpfZKTxiyfmOQH/Z65tfaD3r9PVtWXsvMRuv+VJFU1Kcm7kvzqmPFPJXmq93llVT2W5IwkI7sd9zNJPtPvPH5eVNVIa214oucBhzp/K9A/fy/QH38r0B9/K9C/w/nvpZ9H3h5MMq2qTquqlyW5MMlt/Ry8ql5RVUf/7HOSBUm+PWbIv07yndba+jH7HN97EXiq6rVJpiV5vJ/zAQAAAHDw7fMOpdbas1X1/iR3JhlI8rnW2iNVdXlv+6er6lXZeQfRMUmeq6oPJpmRnbd2fWnne7czKcmft9buGHP4C7Pny7jPS/JHVfVskh1JLm+tbdqPawQAAADgAOrnkbe01r6a5Ku7rfv0mM//kJ2Pwu3ux0nesJfjXjLOur9K8lf9zOswddg9xgcHib8V6J+/F+iPvxXoj78V6N9h+/dSrXV5vzYAAAAA/9L18w4lAAAAAHieoHSIqKq3VdXaqnq0qpZM9HzgUFVVn6uqJ6vq2/seDf9yVdVJVXVPVa2pqkeq6j9M9JzgUFVVR1XV31TVQ72/l/9noucEh7KqGqiqb1bV7RM9FzhUVdUTVfWtqhqtqpF97/HzxyNvh4Det9r9bZL5SdZn5zfrXdRaWz2hE4NDUFWdl2Rbks+31mZN9HzgUFVVr07y6tbaqt43rq5M8pv+twX2VDu/QeYVrbVtVXVkkv+d5D+01u6f4KnBIamqPpRkOMkxrbV3TPR84FBUVU8kGW6t/eNEz+VgcYfSoWFukkdba4+31p5OckuShRM8Jzgktdb+VxLf/Aj70Frb0Fpb1fu8NcmaJK+Z2FnBoanttK23eGTvx391hXFU1YlJfj3Jn0z0XICJJSgdGl6TZN2Y5fXxf/QDcIBU1alJfiXJAxM8FThk9R7hGU3yZJKvt9b8vcD4Ppnk/0ry3ATPAw51LclfV9XKqnrfRE/mYBCUDg01zjr/VQyA/VZVU5L8VZIPttZ+PNHzgUNVa21Ha20oyYlJ5laVx6phN1X1jiRPttZWTvRc4OfAua21NyZ5e5Lf7b2647AiKB0a1ic5aczyiUl+MEFzAeAw0XsXzF8lubm19j8mej7w86C1tjnJ/5fkbRM7EzgknZvkN3rvhrklyVuq6qaJnRIcmlprP+j9+2SSL2Xnq24OK4LSoeHBJNOq6rSqelmSC5PcNsFzAuDnWO8lw59Nsqa19l8mej5wKKuq46vq2N7nlyf510m+M6GTgkNQa+0PWmsnttZOzc7/n+UbrbX/c4KnBYecqnpF70tRUlWvSLIgyWH3LdWC0iGgtfZskvcnuTM7X5r6hdbaIxM7Kzg0VdVfJFmR5HVVtb6q3jvRc4JD1LlJ/n12/tfj0d7Pv5noScEh6tVJ7qmqh7PzP/R9vbXm69ABeLFemeR/V9VDSf4myVdaa3dM8JwOuGrNq3oAAAAA6J87lAAAAADoRFACAAAAoBNBCQAAAIBOBCUAAAAAOhGUAAAAAOhEUAIAAACgE0EJAAAAgE4EJQAAAAA6+f8BdaCpIdS09HsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#System parameters\n",
    "numsites = 3\n",
    "t = 1.0\n",
    "U = 2.\n",
    "classical_time_step = 0.01\n",
    "classical_total_time = 500*0.01\n",
    "times = np.arange(0., classical_total_time, classical_time_step)\n",
    "states_list = fhc.get_states(numsites)\n",
    "#Create full Hamiltonian\n",
    "wfk_full = np.zeros(len(states_list))\n",
    "#wfk_full[18] = 1.    #010010\n",
    "wfk_full[21] = 1.    #010101\n",
    "#wfk_full[2] = 1.   #000010\n",
    "evolution2, engs2, wfks = fhc.sys_evolve(states_list, wfk_full, t, U, classical_total_time, classical_time_step)\n",
    "print(wfks[10])\n",
    "\n",
    "\n",
    "\n",
    "print(evolution2)\n",
    "#print(engs2)\n",
    "colors = list(mcolors.TABLEAU_COLORS.keys())\n",
    "fig2, ax2 = plt.subplots(figsize=(20,10))\n",
    "for i in range(3):\n",
    "    #Create string label\n",
    "    strup = \"Site \"+str(i+1)+r'$\\uparrow$'\n",
    "    strdwn = \"Site \"+str(i+1)+r'$\\downarrow$'\n",
    "    ax2.plot(times, evolution2[:,i], linestyle='-', color=str(colors[i]), linewidth=2, label=strup)\n",
    "    ax2.plot(times, evolution2[:,i+3], linestyle='--', color=str(colors[i]), linewidth=2, label=strdwn)\n",
    "    \n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def get_bin(x, n=0):\n",
    "    \"\"\"\n",
    "    Get the binary representation of x.\n",
    "    Parameters: x (int), n (int, number of digits)\"\"\"\n",
    "    binry = format(x, 'b').zfill(n)\n",
    "    sup = list( reversed( binry[0:int(len(binry)/2)] ) )\n",
    "    sdn = list( reversed( binry[int(len(binry)/2):len(binry)] ) )\n",
    "    return format(x, 'b').zfill(n)\n",
    "\n",
    "\n",
    "#==== Create all Possible States for given system size ===#\n",
    "states_list = []\n",
    "nsite = 3\n",
    "for state in range(0, 2**(2*nsite)):\n",
    "    state_bin = get_bin(state, 2*nsite)\n",
    "    state_list = [[],[]]\n",
    "    for mode in range(0,nsite):\n",
    "        state_list[0].append(int(state_bin[mode]))\n",
    "        state_list[1].append(int(state_bin[mode+nsite]))\n",
    "    #print(state_list)\n",
    "    states_list.append(state_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def repel(l,state):\n",
    "    if state[0][l]==1 and state[1][l]==1:\n",
    "        return state\n",
    "    else:\n",
    "        return []\n",
    "#Check if two states are different by a single hop\n",
    "def hop(psii, psij, hopping):\n",
    "    #Check spin down\n",
    "    hopp = 0\n",
    "    if psii[0]==psij[0]:\n",
    "        #Create array of indices with nonzero values\n",
    "        hops = []\n",
    "        for site in range(len(psii[0])):\n",
    "            if psii[1][site] != psij[1][site]:\n",
    "                hops.append(site)\n",
    "        if len(hops)==2 and np.sum(psii[1]) == np.sum(psij[1]):\n",
    "            if hops[1]-hops[0]==1:\n",
    "                hopp = -hopping\n",
    "                return hopp\n",
    "    #Check spin up\n",
    "    if psii[1]==psij[1]:\n",
    "        hops = []\n",
    "        for site in range(len(psii[1])):\n",
    "            if psii[0][site] != psij[0][site]:\n",
    "                hops.append(site)\n",
    "        if len(hops)==2 and np.sum(psii[0])==np.sum(psij[0]):\n",
    "            if hops[1]-hops[0]==1:\n",
    "                hopp = -hopping\n",
    "                return hopp\n",
    "    return hopp\n",
    "\n",
    "def get_hamiltonian(states, t, U):\n",
    "    H = np.zeros((len(states),len(states)) )\n",
    "    #Construct Hamiltonian matrix\n",
    "    for i in range(len(states)):\n",
    "        psi_i = states[i]\n",
    "        for j in range(i, len(states)):\n",
    "            psi_j = states[j]\n",
    "            if j==i:\n",
    "                for l in range(0,len(states[0][0])):\n",
    "                    if psi_i == repel(l,psi_j):\n",
    "                        H[i,j] = U\n",
    "                        break\n",
    "            else:\n",
    "                #print('psi_i: ',psi_i,'    psi_j: ',psi_j)\n",
    "                H[i,j] = hop(psi_i, psi_j, t)\n",
    "                H[j,i] = H[i,j]\n",
    "    return H\n",
    "\n",
    "\n",
    "def get_mapping(states):\n",
    "    num_sites = len(states[0][0])\n",
    "    mode_list = []\n",
    "    for i in range(0,2*num_sites):\n",
    "        index_list = []\n",
    "        for state_index in range(0,len(states)):\n",
    "            state = states[state_index]\n",
    "        #Check spin-up modes\n",
    "            if i < num_sites:\n",
    "                if state[0][i]==1:\n",
    "                    index_list.append(state_index)\n",
    "        #Check spin-down modes\n",
    "            else:\n",
    "                if state[1][i-num_sites]==1:\n",
    "                    index_list.append(state_index)\n",
    "        if index_list:\n",
    "            mode_list.append(index_list)\n",
    "    return mode_list\n",
    "\n",
    "def wfk_energy(wfk, hamil):\n",
    "    eng = np.dot(np.conj(wfk), np.dot(hamil, wfk))\n",
    "    return eng\n",
    "\n",
    "def get_variance(wfk, h):\n",
    "    h_squared = np.matmul(h, h)\n",
    "    eng_squared = np.vdot(wfk, np.dot(h_squared, wfk))\n",
    "    squared_eng = np.vdot(wfk, np.dot(h, wfk))\n",
    "    var = np.sqrt(eng_squared - squared_eng)\n",
    "    return var\n",
    "\n",
    "\n",
    "def sys_evolve(states, init_wfk, hopping, repulsion, total_time, dt):\n",
    "    hamiltonian = get_hamiltonian(states, hopping, repulsion)\n",
    "    t_operator = la.expm(-1j*hamiltonian*dt)\n",
    "    wavefunctions = []\n",
    "    mapping = get_mapping(states)\n",
    "    #print(mapping)\n",
    "\n",
    "    #Initalize system\n",
    "    tsteps = int(total_time/dt)\n",
    "    evolve = np.zeros([tsteps, len(init_wfk)])\n",
    "    mode_evolve = np.zeros([tsteps, len(mapping)])\n",
    "    wfk = init_wfk\n",
    "    wavefunctions.append(np.ndarray.tolist(wfk))\n",
    "    energies = np.zeros(tsteps)\n",
    "\n",
    "    #Store first time step in mode_evolve\n",
    "    evolve[0] = np.multiply(np.conj(wfk), wfk)\n",
    "    for i in range(0, len(mapping)):\n",
    "        wfk_sum = 0.\n",
    "        norm = 0.\n",
    "        for j in mapping[i]:\n",
    "            wfk_sum += evolve[0][j]\n",
    "            norm += evolve[0][j]\n",
    "        if norm == 0.:\n",
    "            norm = 1.\n",
    "        mode_evolve[0][i] = wfk_sum #/ norm\n",
    "        \n",
    "        #print('wfk_sum: ',wfk_sum,'    norm: ',norm)\n",
    "        energies[0] = wfk_energy(wfk, hamiltonian)\n",
    "        #print('Variance: ',get_variance(wfk, hamiltonian) )\n",
    "#Now do time evolution\n",
    "    print(mode_evolve[0])\n",
    "    times = np.arange(0., total_time, dt)\n",
    "    for t in range(1, tsteps):\n",
    "        wfk = np.dot(t_operator, wfk)\n",
    "        evolve[t] = np.multiply(np.conj(wfk), wfk)\n",
    "        wavefunctions.append(np.ndarray.tolist(wfk))\n",
    "        #print(evolve[t])\n",
    "        energies[t] = wfk_energy(wfk, hamiltonian )\n",
    "        for i in range(0, len(mapping)):\n",
    "            norm = 0.\n",
    "            wfk_sum = 0.\n",
    "            for j in mapping[i]:\n",
    "                wfk_sum += evolve[t][j]\n",
    "                norm += evolve[t][j]\n",
    "            #print('wfk_sum: ',wfk_sum,'    norm: ',norm)\n",
    "            if norm == 0.:\n",
    "                norm = 1.\n",
    "            mode_evolve[t][i] = wfk_sum #/ norm\n",
    "        #print(mode_evolve[t])\n",
    "\n",
    "    #Return time evolution\n",
    "    return mode_evolve, energies, wavefunctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 0. 1. 0. 1.]\n",
      "[0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, (-0.009834352221073475+0.0013193953970894769j), 0j, (0.00981781842836845+0.09801659541892298j), (-0.009900553773458826+0.0006593662648672712j), 0j, 0j, 0j, 0j, (0.009817818428368453+0.09801659541892298j), 0j, (0.9801988924530843+0.0013187325297345433j), (0.009817818428368466+0.09801659541892307j), 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, (-0.009900553773458822+0.0006593662648672711j), 0j, (0.009817818428368465+0.09801659541892303j), (-0.009834352221073477+0.0013193953970894775j), 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kaelyn/anaconda3/envs/qiskit/lib/python3.7/site-packages/ipykernel_launcher.py:117: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "/home/kaelyn/anaconda3/envs/qiskit/lib/python3.7/site-packages/ipykernel_launcher.py:120: ComplexWarning: Casting complex values to real discards the imaginary part\n"
     ]
    }
   ],
   "source": [
    "#System parameters\n",
    "t = 1.0\n",
    "U = 2.\n",
    "classical_time_step = 0.01\n",
    "classical_total_time = 500*0.01\n",
    "times = np.arange(0., classical_total_time, classical_time_step)\n",
    "\n",
    "#Create full Hamiltonian\n",
    "wfk_full = np.zeros(len(states_list))\n",
    "#wfk_full[18] = 1.    #010010\n",
    "wfk_full[21] = 1.    #010101\n",
    "#wfk_full[2] = 1.   #000010\n",
    "evolution2, engs2, wfks = sys_evolve(states_list, wfk_full, t, U, classical_total_time, classical_time_step)\n",
    "print(wfks[10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00\n",
      "  0.00000000e+00 1.00000000e+00]\n",
      " [9.99900006e-05 9.99800020e-01 9.99900006e-05 9.99900010e-01\n",
      "  1.99980001e-04 9.99900010e-01]\n",
      " [3.99840036e-04 9.99200320e-01 3.99840036e-04 9.99600160e-01\n",
      "  7.99680071e-04 9.99600160e-01]\n",
      " ...\n",
      " [4.41520875e-01 1.16958251e-01 4.41520875e-01 5.58479125e-01\n",
      "  8.83041749e-01 5.58479125e-01]\n",
      " [4.43909978e-01 1.12180044e-01 4.43909978e-01 5.56090022e-01\n",
      "  8.87819956e-01 5.56090022e-01]\n",
      " [4.46191365e-01 1.07617271e-01 4.46191365e-01 5.53808635e-01\n",
      "  8.92382729e-01 5.53808635e-01]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb53435eb50>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(evolution2)\n",
    "#print(engs2)\n",
    "colors = list(mcolors.TABLEAU_COLORS.keys())\n",
    "fig2, ax2 = plt.subplots(figsize=(20,10))\n",
    "for i in range(3):\n",
    "    #Create string label\n",
    "    strup = \"Site \"+str(i+1)+r'$\\uparrow$'\n",
    "    strdwn = \"Site \"+str(i+1)+r'$\\downarrow$'\n",
    "    ax2.plot(times, evolution2[:,i], linestyle='-', color=str(colors[i]), linewidth=2, label=strup)\n",
    "    ax2.plot(times, evolution2[:,i+3], linestyle='--', color=str(colors[i]), linewidth=2, label=strdwn)\n",
    "    \n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}