Fig4cd-ion-channel-optimal-partition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from tqdm import tqdm_notebook\n",
    "from matplotlib import pyplot as plt\n",
    "import msmtools\n",
    "import scipy.linalg\n",
    "import itertools\n",
    "from scipy.integrate import odeint\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "from local import Channel, cg_transition_matrix, kchannel_params, dndt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dimer system\n",
    "### system structure\n",
    "```\n",
    "          ____full system_____\n",
    "           /             \\       \n",
    "         channel 1  ~  channel 2  \n",
    "            |               |       \n",
    "(4 x gates - switch)  (4 x gates - switch)\n",
    "```\n",
    "- channels 1 and 2 are weakly coupled (cooperative coupling); if both switches are off, closed gate state is destabilized.\n",
    "\n",
    "- each gate is coupled to switch of its channel; switch switches off individual gates.\n",
    "\n",
    "- gates behave like Hodgkin-Huxley channel (details see previous notebook)\n",
    "\n",
    "### scores\n",
    "Two dependency scores are tested here: difference of transition matrix trace norms and transition matrix Frobenius norms.\n",
    "\n",
    "## System setup\n",
    "### basic channel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set-up Hodgkin-Huxley channel with same parameters as in previous example\n",
    "E_k = -75.\n",
    "g_k = 24 #mmho/cm^2\n",
    "\n",
    "V_clamp = 63\n",
    "\n",
    "dt = 0.1\n",
    "T = 15\n",
    "time = np.arange(0, T, dt)\n",
    "\n",
    "# initial condition\n",
    "n_0 = 0\n",
    "\n",
    "# Other parameters of the ODE\n",
    "params = (V_clamp,)\n",
    "\n",
    "ode_solution = odeint(dndt, n_0, time, params)\n",
    "\n",
    "msmlag = 0.0001 # in seconds\n",
    "\n",
    "alpha, beta, ss, tau = kchannel_params(V_clamp)\n",
    "c = Channel(alpha*1000, beta*1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "single sub-system transition matrix:\n",
      "[[0.9483 0.0517]\n",
      " [0.0055 0.9945]]\n"
     ]
    }
   ],
   "source": [
    "# transition matrix of HH-channel\n",
    "Tm_singlet = c.transition_matrix_singlet(msmlag)\n",
    "Tm_expandedstates = np.kron(np.kron(np.kron(Tm_singlet, Tm_singlet), Tm_singlet), Tm_singlet)\n",
    "\n",
    "with np.printoptions(precision=4, suppress=True):\n",
    "    print(\"single sub-system transition matrix:\")\n",
    "    print(Tm_singlet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### cooperative coupling\n",
    "Modified transition matrix of HH channels for cases of two inactive deactivation switches.\n",
    "This models a comparably weak cooperative coupling as the closed state is slightly destabilized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Tm_singlet_coop = np.array([[0.8, 0.2], \n",
    "                            [0.0055, 0.9945]])\n",
    "Tm_expandedstates_coop = np.kron(np.kron(np.kron(Tm_singlet_coop, Tm_singlet_coop), Tm_singlet_coop), Tm_singlet_coop)\n",
    "msmtools.analysis.is_reversible(Tm_expandedstates_coop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7ff2507480b8>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq4AAADECAYAAABeD6MTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3df3RU1bn/8fdDCL9R+VWtgARuFRUL4UcxgiBKq8Dli7VqC7UK/ljUtn7b+m3r9epdV1fX0qXLtl6tLilXMaBctdZqbS8oVmpBJSIoKggqYgIBBAQVgkAIeb5/ZMAQJsyemZOZzOTzWos1M+c8Z5/nAE/YnNlnb3N3RERERESau1bZTkBEREREJIQ6riIiIiKSE9RxFREREZGcoI6riIiIiOQEdVxFREREJCeo4yoiIiIiOaF1thMQERFpTsxsFjAR2OruZ8S2PQH0j4UcB3zm7sVxji0HdgEHgBp3H5aRpEVaCNM8riIiIl8ys9FAFTDnYMe1wf7fAp+7+6/j7CsHhrn7J02eqEgLlNE7rt27Fnif3olPuf1Am8jP/en+DkFxXQq/iLS9ZOytLgyK+2rHz4Pispljuzb7I20vGbbPEsbs/2wHB77YnTiwBevatZX37lWQMG6PR/9jZI+H/Qxob9WRtpeMPQfC/u52bb07rL0s5ti+IKxeQ9tLxr7axH9/9n78Ofs/35OxenX3RWZWFG+fmRnwXeC8KM/ZvXt3LyqKe0qRFmn58uWfuHuPhtvT+hfHzMYB9wAFwIPufsfR4vv0bs2rz/VM2O6cnYljkvXUx0OC4i4+4Y1I20vGmoqvBsXdfOb/BsVlM8dT+2yOtL1ktF3XNmFMxczfRX7eXJBMzfbuVcC8ed0TtvlOdZfoEoxZubd3UNwZ7TZE2l4yVu8O+7t7abelQXHZzPG0jmH1GtpeMtbuTPx37I0fPxr5edMwCtji7h80st+BBWbmwB/cfWZIo0VFRSxbtiyqHEVynplVxNue8sNZZlYA3A+MB04HppjZ6am2JyJNSzUrEokpwGNH2T/S3YdQV2c/iQ07iMvMppvZMjNbtm3btqjzFMlL6cwqMBxY6+7r3L0aeBy4MJq0RKQJqGZF0mBmrYHvAE80FuPum2KvW4Gnqau7xmJnuvswdx/Wo8cR34iKSBzpdFx7AvW/p6uMbROR5kk1K5KebwJr3L0y3k4z62hmnQ++B84HVmYwP5G8l84Y13gD5Y+YosDMpgPTAXr3TPygh4g0mYQ1W79ee/bUNM/SMpnZY8AYoLuZVQK3uPtDwGQaDBMwsxOpGy8+ATgeeLru+S1aA//j7s9FkdPyik8pW7edkn7dGNon8bjyZOMzeUzU9u/fT2VlJXv37s3K+SU97dq1o1evXhQWhj38mU7HtRKo/zRBL2BTw6DYwPSZAEMHtdXcWyLZk7Bm69froIGFqldpkdx9SiPbp8XZtgmYEHu/DhgUdT7LKz7lsgfLqK6ppU3rVsy9puSoncRk4zN5TFOorKykc+fOFBUVEftPg+QId2f79u1UVlbSt2/foGPSuaXyOnCymfU1szbU/U/02TTaE5GmpZoVyUFl67ZTXVNLrcP+mlrK1m2PND6TxzSFvXv30q1bN3Vac5CZ0a1bt6Tulqd8x9Xda8zsOuB56qbWmeXuq1JtT0SalmpWJDeV9OtGm9at2F9TS2HrVpT06xZpfCaPaSrqtOauZP/s0prH1d3nAfNC48urj+HKirEJ42b3WRjU3mmLrgw9NTcNnh8Ud/ub46Nt788XB8UBnD6iPCjuzhUXBMVlM8f3Xy2KtL2PHwlrD2DHqH0JY7yFjlpJpmYrqrvww48uSRg3q99TQec+/82rguIAfjfgyaC4/7fq0kjbu/rVqUFxAD8fEvZz6sZ3vxMUl80c/+uNsLn0Q9u7e+G4oDiAcSVvJYx5N3CBhHw1tE8X5l5TEjyWNNn4TB7TEtx666106tSJX/7yl43GbNu2jYkTJ1JdXc29997LqFGjkjpHaWkpy5Yt47777uOZZ57hlFNO4fTTj5zdMF4uB+cM7t69O506daKqqipuu81VRlfOEhERkeQN7dMlqY5hsvGZPEbgxRdf5NRTT2X27Nlpt/XMM88wceLEuB3XfKTHhkVERKRFWV7xKff/Yy3LKz6NpL3bbruN/v37881vfpP33nvv0PYPP/yQcePGMXToUEaNGsWaNWtYsWIFN9xwA/PmzaO4uJg9e/bwox/9iGHDhjFgwABuueWWQ8cXFRXxySefALBs2TLGjBlz2HlfffVVnn32WX71q19RXFzMhx9+GMn1NGe64yoiIiItRtSzISxfvpzHH3+cN998k5qaGoYMGcLQoUMBmD59OjNmzODkk0/mtdde48c//jELFy7k17/+9WFfyd9222107dqVAwcOMHbsWN5++20GDhyY8NwjRoxg0qRJTJw4kUsuiT+06+677+bRR79cNnnTpi8nk9mzZw/FxcWHPu/YsYNJkyal9PuQKeq4ioiISIsRbzaEdDquixcv5qKLLqJDhw4Ahzp+VVVVvPrqq1x66Zdj8ffti/8Mxh//+EdmzpxJTU0Nmzdv5t133w3quIa4/vrrjxjjelD79u1ZsWLFoc8Hx7g2Z+q4ioiISIvRFLMhxHsyvra2luOOO+6wjmE8H330Eb/5zW94/fXX6dKlC9OmTTs0PVTr1q2pra0F0AILMRrjKiIiIi3GwdkQ/t/5/SNZNGH06NE8/fTT7Nmzh127dvHXv/4VgGOOOYa+ffvy5JN1M4a4O2+9deQsGjt37qRjx44ce+yxbNmyhfnzv5wRqKioiOXLlwPw1FPxZ3Dp3Lkzu3btSusacok6riIiItKiDO3ThZ+c+7VIZkQYMmQI3/ve9yguLubiiy8+bGqruXPn8tBDDzFo0CAGDBjAX/7ylyOOHzRoEIMHD2bAgAFcddVVjBw58tC+W265hZ/97GeMGjWKgoKCuOefPHkyd911F4MHD9bDWSIiIiJydDfffDM333zzEdv79u3Lc889d8T2adOmMW3atEOfS0tL47Y7atQo3n///aMeP3LkSN599924x996661HbCsvLz/0vv4crvHyao50x1VEREREckKzvOMauiLW6tEPB7f5yK4TUk0nrtDVpm76TtiqQgB/+nhoqunElQs5hq6IdcLl5cFt7ig/MbVkJCWhK2ItGDwruM2V1Z1TTSeu0NWmHhoRPhn4O3t7p5pOXLmQY+iKWNefd+Qdpsas/uKrqaYjIi2Q7riKiIiISE5IueNqZr3N7B9mttrMVpnZz6JMTESipZoVEZFcl84d1xrgF+5+GlAC/MTMWsZCuSK5STUrEsDMZpnZVjNbWW/brWa20cxWxH5NaOTYcWb2npmtNbMbM5e1SMuQcsfV3Te7+xux97uA1UDPqBITkWipZkWClQLxBvTe7e7FsV/zGu40swLgfmA8cDowRf85FIlWJGNczawIGAy8FkV7ItK0VLMijXP3RcCOFA4dDqx193XuXg08DlwYaXIiKbj99tsP+zxixIhI2u3UqdNhn0tLS7nuuuuAuqm4fvOb3xy2v6ioiE8++SStc6bdcTWzTsBTwM/dfWec/dPNbJmZLdv7mZYrE8m2o9Vs/Xqt/mxPdhIUab6uM7O3Y0MJ4s1c3xPYUO9zJUf5VqN+vW3bti3qXKUFOXDgwFH3N+y4vvrqq02ZTpNKq+NqZoXU/QM4193/HC/G3We6+zB3H9buuHbpnE5E0pSoZuvXa5vj2mc+QZHm6wHgX4BiYDPw2zgxRy5YD95Yg/XrrUePHtFkKWE2LIXFv617jcCcOXMYOHAggwYN4vLLLwegoqKCsWPHMnDgQMaOHcv69euPun3atGlce+21jBo1ilNOOYW//e1vQF2n9Fe/+hXf+MY3GDhwIH/4wx8AeOmllzj33HP5/ve/z9e//nUAvv3tbzN06FAGDBjAzJkzAbjxxhvZs2cPxcXFXHbZZcCXd0q/973vMW/el6Nepk2bxlNPPdXoOZuDlOdxNTMDHgJWu/vvoktJRJqCalYkde6+5eB7M/tv4G9xwiqB+pPn9gI2NXFqkqwNS2H2JDhQDQVtYOqz0Ht4ys2tWrWK2267jVdeeYXu3buzY0fdKJPrrruOK664gqlTpzJr1ix++tOf8swzzzS6HepWtfrnP//Jhx9+yLnnnsvatWuZM2cOxx57LK+//jr79u1j5MiRnH/++QAsXbqUlStX0rdvXwBmzZpF165d2bNnD9/4xje4+OKLueOOO7jvvvtYsWLFEblPnjyZJ554ggkTJlBdXc2LL77IAw88wEMPPRT3nAfPc9DBDvFBO3bsYNKkSYc+33333Tz66KOHPm/alH45pHPHdSRwOXBeoqcsRaRZUM2KpMjM6q+UcBGwMk7Y68DJZtbXzNoAk4FnM5GfJKF8cV2n1Q/UvZYvTqu5hQsXcskll9C9e3cAunbtCsCSJUv4/ve/D8Dll1/Oyy+/fNTtAN/97ndp1aoVJ598Mv369WPNmjUsWLCAOXPmUFxczJlnnsn27dv54IMPABg+fPhhncl7772XQYMGUVJSwoYNGw7FNWb8+PEsXLiQffv2MX/+fEaPHk379u2Pes762rdvz4oVKw79+vWvf33Y/uuvv/6w/SeemP4CQSnfcXX3l4n/tYiINEOqWZEwZvYYMAbobmaVwC3AGDMrpu6r/3Lgh7HYE4EH3X2Cu9eY2XXA80ABMMvdV2XhEuRoikbV3Wk9eMe1aFRazbk7dV9oHV1jMfW3N4wxM9yd3//+91xwwQWH7XvppZfo2LHjYZ///ve/s2TJEjp06MCYMWPYu/fozxa1a9eOMWPG8Pzzz/PEE08wZcqUQ9cU75zNQUaXfK2qakfZklMTxpWctSaovakV5wWfe3afhUFx97zcMXEQsPvs3UFxt785PigO4KbB84Pi7nnykqC4bOY4+59hsyxtHFMYFLdzSVFQHMAZIz5KGPNZ2+rg9lqqPVVtWV3WN2HcoBFH/x/9QdeWhz9cXdo33rewR9q3pFtQXLezwx58uWFN2DLJAPee9nhQ3Iwl/xoUl80cj3017Mb7zlFhD+zd89a5QXEANwxekDBmfqvM1qu7T4mz+aFGYjcBE+p9ngccMVWWNCO9h9cNDyhfXNdpTWOYAMDYsWO56KKLuP766+nWrRs7duyga9eujBgxgscff5zLL7+cuXPncvbZZwM0uh3gySefZOrUqXz00UesW7eO/v37c8EFF/DAAw9w3nnnUVhYyPvvv0/Pnkf+G/v555/TpUsXOnTowJo1aygrKzu0r7CwkP3791NYeOS/uZMnT+bBBx9k2bJllJaWAjR6zvod5WzJaMdVREREJOt6D0+7w3rQgAEDuPnmmznnnHMoKChg8ODBlJaWcu+993LVVVdx11130aNHDx5++GGARrcD9O/fn3POOYctW7YwY8YM2rVrxzXXXEN5eTlDhgzB3enRo8ehMbH1jRs3jhkzZjBw4ED69+9PSUnJoX3Tp09n4MCBDBkyhLlz5x523Pnnn88VV1zBpEmTaNOmDUDwObNBHVcRERGRNEydOpWpU6cetq2oqIiFC4/8trex7QAjR47k7rvvPmxbq1atuP3224+Y0mrMmDGMGTPm0Oe2bdsyf378b0XvvPNO7rzzzkOfq6qqDr0vLCxk+/btQedsqH47UDcrwbRp04C6eVwbKi8vP2p7ISJZgEBEREREpKnpjquIiIhIlh0cXypHpzuuIiIiIpIT1HEVERGRnObe6AJl0swl+2enjquIiIjkrHbt2rF9+3Z1XnOQu7N9+3batWsXfIzGuIqIiEjO6tWrF5WVlWzbFjYXsjQv7dq1o1evXsHx6riKiIhIziosLDxs2VPJbxntuHbqtDdoVaylFX0iP/dpL/0kKG71TfcFxT2y64R00onrTx8PDYoLXRGLjzqkkU189/09bNWe6+55Kigu9JqTsfKjxKt27dnXJvLz5pv2nfZxWkniVcjWfRq2elUyBpX/KCjutR/fFRS3srpzOunE9fqefkFxbc/anjgI2L6jUzrpxPX9//1xUNysX/4hKO6dvb3TSSeuFVUnJYz5onZl5OcVkdykMa4iIiIikhPS7riaWYGZvWlmYYuLi0jWqF5FRCSXRXHH9WfA6gjaEZGmp3oVEZGclVbH1cx6Af8KPBhNOiLSVFSvIiKS69K94/pfwA1AbQS5iEjTUr2KBDCzWWa21cxW1tt2l5mtMbO3zexpMzuukWPLzewdM1thZssyl7VIy5Byx9XMJgJb3X15grjpZrbMzJbt/WxvqqcTkTSkUq/Vn+3JUHYizU4pMK7BtheAM9x9IPA+8O9HOf5cdy9292FNlJ9Ii5XOHdeRwCQzKwceB84zs0cbBrn7THcf5u7D2h0XvjKCiEQq6Xptc1z7TOco0iy4+yJgR4NtC9y9JvaxDAifMV1EIpNyx9Xd/93de7l7ETAZWOjuP4gsMxGJjOpVJFJXAfMb2efAAjNbbmbTM5iTSIuglbNEREQCmdnNQA0wt5GQke6+ycy+ArxgZmtid3DjtTUdmA5w0kmJF2IQkYg6ru7+EvBSoriqqnaULTk1YXshq2sBrJp7elAchK82NbXivKC42X0WBsWdtujKoDiAmwY39h/4w93z5CVBcaHX3LO0MCgOYOOYsNjb3xwfFBd6zbc/HbZiF8AZIxKv9vRZ2+rg9vJNaL3uqWrL6rLEyygOGvFB0HlXzzslKA6g29lha45fW35hUFxp37Bpa8976/KgOIB7T3s8KG7Gkn8Nigu95pq/dQ+KA9g5Kmyc8g1rwuor9Jp/UHZ1UBzADYMXJIyZ36p51KuZTQUmAmPd3ePFuPum2OtWM3saGA7E7bi6+0xgJsCwYcPiticih9PKWSIiIgmY2Tjg34BJ7v5FIzEdzazzwffA+YDWqxWJkDquIiIi9ZjZY8ASoL+ZVZrZ1cB9QGfqvv5fYWYzYrEnmtm82KHHAy+b2VvAUuB/3f25LFyCSN7SGFcREZF63H1KnM0PNRK7CZgQe78OGNSEqYm0eLrjKiIiIiI5QR1XEREREckJ6riKiIiISE5Qx1VEREREcoI6riIiIiKSE9RxFREREZGc0CynwwpdEWvAZe8Gt7m0ok+q6cQVuiLW6tEPB7f5yK4TUk0nrtAVsTZO2x/eaHn4KlshQlfEuumip4Lb/POWIammIykIXRHrtAnvB7e5fmeXVNOJK3RFrIWDHgluc2V1tLUQuiJW64mfhDf6eccUs4kvdEWsR0vizhwV19v7eqeajoi0QLrjKiIiIiI5Ia2Oq5kdZ2Z/MrM1ZrbazM6KKjERiZ5qVkREclm6QwXuAZ5z90vMrA3QIYKcRKTpqGZFRCRnpdxxNbNjgNHANAB3rwaqo0lLRKKmmhURkVyXzlCBfsA24GEze9PMHjSzaJ8EEJEoqWZFRCSnpdNxbQ0MAR5w98HAbuDGhkFmNt3MlpnZsgO7d6dxOhFJU8KarV+vtapXERFpZtLpuFYCle7+Wuzzn6j7R/Ew7j7T3Ye5+7CCjrq5I5JFCWu2fr22Ur2KiEgzk3LH1d0/BjaYWf/YprFA+MSqIpJRqlmRMGY2y8y2mtnKetu6mtkLZvZB7DXuZMNmNs7M3jOztWZ2xLeQIpKedOdx/b/AXDN7GygGbk8/JRFpQqpZkcRKgXENtt0IvOjuJwMvEn9oXAFwPzAeOB2YYmZhK+qISJC0psNy9xXAsIhyEZEmppoVSczdF5lZUYPNFwJjYu9nAy8B/9YgZjiw1t3XAZjZ47Hj9M2GSEQyuuRrYZVz4uLahHEbR4e1t6Ts1OBzjzwr7OfGK0vC/nMc2t6V68cExQHM6bMoKO6PCz4Oitt8QdgSsh1faRMUB7D77KqwNl/uFGl7t69oePOjcf9RPC9hzKrWXwS311K1qXJOfPlAwriN54R9cbPita8Fn3v4We8FxS1d0j9xUBLtTa8YHxQHMLvo70FxPf8Z9pBb5XmBY4qX9AiLA44/O+xnxacvh/2sCG3vF+9fGhQHcH//xxLGdGy1L7i9JnS8u28GcPfNZvaVODE9gQ31PlcCZ2YiOZGWQku+ioiIRMPibPNGg+vN4rFt27YmTEskf6jjKiIiktgWM/sqQOx1a5yYSqB3vc+9gE2NNVh/Fo8ePcLvpIu0ZOq4ioiIJPYsMDX2firwlzgxrwMnm1nf2JLKk2PHiUhE1HEVERGpx8weA5YA/c2s0syuBu4AvmVmHwDfin3GzE40s3kA7l4DXAc8D6wG/ujuq7JxDSL5KqMPZ4mIiDR37j6lkV1j48RuAibU+zwPSPyEqIikRHdcRURERCQnqOMqIiIiIjlBHVcRERERyQnquIqIiIhITsjow1ltT9jHSTe8nzDu44o+kZ+77B8DguIK+oatqBTaXjKGfRjW5msv3R8U98iusNVwkvGnj4cGxV1y3XORtpeMW8suTBizefeGhDEtXcEJ1Rz7y/UJ43Z9fmzk535tXVFQ3LGnfBppe8no/8aPg+KWPvG7oLiV1Z3TSSeud/b2ThwEfP3KsHoIbS8ZMz85J2HMtho96yQiddK642pm15vZKjNbaWaPmVm7qBITkeipZkVEJJel3HE1s57AT4Fh7n4GUEDdZMsi0gypZkVEJNelO8a1NdDezFoDHTjK0nYi0iyoZkUkq5ZXfMr9/1jL8oqwoT6pHJOJc2TyGPlSymNc3X2jmf0GWA/sARa4+4LIMhORSKlmRSTblld8ymUPllFdU0ub1q2Ye00JQ/t0ifSYTJwjk8fI4dIZKtAFuBDoC5wIdDSzH8SJm25my8xs2d7P9qaeqYikJaRm69dr9Wd7spGmiOSxsnXbqa6ppdZhf00tZeu2R35MJs6RyWPkcOkMFfgm8JG7b3P3/cCfgRENg9x9prsPc/dh7Y7TcyAiWZSwZuvXa5vj2mclSRHJXyX9utGmdSsKDApbt6KkX7fIj8nEOTJ5jBwunemw1gMlZtaBuq8dxwLLIslKRJqCalZEsmpony7MvaaEsnXbKenXLehr8mSPycQ5MnmMHC6dMa6vmdmfgDeAGuBNYGZUiYlItFSzItIcDO3TJekOW7LHZOIcmTxGvpTWAgTufgtwS0S5iEgTU82KiEguy+jKWVVV7ShbcmrCuJKz1gS1t2ru6cHn3n327qC4ji93jLS9nqWFQXEAG8eExU6tOC8obnafhUFxpy26MigO4KbB84Pibn9zfLTtPX1xUBzAGSM+ShjzWdvq4PZaqj1VbVld1jdh3KARHwS1t3reKcHn7nb2tqC43S/3iLS9mr91D4oD2Dkq7OG1a8sTr+QGUNr3b0Fx5711eVAcwL2nPR4U99PVYdP5hrb3g7Krg+IAbhiceGKL+a1UryJSJ915XEVERFoEM+tvZivq/dppZj9vEDPGzD6vF/Of2cpXJB9l9I6riIhIrnL394BiADMrADYCT8cJXezuEzOZm0hLoTuuIiIiyRsLfOjuFdlORKQlUcdVREQkeZOBxxrZd5aZvWVm881sQGMN1F/wY9u2sHHYIi2dOq4iIiJJMLM2wCTgyTi73wD6uPsg4PfAM421U3/Bjx49wh40FGnp1HEVERFJznjgDXff0nCHu+9096rY+3lAoZmFT1chIkeljquIiEhyptDIMAEzO8HMLPZ+OHX/zmpBepGIaFYBERGRQLElk78F/LDetmsB3H0GcAnwIzOroW5p5cnu7tnIVSQfqeMqIiISyN2/ALo12Daj3vv7gPsynZdIS9EsO66hK2INuOzd4DaXVvRJNZ24QlfE2jhtf3ij5eGrbIUIXRFr9eiHg9t8ZNcJqaYTV+iKWDdd9FRwm3/eMiTVdCQFoStinTbh/eA21++Mdh3v0BWxWk/8JLzRz8NW2QsVuiLWwkGPBLe5sjranymhK2I9WvJQcJtv7+udajoi0gJpjKuIiIiI5ISEHVczm2VmW81sZb1tXc3sBTP7IPYa7e0REUmZalZERPJVyB3XUmBcg203Ai+6+8nAi7HPItI8lKKaFRGRPJSw4+rui4AdDTZfCMyOvZ8NfDvivEQkRapZERHJV6mOcT3e3TcDxF6/El1KItIEVLMiIpLzmvzhrPprMR/YvbupTyciaahfr7WqVxERaWZS7bhuMbOvAsRetzYWWH8t5oKO0U4fIyLBgmq2fr22Ur2KiEgzk2rH9Vlgauz9VOAv0aQjIk1ENSsiIjkvZDqsx4AlQH8zqzSzq4E7gG+Z2QfULX13R9OmKSKhVLMiIpKvEq6c5e5TGtk1NuJcRCQCqlkRkfyyvOJTytZtp6RfN4b2STwNd7LxmTwmXRld8rWwyjlxcW3CuI2jw9pbUnZq8LlHnhW2POwn/xm2NOTmC8KWPu34SpugOIDdZ1cFxYVed+g1X7l+TFAcwJw+i4Li7nklbHxk6DXfvqLhtKSN+4/ieQljVrX+Iri9lqpNlXPiywcSxm08J2zE0YrXvhZ87uFnvRcU98k/OwTFVZ4XOF53SY+wOOD4sz8Oigu97tBrnl4xPigOYHbR34PiqgKvO/Saf/H+pUFxAPf3fyxhTMdW+4LbE8k3yys+5bIHy6iuqaVN61bMvabkqJ3EZOMzeUwUtOSriIiISDNVtm471TW11Drsr6mlbN32SOMzeUwU1HEVERERaaZK+nWjTetWFBgUtm5FSb9ukcZn8pgoZHSogIiISC4zs3JgF3AAqHH3YQ32G3APMAH4Apjm7m9kOk/JH0P7dGHuNSXBY0mTjc/kMVFQx1VERCQ557r7J43sGw+cHPt1JvBA7FUkZUP7dEmqY5hsfCaPSZeGCoiIiETnQmCO1ykDjju4+IeIpE8dVxERkXAOLDCz5WY2Pc7+nsCGep8rY9tEJAIaKiAiIhJupLtvMrOvAC+Y2Rp3rz9PoMU5xuM1FOv4Tgc46aSTos9UJA/pjquIiEggd98Ue90KPA0MbxBSCfSu97kXsKmRtma6+zB3H9ajR/gcwiItmTquIiIiAcyso5l1PvgeOB9Y2SDsWeAKq1MCfO7umzOcqkjeyuhQgf2djE2jEveVj/kw+v70hudPCYrrOXttUNzais7ppBPfR2Gr+5x1zsag2iwAAAr5SURBVOqguLLyvulkE9cpLw0Iilv97/cFxT2yK2wFsmT8acuwhDGf1nwY+XnzTXUnY9PZBQnj2m6P981oetY8GrY6XL87PwiK67Qz+qdet+w4Jiiu+MzAnymfha3al4zT/nl1UNyKa38XFLeyujCddOJaujfxz6ndtZ9Gft4UHQ88XTfjFa2B/3H358zsWgB3nwHMo24qrLXUTYd1ZZZyFclLCTuuZjYLmAhsdfczYtvuAv4PUA18CFzp7p81ZaIiEkY1K9I03H0dMCjO9hn13jvwk8hPvmEplC+GolHQu+HohAjiM3mMSBpCbm2WAg0Xin8BOMPdBwLvA/8ecV4ikrpSVLMi+WPDUpg9CRbeVve6YWm08Zk8Rlq85RWfcv8/1rK8IrVvUhJ2XGNPS+5osG2Bu9fEPpZRN/hcRJoB1axInilfDAeqwQ/UvZYvjjY+k8dIi7a84lMue7CM3y54j8seLEup8xrFYNKrgPkRtCMimaGaFcklRaOgoA1YQd1r0aho4zN5jLRoZeu2U11TS63D/ppaytZtT7qNtB7OMrObgRpg7lFiDs1TV9Als8uCicjhEtVs/XptfZzqVaRZ6D0cpj4bPpY02fhMHiMtWkm/brRp3Yr9NbUUtm5FSb9uSbeRcsfVzKZS9wDI2Nhg9LjcfSYwE6Bt796NxolI0wqp2cPqtZfqVaTZ6D08uY5hsvGZPEZarKF9ujD3mhLK1m2npF83hvZJ/gZJSh1XMxsH/Btwjrt/kUobIpI5qlkREWkOhvbpklKH9aCEY1zN7DFgCdDfzCrN7GrgPqAzdcvdrTCzGUdtREQyRjUrIiL5KuEdV3efEmfzQ02Qi4hEQDUrIiL5KqMrZxVWOScurk0Yt3F0WHv9H9gafO7NF4St0LS+LGzFnpFnvRsU987cM4LiAHafXRUUtyQHcrxy/ZiguDl9FgXFnbLoiqA4gP8onpcwZlVrfVueSJsq58SXDySM23hO2OQk/f68J/jcleeFrSK34rWvBcUNP+u9sPbmnxYUB3D82R+HtZkDOU6vGB8UN7vo70FxY965NCgO4P7+jyWM6dhqX3B7IpLfol9bVURERESkCajjKiIiIiI5QR1XEREREckJ6riKiIiISE5Qx1VEREREcoI6riIiIgHMrLeZ/cPMVpvZKjP7WZyYMWb2eWy+5BVm9p/ZyFUkX2V0OiwREZEcVgP8wt3fMLPOwHIze8HdG849uNjdJ2YhP5G8pzuuIiIiAdx9s7u/EXu/C1gN9MxuViItizquIiIiSTKzImAw8Fqc3WeZ2VtmNt/MBmQ0MZE81yyHCoSuiPXej74S3OYx61LNJr7Q1aa+ftnK4DbLKopSS6YRuZBj6IpY74+eE9zmnJ3dU01HUhC6Ita677QPbrPNZ6lmE1/oalPF41cHt1mxq0uq6cSVCzmGroj10tefDG5zVXWq2WSPmXUCngJ+7u47G+x+A+jj7lVmNgF4Bji5kXamA9MBTjrppCbMWCR/6I6riIhIIDMrpK7TOtfd/9xwv7vvdPeq2Pt5QKGZxf3ftLvPdPdh7j6sR48eTZp3s7JhKSz+bd1rUx2TiXNk8hg5JOEdVzObBUwEtrr7GQ32/RK4C+jh7p80TYoikgzVrEjTMDMDHgJWu/vvGok5Adji7m5mw6m7QbQ9g2k2bxuWwuxJcKAaCtrA1Geh9/Boj8nEOTJ5jBwm5I5rKTCu4UYz6w18C1gfcU4ikp5SVLMiTWEkcDlwXr3priaY2bVmdm0s5hJgpZm9BdwLTHZ3z1bCzU754rpOmx+oey1fHP0xmThHJo+RwyS84+rui2KD0Bu6G7gB+EvEOYlIGlSzIk3D3V8GLEHMfcB9mckoBxWNqrvTePCOY9Go6I/JxDkyeYwcJqWHs8xsErDR3d+q++ZERJoz1ayINAu9h9d9PV6+uK7TFvI1ebLHZOIcmTxGDpN0x9XMOgA3A+cHxh96arJt++OSPZ2IpCmZmlW9ikiT6z08+Q5bssdk4hyZPEYOSWVWgX8B+gJvmVk50At4IzYg/Qj1n5ps3bZj6pmKSKqCa7Z+vRa2Ub2KiEjzkvQdV3d/Bzg0gWrsH8JhekJZpHlSzYqI5LgNS5MbXpBsfCaPSVPIdFiPAWOA7mZWCdzi7g81dWIikhrVrIhIHsmn6cAiEDKrwJQE+4siy0ZE0qaaFRHJI/Gm0DpaBzHZ+EweE4GMLvna6rMvaP9M4pUiqr4dduE9F9UGn3vj6LC40DZD23tlyelhgcDoEauC4j58PGxpyGzmuOjVsOW5Q9u7cn34lCEPn5R4Xrz7CmqC22up7PMvaPfXxPX6xUVnBrX31VfCp7LcNDqsDk9cFNZmaHuvLe0fFAcwsuTdoLhWr4StiJTNHF8pC/sZENre1evPDYoDmNNnUcKYDqZFHqUFy6fpwCDt4QUZ7biKiIiISBLyaTqwCIYXqOMqIiIi0pzly3RgEQwv0PcvIiIiItL0Dg4vsIKUVw7THVcRERERaXoRrBymjquIiIiIZEaaK4dpqICIiIiI5AR1XEVEREQkJ6jjKiIiIiI5QR1XEREREckJ5h6+mk3aJzPbBlQ02Nwd+CRjSTQtXUvzFO9a+rh72JJGLZTqNafk+7Xkfb02Um/5LJ/+zqZC15/4+uPWfUY7rvGY2TJ3H5bVJCKia2me8ulasi2ffi91Lc1TPl2LNK6l/znr+lO/fg0VEBEREZGcoI6riIiIiOSE5tBxnZntBCKka2me8ulasi2ffi91Lc1TPl2LNK6l/znr+lOU9TGuIiIiIiIhmsMdVxERERGRhLLWcTWzcWb2npmtNbMbs5VHVMys3MzeMbMVZrYs2/kkw8xmmdlWM1tZb1tXM3vBzD6IvXbJZo6hGrmWW81sY+zPZoWZTchmjrkqn2pW9do8qF5bnlyuvVTkU72moilqPCsdVzMrAO4HxgOnA1PM7PRs5BKxc929OAenuCgFxjXYdiPworufDLwY+5wLSjnyWgDujv3ZFLv7vAznlPPytGZVr9lXiuq1JcrV2ktFKflTr6koJeIaz9Yd1+HAWndf5+7VwOPAhVnKpcVz90XAjgabLwRmx97PBr6d0aRS1Mi1SPpUs82E6lUkd+RTvaaiKWo8Wx3XnsCGep8rY9tymQMLzGy5mU3PdjIRON7dNwPEXr+S5XzSdZ2ZvR372iJvv5ZpQvlWs6rX5k31mr/yrfZSkW/1moqUazxbHVeLsy3XpzcY6e5DqPsq9SdmNjrbCckhDwD/AhQDm4HfZjednJRvNat6bb5Ur/lNtSdp1Xi2Oq6VQO96n3sBm7KUSyTcfVPsdSvwNHVfreayLWb2VYDY69Ys55Myd9/i7gfcvRb4b3L/zyYb8qpmVa/Nl+o1v+Vh7aUib+o1FenWeLY6rq8DJ5tZXzNrA0wGns1SLmkzs45m1vnge+B8YOXRj2r2ngWmxt5PBf6SxVzScvAHRMxF5P6fTTbkTc2qXps31Wv+ytPaS0Xe1Gsq0q3x1tGmE8bda8zsOuB5oACY5e6rspFLRI4HnjYzqPs9/R93fy67KYUzs8eAMUB3M6sEbgHuAP5oZlcD64FLs5dhuEauZYyZFVP31XY58MOsJZij8qxmVa/NhOq1xcnp2ktFPtVrKpqixrVyloiIiIjkBK2cJSIiIiI5QR1XEREREckJ6riKiIiISE5Qx1VEREREcoI6riIiIiKSE9RxFREREZGcoI6riIiIiOQEdVxFREREJCf8fx1bV6H7RM2QAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# compare regular HH to modified transition matrix (cooperative case)\n",
    "\n",
    "fig, ax = plt.subplots(1, 3, figsize=(12, 3))\n",
    "ax[0].imshow(Tm_expandedstates, norm=plt.matplotlib.colors.LogNorm())\n",
    "ax[1].imshow(Tm_expandedstates_coop, norm=plt.matplotlib.colors.LogNorm())\n",
    "ax[2].plot(msmtools.analysis.timescales(Tm_expandedstates), '.', label='default HH')\n",
    "ax[2].plot(msmtools.analysis.timescales(Tm_expandedstates_coop), '.', label='cooperative HH')\n",
    "ax[2].legend()\n",
    "# dynamics is faster in modified matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### deactivation switch\n",
    "Matrix of switched gates, assembled by Kronecker product as gates are independent. The deactivation switch strongly destabilizes the open gate state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7ff250638128>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD4CAYAAAAjDTByAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAOF0lEQVR4nO3df8yddXnH8c+HpyVK6QZYxUqbFQwhQTOlaQjqZGaMpXaEumR/lOhWfyTGRByYOa0hmf455+Z+Gg0TNrY1kKigjQFtwzRsyVotXQutRSmsQqFS/BFA3FYK1/44d5PTwznteb73j577ud6v5Mlzzrnv89zX+Z7zOfc557m/53JECEA+Z5zuAgCcHoQfSIrwA0kRfiApwg8ktajLjS07by5WrVw87+sdPHp2C9WM99zzr5z3dZYu+Z/OtlVq8S/KrveK8xfmbXuh8CFVOo4lzvj58/O+zv/qeR2N//M063Ya/lUrF+u731o57+u977G3t1DNePdtf8O8r3PlFfs621ap5f9e9i/di//k+0XXm/XbdvjtU+WjkW2VWnLXznlfZ8eLW6del5f9QFKEH0iqVvhtr7X9A9sHbG9qqigA7SsOv+05SZ+X9E5Jl0q6zvalTRUGoF119vyXSzoQEY9GxFFJd0ha30xZANpWJ/wXSHp86Pyh6rIT2P6g7Z22dz790xdrbA5Ak+qEf9z/Sl72f5CIuDki1kTEmle/aq7G5gA0qU74D0ka/qf9CklP1isHQFfqhP97ki62faHtMyVtkLSlmbIAtK34CL+IOGb7eknfkjQn6daIKDvUDUDnah3eGxF3S7q7oVoAdIgj/ICkOp3YU+rFmP8kjDkXTsDo8isNS7dVMCeldDiKlWyvbK5Np7et+GFVeNvaxJ4fSIrwA0kRfiApwg8kRfiBpAg/kBThB5Ii/EBShB9IivADSRF+ICnCDyTVi4k9JZN0SiYDda60xK4n6ZQouW09uF2lD6vOJ1ZNgT0/kBThB5Ii/EBSdTr2rLT9bdv7be+zfUOThQFoV50P/I5J+uOI2GV7qaT7bW+LiLKezgA6Vbznj4jDEbGrOv2cpP0a07EHwGxq5D2/7VWSLpO0Y8wy2nUBM6h2+G2fLemrkm6MiGdHl9OuC5hNtcJve7EGwd8cEXc2UxKALtT5tN+SbpG0PyI+11xJALpQZ8//Nkl/IOm3bO+uftY1VBeAltXp1fcfKj86HcBpxhF+QFK9mNXX6Qy9PrTrmvVtdb29HrTrKhIvtfrn2fMDSRF+ICnCDyRF+IGkCD+QFOEHkiL8QFKEH0iK8ANJEX4gKcIPJEX4gaR6MbGnpF1XsYKnwwXdGqwH24uSXdgMts96Gbe7b2bPDyRF+IGkCD+QVBNf3T1n+79sf6OJggB0o4k9/w0adOsB0CN1v7d/haTflfSlZsoB0JW6e/6/lvRxSe1+2RiAxtVp2nGNpCMRcf8p1qNXHzCD6jbtuNb2QUl3aNC8419HV6JXHzCb6rTo/mRErIiIVZI2SPq3iHhPY5UBaBX/5weSauTY/oj4jqTvNPG3AHSDPT+QVC9m9ZXMmiueCdiHNlMlM+b60K6rcCZgty20Cq9XdJ/RrgtACwg/kBThB5Ii/EBShB9IivADSRF+ICnCDyRF+IGkCD+QFOEHkiL8QFKEH0iqF7P6SmboLej+eb3oM1dwnYV6u6SZvG3s+YGkCD+QFOEHkqrbsecc21+x/ZDt/bbf0lRhANpV9wO/v5H0zYj4fdtnSjqrgZoAdKA4/LZ/RdKVkt4rSRFxVNLRZsoC0LY6L/svkvS0pH+sWnR/yfaS0ZVo1wXMpjrhXyRptaQvRMRlkp6XtGl0Jdp1AbOpTvgPSToUETuq81/R4MkAQA/U6dX3Y0mP276kuugqSd9vpCoArav7af9HJG2uPul/VNL76pcEoAu1wh8RuyWtaagWAB3qxcSeTifp9KH1UwFHxzNLFug4drutdjfG4b1AUoQfSIrwA0kRfiApwg8kRfiBpAg/kBThB5Ii/EBShB9IivADSRF+ICnCDyTVi1l9Je26ihU8HRbX1+FT70tzZTMjF3Tbs1nf1hkFX3s3j6/JZM8PJEX4gaQIP5BU3XZdH7W9z/Ze27fbfkVThQFoV3H4bV8g6Y8krYmIN0qak7ShqcIAtKvuy/5Fkl5pe5EGffqerF8SgC7U+d7+JyT9haTHJB2W9ExEbB1dj3ZdwGyq87L/XEnrJV0o6XWSlth+z+h6tOsCZlOdl/2/Lem/I+LpiHhB0p2S3tpMWQDaVif8j0m6wvZZtq1Bu679zZQFoG113vPv0KA55y5JD1Z/6+aG6gLQsrrtuj4l6VMN1QKgQxzhByTVi1l9JTPLimfa9aHvW8HMsi4nRkoqu22lM+YW6H2meKlwY9Nhzw8kRfiBpAg/kBThB5Ii/EBShB9IivADSRF+ICnCDyRF+IGkCD+QFOEHkurFxJ6SSToLus1U15N0ShRNZGm8iuYtoPuMPT+QFOEHkiL8QFKnDL/tW20fsb136LLzbG+z/XD1+9x2ywTQtGn2/P8kae3IZZsk3RsRF0u6tzoPoEdOGf6IuE/Sz0YuXi/ptur0bZLe1XBdAFpW+p7//Ig4LEnV79dMWpF2XcBsav0DP9p1AbOpNPxP2V4uSdXvI82VBKALpeHfImljdXqjpK83Uw6Arkzzr77bJf2npEtsH7L9AUl/Julq2w9Luro6D6BHTnlsf0RcN2HRVQ3XAqBDHOEHJNWLWX2dztDrQ+unWd9Wx9tzdNgbrNP7rN2NsecHkiL8QFKEH0iK8ANJEX4gKcIPJEX4gaQIP5AU4QeSIvxAUoQfSIrwA0n1YmJPSbuuYgVPhwu6NVgPthdnFGxsBttnvYzbvV3s+YGkCD+QFOEHkipt1/VZ2w/ZfsD2XbbPabdMAE0rbde1TdIbI+LXJf1Q0icbrgtAy4radUXE1og4Vp3dLmlFC7UBaFET7/nfL+meSQtp1wXMplrht32TpGOSNk9ah3ZdwGwqPsjH9kZJ10i6KqLlrxkF0Lii8NteK+kTkn4zIn7ZbEkAulDaruvvJS2VtM32bttfbLlOAA0rbdd1Swu1AOgQR/gBSfViVl/JrLnimYB9aKFVMmOuD+26SmcCznxrMCmKZujRrgtACwg/kBThB5Ii/EBShB9IivADSRF+ICnCDyRF+IGkCD+QFOEHkiL8QFKEH0iqF7P6SmboLej+eX340rQ+zDwsUDQ7T+WzAdvEnh9IivADSRW16xpa9jHbYXtZO+UBaEtpuy7ZXinpakmPNVwTgA4Uteuq/JWkj6sXH9MAGFX0nt/2tZKeiIg9U6xLuy5gBs07/LbPknSTpD+dZn3adQGzqWTP/3pJF0raY/ugBh16d9l+bZOFAWjXvA/yiYgHJb3m+PnqCWBNRPykwboAtKy0XReAnitt1zW8fFVj1QDoDEf4AUn1YmJPiS7bdfWiNVihhXzbulQ6IahN7PmBpAg/kBThB5Ii/EBShB9IivADSRF+ICnCDyRF+IGkCD+QFOEHkiL8QFKEH0jK0WEbIdtPS/rRhMXLJM3CtwFRx4mo40SzXsevRcSrp/kDnYb/ZGzvjIg11EEd1NFNHbzsB5Ii/EBSsxT+m093ARXqOBF1nGjB1DEz7/kBdGuW9vwAOkT4gaQ6Db/ttbZ/YPuA7U1jltv231bLH7C9uoUaVtr+tu39tvfZvmHMOu+w/Yzt3dXPVH0JC+s5aPvBajs7xyxvdUxsXzJ0O3fbftb2jSPrtDYetm+1fcT23qHLzrO9zfbD1e9zJ1z3pI+nBur4rO2HqnG/y/Y5E6570vuwgTo+bfuJofFfN+G68xuPiOjkR9KcpEckXSTpTEl7JF06ss46SfdIsqQrJO1ooY7lklZXp5dK+uGYOt4h6RsdjctBSctOsrz1MRm5j36swYEinYyHpCslrZa0d+iyP5e0qTq9SdJnSh5PDdTxO5IWVac/M66Oae7DBur4tKSPTXHfzWs8utzzXy7pQEQ8GhFHJd0haf3IOusl/XMMbJd0ju3lTRYREYcjYld1+jlJ+yVd0OQ2Gtb6mAy5StIjETHpKMzGRcR9kn42cvF6SbdVp2+T9K4xV53m8VSrjojYGhHHqrPbNWhK26oJ4zGNeY9Hl+G/QNLjQ+cP6eWhm2adxtheJekySTvGLH6L7T2277H9hrZq0KC9xVbb99v+4JjlXY7JBkm3T1jW1XhI0vkRcVgaPFlrqDHskE4fK5Ler8ErsHFOdR824frq7cetE94GzXs8ugz/uJYlo/9nnGadRtg+W9JXJd0YEc+OLN6lwUvfN0n6O0lfa6OGytsiYrWkd0r6sO0rR0sdc53Gx8T2mZKulfTlMYu7HI9pdflYuUnSMUmbJ6xyqvuwri9Ier2kN0s6LOkvx5U55rKTjkeX4T8kaeXQ+RWSnixYpzbbizUI/uaIuHN0eUQ8GxG/qE7fLWmx7WVN11H9/Ser30ck3aXBy7dhnYyJBg/cXRHx1JgaOxuPylPH39pUv4+MWaerx8pGSddIendUb65HTXEf1hIRT0XEixHxkqR/mPD35z0eXYb/e5Iutn1htZfZIGnLyDpbJP1h9Qn3FZKeOf7yrym2LekWSfsj4nMT1nlttZ5sX67BOP20yTqqv73E9tLjpzX4gGnvyGqtj0nlOk14yd/VeAzZImljdXqjpK+PWWeax1MtttdK+oSkayPilxPWmeY+rFvH8Gc8vzfh789/PJr4hHIen2Su0+DT9Uck3VRd9iFJH6pOW9Lnq+UPSlrTQg2/ocHLoQck7a5+1o3Ucb2kfRp8Yrpd0ltbGo+Lqm3sqbZ3usbkLA3C/KtDl3UyHho84RyW9IIGe68PSHqVpHslPVz9Pq9a93WS7j7Z46nhOg5o8D76+OPki6N1TLoPG67jX6r7/gENAr28ifHg8F4gKY7wA5Ii/EBShB9IivADSRF+ICnCDyRF+IGk/h+GQVomcfMoXgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "inactivetmat_singlet = np.array([[0.9483, 0.0517], \n",
    "                                 [.95, .05]])\n",
    "inactivetmat_expanededstates = np.kron(np.kron(np.kron(inactivetmat_singlet, inactivetmat_singlet), inactivetmat_singlet), inactivetmat_singlet)\n",
    "plt.imshow(inactivetmat_expanededstates, norm=plt.matplotlib.colors.LogNorm())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We assemble single channel transition matrix as a block matrix with probability switch_p to shift towards an inactive state. This matrix is only used for visualization purposes and to compare our estimates later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7ff25059e710>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "switch_p = .01\n",
    "#during switching, system stays in same microstate\n",
    "channel_tmat = np.block([[Tm_expandedstates * (1 - switch_p), switch_p * np.eye(16)],   # switch inactive -> inactive, switch inactive -> active\n",
    "                         [switch_p * np.eye(16), (1 - switch_p) * inactivetmat_expanededstates]])  # switch active -> inactive, switch active -> active\n",
    "\n",
    "print(msmtools.analysis.is_transition_matrix(channel_tmat))\n",
    "plt.imshow(channel_tmat, norm=plt.matplotlib.colors.LogNorm())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### assemble full system transition matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def assemble_tmat(_lambda):\n",
    "    \"\"\"\n",
    "    assembles full system as a block matrix.\n",
    "    note: the assembled full system transition matrix does not have the indices \n",
    "    of a Kronecker product but the same entries.\n",
    "    \n",
    "    :param _lambda: float in [0, 1], coupling parameter\n",
    "    \n",
    "    :return:\n",
    "    transition matrix of the full system\n",
    "    \"\"\"\n",
    "    \n",
    "    # compute linear mixture of transition matrices inactive and active (default)\n",
    "    linear_mixture_inactiveactive = _lambda * inactivetmat_expanededstates + (1 - _lambda) * Tm_expandedstates\n",
    "    assert msmtools.analysis.is_tmatrix(linear_mixture_inactiveactive)\n",
    "    \n",
    "    # define basic building blocks, each describing transition of deactivation switch (DG)\n",
    "    DG_switching = switch_p * np.eye(16)\n",
    "    DG_inact = Tm_expandedstates * (1 - switch_p)\n",
    "    DG_act = (1 - switch_p) * linear_mixture_inactiveactive\n",
    "\n",
    "    # describes cooperative state of two inactive deactivation switches\n",
    "    DG_inact_extboost = Tm_expandedstates_coop * (1 - switch_p)\n",
    "\n",
    "    # build transition matrices for dimer system for both deactivation switch transitions\n",
    "    D1G00_D2G11 = np.kron(DG_inact, DG_act)\n",
    "    D1G00_D2G10 = np.kron(DG_inact, DG_switching)\n",
    "    D1G00_D2G01 = np.kron(DG_inact, DG_switching)\n",
    "    D1G00_D2G00 = np.kron(DG_inact_extboost, DG_inact_extboost)\n",
    "    D1G11_D2G11 = np.kron(DG_act, DG_act)\n",
    "    D1G11_D2G10 = np.kron(DG_act, DG_switching)\n",
    "    D1G11_D2G01 = np.kron(DG_act, DG_switching)\n",
    "    D1G11_D2G00 = np.kron(DG_act, DG_inact)\n",
    "    D1G10_D2G11 = np.kron(DG_switching, DG_act)\n",
    "    D1G10_D2G10 = np.kron(DG_switching, DG_switching)\n",
    "    D1G10_D2G01 = np.kron(DG_switching, DG_switching)\n",
    "    D1G10_D2G00 = np.kron(DG_switching, DG_inact)\n",
    "    D1G01_D2G11 = np.kron(DG_switching, DG_act)\n",
    "    D1G01_D2G10 = np.kron(DG_switching, DG_switching)\n",
    "    D1G01_D2G01 = np.kron(DG_switching, DG_switching)\n",
    "    D1G01_D2G00 = np.kron(DG_switching, DG_inact)\n",
    "\n",
    "    # assemble into a single transition matrix\n",
    "    block = np.empty((1024, 1024))\n",
    "    for D1Gstart, D1Gend in np.vstack(np.unravel_index(np.arange(4), (2, 2))).T:\n",
    "        for D2Gstart, D2Gend in np.vstack(np.unravel_index(np.arange(4), (2, 2))).T:\n",
    "            #print(f'{D1Gstart} -> {D1Gend}, {D2Gstart} -> {D2Gend}', np.ravel_multi_index((D1Gstart, D1Gend), (2, 2)))\n",
    "            newstart = np.ravel_multi_index((D1Gstart, D2Gstart), (2, 2))\n",
    "            newend = np.ravel_multi_index((D1Gend, D2Gend), (2, 2))\n",
    "            block[256*newstart:256*(newstart+1), 256*newend:256*(newend+1)] = eval(f'D1G{D1Gstart}{D1Gend}_D2G{D2Gstart}{D2Gend}')\n",
    "            \n",
    "    assert msmtools.analysis.is_tmatrix(block)\n",
    "    return block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## data generation\n",
    "### choose parameters\n",
    "Chosen large enough to ensure converged sampling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tot_T = 1000000 # Steps\n",
    "dt = 20 # skip time steps to ensure convergence w/ limited computer memory\n",
    "\n",
    "n_independent_systems = 2 # dimer\n",
    "n_subsys_switches = 5  # number of gates + desensitization switch\n",
    "num_subsys = n_subsys_switches * n_independent_systems\n",
    "lambdas = np.linspace(0, 1, 21)  # coupling parameter space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# sub-system indices of channel 1 (s1) and channel 2 (s2)\n",
    "# note that due to assembly of subsystem transition matrices, \n",
    "# deactivation switch subsystems are indexed 0 and 1.\n",
    "s1, s2 = (0, 2, 3, 4, 5), (1, 6, 7, 8, 9)\n",
    "gates = (2, 3, 4, 5, 6, 7, 8, 9)\n",
    "\n",
    "def is_extra_channel_edge(n1, n2):\n",
    "    \"\"\"\n",
    "    distinguish if edge is within a channel or between two channels\n",
    "    :param n1: int, sub-system 1 index\n",
    "    :param n2: int, sub-system 2 index\n",
    "    :return: 0 if within channel, 1 if between two channels\n",
    "    \"\"\"\n",
    "    intra = (n1 in s1 and n2 in s1) or (n1 in s2 and n2 in s2)            \n",
    "    if intra:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### define dependency score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_dependency(tmat12, tmat1, tmat2, score='frobenius'):\n",
    "    \"\"\"\n",
    "    compute dependency score between two systems\n",
    "    :param tmat12: np.ndarray, transition matrix in joint space\n",
    "    :param tmat1: np.ndarray, transition matrix in subsystem 1\n",
    "    :param tmat2: np.ndarray, transition matrix in subsystem 2\n",
    "    :param score: str, optional, matrix norm. one of frobenius, tracenorm.\n",
    "    :return: float, dependency score\n",
    "    \"\"\"\n",
    "    if score == 'frobenius':\n",
    "        d = np.linalg.norm(tmat12, ord='fro')**2 - \\\n",
    "                    np.linalg.norm(tmat1, ord='fro')**2 * np.linalg.norm(tmat2, ord='fro')**2\n",
    "    elif score == 'tracenorm':\n",
    "        d = np.linalg.norm(tmat12, ord='nuc') - \\\n",
    "                    np.linalg.norm(tmat1, ord='nuc') * np.linalg.norm(tmat2, ord='nuc')\n",
    "    else:\n",
    "        raise NotImplementedError('score must be one of frobenius, tracenorm.')\n",
    "        \n",
    "    return abs(d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### generate trajectories & compute dependency for different couplings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "23ac0558d8f74a8cbd70d2e74e771ff2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=21), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "fronorms_dict, tracenorms_dict, cols = {}, {}, {}\n",
    "\n",
    "for _lambda in tqdm_notebook(lambdas):\n",
    "    fronorms_dict[_lambda] = []\n",
    "    tracenorms_dict[_lambda] = []\n",
    "    cols[_lambda] = []\n",
    "    \n",
    "    # assemble transition matrix\n",
    "    block = assemble_tmat(_lambda)\n",
    "    # choose time step T(n tau) = T(tau)^n\n",
    "    _T = np.linalg.matrix_power(block, dt)\n",
    "    \n",
    "    # sample Markov chain, draw starting states from stationary distribution\n",
    "    full_sys_traj = msmtools.generation.generate_traj(_T, tot_T, )\n",
    "    \n",
    "    # separate into sub-system trajectories\n",
    "    independent_trajs = list(np.unravel_index(full_sys_traj, tuple((2 for _ in range(num_subsys)))))\n",
    "    \n",
    "    # compute single system transition matrices\n",
    "    dmsm_tmat_dict = dict()\n",
    "    dmsm_cmat_dict = dict()\n",
    "    for n in range(num_subsys):\n",
    "        dmsm_cmat_dict[n] = msmtools.estimation.cmatrix(independent_trajs[n], 1, sparse_return=False)\n",
    "        dmsm_tmat_dict[n] = msmtools.estimation.tmatrix(dmsm_cmat_dict[n])\n",
    "        \n",
    "    # compute pairwise transition matrices and dependency scores\n",
    "    for n1, n2 in itertools.combinations(range(num_subsys), 2):\n",
    "        dmsm_cmat_dict[(n1, n2)] = msmtools.estimation.cmatrix(np.ravel_multi_index(np.vstack(np.array(independent_trajs)[[n1, n2]]), \n",
    "                                                             tuple((2 for _ in range(2)))), \n",
    "                                        1, sparse_return=False)\n",
    "        dmsm_tmat_dict[(n1, n2)] = msmtools.estimation.tmatrix(dmsm_cmat_dict[(n1, n2)])\n",
    "        \n",
    "        # trace norm difference\n",
    "        tracen = compute_dependency(dmsm_tmat_dict[(n1, n2)], \n",
    "                                    dmsm_tmat_dict[n1], \n",
    "                                    dmsm_tmat_dict[n2], \n",
    "                                    score='tracenorm')\n",
    "\n",
    "        # frobenius norm difference\n",
    "        fron = compute_dependency(dmsm_tmat_dict[(n1, n2)], \n",
    "                                  dmsm_tmat_dict[n1], \n",
    "                                  dmsm_tmat_dict[n2], \n",
    "                                  score='frobenius')\n",
    "        \n",
    "        fronorms_dict[_lambda].append(fron)\n",
    "        tracenorms_dict[_lambda].append(tracen)\n",
    "        \n",
    "        # case decision for plotting\n",
    "        cols[_lambda].append(is_extra_channel_edge(n1, n2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### plot score as function of coupling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# some plot properties\n",
    "_node_cols = ['#80aee7ff', '#e68082ff']\n",
    "node_cols = [_node_cols[0] if n in s1 else _node_cols[1] for n in range(num_subsys)]\n",
    "\n",
    "_c = (0., 0., 0.)\n",
    "nodesize = 35\n",
    "edge_cmap = plt.matplotlib.colors.LinearSegmentedColormap.from_list(\"uwe\", [(*_c, 0.025), (*_c, 1)])\n",
    "font = plt.matplotlib.font_manager.FontProperties(size=12)\n",
    "\n",
    "rgb_int = 200\n",
    "cmap_zero_noalpha = (rgb_int/256,rgb_int/256,rgb_int/256, 1)  # visual match between two figures (graph uses alpha)\n",
    "colormap = np.array([edge_cmap(256), cmap_zero_noalpha])\n",
    "colored_patches = [plt.matplotlib.patches.Patch(color=colormap[0], label='intra'),\n",
    "                  plt.matplotlib.patches.Patch(color=colormap[1], label='extra')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7ff24f5854a8>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAM4AAAFXCAYAAADqAXH7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO2dd3wVVdr4v096SEIAkWIITQExLNJEXLAs9oJldXVXfXUtrAXF3VddK8raUfzJCquubRVXLOsq6uqra0VAqQrSe28BAiFNktz7/P6Ye8eZm3tTbm5Lcr6fz3wyc55zzjwzmeeeM2fOeR5RVQwGQ8NIircCBkNTxBiOwRAGxnAMhjAwhmMwhIExHIMhDIzhGAxhYAzHYAgDYzgxQEQ2isgp8dbDEDmM4SQAIpISbx0aSlPUOZIYw4kyIvIa0BX4UERKReTPItJdRFRErhGRzcCXvrz/EpGdIlIsIt+ISIGjnkwReVJENvnks0Qk0ycbJiLfish+EVksIifVos9GEblNRH701fOWiGQ45KNFZK2IFInIByJymEOmIjJGRNYAaxxpN4rIGhEpEZEHReRwEflORA6IyNsikhbh2xp/VNVsUd6AjcApjuPugAJTgSwg05d+NZADpAOTgEWOMn8DvgbygGTgl758ecBe4CysH8JTfceH1qLLPOAwoB2wArjeJxsJ7AEG+eqeDHzjKKvAZ75ymY60D4DWQAFwEPgC6AnkAsuBK+P9P4j4/zTeCrSErRbD6VlLmTa+PLk+g6gAjg6S7w7gtYC0T0M9rD5dLnccPw4859t/CXjcIcsGqoDuvmMFRgbUp8Bwx/FC4A7H8ZPApHj/DyK9ma5afNni3xGRZBF5TETWicgBrAccoL1vywDWBamjG/AbXzdtv4jsB0YAnWs5707HfjmWgYDVCm3yC1S1FKv1ygums4Ndjv2KIMfZNDNa9AteDAk1Bd2ZfilwHnAKltHkAvsAweo+/QQcDiwOqGMLVoszOgJ6bscyRABEJAs4BNgWQucWi2lxYsMurD5/beRgvR/sBVoBj/gFquoFXgb+n4gc5mudjhORdOCfwCgROd2XniEiJ4lIlzD0nAZcJSIDfHU/AsxV1Y1h1NWsMYYTGx4F7vV1pW4LkWcqVjdpG9YL9ZwA+W3AEmA+UARMAJJUdQtWS3U3sBurBbqdMP63qvoFMA74N7ADq4X7bUPraQmI7wXOYDA0ANPiGAxhEFPDEZF2IvKeiJT5PuRdGiLf70XE4/tg6N9OiqWuBkNtxHpU7W9AJdARGAB8JCKLVXVZkLzfqeqImGpnMNSTmLU4vqHNC4FxqlqqqrOwvjj/T6x0MBgiRSy7ar0Bj6qudqQtxpqmEYyBIrJHRFaLyLiWPqnQkFjE8mHMBooD0oqxvl8E8g3QD2t4tgB4C6jGGtZ1ISJ/AP4AcOeddw6+6KKLIqhy02fNmjX06tUr3mokFP57MnjwYAm3jlgaTinWREAnrYGSwIyqut5xuEREHsD6NlHDcFT1eeB5gEmTJungwYMjpnBzwdyTmjT2nsSyq7YaSBER58/f0UCwgYFAFGvqicGQEMTMcFS1DHgXeEBEskRkONYX79cC84rImSLS0bd/JNbX7PdjpavBUBex/gB6I5AJFAJvADeo6jIR6er7VtPVl+9k4EcRKQM+xjK4R4LWaDDEgZiOVKlqEXB+kPTNOKaeq+ptWHOzDIaExEy5MRjCwBiOwRAGxnAMhjAwhmMwhIExHIMhDIzhGAxhYAzHYAgDYzgGQxgYwzEYwsAYjsEQBsZwDIYwMIZjaDGoKpdeeinnnHMOb731VqPqMoZjaJJUVVWxYcMGqqqqasj+9re/MXjwYD799FNX+uGHH84bb7zBzp07+e1vG+dn0RiOIWFZu3YtU6ZMYc4ct1PTFStWkJaWRs+ePUlLS2Pp0qW2bNiwYdx00018//33nHHGGTz99NO2bMOGDZFTLpahEbDiqrwHlGH5E7i0HmW+xFoBmlJX3qeeekoNbhYsWBBvFcJixYoV6vu/K6B/+9vfbFlqaqpLlpKSYsuc6f4tlEybUJgPp1+1y4BnnVHHAhGRyzARFZo1Y8aMISUlhby8PEpLS+30YcOG1cjnJ7B7Vl1dHbL+pKToPOIJ61dNRHKB+4E/x0pHQ3T46quvOPLIIzn77LM5ePCgnT5lyhSeeeYZPB4P27dvp23btrbswIEDIetz5gNo3fpnHzB/+tOfXLJvv/3W3l+zZg3JycmA9b7TKBrTXDVkAwYCFQFptwEfhsj/N+BP/By9zHTVwiDeXbVNmza5ukfZ2dm2LC0tLWS3qnfv3q705ORkW+bxeDQzM1MBzcjIUI/H4zrnsmXL9KmnntIdO3YE1clxT8J+nhPSr5qIDAGGA7cAtcZ5cfpVu/vuu1m4cGFElG0urFixIibn+emnn/j73/9Ox44dueSSSxCxnBJdffXVrnylpaX2/6h169bs2bPHJffLXnzxRU488UT/jygvvPCC6387c+ZMe/+HH36ooc/xxx/Ptm3b2LZtWw2Z/540ykVUY6yuIRtWi1MekHYrAS0OVvdxHnCi77g7psUJm0i3OB6Pp8YvvMfjcbUOqamptqxPnz4hW5XKykpX+tixY2ucb//+/er1eiN6DZFocRLRr1prYAjwlojsxAqkBLBVRI6PvpqGUDz88MMkJyeTnJzMlClT7PQHH3zQlc/58v7ee++5ZP53DIDU1FRUld27d1NVVcVf//rXGufMzc21W69EIhH9qhVjBXEd4NvO8qUPBubGSF1DAKrKvffeax/ffPPN9n6wj5B++vbty/vvv09ubi79+vWjvLy8Rp727duTktK0Bk8Tzq+arwnd6d+wwvMB7FLVyhjr2yLZtWsXmzZtcqWVlNTwVGzzl7/8xXXsbFUAzj33XPbv38+SJUtIS0uLnKJxJCH9qgXINmLc38aMY445hgULFgDQpk0b9u3bB1Brdyk5OZmioiKuvvpqDjvsMCZPnhwTXeNJ02ofDVHHbzQA+/fvZ8uWLeTn55OTEyyoxM+0bdu2xvtMc8bMVWuBvP/++4gIIsKpp55aa94ZM2bY+/v27ePEE0/k5JNPpqysLNpqJjSmxWmBnH/+z73lzz//nBkzZnDiiScGzeuMN9SmTRu+/vrraKvXJDAtjoG77rrL3n/nnXfs/fvuu4+MjIx4qJTwmBanmfLoo49y9913A9bLe20TIc8991x7/8ILL7S/1htCY1qcZorfaAA8Hg9nnnmmfdynTx9X3rFjx8ZMr+aCMZwmzs6dO5k9e3bQD4tOnLOEFy5cyB133MHll1/OkiVLaNWqVbTVbHaYrloT5u233+aSSy6xj4uLi11T7J1cf/319n5WVhaPPfZY1PVrzpgWpwnjNBrANbT8+eef2/v5+fnGUCKMMZxmxPfff2/vn3zyyagqc+fOZfPmzQk5UbIpYwynGdGhQ4caaYHzxlo6ixcv5p133ql17l19MIbTBDjiiCMQEY477jhX+tlnn+06njZtWizVijqqSlFRER6Pp95lPB4Pw4cPJzMzk6uuusolu+WWWxgwYACPPfZYyHfBBinXXLbmuJCtXbt2rsVeAwcOtGVVVVV6ww03aP/+/XXq1KlBy8d76XS4VFRU6JAhQzQpKUk7duyomzdvtmVFRUWalJSkgCYlJenevXtt2VFHHeW6X3/6059sGTUX1IW/MLMxhRNta46GE/jPxrGCsj4kuuFMmjRJ27Ztq8OHD9eqqio7/bHHHnNd87Bhw2xZ4I9J27ZtbVngvUpPTw8p00Y8a6ar1sRITU2NtwoN5qGHHiIlJYWOHTuyevVqO/3dd9/lj3/8I/v27WP27NkcdthhtixwFNDplNC/1MHP/v377f3AQRCnR5xIuoqKqeGISDsReU9EykRkk4hcGiLfb0VklYgUi0ihiLwqIo3slDZNAh1RbN++PU6aWHi9XqurEsCbb75JdnY2HTp0cHnMXLZsGePGjcPj8VBYWEj//v1tmXMVKcDu3bvt/doe8n79+rmO+/bta+8///zzLtlnn31m7ztnSDR6lLExzVVDN6xVn29hLVobgbVMuiBIvnygvW8/G3gdeLqu+ptqV62yslJzc3PtrkVJSYlL/tNPP+n69etdXZn6Esmu2r333mt3cyZMmGCnFxcXh+xOnnLKKSFlw4YNCyl75plnXOmnnXaaLauurtYuXboooHl5eTXuy4wZM/SJJ57QpUuX1riGqVOn6kUXXaTLly9XbQrvOEAWlhfP3o6014DH6iiXDUwFPq7rHE3VcAI9wbRr1y5idYdjOMuWLdMFCxa4vMt4vd6QD/nEiRNDysaMGRNSVlhY6Eq/5ZZbXOe7/PLLNSsrS4877rgaPyaNIRJebkSDNLvRQEQGAt+qaqYj7TYsN1CjguQfAXyE5fWmHLhAVf8bJJ/Tr9rgX//611G6gugxZMiQGmnOlZiNYcWKFa6uTF3ce++9fPLJJ4A1GfT1118HLL9pI0aMCKrjggULXFN6nDKv18uwYcPwer0AnHHGGTz00EN2vr179/Lpp5/Sp0+fxvk5awD+ezJ48ODw+2uNsbqGbMDxwM6AtNHA13WUywPG42ipQm1NtcXxD60S5Fe5sQRrcTZv3qz5+fmak5OjL7/8sksWqEdRUZGqWkPftemYk5Njp48cOdIl83q9unTpUi0sLIzYdTWGpuZXrRSr9XDSGqj1E66qbgM+Ad6Mkl5x55lnnnEdB/o/DgdV5corr+TSSy91LX8G64Pqli1bKCkp4eqrrw7q7dLPzp07gbpHpIqLi5kxYwZLly7liy++cMlEhIKCAg499NAwryYBaYzVNWTj53ecXo60qdTxjuPLNwIoritforc4mzdv1ttuu01nzJhRQzZ9+nQ9/fTTQ37IbCg9evRwtQ6+l2FVrdmqjB8/PqRs69attqxXr14qIpqUlKRHH310RPSMB5FocWJmOGoZwJtYI2tZWL6hQ42qXQZ0xXIL1Q2YAbxbV/2JbDiLFi1yPZAXXnhho+vctm2bPRp37LHHulzTBhrAKaecElL26KOP2rLk5GSXrLy83HW+6667Tm+88caE6XaFQ1M0nHbAdKzAUpvxBZbyGUkp0NV3/DCw1ZdvK/A8cEhd9Sey4aSnp0f8PebQQw911Tdu3DhbFniuk046yZYFvlM5h21ff/11TUlJ0aSkJL3//vsbrWMi0uQMJ9pbIhtO4C95Qwzn9ttv1549e+rEiRNd6YH1derUyZZlZGS4ZO+++64t+/LLLzUtLU2TkpJ09OjRNc5XXl6uBw4cCOMqmwbGcJqQ4Tz33HOuB7lr1651F1LViy66yFXuL3/5iy0LNJy+ffvasiVLltgxZM4999yIX09TxhhOEzIcVdWXX35Zu3TpoldeeWW9y4iIyzgyMzNtWeCX9zfffLNG+USf5BkPoj4cLSJPi8hoETnWF4rQUA9Ug39Uvuqqq9iyZQuvvPJKDVlFRQVLlixxxcEMhnNY+PPPP2fo0KG0bt2aW265pcZSakP0qOs7zm5gJPACUCgia0XkXRH5i4hcKCK9xazJtVFVUlNTSUpKQkR48cUX61Vux44dtGrViv79+5OTk8Py5ctt2ahR7kkVzomKWVlZzJ07l+LiYiZNmhSZizDUi1oNR1UfVNXfqWp/4GrAH+gpF3gSWIE1GmYAzjnnHJfjv9GjR9erXOBUk2OOOcbef+eddzj++ONp1aoVF1xwAQ8//HBklDU0ioa4h3oS6KuqJQAicjvwLLArGoo1RQK/0AcyduxYXn75ZQoKCvjuu+/sbteuXe5b6PSRlpqayjfffBN5ZQ2NoiFTbjxYLQ0AqloF/C9WCHYDbgflgUyYMIHJkydTVlbGvHnz6N69uy375S9/6crbo0ePaKloiBANMZzngDdEpLsjrSPQOZIKNWWeffZZV8QxZ0zLwC7Wli1b7P0ZM2ZwxBFHANC5c+eYRYo2hE9DDOcx4AtgiYjMFZEPsaJDNy/XKo0gMzOTp556ivbt23Psscdy7bXX2rJgrpv8JCUlsWbNGlSV7du3k56eHgt1DY2g3u84ao2xjheRKcDJQHvgr6r6ee0lWw4LFy5kzJgxAOzZs4c+ffrYLcusWbPo3PnnxtkZtdnQ9Giw72hV3YO1/LlF8+OPP9KxY0c6duxop910002uPFu3brX3O3XqxP79+/n222/p27ev6x3H0PQwTtcbiNfrdXnHHDhwoO161r/KMRS5ubmucBuGpotxD9VArr76atex0wvNs88+65Ll5+fHRCdD7DGG00AWL14cUjZo0CD++c9/0q1bN84880xWrlwZQ80MsSRR/apdKSILReSAiGwVkcdFJCG6lb///e9rlV922WVs3LiRjz/+2ARsasbEusX5G9by6Y5YqzyfFZGCIPlaAX/EGrk7FmsU77ZYKVkbgevpDS2TmBmOb3b1hcA4VS1V1VnAB8D/BOZV1WdVdaaqVqrlrON1rKXWceeJJ56ItwqGBCCW3Z/egEdVVzvSFgMn1qPsCcCyYIIAv2osXLiwsXrWyT333MOECRPIysriP//5T0zOGYyUlBRUtVZ3rl6vt9b3suaM1+sNOtLpn5nRKD9ujVnM05CN8P2qXYXld6B9XeeI9EK29evX644dOyJaZyQoLi7W1atXa1lZmcvbZjBKS0tjpFVi4fF4dPPmzbpr164asmbvV01Ezsea6nOmWh9eY0anTp3o2bMnnTt3ZuTIkbE8dZ0UFhaSl5dHq1atTIjCECQlJdGxY0eKi4ujU39Uag3OaiBFRHo50o4mdBfsDKwFdKNUdUkM9LNZt26da6r/V199FcvT10lVVRWZmZl1Z2zhpKamutZHRZKYGY6qlgHvAg+ISJaIDAfOw3K87kJERmINCFyoqvNipaOfutbVJAKmpambaN6jWA9H3whkAoVYjglvUNVlItJVREpFpKsv3zistT8f+9JLReT/YqXkgQMHYnWqZklBQQFff/11vNWIKjE1HFUtUtXzVTVLVbuq6jRf+mZVzVbVzb7jX6lqii/Nv8VskteFF5q1eY1h2bJlnHTSSXXm6969O59/3jQn15spN0HIz893zTMLdJiRiHTq1AkRqbFlZ2cHTW/o1qlTp5hfU7TeTyKBMZwQbNq0ifnz57N8+XI++OCDeKtTJ4F+C+JZv78lGT9+PBdffDFXXHEFOTk5FBQU2HFz/ud//ofNmzczatQosrOzefzxx9m4cSMiwksvvUTXrl3t0czf/OY3dOrUidzcXE444QSWLQs6nhRTWrTh7Nq1i0GDBjFgwIAasTVFhCFDhjQoKJOhJh988AG//e1v2b9/P+eee669Zum1116ja9eufPjhh5SWlvLnP//ZLjNjxgxWrFjBp59+CsCZZ57JmjVrKCwsZNCgQVx22WVxuRYnCTFxMl44ux95eXkhHQkawmfEiBGcddZZgNXK1Mf/2/jx48nK+tn/pXMpx/jx42nbti3FxcXk5uYGKx4TWnSLE0gi96mbKs4fp1atWvHTTz/VeZ+d75cej4c777yTww8/nNatW9srZ/fsien38BoYwzHEjVDfWZzp06ZN4/333+fzzz+nuLiYjRs3AqHdDMeKFm04Tj/MIkJKSovuucacjh07sn79+lrzlJSUkJ6eziGHHEJ5eTl33313jLSrnRZtOM5+dEZGRhw1aZncddddPPTQQ7Rp04aJEycGzXPFFVfQrVs38vLyOOqooxg2bFiMtQxBY2aIJtrW0NnRBMSXqaqqalD5eOGM5+mnY8eONa4nklvHjh3jcKWNJ9i9isTsaNM3cVBZWdlku2v+6NCBlJWVuVpWQ2Ro0V21QEx3zVBfWrThXHzxxfb+ueee6xosMBhqo0U/KW+99ZbdZ33//ffjrY6hCdGiDcdgCJdE9avWT0Q+FZE9vuCxBkNCkah+1aqAt4FrYqibwVBvEtWv2ipVfYkQ/ggawrJly2jVqhWpqan1DmZrMNRFLFucUH7VgrU4EaNfv35UVFRQXV3N6NGj6wyHbjDUh1h+7csGAn31FAM5jam0oQ4J77vvvoRYz9EYUlJSKCsrq1fen376KcraRIZ//vOfvPrqq3z22WcRrbeysrLGMxEJh4SxNJwG+1WrD6r6PPA8wKRJk7Sum3HTTTfRs2fPxpwy7qxYsaLGbICFCxdSVVUVtXOmpqY2zvNlHaSnp5OUlFTrLAePx+OKTVQf0tLSOProo2ukN/ZaEtavWqR46KGH7P3hw4c3eaMJRTSNpqH1b9++nQsvvJBDDz2UHj168PTTTwNw1llnceutt9r5LrnkEq6++mpWrFjB9ddfz3fffUd2djZt2rQBrMgQN9xwA2eddRZZWVl89dVXfPTRRwwcOJDWrVuTn5/P+PHjI3qd9SVmLY6qlomI36/atcAALL9qvwzMK9aCjHQgzXecYVWhBxt63nvuuYd77rmnUbob6o/X62XUqFGcd955vPHGG2zdupVTTjmFPn368PLLL9O/f3/OPvtsduzYwfz581m8eDE5OTk899xzvPjii8yaNctV37Rp0/j444/5z3/+Q2VlJXPmzGHq1KkUFBSwdOlSTj31VAYMGMD5558f0+tMVL9q3YAKfm6NKoBV4ZxwzZo19qjayy+/3Ej1DXUxf/58du/ezX333UdaWho9e/Zk9OjRvPnmm3Tq1InnnnuOK6+8kltuuYWpU6eSk1P7K+55553H8OHDSUpKIiMjg5NOOolf/OIXJCUl0b9/f373u9/FxYFkovpV26iqErB1D+ecvXv3tkfVrrnmGkpKGvVKZaiDTZs2sX37dtq0aWNvjzzyiO0l55xzzsHj8dCnTx9GjBhRZ32B4SDnzp3Lr371Kw499FByc3N57rnn4rKMusVNuXnkkUfirUKzJj8/nx49erB//357Kykp4eOPPwasrnPfvn3ZsWMHb7zxhl2uPsuoAS699FLOPfdctmzZQnFxMddff31cllG3OMMJNsJiiBxDhw6ldevWTJgwgYqKCjweD0uXLmX+/Pl88803/OMf/2Dq1KlMnTqVm2++mW3btgHWMuqtW7dSWVlZa/0lJSW0a9eOjIwM5s2bx7Rp02JxWTVo9obTtm1b1/Ell1wSJ01aBsnJyXz44YcsWrSIHj160L59e6699lp27NjBFVdcwZQpU8jLy2PEiBFcc801XHXVVagqI0eOpKCggE6dOtG+ffuQ9T/zzDPcd9995OTk8MADD7iWhsQSiUczFy0mTZqkf/zjH11pqsorr7zCzp07+d///V/S09PjpF3kWLFiRQ1HiU39O060CHWvfNcSdjiDprlOuAGICFdddVW81Yg6oR5qs3Q6OjT7rprBEA2M4RgMYWAMx2AIA2M4BkMYGMNponi93nirkPBEc8TYGE4TJCsri23btlFZWRl35+OJiqqyd+/eqPnKa/bD0c2RLl26sGfPHjZt2lRnyIzKykrS0tJipFlikZGRQZcuXaJSd7M3HFVl06ZNVFZW0qNHD1JTU+OtUqNJSkqiQ4cOdOjQoc68CxcuNNOMokCzMpxg3Za5c+fa+0VFRQwdOtT22Llv3z5WrbJWK/Tu3Zt27dq56iopKSE5Odl8QDTUICH9qvny/klEdopIsYi8LCJ1zpUpKyurc23Gli1b7H2/0QCsXr3alW/u3LksX76cJUuWMGfOHJdszZo1zJkzhzlz5nDwoHttXVlZGT/++KMdAMmJqtoTH4NR2wt/OO8yqhqyzrpkoc7n9XrDKhdpVJXq6uoGn89frrHEusVx+lUbAHwkIotV1bV8WkROB+4ERgLbgfeAv/jSQrJlyxYuvfRSvvzyS/r06RM0T3l5ecjy/riStUVY3rNnD3v37rWPf/jhBztmS0lJiR0Ruby8nJ07d9qyyspKvv/+e7vcYYcdRteu1rq90tJSli5dast69uxpd8MOHDjA8uXLbdnAgQPt+XaFhYWuwEzHHnusPQ1/xYoVFBcXs3LlSjweT1CZH2fMmUWLFrkcfDhlgT8goWTZ2dn069cvqCw/P5+8vLygsqOPPprMzEzAesCdvYUBAwbYL/rO+wxQUFBgL4gLvM/O6163bh27d+9m5cqVqGqjYu0kpF814ErgJVVdpqr7gAeB39fnPNu3b+exxx4LKfevZw9Gq1atANi/f3/IPGvXrg0pqy2MuPOfCbiiXDuNBnAZg9NowDLUYPnA3S11GkZdMqfegV5x/D80tU339y8N8ON0wbV48WKXzNniBxqiM69TX7AMOpi+gceB99lZz+7du4NfQBgkql+1Ap/Mma+jiBxSnxM5u2CB1Na0+7tQ8YxmHA9qWxXr73I6W9lAtm7dGlJWUVERtl4JTWOiUjVkA44HdgakjQa+DpJ3HXCG4zgVKzJY9yB5/wAsABaMHTt2aayux2wte0tUv2qBef37NfKqw6+awRArEtWv2jKfzJlvl6qG7i8YDDEkpitAReRNrC6X36/ax8Avteao2hnAK1ijajuAfwPzVLXWUTWDIVYkpF81Vf0EeBz4Ctjk2+6Psa4GQ0ialc8BgyFWmNnRBkMYGMMxGMLAGI7BEAbGcAyGMDCGYzCEgTEcgyEMjOEYDGFgDMdgCANjOA1ERPqIyA8iUiIiY8Mo/3sRmVV3zrB0+z8RuTIadRvcNCufAzHiz1hLIQbGW5FAVPXMeOvQUjAtTsPpRi2RskWkYfHEWxDN6d4Yw2kAIvIl8Ctgim9Sam8ReUVEnhWRj0WkDPiViOSKyFQR2e1zSnKviCS5q5LJPkckK0XkZIcgV0ReEpEdIrJNRB7yP3D+bp6ITBSRfSKyQUTOdJT92hfRGxEZLyL/dMi6i4iKSIqjrvW+LucGEbksxDWPF5G3fddTIiLLRGSIQ97Xd979Ptm5Dlmwe/OKiDzj61aWishsEekkIpN817RSRBKuNQ/EGE4DUNWRwEzgJrWC/fqXgV8KPAzkALOAyUAu0BM4EbgCcAbpORZYD7THmvX9roj4fVO9ClQDRwADgdOwlmE4y67ylX0ceElCBdAMgc//w9PAmaqaA/wSWFRLkXOBN4E2WH4ipvjqSQU+BP4LdABuBl4XEaenlMB7A3AxcK/vGg4C3wHf+47fAW+BYawAACAASURBVP5fQ64nHhjDiQzvq+psVfUCVcAlwF2qWqKqG4EncTslKQQmqWqVqr6FZQhni0hH4Ezgj6papqqFwFPAbx1lN6nqC6rqwTKyzlhegxqKF+gnIpmquiNwTVQAs1T1Y985X+PnRYbDgGzgMVWtVNUvgf8Av3OUte+Nqvo9gbynqgt9x+8BP6nqVF/9b2H9YCQ0xnAiwxbHfnsgDWsNkZ9NQJ7jeJu613NsAg7Den9KBXb4uj77gb9j/Zr72enfUVW/r6vshiirqmVYxn2971wficiRtRTZ6dgvBzJ8Xb7DgC2+HwzntTiv1Xlv/Dj9b1UEOW7Q9cQDYziRwWkEe7BanW6OtK6A04dSXkD3qiuW/7gtWF2X9qraxre1VtVgnoDqogxo5Tju5FJY9VNVPRWrxVoJvBDGObYD+QHvb4HX2iwXfBnDiTC+7sbbwMMikiMi3YD/Bf7pyNYBGCsiqSLyG6Av8LGq7sB6X3hSRFqLSJKIHC4iJ4ahyiLgBN/q2lzgLr9ARDqKyLm+d52DWM5RgrsXrZ25WAb6Z9+1nASMwnofatYYw4kON2M9UOuxXoinAS875HOBXlit08PARQ5HJFdgdfWWA/uwXpY7N1QBVf0M633hR2Ah1ruHnyTgVqwWowhrAOPGMM5RiTVwcKbvWp4BrlDVlQ2tq6lhlk4bDGFgWhyDIQwSMlqB7+Ocx/eBzL+dFEtdDYbaSMhoBT6+U9URMdXOYKgniRqtwGBIaBI1WgHAQBHZIyKrRWScf46VwZAIxPJhzAaKA9KKseYwBfIN0A/rK3QB1rBqNfBoYEYR+QNWxALuvPPOwRdddFEEVW76rFmzhl69etWdsQXhvyeDBw9u0Bw/JwkZrUBVnRGTlojIA8DtBDEcZ7SCSZMm6eDBgyOmcHPB3JOaNPaeJGq0gkAUCPvXwWAAKyzkBRdcwKhRo5g8eXKj6oqZ4fgmFr4LPCAiWSIyHDgPa7atCxE50zdTGN/kw3HA+7HS1ZAYlJaWMnPmzBoxWVWVu+66ix49enDHHXfg/IivqrzwwgtcfvnlfPzxx65y1113HdOnT2fHjh3ccsstjVMullGsgHbAdKzpKJuBS33pXbG6cl19xxOxZsz6p608AKTWVf9TTz2lBjcLFiyItwq1smPHDp04caJ++eWXrvTCwkLNzMxUQJOSkvSbb76xZXfffbdi9UIU0Ntvv92WTZ482SWbM2eOLUtNTXXJtDHPcmMKJ9pmDKcm4RjOwoULddasWerxeFzpxcXFOnHiRH3qqae0rKysXnV5PB4966yzbAOYOXOmLdu5c6frQb7++utt2ejRo+30Vq1a6ZFHHmnLMjIyXOXS0tJsWVpamktWUFBgy5zpjTUcM8RrcHH//fczceJEkpKSOPPMM3n77bdt2SmnnMKPP/6IiPDBBx/w5Zdfuso9+OCDJCcn88UXX3DCCScAMHXqVNLS0jjppJMAGDduHPffb4U6+sc//mGnA6xcuZKvv/4asCJZ+2UZGRnk5uZSVVVFamoqXq9z+Y87IHJgdOx169Y16n6EpDFWl2ibaXFqEqrF2bp1qy5ZskS9Xq8rPSsry/5FFhG7ZfF4PK5f66SkJLtMYWFhsF9zLSsr09GjR+vJJ59cQ6aq2q1bt6DlVFU7derkSr/gggt08eLF6vV6a9R34okn2uVyc3NdspEjR9qyQYMGmRbHED5vvPEGl19+OWC1Ip988gn+dXXO8OqqSlJS8PEj56/+G2+8UUOuqqxevZqBAweyZMkSV8vib1Wuu+46/vvf/9rpqamptuzmm2/ms88+s2UZGRl4PB42b97M008/Tf/+/fF4PCQlJblGyFatWkV+fj5VVVW0b9+eTz75xHXes846i6VLl3LrrbfWdZtqpzFWl2ibaXHcrFy5UqdMmaLl5eWu9KSkJNcv7/Lly20ZAS1AYWGhqlqtR6DMzxdffFFDtn37dl2wYIF+/fXXrvScnBy7XFVVlfbt21cBTU5O1nnz5tmyoqIi7dKli2ZkZGhWVpb++OOP+tNPP+ns2bN13759unXrVp0+fbpu2bIl6LUHtqROHK1w2M9a3B/2SG7GcH7mxRdftB/W3NxcraiosGWBD/mDDz4YUrZw4UJVVa2srAxpONXV1ZqSkmKn9+3bV2fNmqUlJSVaXl6uHTp00KSkJE1JSdH77rvPpafX69WtW7e69PNTVlam8+bN0z179thpe/fu1dmzZ+vBgwfDvjeRMByzHqcJo6rceuutDB06lH/9618u2bXX/uxRqri4mCeffDJkPcnJof0EHn205dAmNTWVvLyffXAcccQRrvI7d+7k5ptv5oEHHuCtt96ic+fOZGdnk5mZybJly5gyZQrvvvsu48ePd9UvIuTl5ZGRkVHj3K1ateKYY47hkEMOsdPatWtH586dWb58ufXLHy8aY3WJtrW0Fue0005ztQCfffaZLSOgdRg0aJAtS09Pd8k2btxoy5YtW6Z5eXl6yCGH6Keffuo6X3V1tf7973/Xl19+OWRXaPfu3Tpnzhytrq6O8NX+jNfr1R9++EHXr18fVnnTVWshhvPoo4/q0KFD9aWXXnKlBxpHfn5+SNlNN91kyxYtWqTt27fXjIwMffTRRyOmZ1VVlX777bdaVFQUsTpDcfDgQZ09e7bu3bu3wWWN4bQAwxk7dqzLAJ555hlbFmgcHTp0sGXXX3+9a+g4Fg/z6tWrdcWKFVE/j599+/bp7Nmzg74f1YZ5x2kmqCrjxo2jV69e3HTTTXg8P3tqeu6551x5ne8IRx11lEvmfI959tlnmT59OqNHj2bHjh20bds2Osr7KC4uZvfu3Rx++OFRPY+TNm3akJeXx/Lly2t8FI06jbG6RNuaaovz6quvulqOhx9+2JaJiEuWmZlpyyorK/XUU0/VQw45xDUy5iQWc9U8Ho/OmzdPd+3aFfVzBeL1enXx4sW6du3aepcxLU4z4bbbbnMdP/jgg/Z+585ul2r+US6wRrr++9//smfPHu69997oKlkLW7ZsIT09nUMPPTTm5xYR+vbtS2FhIXv27InZeY3hJADFxe6FsQcPHrT3586daw8XZ2Zm8vnnn8dUt7ooLy9n69at9O7d2559EGtSU1MpKChg1apVrpkP0cQYTgyZNm0aBQUFjB07FtWfv0Ecc8wxrnw9evSw97t06UJVVRVlZWWUl5eTlZUVM33rQlVZtWoV3bp1C/odJpa0bt2abt26xex9JyH9qgWU+dIZEKmp8u9//5vLLruM5cuXM3nyZNfcrVdeecWeEyYivPmm2/WyiNCqVSsSjR07duD1el0fRuNJXl4e6enp0ZsR7SDWLY7Tr9plwLMiEtITvy9KWJM2GD9jxoxxHX/zzTf2/hFHHMHGjRt56623WLNmTY0WKBE5ePAgGzZsoE+fPnHrogUiIhx55JEUFRVRWFgY1XPF7KF0+FXrp6qlwCwR8ftVuzNI/lysaGVXYEXsatKEmmXsJz8/n/z8/Bhp03jWrl1rT6tJJFJSUjjqqKP48ccfyc7OjlpLnch+1R4BnsUd1KjJEjhHa9CgQfFRJALs3buX0tJSunXrFm9VgpKTk0OPHj1YtmxZ1N53EtKvmi8463DgFqBLbZU6/ardfffdLFy4MCLKRppBgwZxyimn8NVXX9GlSxcef/zxmOi6YsWKiNdZWlrKhRdeSPfu3SNed7isXLmSsrIywGrdjzzySDIzM1m7di1ffPGFK6//njTKRVRjPgI1ZMOK61gekHYr8GFAWhIwDzjRd9wd6+NfSl3niPcHUI/Hozk5OfbHytdffz2u+qhG7wPo4MGDo1JvuMyaNUuzsrI0PT1df/3rX9uTUIPp2dQ+gNbXr1prYAjwlojsBOb70reKyPHRVzN8rrvuOkpKfvaveNllQSOgG6LA8OHDKSwsZMOGDbzzzjtRH7CIWVdNVctExO9X7VqsaAXnYYUKd1KMFZTVTz5WCzQY2B0LXcMl0T5OtjRatWoVs2H7WA9H3whkYoUrfwO4QVWX+eJUlopIV18TutO/8bOx7FIrdF7Ccued7sHBukbSDE2XmP5nVbVIVc9X1SxV7aqq03zpm1U1W1U3BymzUVVFVatjqWs4XHfddZx//vmA9eu3fv36OkoYmirN4uNiIvHee+/FW4Umx8qVK5kyZQpdu3blj3/8I2lpafFWqU6M4YRBVVUV77//Pl27dmXo0KHxVqdJU1JSwnHHHUdxcTEZGRmsX7++xhqkRMQYTgPxeDykp6fbkzSHDBnC/Pnz6yhlCMWmTZuorq5GVamoqGDmzJnxVqlemLfXBnLvvfe6ZjYvWLAgjto0fXr37k2nTp3IysoiKyuLq666Kuy6Fi1axIcffmh/CI0mpsVpILH4p7Qk0tLSmD17NhMnTqRXr16MHj06rHqmTp3KDTfcQHJyMocddhiLFy8mPT09wtr+jDGcBjJmzBiXy9XU1NQ4atP0qa6u5rTTTmPt2rV4vV5UlT/84Q8NrmfKlCmUl5cDsH37dn788ceozjI3XbUGcsQRRzB06FAyMjJIT0/nr3/9a7xVatKsXLmSpUuXUlZWRkVFBY888khY9QwZMsRuYbxeb9Tn0ZkWp4EkJyczc+ZMZsyYQYcOHVw+AAwNp6KiwuXV58CBA2HVc8IJJ/DCCy+QkpJCXl4ebdq0iZSKQTEtThikpaVx6qmnGqOJAPn5+a7vNkOGDAmrnkcffZTq6mqqq6tZv349ixcvjpSKQTGGYwiboqIiRowYQevWrbn55ptdo431pU2bNuTk5CAiJCUlhf1j5FwuXV1dze7d0Z3WaAzHEDZ33HEHs2fPpqSkhGeffdYVz6a+rF27loMHD6KqeL3eGgFv60vggrWioqKw6qkvxnAMYfPVV1/Z+x6PJ6yPl927d7cnwyYnJ9shEBtK+/btXce9e/cOq576YgwnBKtXr2bIkCGMHDky6r9eTZXArlk4a2AqKyupqqqyj/ft2xeWLoMGDbLPn5GREXXniGZULQher5c+ffrYx4cddhg//fRTHDVKTAJHrjp06NDgOrZv324HvPV4PMyZMycsXZ599ln27dvHhg0buP/++81wdDz44YcfXMdOz5qGnwn0cBPuIjJnyxWuc43OnTszY8aMsMqGQ0I6JBSR34rIKhEpFpFCEXlVRFrHSk/n8mdDaJyGkpSUFNYsig4dOtjD0cnJyU1miD9RHRLOBoarai7QE6tlfChWSv7yl4GruQ3BOPvss23jycjICGuKS4cOHXjllVfIz89n6NChvPTSS5FWMyrEzHAcDgnHqWqpqs4C/A4JXajqFlV1up73AEcE5osWaWlpTJ8+nZycHNq3b8/KlStjdeomxZgxY5g4cSJXXnklH330EUceeWSD66isrGT8+PHs27ePxYsXBw39nohIOB+twjqRyEDgW1XNdKTdhuUGalSQ/COAj7C83pQDF6jqf4Pkc/pVG/zrX/86SlfQNFmxYgV9+/aNeL3XXXddRJZULF26lOOOO47S0lIACgoKWLp0aaPr9XPUUUfx2muvudL892Tw4MFhu8JJSIeEAL4WKVdE8oDRwMYQ+Z4HngeYNGmSNsrJXDMlke9Jfn4+SUlJiAjp6ekMGzYsovW3atUq6PU39p7E8h2nFKv1cNIaqPVNXFW3AZ8Ab9aWzxB7PB4PDzzwAGeddRbvv/9+WHXk5uYye/ZsrrrqKu68806mTJkSYS2jQyxbHNshoaqu8aUFc0gYjBQgdsElDfXiySefZMKECZSXlzNjxgy+++47+vfv3+B6+vXr12QGBfzErMVR1TLA75AwS0SGYzkkfC0wr4hc5vO1JiLSDXgY+CIwnyG+LF682F48lpSUxOrVq+so0XxIOIeEvnxHAd9ide9mA6uw3nMMCcT1119Pq1ataN26NTk5OZx88slh1VNeXs706dOZO3duhDWMHjGdOaCqRcD5QdI3Yw0e+I/vAe6JoWqGMDj++ONZtmwZq1atYtiwYeTm5ja4jqqqKoYOHcqmTZvwer088cQT3HjjjVHQNrKYSZ6GRtG9e3dOP/30sIwGYNWqVWzatInS0lLKy8t55plnwqpn165djBw5kp49e/LKK6+EVUdDMIZjiCv+4WiwZh+E6+DxhhtuYObMmWzYsIEbbriBjRs3RlDLmtTaVRORp4ElwI/AUt8LvsEQMXJzc/nmm2+YOHEi3bp14557wuuh79q1i+pqy714cnIy+/fvj6SaNajrHWc3MBK4GThcRHZgGdESx981GqvpB4ZmydFHH13j635DmTBhAmeccQYej4dTTjklrGHxhlCr4ajqg/59EbkEy4DmY03SfBIrds1PQFYUdYwqpaWlqCo5OUEnMBiaCCNGjGDXrl3s27ePvLy8hAos9STQV1VLAETkdqzgtruioVgsmDx5MmPHjgXgiSee4LbbbouzRk2HjRs3hu2RJpZE612nIYbjAXLxTZFR1SoR+V+saGlNcujYbzQAt99+O7feemvUf6maC3v27Kk7UzOmIaNqzwFviEh3R1pHoHMkFYonTsd4BkNtNKTFeQxIB5aIyHKsr/8jgGnRUCwemDEOQ32pt+H4Rs7Gi8gU4GSgPfBXVW02EWNTUowLBkP9aPAHUFXdo6pvqerfmrrR/PWvf0VEEBGeeOIJ835jqDct+id27Nix3HTTTYCJEG1oGC3acMAYjCE8zFNjMIRBovpVu1JEForIARHZKiKPi0iLbx0NiUOi+lVrBfwRa+TuWKxRPPNZ35AwJKpftWdVdaaqVvqcdbwODI+VrvFg06ZNPP300y1q+XFTJpbdn96AR1WdT8Zi4MR6lD2BEE49AvyqsXDhwsbqGTWuvfZaFi1aRHZ2Nl988QXJyckAzJ07lzFjxtj57rrrLi688EL7ePr06XzzzTeMGjWKX/3qVw0654oVKyKjfDPCf08a5SJKVWOyAccDOwPSRgNf11HuKmAr0L6uczz11FMabw4ePKgTJ07UBQsWuNJHjRqlgL0lJSXZsoyMDJdMRGzZZZdd5pJNnjzZlpWVlWmrVq0U0MGDBwfVJ1APg+uehP88N6Zwg04EA4HygLRbgQ9rKXM+1uzrX9TnHPE2nOLiYtdDXlBQYMtExCWzfrMsAtPrK0tKSnKlX3zxxbZs7ty5dvoRRxxRQ9dVq1bpl19+qV6vN9K3IeGJhOHEcnDA9qvmSAvpV01EzgBeAEap6pIY6NdoevXq5TpetuznS+vUqVPIcoFrgeo7gyEwJMY777xj7x977LH2/tq1a7njjjvs40GDBtGnTx9GjhxJUlKSa46eqjJjxgw++ugjM+m1NhpjdQ3dsLxxvoG18G04lgvcgiD5RgJ7gRMaUn+sWpypU6dqSkqKHnLIIbpnzx47vW3btiFbh8rKSlerM2/ePFu2ZMkSV5lPPvnElgV28R566CFbFniujh07hpRlZ2eHlN177722rEePHnZ6ZmZm5G5aAtGkumpqGUQ7YDpQBmwGLvWld8XyodbVd/wVUO1L82//V1f9sTCcdevWhTSOTZs2hXyQ/ZSWlgbtHlVUVOisWbO0pKSkhuypp57S4447Tl977TVX+quvvuo6X0VFhS0L1PGcc84JKRs5cmRI2bp162zZxIkT7fQXXnihnncs8WhyhhPtLRaG069fv5CGo6q6fft2Pe+88/S5556Lui6qqlVVVbp79+4axvjggw/a+iUnJ2tVVZUtC9T/gw8+CCl7/fXXQ8qcjB8/3h7Y+OGHH6J0tZHBGE4cDGfs2LG1PkCJxO7du/XNN9/U6upqV/qECRNs3Xv27OmSBV6bv+zOnTtDXveOHTtqvSeZmZl2+iOPPOKSeb1e3bp1q6u1jDbGcOJgOF6v1zWadfrpp0f9nI0h1HB0VVWVlpeX10hfsmSJpqSkqIjotGnTXPlDGcfFF18cUnbNNdfU+t7nTA80qiFDhiig7du3D6pruBjDibLhfPLJJzpnzpwa6V6vV1etWqWFhYURPV80iOR3nP79+9sP+fHHH2+nf/XVVyGNo2PHjiFlPXv2DCk755xzQg5ueDweHTJkiCYnJ+ugQYNqtKh1YQwniobj/Kfl5ORErN5YE+kPoJWVla73JT9OA7nyyivt9M8//zykcaSmpoaU1fbd65hjjnGlDxw40JbNnz/fJTt48GANXY3hRMlwPvvssybzHlMXsZw54PF4go4YPvLIIyoimpOTo2VlZXb6uHHjXPfYOWMicDaF838QmF6bzDmkPmvWLDs9JSVFtRHPmlmPE4QNGzbEW4UmiT8kYSB33XUXXq+XAwcOuEK8P/DAA5x33nkAZGdnU1RUZMvmzJnjquP++++39xuyxL2iosLeHzFihL3vd5cbLsZwgnDNNdfEW4UWw/Tp01FVSkpKaNOmjZ1+9NFHs2HDBh599FHmzp3L+PHjbVlgRIOnn37a3m/d2h0tc9SoGnGZI0NjmqtE24J11WbOnKkZGRmanJysEyZMqCEPRVFRkQ4YMEBPPvnkBr98JhLNdZLnt99+qzfffLPOnj3ble71erWgoECTk5P1ggsucMkC35u0Ec9a3B/2SG7BDIeAPu++fftC/zeaIc3VcMLh4MGDmpOTo4Cef/75qo141lpcV+2jjz6KtwqGOJGWlsaBAwdYsGAB7733XqPqanGG061bt3irYGgGNHvDadu2revYOd1+w4YNtG/fnnbt2rF27dpYq2ZowjR7w1m+fDmnnXYaQ4YMYcGCBaSmptqynj17snfvXvbt21djLY3BUBvN3uVSp06d+PTTT+uVt6ysjKysJhsjyxBDEtWvWj8R+VRE9viGEGNCenp6rE5laOIkql+1KuBtIKpfIp3vPzk5OSZagaHexOxJcfhV66eqpcAsEfH7VbvTmVdVVwGrROSIaOpUVFREcXExqur6am0w1EVT8asWNXJzc+N5ekMTJZaGk43lnMNJMdCocM9NySFhPDAOCWsSCYeEsTScUqB1QFprfMF4w0VVnweeB5g0aZI2yjtjM8Xck5o09p4krF81gyGRiZnhqGoZ8C7wgIhkichw4DzgtcC8YpEBpPmOM0QkrLHiiooKBgwYQF5enllnY4gYsR5/vRF4GSti9V7gBlVdJiJdgeXAUaq6GegGOJ/yCmAT0L2hJ3QunOrZsydVVVVm2NnQaGL6HUdVi1T1fFXNUtWuqjrNl75ZVbN9RoOqblRVCdi6R0KH22+/PRLVGFo4zX6uWiAjR46MtwqGZkCzN5x+/frZ+2lpadFbSmtoUTT7zv6SJU0i0IGhidHsWxyDIRoYwzEYwsAYjsEQBsZwDIYwMIZjMISBMRyDIQyM4RgMYWAMx2AIg2ZlONu2bWPWrFnxVsPQAmhWhnPgwAFuuukmtm7dGm9VDM2cZmU4AIsXL+buu++OtxqGZk5M56qJSDvgJeA0YA9wl39pQZC8fwLuADKBf2Ot3TlYn/M4AxR9//33VFZW2sfDhg0LV/1GU11dzfbt22nfvr1rnRBYUSMqKirIyMggKcn9e7Z161Z27NhB165d6dixo0u2adMmCgsL6dWrVw1PPdu2bWPdunX069fP5TNOVZk7dy4Ahx9+OIceeqgt83g8LFy4EK/Xyy9+8QuXg8aKigoWL14MwIABA8jIyLBl+/fvZ+XKlQAMHTrUdQ3l5eWsXLmS7Oxsevfu7dJx+/btbN68mfT0dAYOHOiSbdy4kZ07d5Kdne2arAvwww8/cPDgQdLS0hg0aJBLNm/ePLxeL5mZmRx99NE1rnvlypWkp6fXqLMhxHqSp9Ov2gDgIxFZrKqu5dMicjqWy6iRwHbgPeAvBLiRCkWnTp3sfafRAOzatct++AKjfjmNyikL/Oc4Zc5/uPOBBEhJSWHIkCH2ef0rULdv3+463+bNm+00sDzv9O3bF/j5IQDL13VhYSG/+MUvauixcuVKunTpQpcuXVyy8vJyfvjhB/r27Wt79HHquG7dOtLS0mzZ/PnzbdmSJUtc98RvNACLFi2yZQcPHrSNxq+zX3bgwAGWL18OWD9oc+bMsWVbtmxh27Ztdh1O2dKlSyktLQWgtLTUJXNed2VlZUhZRUUF33//vf2/c163v+5wiVlXzeFXbZyqlqrqLMDvVy2QK4GXVHWZqu4DHgR+X5/zJCcn8+CDD4aUOx/QQFQtp6H79u1zpTuNz/nwgPUP9+P8x4A7XF5ty7YDdSou/tkZkN9o/JSVlYWsp7Z3u9q83dQmW7NmDQA7d+4Mmae2Geh+owmG32iC0dgH20/gD2ekiOU7Tii/asE8eRb4ZM58HUXkkNpO0KZNGz7++ONafaXVJvM/HJs3bw6ZxxlTsrmQnJwcUuZ3Up+ZmRkyT0t0HSz+X9mon0jkeOBfqtrJkTYauExVTwrIuw4Yo6qf+I5Tsbp4PVR1Y0Be26/aXXfd1S89PX1pNK+jqVFaWto+Ozt7T7z1SCQc92TP/ffff0Y4dSSqX7XAvP79GnmdftVEZIGqDmm8qs0Hc09qEol7kqh+1Zb5ZM58u1R1bxT1MxjqTUL6VQOmAteIyFEi0ha4F3glVroaDHUR6w+gN2J9lykE3sDhV01ESn3+1fC92zwOfIXlT20TcH896n8+Omo3acw9qUmj70nMBgcMhuZEs5tyYzDEAmM4BkMYNAvDqW9s0eZKA2Kr/l5EPL73Sf92UozVjRsicpOILBCRgyLySmPqai4OCes1B64Z05Dr/05VR8RUu8RhO/AQcDrWIFXYNPkWp4Fz4JodLf36G4Kqvquq07EiZTSKJm84NGwOXHOkodc/UET2iMhqERknIs2l1xFTmsNNi0ps0SZEQ67/G6Af1nexAuAtoBp4NJoKNkeaQ4sTldiiTYh6X7+qrlfVDarqVdUlwAPARTHQsdnRHAynpccWbcz1KyBR0aqZ0+QNp4Fz4JodDYyteqaIdPTtHwmMA96Ppb7xRERSfLFln0rwrAAAA1BJREFUk4FkX2zZ8F5XVLXJb0A7YDpQBmwGLo23Tolw/UBXrK5cV9/xRGCXL996rK5aarz1j+F9Go/Vyjq38eHUZeaqGQxh0OS7agZDPDCGYzCEgTEcgyEMjOEYDGFgDMdgCANjOAZDGBjDMRjCwBiOwRAGxnBaACKyUURO8e0va0mrPqNFc1hWYGgAqhq1dUoisgJrOcPp2sxX35oWxxBJ+mHN1r4w3opEG2M4MUZE8kXkXRHZLSJ7RWSKL72viHwtIvt93alzHWVURI5wHL8iIg85jjeKyF0islxE9onIP3yzgIOd39lt2ygit4nIjyJSLCJvOcuJyCAR+UFESkTkXz75Q8HqBVBVDzALt/viZokxnBgiIsnAf7BWYHYH8oA3fdEYPgT+C3QAbgZeF5E+Daj+MiwnFIdjLae+t57lLgbOAHoA/fHFIRKRNKyAXq9gzb5+A7igtopEJBP4ra+eZo0xnNgyFDgMuF1Vy1T1J7WcawzDWgL9mKpWquqXWAb2uwbUPUVVt6hqEfBwA8o+rarbfeU+xPKSg0+nFJ+8SlXfBebVUdfDwDbgcBHJboDuTQ5jOLElH9ikqtUB6YcBW1TVGX5tE1aLVF+2BJQ9rJ7lnKHWyrEM2K/TNnWvO3Gew4WIHIfVel2I5fMg/ACbTQBjOLFlC9A1yKrD7UC+iDj/H12xfr3BeqCd0XY7UZP8gLKhYzbWjx1Anog4l1bnB8voey96Gbje13Itppm/5xjDiS3zsB7Ix3zLnDN8S53nYq3K/LOIpPq+s4wC3vSVWwRcKiLJInIGcGKQuseISBdfZO+7sTzYNIbvAA9wk2/J8XlYXc1gPIDl6PA/Dn2b9XuOMZwY4ht1GgUcgbXEeStwiapWAucCZ2KFsX8GuEJV/aGcb/GV2481CDA9SPXTsAYX1vu2kKNf9dS1Evg1cI3vvJdjvXcddOYTkaHAb4A/OZIX0cxbHLN0uhkgIhuBa1X18yifZy7wnKr+I5rnaQqYFscQEhE5UUQ6+bpqV2J1vz6Jt16JgJlyY6iNPsDbWCNt64CLVHVHfFVKDExXzWAIA9NVMxjCwBiOwRAGxnAMhjAwhmMwhIExHIMhDIzhGAxhYAzHYAgDYzgGQxj8f6wteuUCCnadAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 180x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 1, gridspec_kw={'hspace':.25}, figsize=(2.5, 5))\n",
    "axin = ax[1].inset_axes([0.65, 0.5, 0.3, 0.3]) # [x0, y0, width, height]\n",
    "axin.set_xlim(0.74, 0.86)\n",
    "axin.set_ylim(0.465, 0.475)\n",
    "\n",
    "for _lambda in lambdas:    \n",
    "    ax[0].scatter([_lambda for _ in range(len(tracenorms_dict[_lambda]))], \n",
    "               tracenorms_dict[_lambda], c=colormap[np.array(cols[_lambda])], marker='.')\n",
    "    \n",
    "    for _ax in [ax[1], axin]:\n",
    "        _ax.scatter([_lambda for _ in range(len(tracenorms_dict[_lambda]))], \n",
    "                   fronorms_dict[_lambda], c=colormap[np.array(cols[_lambda])], marker='.')\n",
    "\n",
    "for n_ax, _ax in enumerate(ax.flat):\n",
    "    \n",
    "    #_ax.yaxis.tick_right()\n",
    "    _ax.set_ylabel(r'$d$', fontproperties=font)\n",
    "    #_ax.get_yaxis().set_label_position('right')\n",
    "    _ax.spines['top'].set_color('none')\n",
    "    \n",
    "    if n_ax != 1:\n",
    "        _ax.spines['bottom'].set_color('none')\n",
    "        _ax.set_xticklabels([])\n",
    "        _ax.tick_params(axis='x', colors='none')\n",
    "        _ax.xaxis.set_tick_params(pad=0)\n",
    "    else:\n",
    "        _ax.spines['bottom'].set_color('grey')\n",
    "        #_ax.xaxis.set_tick_params(pad=0)\n",
    "        \n",
    "    \n",
    "    _ax.spines['left'].set_color('grey')\n",
    "    _ax.spines['right'].set_color('none')\n",
    "\n",
    "    grid = _ax.grid(True, color='k', alpha=.25, which='both', ls='-')\n",
    "\n",
    "    _ax.set_xticks([0, 0.5, 1])\n",
    "    _ax.set_xticklabels(['0', '0.5', '1'])\n",
    "\n",
    "    for _t in list(_ax.yaxis.get_ticklabels()) + list(_ax.xaxis.get_ticklabels()):\n",
    "        _t.set_font_properties(font)\n",
    "    \n",
    "    _ax.set_ylim(0, .5)\n",
    "    _ax.set_xlim(lambdas[0], lambdas[-1]+0.01)\n",
    "    \n",
    "ax[1].set_xlabel(r'coupling $\\lambda$', fontproperties=font)\n",
    "\n",
    "ax[0].set_title('trace norm', fontproperties=font)\n",
    "ax[1].set_title('frobenius norm', fontproperties=font)\n",
    "\n",
    "axin.set_xticks([])\n",
    "axin.set_yticks([])\n",
    "ax[1].indicate_inset_zoom(axin)\n",
    "\n",
    "fig.legend(loc=(.53, .6), handles=colored_patches, prop=font)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## graph analysis\n",
    "Analyze strongest coupling case. Can we estimate the network from data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# following code works on the last defined objects in this for loop, i.e. correspond to strongest coupling\n",
    "assert _lambda == 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### assemble graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute different scores and store in a networkx graph object\n",
    "graph_fronorm = nx.Graph()\n",
    "graph_trace = nx.Graph()\n",
    "\n",
    "# for all pairs of subsystems, compute dependency scores with Frobenius and trace norm\n",
    "for n1, n2 in itertools.combinations(range(num_subsys), 2):\n",
    "    d = compute_dependency(dmsm_tmat_dict[(n1, n2)], \n",
    "                                  dmsm_tmat_dict[n1], \n",
    "                                  dmsm_tmat_dict[n2], \n",
    "                                  score='tracenorm')\n",
    "    graph_trace.add_edge(n1, n2, weight=d)\n",
    "    \n",
    "\n",
    "    d = compute_dependency(dmsm_tmat_dict[(n1, n2)], \n",
    "                                  dmsm_tmat_dict[n1], \n",
    "                                  dmsm_tmat_dict[n2], \n",
    "                                  score='frobenius')\n",
    "    graph_fronorm.add_edge(n1, n2, weight=d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### plot graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 180x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2, 1, figsize=(2.5, 5), gridspec_kw={'hspace':.25})\n",
    "names = ['trace norm', 'frobenius norm']\n",
    "for n_graph, graph in enumerate([graph_trace, graph_fronorm]):\n",
    "    \n",
    "    ax = axes[n_graph]\n",
    "    # positions by Fruchterman-Reingold\n",
    "    pos_dict = nx.spring_layout(graph, k=0.75 if n_graph == 0 else 0.4, seed=40, )\n",
    "    ax.set_title(names[n_graph], fontproperties=font)\n",
    "\n",
    "    weights = np.array(list(nx.get_edge_attributes(graph, 'weight').values()))\n",
    "\n",
    "    # draw nodes representing gates (symbol o)\n",
    "    nx.draw_networkx_nodes(graph, node_shape='o', \n",
    "                           nodelist=graph.subgraph([n for n in range(num_subsys) if n in gates]).nodes,\n",
    "                           node_size=nodesize, \n",
    "                           pos=pos_dict, \n",
    "                           node_color=[node_cols[n] for n in range(num_subsys) if n in gates], \n",
    "                          ax=ax)\n",
    "    \n",
    "    # draw nodes representing deactivation switches (symbol square)\n",
    "    nx.draw_networkx_nodes(graph, node_shape='s', \n",
    "                           nodelist=graph.subgraph([n for n in range(num_subsys) if n not in gates]).nodes,\n",
    "                           node_size=nodesize, \n",
    "                           pos=pos_dict, \n",
    "                           node_color=[node_cols[n] for n in range(num_subsys) if n not in gates], \n",
    "                          ax=ax)\n",
    "    # draw all edges\n",
    "    pc = nx.draw_networkx_edges(graph, \n",
    "                     edge_color=weights, width=2.4,\n",
    "                     pos=pos_dict, node_size=nodesize,\n",
    "                     ax=ax,\n",
    "                    )\n",
    "    \n",
    "    # define colormap\n",
    "    pc.set_array(weights)\n",
    "    pc.set_cmap(edge_cmap)\n",
    "\n",
    "    cb = fig.colorbar(pc, ax=ax,\n",
    "                      aspect=25, pad=.15)\n",
    "    cb.set_label(r'$d$', fontproperties=font)\n",
    "    cbarticks = cb.ax.yaxis.get_ticklabels()\n",
    "    \n",
    "    # set font properties\n",
    "    for _t in list(cbarticks):\n",
    "        _t.set_font_properties(font)\n",
    "    ax.axis('off');\n",
    "axes[1].text(0.5, 0, r'$\\lambda = 1$', transform=axes[1].transAxes, fontproperties=font);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## modeling a single channel independently\n",
    "\n",
    "Now that we have found the optimal partition, can we retrieve the model of one of the monomers, ignoring weak coupling between the channels?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sub-system indexing ordered to match resulting matrices\n",
    "subsystem_trajectory = np.ravel_multi_index(\n",
    "    np.vstack(np.array(independent_trajs)[[0, 5, 4, 3, 2]]), tuple((2 for _ in range(n_subsys_switches)))\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note that this estimate is at a lagtime dt because trajectory was generated from T^dt\n",
    "C = msmtools.estimation.cmatrix(subsystem_trajectory, 1, sparse_return=False)\n",
    "T = msmtools.estimation.tmatrix(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### compare transition matrices & implied timescales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2)\n",
    "ax[0].imshow(T, norm=plt.matplotlib.colors.LogNorm())\n",
    "ax[0].set_title('estimated')\n",
    "ax[1].imshow(np.linalg.matrix_power(channel_tmat, dt), norm=plt.matplotlib.colors.LogNorm())\n",
    "ax[1].set_title('reference');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/storage/mi/thempel/anaconda3/envs/py37_oct19/lib/python3.7/site-packages/msmtools/analysis/dense/decomposition.py:540: ImaginaryEigenValueWarning: Using eigenvalues with non-zero imaginary part\n",
      "  warnings.warn('Using eigenvalues with non-zero imaginary part', ImaginaryEigenValueWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7ff24ec01048>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(8, 4))\n",
    "\n",
    "ax[0].plot(T.flat, np.linalg.matrix_power(channel_tmat, dt).flat, '.')\n",
    "ax[0].loglog()\n",
    "\n",
    "its_ref = msmtools.analysis.timescales(np.linalg.matrix_power(channel_tmat, dt))\n",
    "its_est = msmtools.analysis.timescales(T)\n",
    "\n",
    "ax[1].plot(its_ref, 'r.', label='reference')\n",
    "ax[1].plot(its_est, 'b.', label='estimate')\n",
    "#ax[1].semilogy()\n",
    "fig.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spectrum is well-approximated. As it does not incoporate the weak coupling between channels, it is only an approximation."
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}