logos-blockchain-pocs/cryptarchia/total-stake-inference.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "57dd6103-97be-4fa2-8c3a-dde96cfc8851",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import curve_fit\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from ipywidgets import interact\n",
    "import concurrent.futures\n",
    "from scipy.special import erf\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "aa0d24be-1c25-4f8a-9316-7fb326e1ca0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Large Mass Model of D_\\inf with a Gaussian Noise Assumption\n",
    "\n",
    "def gauss_field_mean(stake, f):\n",
    "    D0 = stake.sum()\n",
    "    D02 = (stake**2).sum()\n",
    "    return D0/2 + np.sqrt(D0**2 + 2*D02*np.log(1 - f))/2;\n",
    "\n",
    "def gauss_field_var(stake, f, delta, T):\n",
    "    D0 = stake.sum()\n",
    "    D02 = (stake**2).sum()\n",
    "    ED = gauss_field_mean(stake, f)\n",
    "    return delta*(2*D0*ED + 3*D02*np.log(1 - f))*ED**2/(2*D0*T*(D0*delta*np.log(1 - f) + ED**2));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a1b9bf88-d9ba-4c18-8cc4-fb2df8b297be",
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "def phi(f, alpha):\n",
    "    return 1 - (1-f)**alpha\n",
    "\n",
    "@dataclass\n",
    "class Params:\n",
    "    epochs: int\n",
    "    sims: int\n",
    "    stake: np.array\n",
    "    T: int\n",
    "    f: float\n",
    "    beta: float\n",
    "    D_init: float\n",
    "\n",
    "    @property\n",
    "    def h_at_fixpoint(self):\n",
    "        D_inf = gauss_field_mean(f=self.f, stake=self.stake)\n",
    "        return D_inf / np.log(1/(1-self.f)) * self.beta\n",
    "    \n",
    "    def __str__(self):\n",
    "        import dataclasses\n",
    "        \"\"\"Returns a string containing only the non-default field values.\"\"\"\n",
    "        s = ', '.join(f'{field.name}={getattr(self, field.name)!r}'\n",
    "                      for field in dataclasses.fields(self)\n",
    "                      if field.name != \"stake\")\n",
    "        s += f\", stake=(N={len(self.stake)}, mean={self.stake.mean():.2f}, var={self.stake.var():.2f})\"\n",
    "        return f'{type(self).__name__}({s})'\n",
    "    \n",
    "\n",
    "@dataclass\n",
    "class EmpiricalResult:\n",
    "    seed: int\n",
    "    D: np.array\n",
    "    leader_rate: np.array\n",
    "\n",
    "\n",
    "def sim_empirical(params: Params, seed=None):\n",
    "    if seed is not None:\n",
    "        np.random.seed(seed)\n",
    "    D = np.zeros((params.sims, params.epochs + 1)) # D values evolved across time for each simulation\n",
    "    D[:,0] = params.D_init\n",
    "    leader_rate = np.zeros((params.sims, params.epochs)) # How many leaders were observed / slot for each epoch\n",
    "\n",
    "    stake_per_sim = np.repeat(params.stake, params.sims).reshape((len(params.stake), params.sims)).transpose()\n",
    "\n",
    "    start = time.time()\n",
    "    info_rate = 1000\n",
    "    for epoch in range(params.epochs):\n",
    "        if epoch > 0 and epoch % info_rate == 0:\n",
    "            elapsed = time.time() - start\n",
    "            per_epoch = elapsed / epoch\n",
    "            estimate = per_epoch * params.epochs\n",
    "            print(\"epoch=\",epoch,\"of\",params.epochs, f\"eta={estimate-elapsed:.2f}s\", f\"{info_rate} epochs={info_rate*per_epoch:.2f}s\")\n",
    "    \n",
    "        D_t = D[:,epoch]\n",
    "        D_per_stake = np.repeat(D_t, len(params.stake)).reshape((params.sims, len(params.stake)))\n",
    "        relative_stake = stake_per_sim / D_per_stake\n",
    "        bias = phi(params.f, relative_stake)\n",
    "\n",
    "        # bias (# of paths, # of nodes)\n",
    "        \n",
    "        leader_rate[:,epoch] = np.random.binomial(params.T, bias).sum(axis=1) / params.T\n",
    "        error = np.log(1/(1-params.f)) - leader_rate[:,epoch]\n",
    "        h = D_t / np.log(1/(1-params.f)) * params.beta\n",
    "        correction = h * error\n",
    "        D[:,epoch+1] = np.maximum(D_t - correction, np.zeros(params.sims) + 1e-6)\n",
    "\n",
    "    return EmpiricalResult(\n",
    "        seed=seed,\n",
    "        D=D[:,:params.epochs],\n",
    "        leader_rate=leader_rate\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ffb0c965-5e6e-4e17-b6d8-5a7b269be102",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This simulation runs our models derived in overleaf, the numerical results can later be compared against the empirical results above\n",
    "\n",
    "@dataclass\n",
    "class NumericalResult():\n",
    "    D: np.array\n",
    "    D_var: np.array\n",
    "    leader_rate: np.array\n",
    "    leader_rate_var: np.array\n",
    "    \n",
    "def sim_numerical(params: Params):\n",
    "    D = np.zeros(params.epochs + 1)\n",
    "    D[0] = params.D_init\n",
    "    D_var = np.zeros(params.epochs + 1)\n",
    "    leader_rate = np.zeros(params.epochs)\n",
    "    leader_rate_var = np.zeros(params.epochs)\n",
    "    \n",
    "    start = time.time()\n",
    "    info_rate = 10000\n",
    "    for epoch in range(params.epochs):\n",
    "        if epoch > 0 and epoch % info_rate == 0:\n",
    "            elapsed = time.time() - start\n",
    "            per_epoch = elapsed / epoch\n",
    "            estimate = per_epoch * params.epochs\n",
    "            print(\"epoch=\",epoch,\"of\",params.epochs, f\"eta={estimate-elapsed:.2f}s\", f\"{info_rate} epochs={info_rate*per_epoch:.2f}s\")\n",
    "    \n",
    "        D_t = D[epoch]\n",
    "        relative_stake = params.stake / D_t\n",
    "        phi_outcomes = phi(params.f, relative_stake)\n",
    "        leader_rate[epoch] = phi_outcomes.sum()\n",
    "        error = np.log(1/(1-params.f)) - leader_rate[epoch]\n",
    "        h = D_t / np.log(1/(1-params.f)) * params.beta\n",
    "        correction = h * error\n",
    "        D[epoch+1] = np.maximum(D_t - correction, 1e-6)\n",
    "        D_var[epoch+1] = h**2 *  (phi_outcomes * (1 - phi_outcomes)).sum() / params.T\n",
    "        leader_rate_var[epoch] = (phi_outcomes * (1 - phi_outcomes)).sum() / params.T\n",
    "    return NumericalResult(\n",
    "        D=D[:params.epochs],\n",
    "        D_var=D_var[:params.epochs],\n",
    "        leader_rate=leader_rate,\n",
    "        leader_rate_var=leader_rate_var,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "43b85a7c-6323-418b-8777-1672586e93d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper for driving hyper-parameter analysis\n",
    "def run_empirical_sims(params, seed=lambda i: 0):\n",
    "    def driver(pair):\n",
    "        i, p = pair\n",
    "        print(f\"Started {i + 1} / {len(params)}\")\n",
    "        result = sim_empirical(p, seed=seed(i))\n",
    "        print(f\"Finished {i + 1} / {len(params)}\")\n",
    "        return result\n",
    "\n",
    "    with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:\n",
    "        results = list(executor.map(driver, enumerate(params)))\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "06112af5-1c3a-4d54-bb4d-d40082cd2f68",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:84: SyntaxWarning: invalid escape sequence '\\D'\n",
      "<>:92: SyntaxWarning: invalid escape sequence '\\D'\n",
      "<>:104: SyntaxWarning: invalid escape sequence '\\e'\n",
      "<>:114: SyntaxWarning: invalid escape sequence '\\D'\n",
      "<>:84: SyntaxWarning: invalid escape sequence '\\D'\n",
      "<>:92: SyntaxWarning: invalid escape sequence '\\D'\n",
      "<>:104: SyntaxWarning: invalid escape sequence '\\e'\n",
      "<>:114: SyntaxWarning: invalid escape sequence '\\D'\n",
      "/private/tmp/nix-shell-78445-0/ipykernel_80506/763334158.py:84: SyntaxWarning: invalid escape sequence '\\D'\n",
      "  ax_leader_var.plot(x_epochs, numerical.leader_rate_var, color=\"orange\", label=\"numerical $\\Delta=0$\")\n",
      "/private/tmp/nix-shell-78445-0/ipykernel_80506/763334158.py:92: SyntaxWarning: invalid escape sequence '\\D'\n",
      "  ax_D.plot(x_epochs, numerical_D_ratio, c=\"orange\", linewidth=2, label=\"numerical $\\Delta=0$\")\n",
      "/private/tmp/nix-shell-78445-0/ipykernel_80506/763334158.py:104: SyntaxWarning: invalid escape sequence '\\e'\n",
      "  ax_D2.set_title(\"($D_\\ell - D^0)^2$\")\n",
      "/private/tmp/nix-shell-78445-0/ipykernel_80506/763334158.py:114: SyntaxWarning: invalid escape sequence '\\D'\n",
      "  ax_D2.plot(x_epochs, ((numerical.D_var + (numerical.D - D_true)**2)), c=\"orange\", label=\"numerical $\\Delta=0$\")\n"
     ]
    }
   ],
   "source": [
    "def boltzmann_D_mean_v2(beta, stake, f):\n",
    "    D0 = stake.sum()\n",
    "    D02 = (stake**2).sum()\n",
    "    \n",
    "    a = D0/2 + np.sqrt(D0**2 + 2*D02*np.log(1 - f))/2\n",
    "    A = (-np.log(1 - f)*D0/(2*a**2) - D02*np.log(1 - f)**2/(2*a**3))\n",
    "\n",
    "    # num =     sqrt(Pi)*a*erf(A*a*beta/sqrt(A*beta))*A*beta + a*sqrt(Pi)*A*beta + exp(-A*a^2*beta)*sqrt(A*beta)\n",
    "    numerator = np.sqrt(np.pi)*a*erf(A*a*beta/np.sqrt(A*beta))*A*beta + a*np.sqrt(np.pi)*A*beta + np.exp(-A*a**2*beta)*np.sqrt(A*beta)\n",
    "    # denum = A*beta*sqrt(Pi)*(1 + erf(A*a*beta/sqrt(A*beta)))\n",
    "    denominator = A*beta*np.sqrt(np.pi)*(1 + erf(A*a*beta/np.sqrt(A*beta)))\n",
    "\n",
    "    result = numerator / denominator\n",
    "    return result\n",
    "\n",
    "def boltzmann_D_var_v2(beta, stake, f):\n",
    "    D0 = stake.sum()\n",
    "    D02 = (stake**2).sum()\n",
    "\n",
    "    # a := D0/2 + sqrt(D0^2 + 2*D02*ln(1 - f))/2;\n",
    "    a = D0/2 + np.sqrt(D0**2 + 2*D02*np.log(1 - f))/2\n",
    "\n",
    "    # A:=(-ln(1 - f)*D0/(2*a^2) - D02*ln(1 - f)^2/(2*a^3));\n",
    "    A = (-np.log(1 - f)*D0/(2*a**2) - D02*np.log(1 - f)**2/(2*a**3))\n",
    "\n",
    "    numerator = (-2*np.sqrt(A*beta)*erf(A*a*beta/np.sqrt(A*beta))*np.exp(-A*a**2*beta)*np.pi*a +\n",
    "                 np.pi**(3/2)*erf(A*a*beta/np.sqrt(A*beta))**2 -\n",
    "                 2*np.sqrt(A*beta)*np.exp(-A*a**2*beta)*np.pi*a +\n",
    "                 2*np.pi**(3/2)*erf(A*a*beta/np.sqrt(A*beta)) -\n",
    "                 2*np.sqrt(np.pi)*np.exp(-2*A*a**2*beta) +\n",
    "                 np.pi**(3/2))\n",
    "\n",
    "    denominator = 2*A*beta*np.pi**(3/2)*(1 + erf(A*a*beta/np.sqrt(A*beta)))**2\n",
    "    result = numerator / denominator\n",
    "    return result\n",
    "\n",
    "def large_mass_mean(f, Ew, Vw, N):\n",
    "    return Ew*N/2 + np.sqrt((N*Ew)**2  - 2*(Ew**2*N + Vw*(N-1))*np.log(1/(1-f)))/2\n",
    "\n",
    "def large_mass_var(f, Ew, Vw, N, T, delta):\n",
    "    D_infty = large_mass_mean(f, Ew, Vw, N)\n",
    "    num = D_infty**2*delta*(2*D_infty*Ew*N-3*(Ew**2*N + Vw*(N-1))*np.log(1/(1-f)))\n",
    "    denum = 2*Ew*N*T*(D_infty**2 - Ew*N*delta*np.log(1/(1-f)))\n",
    "    return num / denum\n",
    "\n",
    "def plot(params, empirical, numerical):\n",
    "    x_epochs = np.array(range(params.epochs))\n",
    "    \n",
    "    D_true = params.stake.sum()\n",
    "    XX = 10000000\n",
    "    leader_rate_true = (np.random.binomial(XX, phi(params.f, params.stake / D_true)) / XX).sum()\n",
    "    \n",
    "    leader_rate_mean = empirical.leader_rate.mean(axis=0)\n",
    "    leader_rate_std = np.sqrt(empirical.leader_rate.var(axis=0))\n",
    "    \n",
    "    D_ratio = empirical.D/D_true\n",
    "    D_ratio_mean = D_ratio.mean(axis=0)\n",
    "    D_ratio_std = np.sqrt(empirical.D.var(axis=0)) / D_true\n",
    "    \n",
    "    d_sq_err = np.abs(empirical.D - D_true) ** 2\n",
    "    d_sq_err_mean = d_sq_err.mean(axis=0)\n",
    "    d_sq_err_std = np.sqrt(d_sq_err.var(axis=0))\n",
    "    \n",
    "\n",
    "    numerical_D_ratio = numerical.D/D_true\n",
    "    numerical_D_ratio_std = np.sqrt(numerical.D_var) / D_true\n",
    "    \n",
    "    \n",
    "    plt.figure(figsize=(16,10), dpi=120)\n",
    "    ax_leaders = plt.subplot(321)\n",
    "    ax_leaders.set_title(\"observed leader rate\")\n",
    "    ax_leaders.set_xlabel(\"epochs\")\n",
    "    ax_leaders.set_ylabel(\"leaders/slot\")\n",
    "    ax_leaders.vlines(x_epochs, ymin=leader_rate_mean - leader_rate_std, ymax=leader_rate_mean + leader_rate_std, colors=\"lightgray\", label=\"std\")\n",
    "    ax_leaders.plot(x_epochs, leader_rate_mean, c=\"k\",linewidth=1,  label=\"mean\")\n",
    "    ax_leaders.plot(x_epochs, x_epochs * 0 + leader_rate_true, c=\"red\", label=\"optimal leader rate\")\n",
    "    ax_leaders.plot(x_epochs, x_epochs * 0 + np.log(1 / (1-params.f)), c=\"blue\", label=\"leader rate upper target\")\n",
    "    ax_leaders.plot(x_epochs, numerical.leader_rate, c=\"orange\", label=\"numerical\")\n",
    "    ax_leaders.legend()\n",
    "    \n",
    "    ax_leader_var = plt.subplot(322)\n",
    "    ax_leader_var.set_title(\"Leader rate variance\")\n",
    "    ax_leader_var.plot(x_epochs, leader_rate_std **2, color=\"k\", label=\"empirical\")\n",
    "    ax_leader_var.plot(x_epochs, numerical.leader_rate_var, color=\"orange\", label=\"numerical $\\Delta=0$\")\n",
    "    ax_leader_var.legend()\n",
    "    \n",
    "    ax_D = plt.subplot(323)\n",
    "    ax_D.set_title(\"$E[D/D^0]$\")\n",
    "    ax_D.set_xlabel(\"epochs\")\n",
    "    ax_D.set_ylabel(\"$D/D^0$\")\n",
    "    ax_D.plot(x_epochs, D_ratio_mean, c=\"k\", linewidth=1, label=\"D_ratio\")\n",
    "    ax_D.plot(x_epochs, numerical_D_ratio, c=\"orange\", linewidth=2, label=\"numerical $\\Delta=0$\")\n",
    "    ax_D.plot(x_epochs, np.ones(params.epochs), c=\"red\", label=\"D_true\")\n",
    "    ax_D.plot(x_epochs, np.zeros(params.epochs) + np.log(1-params.f) / np.log(1-np.log(1/(1-params.f))), c=\"blue\", label=\"lower-bound\")\n",
    "    ax_D.plot(x_epochs, np.zeros(params.epochs) + gauss_field_mean(f=params.f, stake=params.stake) / D_true, label=\"large mass model\")\n",
    "    ax_D.legend()\n",
    "    \n",
    "    ax_D_var = plt.subplot(324)\n",
    "    ax_D_var.set_title(\"Var[D]\")\n",
    "    ax_D_var.plot(x_epochs, empirical.D.var(axis=0), color=\"k\", label=\"empirical\")\n",
    "    ax_D_var.legend()\n",
    "\n",
    "    ax_D2 = plt.subplot(313)\n",
    "    ax_D2.set_title(\"($D_\\ell - D^0)^2$\")\n",
    "    ax_D2.set_xlabel(\"epochs\")\n",
    "    ax_D2.set_ylabel(\"squared error\")\n",
    "    ax_D2.vlines(x_epochs,\n",
    "                 ymin=np.maximum(np.zeros(params.epochs), (d_sq_err_mean - d_sq_err_std)),\n",
    "                 ymax=(d_sq_err_mean + d_sq_err_std),\n",
    "                 colors=\"lightgray\",\n",
    "                 label=\"std\"\n",
    "                )\n",
    "    ax_D2.plot(x_epochs, d_sq_err_mean, c=\"k\", linewidth=3, label=\"squared error\")\n",
    "    ax_D2.plot(x_epochs, ((numerical.D_var + (numerical.D - D_true)**2)), c=\"orange\", label=\"numerical $\\Delta=0$\")\n",
    "    ax_D2.set_ylim((0, None))\n",
    "    ax_D2.legend()\n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "    print(str(params), f\"whale={params.stake.max() / params.stake.sum() * 100:.2f}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "802b042e-40d6-48e3-bc48-ac533e849745",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Params(epochs=100, sims=1000, T=432000, f=0.05, beta=0.5, D_init=np.float64(12365.651688404821), stake=(N=1000, mean=12.37, var=30208.31)) whale=42.24%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1920x1200 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 1000\n",
    "np.random.seed(0)\n",
    "stake = np.random.pareto(1, N)\n",
    "f=0.05\n",
    "params = Params(\n",
    "    epochs=100,\n",
    "    sims=1000,\n",
    "    stake=stake,\n",
    "    D_init=stake.sum(), # analysis when initial estimate D_0 is total stake\n",
    "    T=60 * 60 * 24 * 5, # 5 days at 1 second slots\n",
    "    f=f,\n",
    "    beta=0.5,\n",
    ")\n",
    "\n",
    "empirical_results = sim_empirical(params)\n",
    "numerical_results = sim_numerical(params)\n",
    "\n",
    "plot(params, empirical_results, numerical_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6059b23a-34c4-4c43-a344-a19446dc530b",
   "metadata": {},
   "source": [
    "# Study Behaviour as $T$ (epoch length) is Varied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f18004d2-1b5c-47b6-9980-caecb36a04fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "evaluations = 100\n",
    "N = 1000\n",
    "stake = np.random.pareto(5, N)\n",
    "params = [Params(\n",
    "    epochs=100,\n",
    "    sims=100,\n",
    "    stake=stake,\n",
    "    D_init=stake.sum(),\n",
    "    T=60*60*24*5*((i+1)/evaluations),\n",
    "    f=0.05,\n",
    "    beta=0.8,\n",
    ") for i in range(evaluations)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39b35028-07ca-41a4-b41d-05dff40fe9e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started 1 / 100\n",
      "Started 2 / 100\n",
      "Started 3 / 100\n",
      "Started 4 / 100\n",
      "Started 5 / 100\n",
      "Started 6 / 100\n",
      "Started 7 / 100\n",
      "Started 8 / 100\n",
      "Started 9 / 100\n",
      "Started 10 / 100\n",
      "Started 11 / 100\n",
      "Started 12 / 100\n",
      "Started 13 / 100\n",
      "Started 14 / 100\n",
      "Started 15 / 100\n",
      "Started 16 / 100\n",
      "Started 17 / 100\n",
      "Started 18 / 100\n",
      "Started 19 / 100\n",
      "Started 20 / 100\n",
      "Started 21 / 100\n",
      "Started 22 / 100\n",
      "Started 23 / 100\n",
      "Started 24 / 100\n",
      "Started 25 / 100\n",
      "Started 26 / 100\n",
      "Started 27 / 100\n",
      "Started 28 / 100\n",
      "Started 29 / 100\n",
      "Started 30 / 100\n",
      "Started 31 / 100\n",
      "Started 32 / 100\n",
      "Started 33 / 100\n",
      "Started 34 / 100\n",
      "Started 35 / 100\n",
      "Started 36 / 100\n",
      "Started 37 / 100\n",
      "Started 38 / 100\n",
      "Started 39 / 100\n",
      "Started 40 / 100\n",
      "Started 41 / 100\n",
      "Started 42 / 100\n",
      "Started 43 / 100\n",
      "Started 44 / 100\n",
      "Started 45 / 100\n",
      "Started 46 / 100\n",
      "Started 47 / 100\n",
      "Started 48 / 100\n",
      "Started 49 / 100\n",
      "Started 50 / 100\n"
     ]
    }
   ],
   "source": [
    "empirical_results = run_empirical_sims(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e867df3-fb0b-4e69-894b-316e25589a81",
   "metadata": {},
   "outputs": [],
   "source": [
    "numerical_results = [sim_numerical(p) for p in params]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b47ae84c-0f4f-4aef-8d82-aa52d7e62698",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot(params[-1], empirical_results[-1], numerical_results[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dead8a23-1097-4b53-b199-78dd8a2030f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "skip_epochs = 20\n",
    "empirical_D_mean = [r.D[:,skip_epochs:].flatten().mean() for r in empirical_results]\n",
    "empirical_D_var = [r.D[:,skip_epochs:].flatten().var(axis=0) for r in empirical_results]\n",
    "T = [p.T for p in params]\n",
    "numerical_D_mean = [r.D[skip_epochs:].mean() for r in numerical_results]\n",
    "numerical_var = [r.D_var[skip_epochs:].mean() for r in numerical_results]\n",
    "empirical_leader_var = [r.leader_rate[:,skip_epochs:].flatten().var() for r in empirical_results]\n",
    "numerical_leader_var = [r.leader_rate_var[skip_epochs:].mean() for r in numerical_results]\n",
    "gauss_mean = [gauss_field_mean(stake=p.stake, f=p.f) for p in params]\n",
    "gauss_var = [gauss_field_var(stake=p.stake, f=p.f, delta=p.h_at_fixpoint, T=p.T) for p in params]\n",
    "\n",
    "plt.figure(figsize=(16,8), dpi=120)\n",
    "D_var_vs_T = plt.subplot(221)\n",
    "_ = D_var_vs_T.set_title(\"$Var[D]$ vs. T\")\n",
    "_ = D_var_vs_T.set_ylabel(\"$Var[D]$\")\n",
    "_ = D_var_vs_T.set_xlabel(\"T\")\n",
    "_ = D_var_vs_T.plot(T, empirical_D_var, c=\"k\", label=\"empirical\")\n",
    "_ = D_var_vs_T.plot(T, gauss_var, c=\"red\", label=\"gauss\")\n",
    "_ = D_var_vs_T.legend()\n",
    "\n",
    "D_var_vs_leader_var = plt.subplot(222)\n",
    "D_var_vs_leader_var.set_title(\"Var$\\\\left[\\sum s_i\\\\right]$ vs T\")\n",
    "D_var_vs_leader_var.set_ylabel(\"Var$\\\\left[\\sum s_i\\\\right]$\")\n",
    "_ = D_var_vs_leader_var.set_xlabel(\"T\")\n",
    "_ = D_var_vs_leader_var.plot(T, empirical_leader_var, c=\"k\", label=\"empirical\", linewidth=3)\n",
    "_ = D_var_vs_leader_var.plot(T, numerical_leader_var, c=\"orange\", label=\"$\\\\Delta = 0$\", linewidth=1)\n",
    "_ = D_var_vs_leader_var.legend()\n",
    "\n",
    "D_mean_vs_T = plt.subplot(223)\n",
    "D_mean_vs_T.set_title(\"E$\\\\left[D\\\\right]$ vs T\")\n",
    "D_mean_vs_T.set_ylabel(\"E$\\\\left[D\\\\right]$\")\n",
    "_ = D_mean_vs_T.set_xlabel(\"T\")\n",
    "_ = D_mean_vs_T.plot(T, empirical_D_mean, c=\"k\", label=\"empirical\")\n",
    "_ = D_mean_vs_T.plot(T, numerical_D_mean, c=\"orange\", label=\"numerical\")\n",
    "_ = D_mean_vs_T.plot(T, gauss_mean, color=\"red\", label=\"gauss\")\n",
    "_ = D_mean_vs_T.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "print(params[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43c75d16-8e6f-4336-be57-7f4d46bc834f",
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluations = 100\n",
    "def make_params(i):\n",
    "    np.random.seed(0)\n",
    "    N = 100\n",
    "    stake = np.random.uniform(0, 1, N) ** (i*2+1)\n",
    "    return Params(\n",
    "        epochs=70,\n",
    "        sims=10,\n",
    "        stake = stake,\n",
    "        D_init = stake.sum(),\n",
    "        T=60*60*24*5,\n",
    "        f=0.05,\n",
    "        beta=0.5,\n",
    "    )\n",
    "\n",
    "vary_stake_params = [make_params(i) for i in range(evaluations)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38c400cb-1af5-469d-90a5-646511a0eccf",
   "metadata": {},
   "outputs": [],
   "source": [
    "vary_stake_empirical_results = run_empirical_sims(vary_stake_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54d0face-ea6b-4ef6-a07a-8a6554188254",
   "metadata": {},
   "outputs": [],
   "source": [
    "vary_stake_numerical_results = [sim_numerical(p) for p in vary_stake_params]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a58c0731-a056-4691-8c54-31186bde9cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "@interact(i=(0,len(vary_stake_params)-1))\n",
    "def polt_i(i):\n",
    "    plot(vary_stake_params[i], empirical=vary_stake_empirical_results[i], numerical=vary_stake_numerical_results[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c04a919-f258-4533-8a45-8746277bf508",
   "metadata": {},
   "outputs": [],
   "source": [
    "skip_first_epochs = 10\n",
    "D_true = np.array([p.stake.sum() for p in vary_stake_params])\n",
    "empirical_D_mean = [r.D[:,skip_first_epochs:].flatten().mean() for r in vary_stake_empirical_results]\n",
    "empirical_D_var = [r.D[:,skip_first_epochs:].flatten().var() for r in vary_stake_empirical_results]\n",
    "numerical_D_mean = [r.D[:skip_first_epochs].mean() for r in vary_stake_numerical_results]\n",
    "numerical_D_var = [r.D[:skip_first_epochs].var() for r in vary_stake_numerical_results]\n",
    "w_mean = [p.stake.mean() for p in vary_stake_params]\n",
    "w_var = [(p.stake/p.stake.sum()).var() for p in vary_stake_params]\n",
    "gauss_mean_vary_stake = [gauss_field_mean(f=p.f, stake=p.stake) for p in vary_stake_params]\n",
    "gauss_var_vary_stake = [gauss_field_var(f=p.f, stake=p.stake, delta=p.h_at_fixpoint, T=p.T) for p in vary_stake_params]\n",
    "\n",
    "D_upper_bound = D_true\n",
    "D_lower_bound = np.array([np.log(1-p.f)/np.log(1-np.log(1/(1-p.f))) * p.stake.sum() for p in vary_stake_params])\n",
    "\n",
    "plt.figure(figsize=(16,8), dpi=120)\n",
    "D_mean_vs_w_var = plt.subplot(221)\n",
    "_ = D_mean_vs_w_var.set_title(\"E[D/D_true] vs Var[$\\\\alpha_i$]\")\n",
    "_ = D_mean_vs_w_var.set_ylabel(\"E[D/D_true]\")\n",
    "_ = D_mean_vs_w_var.set_xlabel(\"Var[$\\\\alpha_i$]\")\n",
    "_ = D_mean_vs_w_var.scatter(w_var, empirical_D_mean / D_true, color=\"k\", label=\"empirical\")\n",
    "_ = D_mean_vs_w_var.scatter(w_var, gauss_mean_vary_stake / D_true, marker=\"x\", color=\"C3\", label=\"large mass model\")\n",
    "_ = D_mean_vs_w_var.plot(w_var, D_upper_bound / D_true, color=\"C4\", label=\"D_upper_bound\")\n",
    "_ = D_mean_vs_w_var.plot(w_var, D_lower_bound / D_true, color=\"C5\", label=\"D_lower_bound\")\n",
    "_ = D_mean_vs_w_var.legend()\n",
    "\n",
    "\n",
    "\n",
    "D_var_vs_w_var = plt.subplot(222)\n",
    "_ = D_var_vs_w_var.set_title(\"Var[D] vs Var[$\\\\alpha_i$]\")\n",
    "_ = D_var_vs_w_var.set_ylabel(\"Var[D]\")\n",
    "_ = D_var_vs_w_var.set_xlabel(\"Var[$\\\\alpha_i$]\")\n",
    "_ = D_var_vs_w_var.scatter(w_var, empirical_D_var, color=\"k\", label=\"empirical\")\n",
    "_ = D_var_vs_w_var.scatter(w_var, gauss_var_vary_stake, marker=\"x\", color=\"C3\", label=\"large mass\")\n",
    "_ = D_var_vs_w_var.set_yscale(\"log\")\n",
    "_ = D_var_vs_w_var.legend()\n",
    "\n",
    "\n",
    "D_mean_vs_w_mean = plt.subplot(223)\n",
    "_ = D_mean_vs_w_mean.set_title(\"E[D/D_true] vs E[$w_i$]\")\n",
    "_ = D_mean_vs_w_mean.set_ylabel(\"E[D/D_true]\")\n",
    "_ = D_mean_vs_w_mean.set_xlabel(\"E[$w_i$]\")\n",
    "_ = D_mean_vs_w_mean.scatter(w_mean, empirical_D_mean / D_true, color=\"k\", label=\"empirical\")\n",
    "_ = D_mean_vs_w_mean.scatter(w_mean, gauss_mean_vary_stake / D_true, marker=\"x\", color=\"C3\", label=\"large mass model\")\n",
    "_ = D_mean_vs_w_mean.plot(w_mean, D_upper_bound / D_true, color=\"C4\", label=\"D_upper_bound\")\n",
    "_ = D_mean_vs_w_mean.plot(w_mean, D_lower_bound / D_true, color=\"C5\", label=\"D_lower_bound\")\n",
    "_ = D_mean_vs_w_mean.legend()\n",
    "\n",
    "\n",
    "\n",
    "D_var_vs_w_var = plt.subplot(224)\n",
    "_ = D_var_vs_w_var.set_title(\"Var[D] vs E[$w_i$]\")\n",
    "_ = D_var_vs_w_var.set_ylabel(\"Var[D]\")\n",
    "_ = D_var_vs_w_var.set_xlabel(\"E[$w_i$]\")\n",
    "_ = D_var_vs_w_var.scatter(w_mean, empirical_D_var, color=\"k\", label=\"empirical\")\n",
    "_ = D_var_vs_w_var.scatter(w_mean, gauss_var_vary_stake, marker=\"x\", color=\"C3\", label=\"large mass model\")\n",
    "_ = D_var_vs_w_var.set_yscale(\"log\")\n",
    "_ = D_var_vs_w_var.set_xscale(\"log\")\n",
    "_ = D_var_vs_w_var.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "print(vary_stake_params[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3401130a-2251-487c-a682-f1322e406173",
   "metadata": {},
   "source": [
    "# Verify that noise at fixpoint is Gaussian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "939690d2-ac86-4beb-962b-b9da3b8f19b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Checking if D ~ Gaussian\n",
    "def sim_d_gaussian():\n",
    "    N = 1000\n",
    "    stake = np.random.pareto(4, N)\n",
    "    p = Params(\n",
    "        epochs=20000,\n",
    "        sims=1,\n",
    "        stake = stake,\n",
    "        D_init = stake.sum(),\n",
    "        T=60*60*24*5,\n",
    "        f=0.05,\n",
    "        beta=0.5,\n",
    "    )\n",
    "    return sim_empirical(p), p\n",
    "\n",
    "r, p = sim_d_gaussian()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fad944c4-3aed-463d-8a59-814889535062",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = r.D[:, 1000:].flatten() # skip the first 1000 epochs to discard convergence time\n",
    "from scipy import stats \n",
    "x_data = np.arange(data.min() * 0.999, data.max(), 0.1) \n",
    "## y-axis as the gaussian \n",
    "y_data = stats.norm.cdf(x_data, data.mean(), np.sqrt(data.var())) \n",
    "\n",
    "boltz_mean = boltzmann_D_mean_v2(beta=p.T, stake=p.stake, f=p.f)\n",
    "boltz_var = boltzmann_D_var_v2(beta=p.T, stake=p.stake, f=p.f)\n",
    "boltz_cdf = stats.norm.cdf(x_data, boltz_mean, np.sqrt(boltz_var))\n",
    "gauss_mean = gauss_field_mean(stake=p.stake, f=p.f)\n",
    "gauss_var = gauss_field_var(stake=p.stake, f=p.f, T=p.T, delta=p.h_at_fixpoint)\n",
    "gauss_cdf = stats.norm.cdf(x_data, gauss_mean, np.sqrt(gauss_var))\n",
    "\n",
    "plt.title(\"D distribution at fixed point\")\n",
    "_ = plt.hist(data, bins=100, cumulative=True, density=True)\n",
    "_ = plt.plot(x_data, y_data, label=\"empirical fit\")\n",
    "_ = plt.plot(x_data, boltz_cdf, label=\"boltzman\")\n",
    "_ = plt.plot(x_data, gauss_cdf, label=\"large mass\")\n",
    "_ = plt.legend()\n",
    "print(p)\n",
    "print(\"large mass std\", np.sqrt(gauss_var))\n",
    "print(\"empirical std\",  np.sqrt(data.var()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f480cd1f-2546-407e-b847-d4778c72551a",
   "metadata": {},
   "source": [
    "# Stability Analysis\n",
    "\n",
    "Stability Analysis shows we should have a stable fixed point when the following condition is met:\n",
    "\n",
    "\\begin{equation}\n",
    "0<h\\left[-\\frac{\\log(1-f)D^0[\\{w_i\\}]}{D_{\\infty}^2} - \\frac{D^0[\\{w^2_i\\}]\\log(1-f)^2}{D_{\\infty}^3}\\right]<1\n",
    "\\end{equation}\n",
    "\n",
    "Or written another way:\n",
    "\n",
    "\\begin{equation}\n",
    "0< h < \\frac{1}{-\\frac{\\log(1-f)D^0[\\{w_i\\}]}{D_{\\infty}^2} - \\frac{D^0[\\{w^2_i\\}]\\log(1-f)^2}{D_{\\infty}^3}}\n",
    "\\end{equation}\n",
    "\n",
    "\n",
    "We can take $h$ to be $\\beta\\frac{D_\\ell}{-\\log(1-f)}$ and on inspection\n",
    "\n",
    "\\begin{equation}\n",
    "0< h = \\beta\\frac{D_\\ell}{-\\log(1-f)} < \\frac{1}{-\\frac{\\log(1-f)D^0[\\{w_i\\}]}{D_{\\infty}^2} - \\frac{D^0[\\{w^2_i\\}]\\log(1-f)^2}{D_{\\infty}^3}}\n",
    "\\end{equation}\n",
    "\n",
    "holds for $\\beta < 0.97$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70eb0805-f846-41a8-b1de-0d12aa97c268",
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluations = 100\n",
    "def make_params(i):\n",
    "    np.random.seed(0)\n",
    "    N = 500\n",
    "    stake = np.random.pareto(5, N)\n",
    "    f = 0.05\n",
    "    beta = (i+1) / evaluations * 4\n",
    "    return Params(\n",
    "        epochs=2000,\n",
    "        sims=10,\n",
    "        stake = stake,\n",
    "        D_init = stake.sum(),\n",
    "        T=60*60*24*5,\n",
    "        f=f,\n",
    "        beta=beta,\n",
    "    )\n",
    "\n",
    "vary_beta_params = [make_params(i) for i in range(evaluations)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "806d5235-e266-4872-9df8-6edcb0788dc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "vary_beta_empirical = run_empirical_sims(vary_beta_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1aed4638-c52b-4e6f-8f9c-e487d29e965c",
   "metadata": {},
   "outputs": [],
   "source": [
    "vary_beta_numerical = [sim_numerical(p) for p in vary_beta_params]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ad3afed-e0fe-4bda-83bb-38b52b8e00c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "last_N = 1000\n",
    "offset = 0\n",
    "empirical_D_mean = [r.D[:,last_N:].mean(axis=0) for r in vary_beta_empirical][offset:]\n",
    "empirical_D_var = [r.D[:,last_N:].var(axis=0) for r in vary_beta_empirical][offset:]\n",
    "w_mean = [p.stake.mean() for p in vary_beta_params][offset:]\n",
    "w_var = [(p.stake / p.stake.sum()).var() for p in vary_beta_params][offset:]\n",
    "beta = [p.beta for p in vary_beta_params][offset:]\n",
    "gauss_mean = [gauss_field_mean(f=p.f, stake=p.stake) for p in vary_beta_params][offset:]\n",
    "gauss_var = [gauss_field_var(f=p.f, stake=p.stake, delta=p.h_at_fixpoint, T=p.T) for p in vary_beta_params][offset:]\n",
    "\n",
    "print(len(beta), len(empirical_D_var))\n",
    "plt.figure(figsize=(16,8), dpi=120)\n",
    "D_mean_vs_beta = plt.subplot(121)\n",
    "_ = D_mean_vs_beta.set_title(\"E[D] vs $\\\\beta$\")\n",
    "_ = D_mean_vs_beta.set_ylabel(\"E[D]\")\n",
    "_ = D_mean_vs_beta.set_xlabel(\"$\\\\beta$\")\n",
    "for i, p in enumerate(vary_beta_params):\n",
    "    _ = D_mean_vs_beta.scatter(np.zeros(p.epochs - last_N) + p.beta, empirical_D_mean[i], color=\"k\", s=0.01)\n",
    "_ = D_mean_vs_beta.scatter(beta, gauss_mean, marker=\"x\", color=\"C3\", label=\"large mass\")\n",
    "_ = D_mean_vs_beta.set_yscale(\"log\")\n",
    "_ = D_mean_vs_beta.legend()\n",
    "\n",
    "\n",
    "\n",
    "D_var_vs_beta = plt.subplot(122)\n",
    "D_var_vs_beta.set_title(\"Var[D] vs $\\\\beta$\")\n",
    "D_var_vs_beta.set_ylabel(\"Var[D]\")\n",
    "D_var_vs_beta.set_xlabel(\"$\\\\beta$\")\n",
    "D_var_vs_beta.set_yscale(\"log\")\n",
    "\n",
    "for i, p in enumerate(vary_beta_params):\n",
    "    D_var_vs_beta.scatter(np.zeros(p.epochs - last_N) + p.beta, empirical_D_var[i], color=\"k\", s=0.01)\n",
    "D_var_vs_beta.scatter(beta, gauss_var, marker=\"x\", color=\"C3\", label=\"large mass\")\n",
    "D_var_vs_beta.legend()\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "print(vary_beta_params[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dace7813-3c47-45e3-8b07-b4d713ae9419",
   "metadata": {},
   "outputs": [],
   "source": [
    "@interact(i=(0, len(vary_beta_params) - 1))\n",
    "def plot_i(i=0):\n",
    "    plot(params=vary_beta_params[i], empirical=vary_beta_empirical[i], numerical=vary_beta_numerical[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3a23719-857e-4f52-8e67-ade584973311",
   "metadata": {},
   "outputs": [],
   "source": [
    "@interact(i=(0, len(vary_beta_params)-1), last_epochs=(1, vary_beta_params[0].epochs))\n",
    "def plot_sims(i=0, last_epochs=vary_beta_params[0].epochs):\n",
    "    params=vary_beta_params[i]\n",
    "    empirical=vary_beta_empirical[i]\n",
    "    numerical=vary_beta_numerical[i]\n",
    "    start_epoch = params.epochs - last_epochs\n",
    "    epochs = np.array(range(start_epoch, params.epochs))\n",
    "    D_true = params.stake.sum()\n",
    "    plt.figure(figsize=(16,10), dpi=120)\n",
    "    ax_D = plt.subplot(211)\n",
    "    ax_D.plot(epochs, empirical.D.transpose()[start_epoch:,0] / D_true, linewidth=0.5)\n",
    "    ax_D.set_ylabel(\"$D_\\\\ell / D^0$\")\n",
    "    ax_D.set_xlabel(\"epochs $\\\\ell$\")\n",
    "    print(f\"beta={params.beta:.2f}\")\n",
    "    print(params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dd2ab3e-0498-4eff-8c42-d9e22b6f1825",
   "metadata": {},
   "source": [
    "# Convergence Analysis\n",
    "\n",
    "Models suggest that convergence should be bounded by the following for some $\\alpha > 0$\n",
    "\\begin{equation}\n",
    "    \\left|D_\\ell - D_\\infty\\right| < \\alpha \\left|D_0 - D_\\infty\\right|\\left|1 - h\\frac{\\log\\left(\\frac{1}{1-f}\\right)D_\\infty\\sum w_i-\\sum w_i^2\\log\\left(\\frac{1}{1-f}\\right)^2}{D^3_\\infty}\\right|^\\ell\n",
    "\\end{equation}\n",
    "\n",
    "Empirical data suggests $\\alpha=1$ matches the model very well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "277af8a1-b994-4933-a517-51a383c82a9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluations = 100\n",
    "def make_params(i):\n",
    "    np.random.seed(0)\n",
    "    N = 1000\n",
    "    stake = np.random.pareto(5, N)\n",
    "    return Params(\n",
    "        epochs=10,\n",
    "        sims=1000,\n",
    "        stake = stake,\n",
    "        D_init = stake.sum() * 2,\n",
    "        T=60*60*24*5,\n",
    "        f=0.05,\n",
    "        beta=i / evaluations,\n",
    "    )\n",
    "\n",
    "#convergence_params = [make_params(i) for i in range(evaluations)]\n",
    "convergence_params = [make_params(85)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbafad94-f658-44d6-adeb-9fcb0b269632",
   "metadata": {},
   "outputs": [],
   "source": [
    "convergence_empirical = run_empirical_sims(convergence_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1412d359-d4f4-4774-9feb-950616340750",
   "metadata": {},
   "source": [
    "\n",
    "We will plot the following inequality, for different $\\alpha$'s ontop of simulation data.\n",
    "\\begin{equation}\n",
    "    \\frac{\\left|D_\\ell - D_\\infty\\right|}{\\left|D_0 - D_\\infty\\right|} < \\alpha \\left|1 - h\\frac{\\log\\left(\\frac{1}{1-f}\\right)D_\\infty\\sum w_i-\\sum w_i^2\\log\\left(\\frac{1}{1-f}\\right)^2}{D^3_\\infty}\\right|^\\ell\n",
    "\\end{equation}\n",
    "\n",
    "Since $h$ is dynamic in simulation, we use $h=\\beta\\frac{D_{\\infty}}{\\log\\left(\\frac{1}{1-f}\\right)}$ when computing the bound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25dc71f3-1017-489e-b503-09abdea450a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "@interact(i=(0, len(convergence_params)-1))\n",
    "def plot_convergence(i=0):\n",
    "    p = convergence_params[i]\n",
    "    D0 = p.stake.sum()\n",
    "    D02 = (p.stake**2).sum()\n",
    "    empirical=convergence_empirical[i]\n",
    "    D_infty = gauss_field_mean(f=p.f, stake=p.stake)\n",
    "    abs_diff_0 = np.abs(p.D_init - D_infty)\n",
    "    abs_diff_ell = np.abs(empirical.D - p.stake.sum())  / p.stake.sum()\n",
    "    logf = np.log(1/(1-p.f))\n",
    "    \n",
    "    epochs = np.array(range(p.epochs))\n",
    "    \n",
    "    bound = abs_diff_0 * np.abs(1 - p.h_at_fixpoint * (logf * D_infty * D0 - D02*logf**2) / (D_infty ** 3))**epochs / abs_diff_0\n",
    "    print(bound.shape, epochs.shape)\n",
    "    \n",
    "    plt.figure(figsize=(16,4), dpi=120)\n",
    "    ax_abs_diff_vs_epochs = plt.subplot()\n",
    "    # ax_abs_diff_vs_epochs.plot(epochs, np.zeros(p.epochs) + 1e-6)\n",
    "\n",
    "    # for alpha in [0.5, 1, 2]:\n",
    "    #     ax_abs_diff_vs_epochs.plot(epochs, alpha * bound, label=f\"bound $\\\\alpha={alpha}$\")\n",
    "        \n",
    "    for sim in range(p.sims):\n",
    "        ax_abs_diff_vs_epochs.plot(epochs, abs_diff_ell[sim], c=\"k\", linewidth=0.02)\n",
    "    ax_abs_diff_vs_epochs.set_title(r\"$D$ normalized err vs. $ep$\")\n",
    "    ax_abs_diff_vs_epochs.set_ylabel(r\"$D$ normalized err\")\n",
    "    ax_abs_diff_vs_epochs.set_xlabel(r\"$ep$\")\n",
    "    ax_abs_diff_vs_epochs.set_yscale(\"log\")\n",
    "    ax_abs_diff_vs_epochs.set_ylim(1e-4, None)\n",
    "    ax_abs_diff_vs_epochs.set_xlim(0, p.epochs - 1)\n",
    "    # ax_abs_diff_vs_epochs.legend()\n",
    "    ax_abs_diff_vs_epochs.set_xticks(epochs)\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52a530d7-1a1f-4d25-8668-222a96122e3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluations = 10\n",
    "def make_params(i):\n",
    "    np.random.seed(0)\n",
    "    N = 1000\n",
    "    stake = np.random.pareto(5, N)\n",
    "    scale = 10\n",
    "    p = ((i + 1) / evaluations)\n",
    "    return Params(\n",
    "        epochs=5,\n",
    "        sims=1,\n",
    "        stake = stake,\n",
    "        D_init = (1 / scale) * (1-p) + scale * stake.sum() * p,\n",
    "        T=60*60*24*5,\n",
    "        # T = 10000,\n",
    "        f=0.05,\n",
    "        beta=0.85,\n",
    "    )\n",
    "\n",
    "initial_conditions_params = [make_params(i) for i in range(evaluations)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eef3833-7bb6-465b-9c4d-a4c2b4810eb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_conditions_empirical = run_empirical_sims(initial_conditions_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cce43ea-d550-42a7-9c0e-c3bb166ed7a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "p = initial_conditions_params[i]\n",
    "r = initial_conditions_empirical[i]\n",
    "D_ratio = np.array([r.D.mean(axis=0) for r in initial_conditions_empirical]) / p.stake.sum()\n",
    "eps = np.arange(p.epochs)\n",
    "\n",
    "D_true = p.stake.sum()\n",
    "\n",
    "# _ = plt.plot(eps.repeat(evaluations).reshape(evaluations, p.epochs, ), D)\n",
    "for r in initial_conditions_empirical:\n",
    "    for D_i in r.D:\n",
    "        _ = plt.plot(eps, D_i / D_true, linewidth=0.1, c='k')\n",
    "\n",
    "# plt.yscale(\"log\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b67373d-2a39-4954-bc11-24141b2de68c",
   "metadata": {},
   "source": [
    "# Study Behaviour When Number of Nodes is Varied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82ba9ef6-466b-401a-8b4f-7e0fb3986e74",
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluations = 50\n",
    "pareto_shape = 5\n",
    "pareto_mode = 1\n",
    "def make_params(i):\n",
    "    np.random.seed(0)\n",
    "    p_i = (i + 1) / evaluations\n",
    "    N = int(10000 * p_i)\n",
    "    stake = (np.random.pareto(pareto_shape, N) + 1) * pareto_mode\n",
    "    return Params(\n",
    "        epochs=1000,\n",
    "        sims=10,\n",
    "        stake = stake,\n",
    "        D_init = stake.sum(),\n",
    "        T=60*60*24*5,\n",
    "        f=0.05,\n",
    "        beta=0.5,\n",
    "    )\n",
    "\n",
    "vary_N_params = [make_params(i) for i in range(evaluations)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72b1e50d-b2ad-4ac8-bc49-112e0e9eece3",
   "metadata": {},
   "outputs": [],
   "source": [
    "vary_N_empirical = run_empirical_sims(vary_N_params)\n",
    "vary_N_numerical = [sim_numerical(p) for p in vary_N_params]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaf2480a-1e15-444a-9c80-a665863d3915",
   "metadata": {},
   "outputs": [],
   "source": [
    "skip_epochs = 100 # we are looking at behaviour at fixedpoint\n",
    "\n",
    "N = [len(p.stake) for p in vary_N_params]\n",
    "Ew = [p.stake.mean() for p in vary_N_params]\n",
    "Vw = [p.stake.var() for p in vary_N_params]\n",
    "pop_Vw = [p.stake.var()*len(p.stake)/(len(p.stake)-1) for p in vary_N_params]\n",
    "var_D = [r.D[:,skip_epochs:].flatten().var() for r in vary_N_empirical]\n",
    "gauss_var = [gauss_field_var(f=p.f, stake=p.stake, delta=p.h_at_fixpoint, T=p.T) for p in vary_N_params]\n",
    "pareto_mean = pareto_shape*pareto_mode/(pareto_shape - 1)\n",
    "pareto_var = pareto_mode*pareto_shape/(pareto_shape-1)**2/(pareto_shape-2)\n",
    "large_mass_pareto_mean = [large_mass_mean(f=p.f, N=len(p.stake), Ew=pareto_mean, Vw=pareto_var) for p in vary_N_params]\n",
    "large_mass_pareto_var = [large_mass_var(f=p.f, N=len(p.stake), Ew=pareto_mean, Vw=pareto_var, T=p.T, delta=p.h_at_fixpoint)for p in vary_N_params]\n",
    "\n",
    "plt.figure(figsize=(16,8), dpi=120)\n",
    "ax_varD_vs_N = plt.subplot(211)\n",
    "ax_varD_vs_N.plot(N, var_D, c='k', label=\"empirical\")\n",
    "ax_varD_vs_N.plot(N, gauss_var, c='orange', label=\"large mass\")\n",
    "ax_varD_vs_N.plot(N, large_mass_pareto_mean, c='red', label=\"large mass mean pareto\")\n",
    "ax_varD_vs_N.plot(N, large_mass_pareto_var, c='blue', label=\"large mass var pareto\")\n",
    "ax_varD_vs_N.set_title(r\"$Var[D]$ vs. N\")\n",
    "ax_varD_vs_N.set_ylabel(r\"$Var[D]$\")\n",
    "ax_varD_vs_N.set_xlabel(r\"N\")\n",
    "# ax_varD_vs_N.set_yscale(\"log\")\n",
    "ax_varD_vs_N.legend()\n",
    "\n",
    "ax_w_vs_N = plt.subplot(212)\n",
    "ax_w_vs_N.plot(N, Ew, c='k', label=\"E[w_i]\")\n",
    "ax_w_vs_N.plot(N, Vw, c='red', label=\"Var[w_i]\")\n",
    "ax_w_vs_N.plot(N, np.zeros(len(vary_N_params)) + 5/(5-1), label=\"paretto E[w_i]\")\n",
    "ax_w_vs_N.plot(N, np.zeros(len(vary_N_params)) + 5/(5-1)**2/(5-2), label=\"paretto Var[w_i]\")\n",
    "ax_w_vs_N.set_title(r\"$w_i$ vs. N\")\n",
    "ax_w_vs_N.set_xlabel(r\"N\")\n",
    "# ax_w_vs_N.set_yscale(\"log\")\n",
    "ax_w_vs_N.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "print(vary_N_params[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f03ce4f2-9f89-4fc8-bf3c-7b60818bf75d",
   "metadata": {},
   "source": [
    "# ODE Modelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7dfc07e0-5ac9-40a0-9fe2-c9b0b5cb3a6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.integrate import odeint\n",
    "\n",
    "np.random.seed(0)\n",
    "stake = np.random.pareto(1, 10) + 1\n",
    "D0 = stake.sum()\n",
    "\n",
    "def vf(x, t):\n",
    "    dx = np.zeros(2)\n",
    "    dx[0] = 1.0\n",
    "    # dx[1] = -(np.log(1/(1-f)) - D0/x[1]*np.log(1/(1-f))) if x[1] != 0 else -100\n",
    "    dx[1] = -(np.log(1/(1-f)) - phi(f, stake/x[1]).sum()) if x[1] != 0 else -100\n",
    "\n",
    "    return dx\n",
    "\n",
    "\n",
    "# Solution curves\n",
    "t0 = 0.0\n",
    "tEnd = 400.0\n",
    "\n",
    "f=0.5\n",
    "\n",
    "XX = tEnd\n",
    "YY = D0 * 2\n",
    "S = 20\n",
    "# Vector field\n",
    "X, Y = np.meshgrid(np.linspace(0, XX, S), np.linspace(1e-6, YY, S))\n",
    "\n",
    "U = 1.0\n",
    "V = -(np.log(1/(1-f)) - np.array([phi(f, s/Y) for s in stake]).sum(axis=0))\n",
    "# Normalize arrows\n",
    "N = np.sqrt(U ** 2 + V ** 2)\n",
    "U = U / N\n",
    "V = V / N\n",
    "\n",
    "\n",
    "\n",
    "plt.quiver(X, Y, U, V, angles=\"xy\")\n",
    "\n",
    "t = np.linspace(t0, tEnd, 1000)\n",
    "for y0 in np.linspace(1, D0 * 2, 10):\n",
    "    y_initial = [0, y0]\n",
    "    y = odeint(vf, y_initial, t)\n",
    "    plt.plot(y[:, 0], y[:, 1], \"-\")\n",
    "# plt.plot(np.linspace(0, XX, S), np.zeros(S) + np.log(1/(1-f)), label=\"log(1/(1-f))\")\n",
    "plt.plot(np.linspace(0, XX, S), np.zeros(S) + D0, label=\"D_true\")\n",
    "\n",
    "plt.xlim([0, XX])\n",
    "plt.ylim([0, YY])\n",
    "plt.xlabel(r\"$epochs$\")\n",
    "plt.ylabel(r\"$D$\")\n",
    "plt.legend()\n",
    "_ = plt.title(\"$D' = -(\\\\log(\\\\frac{1}{1-f}) - \\\\sum \\\\phi_f(w_i / D))$\")"
   ]
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}