Delete exp5.py

[Neurips2024_16722.git] / Appendix_check_theorem.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from graph.graph_pg_extra import generate_graph_and_matrices\n",
    "import numpy as np\n",
    "import inspect \n",
    "import os\n",
    "import copy as cp \n",
    "import matplotlib\n",
    "from matplotlib.font_manager import FontProperties\n",
    "from tqdm import tqdm\n",
    "from utilities.asy_dagp_utils import update_estimates_dagp, update_variables_dagp, broadcast_dagp, save_vars_dagp\n",
    "\n",
    "from Problems.synthetic_cosh import synthetic\n",
    "from analysis.analysis import error\n",
    "from graph.graph import Random\n",
    "from utilities import utilities as ut\n",
    "from Optimizers import DOPTIMIZER as dopt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### define necessary functions that buid the delay factor\n",
    "def base_function(m, k, z_p):\n",
    "    exponent = np.abs(k - m)\n",
    "    sign = 1 if (k - m) >= 0 else -1\n",
    "    return (z_p ** exponent) * sign\n",
    "\n",
    "def term_1(m, K, z_p):\n",
    "    return 2*sum([abs(base_function(m, k, z_p)) for k in K])\n",
    "\n",
    "def term_3_inner_function(m, k1, z_p, other_ks, c):\n",
    "    \"\"\"\n",
    "    - m (int): Parameter for the base function.\n",
    "    - k1 (float): The k value for the primary base function.\n",
    "    - z_p (float): The common z_p value used in the base function.\n",
    "    - other_ks (list[float]): A list of k values for the other base functions.\n",
    "    - c (float): A scaling constant applied to the sum of the other base functions.\n",
    "    \"\"\"\n",
    "    first_term = base_function(m, k1, z_p)\n",
    "    sum_of_terms = np.float64(c) * sum([base_function(m, k, z_p) for k in other_ks])\n",
    "    return abs(first_term - sum_of_terms)\n",
    " \n",
    "def term_3(m, k1_range, z_p, other_ks_list, c_list):    \n",
    "    \"\"\"\n",
    "    - m (int): Parameter for the base function.\n",
    "    - k1_values (list[float]): A list of k1 values.\n",
    "    - z_p (float): The common z_p value used in the base function.\n",
    "    - other_ks_list (list[list[float]]): A list where each element is a list of k values for the other base functions.\n",
    "    - c_list (list[float]): A list of scaling constants for each group of other base functions.\n",
    "    \"\"\"    \n",
    "    return sum([term_3_inner_function(m, k1, z_p, other_ks, c) for k1, other_ks, c in zip(k1_range,other_ks_list,c_list)])\n",
    "\n",
    "def base_function2(m, k, z_p):\n",
    "    exponent = np.abs(k-1 - m)\n",
    "    sign = 1 if (k-1 - m) >= 0 else -1\n",
    "    return (z_p ** exponent) * sign\n",
    "\n",
    "def term_2_inner_function(m, k1, z_p, other_ks, c):\n",
    "    first_term = base_function2(m, k1, z_p)\n",
    "    sum_of_terms = np.float64(c) * sum([base_function2(m, k, z_p) for k in other_ks])\n",
    "    return abs(first_term - sum_of_terms)\n",
    " \n",
    "def term_2(m, k1_range, z_p, other_ks_list, c_list):    \n",
    "    return sum([term_2_inner_function(m, k1, z_p, other_ks, c) for k1, other_ks, c in zip(k1_range,other_ks_list,c_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_delay_matrix(seed, num_nodes, max_iter, delay_type):\n",
    "    np.random.seed(seed)\n",
    "    if delay_type == 'uniform:1-100':\n",
    "        Delay_mat = np.random.uniform(1, 100, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-50':\n",
    "        Delay_mat = np.random.uniform(1, 50, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-60':\n",
    "        Delay_mat = np.random.uniform(1, 60, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform_1-40_with_ideal':\n",
    "        Delay_mat = np.random.uniform(1, 40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        flat_matrix = Delay_mat.flatten()\n",
    "        num_zeros = int(flat_matrix.size // 2)\n",
    "        random_indices = np.random.choice(flat_matrix.size, num_zeros, replace=False)\n",
    "        flat_matrix[random_indices] = 0\n",
    "        Delay_mat = flat_matrix.reshape(Delay_mat.shape)        \n",
    "    elif delay_type == 'uniform_1-40_with_loss':\n",
    "        Delay_mat = np.random.uniform(1, 40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        flat_matrix = Delay_mat.flatten()\n",
    "        num_zeros = flat_matrix.size // 2\n",
    "        random_indices = np.random.choice(flat_matrix.size, num_zeros, replace=False)\n",
    "        flat_matrix[random_indices] = 1e7\n",
    "        Delay_mat = flat_matrix.reshape(Delay_mat.shape)   \n",
    "    elif delay_type == 'uniform:1-80':\n",
    "        Delay_mat = np.random.uniform(1, 80, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-1':\n",
    "        Delay_mat = np.random.uniform(1, 1, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-2':\n",
    "        Delay_mat = np.random.uniform(1, 2, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-3':\n",
    "        Delay_mat = np.random.uniform(1, 3, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-4':\n",
    "        Delay_mat = np.random.uniform(1, 4, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-20':\n",
    "        Delay_mat = np.random.uniform(1, 20, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-30':\n",
    "        Delay_mat = np.random.uniform(1, 30, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-40':\n",
    "        Delay_mat = np.random.uniform(1, 40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-5':\n",
    "        Delay_mat = np.random.uniform(1, 5, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-10':\n",
    "        Delay_mat = np.random.uniform(1, 10, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-500':\n",
    "        Delay_mat = np.random.uniform(1, 500, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-1000':\n",
    "        Delay_mat = np.random.uniform(1, 1000, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-50':\n",
    "        Delay_mat = np.random.uniform(1, 50, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'exp:scale:10':\n",
    "        Delay_mat = np.random.exponential(10,   size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'no_delay':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'one_node_constant_delay_500':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[:,0,:] = np.random.uniform(500,500,(num_nodes, max_iter+2))\n",
    "    elif delay_type == 'all_nodes_constant_delay_100':\n",
    "        Delay_mat = np.random.uniform(100, 100, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'all_nodes_constant_delay_500':\n",
    "        Delay_mat = np.random.uniform(500, 500, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'all_nodes_constant_delay_1000':\n",
    "        Delay_mat = np.random.uniform(1000, 1000, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == '20percent_1_link_delay_10_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2)) \n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(10,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_20_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2)) \n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(20,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_40_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2)) \n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(40,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_80_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(80,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_160_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(160,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_400_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(400,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == 'normal_150_10':\n",
    "        Delay_mat = np.random.normal(150,10, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_20':\n",
    "        Delay_mat = np.random.normal(150,20, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_40':\n",
    "        Delay_mat = np.random.normal(150,40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_80':\n",
    "        Delay_mat = np.random.normal(150,80, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_600_80':\n",
    "        Delay_mat = np.random.normal(600,80, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_0':\n",
    "        Delay_mat = np.random.normal(150,0,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_10_1':\n",
    "        Delay_mat = np.random.normal(10,1,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_10_5':\n",
    "        Delay_mat = np.random.normal(10,5,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_10_20':\n",
    "        Delay_mat = np.random.normal(10,20,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    for i in range(max_iter):\n",
    "        np.fill_diagonal(Delay_mat[:,:,i], 0)\n",
    "    range_iters = np.arange(max_iter)\n",
    "    return Delay_mat[:,:,range_iters]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tau_vu_p_m(Delay_mat, receiver, sender, min_K, max_K, z_p, m_min, m_max):\n",
    "    delay_iters  = Delay_mat[receiver,sender,:]\n",
    "    iters_num    = np.arange(len(delay_iters))\n",
    "    receive_time = np.ceil(delay_iters + iters_num)\n",
    "    unique_times = np.unique(receive_time)\n",
    "    indices_dict = {time: np.where(receive_time == time)[0] for time in unique_times}\n",
    "\n",
    "    ##### The initial iterations can be considered as a warm start. \n",
    "    K = np.arange(min_K,max_K,1)\n",
    "    empty_iters_in_this_interval     = [element for element in K if element not in indices_dict]\n",
    "    non_empty_iters_in_this_interval = [element for element in K if element in indices_dict]\n",
    "\n",
    "    Tvu_all       = []\n",
    "    c_list1       = []\n",
    "    receive_iters = []\n",
    "    c_list2       = []\n",
    "\n",
    "    for k in K:\n",
    "        if k in empty_iters_in_this_interval:\n",
    "            Tvu_all.append([])\n",
    "            c_list1.append(0)\n",
    "        elif k in non_empty_iters_in_this_interval:\n",
    "            Tvu_all.append(indices_dict[k])\n",
    "            c_list1.append(1/len(indices_dict[k]))\n",
    "\n",
    "        receive_iters.append([receive_time[k]])\n",
    "        if receive_time[k] in indices_dict:\n",
    "            c_list2.append(1/len(indices_dict[receive_time[k]]))\n",
    "\n",
    "    m_discrete_values = np.arange(m_min, m_max, 1)  \n",
    "    term1 = [term_1(m, empty_iters_in_this_interval, z_p) for m in m_discrete_values]\n",
    "    term2 = [term_2(m, K, z_p, other_ks_list=Tvu_all , c_list=c_list1) for m in m_discrete_values]\n",
    "    term3 = [term_3(m, K, z_p, other_ks_list=receive_iters, c_list=c_list2) for m in m_discrete_values]\n",
    "\n",
    "    tau_vu_p = np.array(term1)+np.array(term2)+np.array(term3)\n",
    "\n",
    "    return tau_vu_p, m_discrete_values, term1, term2, term3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def plot_sorted(in_list, show=True):\n",
    "    kappa_sorted = sorted(in_list)\n",
    "    indexed_list = list(enumerate(in_list))\n",
    "    sorted_indexed_list = sorted(indexed_list, key=lambda x: x[1])\n",
    "    sorted_indices = [index for index, value in sorted_indexed_list]\n",
    "\n",
    "    callers_local_vars = inspect.currentframe().f_back.f_locals.items()\n",
    "    var_names = [var_name for var_name, var_val in callers_local_vars if var_val is in_list]\n",
    "\n",
    "    if show:\n",
    "        plt.plot(np.arange(len(kappa_sorted)), kappa_sorted, marker='o') \n",
    "        ax = plt.gca()\n",
    "        new_tick_positions = range(len(kappa_sorted))\n",
    "        ax.set_xticks(new_tick_positions)\n",
    "        ax.set_xticklabels(sorted_indices) \n",
    "\n",
    "        plt.title(f'{var_names}')\n",
    "    return sorted_indices\n",
    "\n",
    "def compute_kappa_and_terms_max(delay_profiles, min_K, z_p, m_min, m_max, folder='check_theorem_figure', show=True):\n",
    "    matplotlib.rcParams['text.usetex'] = True\n",
    "    plt.rcParams['axes.linewidth'] = 2\n",
    "    plt.rcParams[\"font.family\"] = \"Arial\"\n",
    "    plt.rcParams['text.latex.preamble'] = r'\\usepackage{amsmath}'\n",
    "    plt.rcParams['pdf.fonttype'] = 42\n",
    "    font = FontProperties()\n",
    "    font.set_size(17)\n",
    "    linewidth = 2\n",
    "\n",
    "    kappa_list = []\n",
    "    term1_list = []\n",
    "    term2_list = []\n",
    "    term3_list = []\n",
    "    for my_delay in delay_profiles:\n",
    "        max_K = len(my_delay)\n",
    "        Delay_mat = np.zeros((4,4,len(my_delay)))\n",
    "        Delay_mat[1,0,np.arange(len(my_delay))] = my_delay\n",
    "        kappa, m_range, t1,t2,t3 = tau_vu_p_m(Delay_mat,1,0,min_K,max_K, z_p, m_min, m_max)\n",
    "        max_index_kappa = np.argmax(kappa)\n",
    "        max_value__kappa = kappa[max_index_kappa]\n",
    "        max_index_term1 = np.argmax(t1)\n",
    "        max_value__term1 = t1[max_index_term1]\n",
    "        max_index_term2 = np.argmax(t2)\n",
    "        max_value__term2 = t2[max_index_term2]\n",
    "        max_index_term3 = np.argmax(t3)\n",
    "        max_value__term3 = t3[max_index_term3]\n",
    "\n",
    "        kappa_list.append(max_value__kappa)\n",
    "        term1_list.append(max_value__term1)    \n",
    "        term2_list.append(max_value__term2)    \n",
    "        term3_list.append(max_value__term3)\n",
    "\n",
    "    if not os.path.exists(folder):\n",
    "        os.makedirs(folder)\n",
    "\n",
    "    x_axis = np.arange(len(delay_profiles))+1\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.tick_params(labelsize=19, width=3)\n",
    "    plt.scatter(x_axis, kappa_list, color='c', s=120, linewidth = linewidth)\n",
    "    plt.legend([r'\\textbf{Delay factor}'],  prop={'size': 20})\n",
    "    plt.xlabel(r'\\textbf{Delay profile}', fontsize = 18)\n",
    "    plt.grid(True, alpha=0.4)\n",
    "    path = os.path.join(folder, f'zp_{z_p}')\n",
    "    plt.savefig( path + \".pdf\", format = 'pdf', bbox_inches='tight')\n",
    "    if show:\n",
    "        plt.show()\n",
    "\n",
    "    return kappa_list, term1_list, term2_list, term3_list\n",
    "\n",
    "def plot_profile(n_dots, connections,num_profile,z_p, folder='check_theorem_figure'):\n",
    "\n",
    "    top_dots = [(i, 1) for i in range(n_dots)]\n",
    "    bottom_dots = [(i, 0) for i in range(n_dots)]\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(25,1))\n",
    "\n",
    "    for x, y in top_dots + bottom_dots:\n",
    "        ax.plot(x, y, 'o', color='c', markersize=8)\n",
    "\n",
    "    for i, j in connections:\n",
    "        ax.annotate(\"\", xy=bottom_dots[j], xycoords='data', xytext=top_dots[i], textcoords='data',\n",
    "                    arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"arc3\", color='c', linewidth=2))\n",
    "\n",
    "    ax.set_ylim(-0.1, 1.1)\n",
    "\n",
    "    if not os.path.exists(folder):\n",
    "        os.makedirs(folder)\n",
    "\n",
    "    ax.set_aspect('equal')\n",
    "    plt.axis('off')\n",
    "    path = os.path.join(folder, f'profile_{num_profile}_zp_{z_p}')\n",
    "    plt.savefig( path + \".pdf\", format = 'pdf', bbox_inches='tight')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 1\n",
      "[0, 0, 0, 0, 100000.0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 2\n",
      "[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAABhCAYAAADGD1rPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAKXklEQVR4nO3cT2xT9wEH8O/Le4bnRoBjP6chS4hhFHxw18MmbUjdukM3VGlBMECbumpD62GTpnJB2wWh/pM27bLDNvUy7RBx6FroSHPtDlsviaMiV1XEgKZtspRg4pc4NFFs7PfsHWw/HGKTBN7zs3+/7+di5SXK+31/+fnrX+xnK+VyuQwiIup4XX4PgIiI3MFCJyISBAudiEgQLHQiIkGw0ImIBMFCJyISBAudiEgQLHQiIkGw0ImIBKF5+cvzto1LmQxGTROLxSIigQCOGwZOR6PQVdXLU7cF5pc7P8A5YP7W5le8euv/mGnizPXryFoWugCUAOe2R9MwEo9j2DC8OHVbYH658wOcA+ZvfX5PCn3MNHF8agoA0OiXK9Xb0UQCxwT8gzK/3PkBzgHz+5Pf9ULP2zb6x8exbFkNgzgnBhDSNMwfOSLUv17ML3d+gHPA/P7ld/1F0UuZDLKbBAEqj1pZy8LlTMbtIfiK+eXOD3AOmN+//K4X+qhpbvmXdgG4YppuD8FXzC93foBzwPz+5Xe90BeLRZS2+LMlAEvFottD8BXzy50f4Bwwv3/5XS/0SCCwrUencCDg9hB8xfxy5wc4B8zvX37XC/24YWzr0emEYK9wM7/c+QHOAfP7l9/1Qj8djaJH05zLcppRULkW81Q06vYQfMX8W8sPAMGuLuHyA1wDzO9fftcLXVdVjMTjANA0UO34SDwu1OVKAPNvJX9NrlTC327f9n5QLcY1wPx+5ffks1yGDQOjiQRC2vpPFqiFCGka3k8khH2XWLP8NbLlry2y2q2u3F/mZ6en8Zcvv2ztAFug2RqozYFsa6BG9g7wOr9nb/0HKhfYn/vsM7w1Pw8A+EZ3N347OIhTEn2Ow5/m5nB+ZgYAENN1vBmLSZX/ciaDK6aJpWIR4UAAJwwDJw0Df5ibw5uzs87P/vngQbwyMODjaL2Rt23sTyaRLhSgKQqORSI4YRhSrYHvplL4aHUVAPBCOIwXe3ulyv+Ta9cwtrgIAHh29278qr/fs/yefjiXrqp4ds8ep9Bf3rsXL/X1eXnKtqKrKn5kGE6h/7CnR7r8L/X1Ncz8eiwGAE6pn52eBgDhSl1XVexWVaQB7FJVvJdI+D2kltJVFYO67hT63w8fxt6dO30eVevoqoqnu7udQn81FsPz4bBn5+PH55IvFEXB67EYLgwNOcdEffqFqFVY6OQbljqRu1jo5CuWOpF7WOjkO5Y6kTtY6NQWWOpEj4+FTm2DpU70eFjo1FZY6kSPjoVObYelTvRoWOjUlljqRNvHQqe2xVIn2h4WOrU1ljrR1rHQqe2x1Im2hoVOHYGlTrQ5Fjp1DJY60cOx0KmjsNSJmmOhU8dhqRM1xkKnjsRSJ9qIhU4di6VOtB4LnToaS53oPhY6dTyWOlEFC52EwFInYqGTQFjqJDsWOgmFpU4yY6GTcFjqJCsWOgmJpU4yYqGTsFjqJBsWOgmNpU4yYaGT8FjqJAsWOkmBpU4yYKGTNFjqJDoWOkmFpU4iY6GTdFjqJCoWOkmJpU4iYqGTtFjqJBoWOkmNpU4iYaGT9FjqJAoWOhFY6iQGFjpRFUudOh0LnagOS506GQud6AEsdepULHSiBljq1IlY6ERNsNSp07DQiR6CpU6dxLNCX7UszORyG47P5fP4yrK8Om3buFcqYXptDeVyed3xO4UCzELBp1HRo3jUUv9fPo+VB9b6mm3ji1xuw7oQUaO1bpfLmF5bg1Uq+TSq1skWi5i/d2/D8c9zOeRs25NzelLoVqmEI6kU9ieT+CCbdY6nVlYQm5jAMx99tGGhi+Zn167hqclJ/HFuzjm2UCjgYDKJA8kkptfWfBwdbdd2S/2dhQUMTUzgW1evwq6Wd7lcxvdSKRxIJvHW/HxLxu2Xqysr2Dc+jvjk5Lr7+m8+/RRPTU7i7PS0j6Pz3p1CAYcnJ7F/YgKf121sL965g68nk3jhk088Oa8nha4oCq5XC+udhQXn+OjiIkoAZvJ5FATfodys/hH/UZc/ubKCVdvGim0jzV16x9ms1EfSaTyXSuHf2SxuVtf/zVwOy9VCK5TLuLq6CgC4IfgD+mz1Pr5oWfhvXdaxxUUAcOZHVMuWhUyxiEK5jH8tLzvH3672wY0Gz164wZNCVxUFP3/ySQDAWt2/VrWFPRyJIBIIeHHqtvGLvj4AQP3D1u1qiR8KBvGd3bt9GBU9roeV+mszM/jw7l388sYNvNjbC7X6/Wx13efq7gu19SGqo+Eweqv38VsNNi9nBM9/KBjEt3ftAgBkikXneLG6kfUqv2fPoZ8fGnIW9INejcW8Om3b+HV/v7OgH3RhaAhaF1+P7lTNSn2nogAAvsjnkbUsp7RrNV57cB+ORPDN6p1dVN2qit/t29fwe4eCQfy0t7fFI2otRVHwWpOe6+7qwrmBAU/O61mrHAgGG+5CZFjMQPMFLcNilkGjUq//N/rdTKbppkaGDQ3QfFMjy4bmaDjs7NLrvTIwAGPHDk/O6emsnh8a2nACWRYzUFnQYU1bd0yWxSyDkXQa72UyiD/xxIbvXcpksF/XN2xqZNnQAI03NQd0XZoNTaNduu7h7hzwuNAPBIN4LhRyvn66u1uaxQxUFvTLe/c6X4dUVZrFLIO/3rqFa2trzgUA9WbyeVxdWcH5uh08INeGBqhsampPRQHAucFBqTY0R8NhfK1uN/5jw/Bsdw54XOh528YPQiHU/px7VBUX02nkPboGs93kbRsHdR1adUEP6jreXliQKv/FdBonp6bw/VQKJ6emhPr7X4jFEH3Ii/tvzM6if8cOPNPdDQDYpar4/eysUHOwGRXA8z09AICAouCDpSWp8t8rlXAsEgFQKdtssehpfqXs0TscxkwTZ65fR9ayoKDyglAXKi8Q9WgaRuJxDBuGF6duC8x/P38tt4j5rVIJH969i3cXFvBP01x3RUNE01ACuAaYv2X5PSn0MdPE8akpAOsv23NOWr0dTSRwTMA/KPPLmd8qlfCf5WW8MTuLj1dX8ZVtO3fkB4k6BzWyroEav/K7Xuh520b/+DiWLathEOfEAEKahvkjR6CrzS5w7DzML3d+gHPA/P7ld/059EuZDLKbBAEqj1pZy8LlTMbtIfiK+eXOD3AOmN+//K4X+qhpbvmXdgG4YppuD8FXzC93foBzwPz+5Xe90BeLRWz1c9RKAJbqXkQSAfPLnR/gHDC/f/ldL/RIILCtR6ewYJ/pwvxy5wc4B8zvX37XC/24YWzr0emEYK9wM7/c+QHOAfP7l9/1Qj8djaJH06Bs8nMKKtdinopG3R6Cr5hf7vwA54D5/cvveqHrqoqReBwAmgaqHR+Jx4W6XAlgftnzA5wD5vcvvydv/R82DIwmEghVP5iqdpLabUjT8H4iIey7xJhf7vwA54D5/cnv2Vv/gcoF9pczGVwxTSwViwgHAjhhGDgVjQr3qNwI88udH+AcMH9r83ta6ERE1DryfI4lEZHgWOhERIJgoRMRCYKFTkQkCBY6EZEgWOhERIJgoRMRCYKFTkQkiP8DHLzRb9AeBAcAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 3\n",
      "[0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 4\n",
      "[0, 0, 0, 100000.0, 100000.0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 5\n",
      "[0, 0, 0, 10000000.0, 1, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 6\n",
      "[0, 0, 0, 2, 1000000.0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 7\n",
      "[0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay profile 8\n",
      "[0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "delay_profiles_connections =[[(0, 0), (1, 1), (3, 3), (4, 4), (5, 5)],\n",
    "                             [(0, 0), (3, 3), (4, 4), (5, 5)],\n",
    "                             [(0, 0), (1, 1), (2, 3), (3, 3), (4, 4), (5, 5)],\n",
    "                             [(0, 0), (1, 3), (3, 3), (4, 4), (5, 5)],\n",
    "                             [(0, 0), (1, 3), (2, 3), (3, 3), (4, 4), (5, 5)],\n",
    "                             [(0, 0), (2, 3), (3, 3), (4, 4), (5, 5)],\n",
    "                             [(0, 0), (1, 4), (2, 3), (3, 3), (4, 4), (5, 5)],\n",
    "                             [(0, 0), (1, 1), (2, 4), (3, 3), (4, 4), (5, 5)]\n",
    "                             ]\n",
    "\n",
    "delay_profiles = [\n",
    "                  [0,0,0,0,1e5,0,0,0,0,0,0],\n",
    "                  [0,0,0,1e5,1e5,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,1,0,0,0,0,0,0],\n",
    "                  [0,0,0,2,1e6,0,0,0,0,0,0],\n",
    "                  [0,0,0,2,1,0,0,0,0,0,0],\n",
    "                  [0,0,0,1e7,1,0,0,0,0,0,0],\n",
    "                  [0,0,0,3,1,0,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,2,0,0,0,0,0,0,0],\n",
    "                  ]\n",
    "\n",
    "\n",
    "z_p     = 0.9\n",
    "min_K   = 0\n",
    "m_min   = -5\n",
    "m_max   = 15\n",
    "\n",
    "\n",
    "kapaa_list, t1_list, t2_list, t3_list   = compute_kappa_and_terms_max(delay_profiles, min_K, z_p, m_min, m_max, show=False )\n",
    "sorted_indicies_kappa                   = plot_sorted(kapaa_list, show=False)\n",
    "reordered_delay_profiles_connections    = [delay_profiles_connections[i] for i in sorted_indicies_kappa]\n",
    "reordered_delay_profiles                = [delay_profiles[i] for i in sorted_indicies_kappa]\n",
    "kappa_final, _, _, _                    = compute_kappa_and_terms_max(reordered_delay_profiles, min_K, z_p, m_min, m_max , show=True)\n",
    "\n",
    "\n",
    "for connections, delays, i in zip(reordered_delay_profiles_connections, reordered_delay_profiles, np.arange(len(delay_profiles_connections))):\n",
    "    print(f'delay profile {i+1}')\n",
    "    print(delays)\n",
    "    plot_profile(6,connections,i+1,z_p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## delay factor on real delay matrix and real environment \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### no need to sum over all links, they behave approximately the same, the maximum has a mean and variance and we should consider the mean by the law of large numbers.\n",
    "\n",
    "num_runs    = 100\n",
    "z_p         = 0.95\n",
    "min_K       = 2000\n",
    "max_K       = 2300\n",
    "m_min       = 1950\n",
    "m_max       = 2350\n",
    "u = 0 \n",
    "v = 1 \n",
    "\n",
    "\n",
    "delay_types   = ['uniform:1-20','uniform:1-40', 'uniform:1-60', 'uniform_1-40_with_ideal', 'uniform_1-40_with_loss']\n",
    "results_delay = []\n",
    "\n",
    "for d_type in delay_types:\n",
    "    results = np.zeros((num_runs,m_max-m_min))\n",
    "    print(d_type)\n",
    "    for run in tqdm(range(num_runs)):\n",
    "        seed = np.random.randint(1000000)\n",
    "        num_nodes = 4\n",
    "        max_iters = 20000\n",
    "\n",
    "        if d_type == 'uniform_1-40_with_ideal':\n",
    "            Delay_mat = compute_delay_matrix(seed, num_nodes, max_iters, delay_type='uniform:1-40')\n",
    "            flat_matrix = Delay_mat.flatten()\n",
    "            num_zeros = int(flat_matrix.size * 0.5)\n",
    "            random_indices = np.random.choice(flat_matrix.size, num_zeros, replace=False)\n",
    "            flat_matrix[random_indices] = 0\n",
    "            Delay_mat = flat_matrix.reshape(Delay_mat.shape)        \n",
    "        elif d_type == 'uniform_1-40_with_loss':\n",
    "            Delay_mat = compute_delay_matrix(seed, num_nodes, max_iters, delay_type='uniform:1-40')\n",
    "            flat_matrix = Delay_mat.flatten()\n",
    "            num_zeros = int(flat_matrix.size * 0.5)\n",
    "            random_indices = np.random.choice(flat_matrix.size, num_zeros, replace=False)\n",
    "            flat_matrix[random_indices] = 1e7\n",
    "            Delay_mat = flat_matrix.reshape(Delay_mat.shape)   \n",
    "        else:\n",
    "            Delay_mat = compute_delay_matrix(seed, num_nodes, max_iters, delay_type=d_type)\n",
    "\n",
    "        kappa, m_range, _, _, _ = tau_vu_p_m(Delay_mat,v,u,min_K,max_K, z_p, m_min, m_max)\n",
    "        results[run,:] = cp.deepcopy(kappa)\n",
    "    results_delay.append(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "matplotlib.rcParams['text.usetex'] = True\n",
    "plt.rcParams['axes.linewidth'] = 2\n",
    "plt.rcParams[\"font.family\"] = \"Arial\"\n",
    "plt.rcParams['text.latex.preamble'] = r'\\usepackage{amsmath}'\n",
    "plt.rcParams['pdf.fonttype'] = 42\n",
    "font = FontProperties()\n",
    "font.set_size(17)\n",
    "font2 = FontProperties()\n",
    "font2.set_size(17)\n",
    "mark_every = 50000\n",
    "linewidth = 2\n",
    "folder   = 'check_thm_real_profiles_avg50' \n",
    "\n",
    "if not os.path.exists(folder):\n",
    "    os.makedirs(folder)\n",
    "\n",
    "colors = plt.cm.tab20(np.linspace(0, 1, len(delay_types)+1))\n",
    "\n",
    "legend_list = []\n",
    "%matplotlib inline\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.tick_params(labelsize=18, width=3)\n",
    "for iii in range(len(delay_types)):\n",
    "    mean_values = np.mean(results_delay[iii], axis=0)\n",
    "    std_dev_values = np.std(results_delay[iii], axis=0)\n",
    "    legend_list.append(delay_types[iii])\n",
    "\n",
    "    plt.errorbar(m_range, mean_values, yerr=std_dev_values, fmt='none', ecolor=colors[iii], alpha=0.2)\n",
    "    plt.plot(m_range, mean_values, color=colors[iii], linewidth=2)\n",
    "# plt.legend(legend_list)\n",
    "plt.legend(['$U(1,20)$', '$U(1,40)$', '$U(1,60)$', r'$U(1,40)$, with 50\\% ideal', r' $U(1,40)$, with 50\\% missed'], prop={'size': 16})\n",
    "plt.grid(True, alpha=0.4)\n",
    "# plt.legend([r'\\textbf{Delay factor}'],  prop={'size': 20})\n",
    "plt.xlabel(r'$m$', fontsize = 18)\n",
    "plt.ylabel(r'\\textbf{Delay factor}', fontsize = 18)\n",
    "path = os.path.join(folder, 'kappa_new2')\n",
    "plt.savefig( path + \".pdf\", format = 'pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### now run the asy-dagp for those profile for several times and compute average. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Asy_DAGP_init(seed, prd, num_nodes, dim, max_iter, min_delay, max_delay, neighbors, expScale_delay, delay_type, cons=False, drop_msg=False, drop_prob=0.001):\n",
    "    z = np.random.randn(num_nodes,dim) \n",
    "    if cons:\n",
    "        x = prd.network_projection(z) \n",
    "    else:\n",
    "        x = cp.deepcopy(z)\n",
    "\n",
    "    Message=[[[] for a in range(num_nodes)] for aa in range(num_nodes)]\n",
    "\n",
    "    f_grad = prd.networkgrad(x)\n",
    "    g = np.zeros(f_grad.shape)\n",
    "    h = np.zeros(g.shape)\n",
    "    p = np.zeros(g.shape)\n",
    "\n",
    "    # print(delay_type)\n",
    "    np.random.seed(seed)\n",
    "    if delay_type == 'uniform:1-100':\n",
    "        Delay_mat = np.random.uniform(1, 100, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-50':\n",
    "        Delay_mat = np.random.uniform(1, 50, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-60':\n",
    "        Delay_mat = np.random.uniform(1, 60, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform_1-40_with_ideal':\n",
    "        Delay_mat = np.random.uniform(1, 40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        flat_matrix = Delay_mat.flatten()\n",
    "        num_zeros = int(flat_matrix.size // 2)\n",
    "        random_indices = np.random.choice(flat_matrix.size, num_zeros, replace=False)\n",
    "        flat_matrix[random_indices] = 0\n",
    "        Delay_mat = flat_matrix.reshape(Delay_mat.shape)        \n",
    "    elif delay_type == 'uniform_1-40_with_loss':\n",
    "        Delay_mat = np.random.uniform(1, 40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        flat_matrix = Delay_mat.flatten()\n",
    "        num_zeros = flat_matrix.size // 2\n",
    "        random_indices = np.random.choice(flat_matrix.size, num_zeros, replace=False)\n",
    "        flat_matrix[random_indices] = 1e7\n",
    "        Delay_mat = flat_matrix.reshape(Delay_mat.shape)   \n",
    "    elif delay_type == 'uniform:1-80':\n",
    "        Delay_mat = np.random.uniform(1, 80, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-1':\n",
    "        Delay_mat = np.random.uniform(1, 1, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-2':\n",
    "        Delay_mat = np.random.uniform(1, 2, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-3':\n",
    "        Delay_mat = np.random.uniform(1, 3, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-4':\n",
    "        Delay_mat = np.random.uniform(1, 4, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-20':\n",
    "        Delay_mat = np.random.uniform(1, 20, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-30':\n",
    "        Delay_mat = np.random.uniform(1, 30, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-40':\n",
    "        Delay_mat = np.random.uniform(1, 40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-5':\n",
    "        Delay_mat = np.random.uniform(1, 5, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-10':\n",
    "        Delay_mat = np.random.uniform(1, 10, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-500':\n",
    "        Delay_mat = np.random.uniform(1, 500, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-1000':\n",
    "        Delay_mat = np.random.uniform(1, 1000, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'uniform:1-50':\n",
    "        Delay_mat = np.random.uniform(1, 50, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'exp:scale:10':\n",
    "        Delay_mat = np.random.exponential(10,   size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'no_delay':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'one_node_constant_delay_500':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[:,0,:] = np.random.uniform(500,500,(num_nodes, max_iter+2))\n",
    "    elif delay_type == 'all_nodes_constant_delay_100':\n",
    "        Delay_mat = np.random.uniform(100, 100, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'all_nodes_constant_delay_500':\n",
    "        Delay_mat = np.random.uniform(500, 500, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'all_nodes_constant_delay_1000':\n",
    "        Delay_mat = np.random.uniform(1000, 1000, size=(num_nodes,num_nodes,max_iter+2))\n",
    "    elif delay_type == 'counter_example_one_node_fails': ## all messages are lost\n",
    "        Delay_mat = np.random.uniform(min_delay, max_delay, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[:,0,:] = np.random.normal(1e10, 0, (num_nodes, max_iter+2))\n",
    "    elif delay_type == '20percent_1_link_delay_10_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2)) \n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(10,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_20_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2)) \n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(20,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_40_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2)) \n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(40,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_80_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(80,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_160_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(160,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == '20percent_1_link_delay_400_others_ideal':\n",
    "        Delay_mat = np.zeros((num_nodes,num_nodes,max_iter+2))\n",
    "        np.random.seed(seed)\n",
    "        rand_iters = np.random.randint(1, max_iter, size=int(max_iter/5))\n",
    "        Delay_mat[:,0, rand_iters] = np.random.normal(400,0,(num_nodes,len(rand_iters)))\n",
    "    elif delay_type == 'normal_150_10':\n",
    "        Delay_mat = np.random.normal(150,10, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_20':\n",
    "        Delay_mat = np.random.normal(150,20, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_40':\n",
    "        Delay_mat = np.random.normal(150,40, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_80':\n",
    "        Delay_mat = np.random.normal(150,80, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_600_80':\n",
    "        Delay_mat = np.random.normal(600,80, size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_150_0':\n",
    "        Delay_mat = np.random.normal(150,0,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_10_1':\n",
    "        Delay_mat = np.random.normal(10,1,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_10_5':\n",
    "        Delay_mat = np.random.normal(10,5,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    elif delay_type == 'normal_10_20':\n",
    "        Delay_mat = np.random.normal(10,20,  size=(num_nodes,num_nodes,max_iter+2))\n",
    "        Delay_mat[Delay_mat < 0] = 0\n",
    "    for i in range(max_iter):\n",
    "        np.fill_diagonal(Delay_mat[:,:,i], 0)\n",
    "\n",
    "    active_set= []\n",
    "\n",
    "    A = np.zeros((num_nodes,num_nodes,dim))\n",
    "    for node in range(num_nodes):\n",
    "        A[node,node,:] = x[node,:]\n",
    "    B = np.zeros((num_nodes,num_nodes,dim))\n",
    "\n",
    "    for node in range(num_nodes):\n",
    "        Message, _ = broadcast_dagp(node, x, p, current=0, Delay_mat=Delay_mat, Message=Message, itr=0, dropping_msg=drop_msg, dropping_prob=drop_prob, neighbors=neighbors)\n",
    "\n",
    "    x_out = [cp.deepcopy(x)]\n",
    "    z_out = [cp.deepcopy(z)]\n",
    "    g_out = [cp.deepcopy(g)]\n",
    "    h_out = [cp.deepcopy(h)]\n",
    "    p_out = [cp.deepcopy(p)]\n",
    "\n",
    "    return x, z,  Message, Delay_mat, f_grad, g, h, p, A, B, active_set, x_out, z_out, g_out, h_out, p_out\n",
    "\n",
    "\n",
    "def Asy_DAGP(seed, T_active, Tv_nodes, prd, R, C, learning_rate, max_iter, num_nodes, dim, rho, alpha, alpha_vr, eta, neighbors, \\\n",
    "        cons = False, delay_type='uniform', min_delay=0, max_delay=10, expScale_delay=10, drop_msg=False, drop_prob=0.001):\n",
    "\n",
    "    x, z, Message, Delay_mat, f_grad, g, h, p, A, B, active_set, x_out, z_out, g_out, h_out, p_out = Asy_DAGP_init(seed, prd, num_nodes, dim, \\\n",
    "            max_iter=max_iter, min_delay=min_delay, max_delay=max_delay, neighbors=neighbors, expScale_delay=expScale_delay,\\\n",
    "                  delay_type=delay_type, cons=cons, drop_msg=drop_msg, drop_prob=drop_prob)\n",
    "\n",
    "    drop_counter = 0\n",
    "    itr = 0\n",
    "    for t_active in T_active[1:max_iter]:\n",
    "        itr += 1\n",
    "        active_set.append(ut.active_set(t_active, Tv_nodes))\n",
    "        \n",
    "        for node in active_set[-1]:\n",
    "            z, x, g, p, h, f_grad = update_variables_dagp(node,prd,z,x,g,p,h,f_grad,R,learning_rate,alpha,eta,alpha_vr,rho,C,A,B,cons)\n",
    "            \n",
    "        for node in active_set[-1]:\n",
    "            Message, tmp_counter  = broadcast_dagp(node, x, p, t_active, Delay_mat, Message, itr, dropping_msg=drop_msg, dropping_prob=drop_prob, neighbors=neighbors)\n",
    "            drop_counter += tmp_counter\n",
    "\n",
    "        for node in active_set[-1]:\n",
    "            Message, A, B = update_estimates_dagp(node, Message, A, B, dim, t_active, neighbors)\n",
    "            \n",
    "        x_out, z_out, g_out, h_out, p_out = save_vars_dagp(x,z,g,h,p, x_out, z_out, g_out, h_out, p_out)\n",
    "        # ut.monitor('ASY-DAGP',itr,max_iter)\n",
    "    if drop_msg:\n",
    "        print(f'number of dropped messages: {drop_counter}')\n",
    "\n",
    "    return x_out, z_out, g_out, h_out, p_out, Delay_mat\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed         = np.random.randint(12345)  \n",
    "np.random.seed(seed)\n",
    "\n",
    "num_nodes    = 4\n",
    "dim          = 8\n",
    "mincomp      = np.array([1,1,1,1,1,1,1,1,1,1])\n",
    "maxcomp      = np.array([1,1,1,1,1,1,1,1,1,1])\n",
    "\n",
    "T_active_exp1, Tv_nodes_exp1, node_comp_time_exp1 = \\\n",
    "    ut.create_computation_time(num_nodes, max_iter=int(1e5), comp_time_dist='random_uniform' , mean_comp=None,\\\n",
    "                                      min_comp = mincomp, max_comp=maxcomp, variance_comp=None, make_integer=True) \n",
    "\n",
    "                                   \n",
    "learning_rate     = 0.01\n",
    "max_iter_asyn     = 6000\n",
    "\n",
    "rho               = 0.01         \n",
    "alpha             = 0.1\n",
    "gamma             = 0.5\n",
    "eta               = 1.0\n",
    "\n",
    "graph_prob        = 1.0\n",
    "drop_prob         = 0.0\n",
    "\n",
    "\n",
    "prd = synthetic(seed, num_nodes, dim)\n",
    "error_prd = error(prd,np.zeros(num_nodes),0)\n",
    "\n",
    "zero_row_sum,zero_column_sum,row_stochastic,col_stochastic,N_out,neighbors = Random(num_nodes, prob=graph_prob, Laplacian_dividing_factor= 2).directed()\n",
    "\n",
    "expScale = 1/10.\n",
    "\n",
    "delay_types   = ['uniform:1-20','uniform:1-40', 'uniform:1-60', 'uniform_1-40_with_ideal', 'uniform_1-40_with_loss' ]\n",
    "\n",
    "num_runs = 10\n",
    "\n",
    "x_asy_dagp_list = []\n",
    "f_asy_dagp_list = []\n",
    "\n",
    "for delay_type in delay_types:\n",
    "    print(delay_type)\n",
    "    results2 = np.zeros((num_runs,max_iter_asyn))\n",
    "    for run in tqdm(range(num_runs)):\n",
    "        seed = np.random.randint(1000000)\n",
    "        x_asy_dagp, z_asy_dagp, g_asy_dagp, h_asy_dagp, p_asy_dagp, Delay_mat_dagp = \\\n",
    "            Asy_DAGP(seed, T_active_exp1, Tv_nodes_exp1,  prd, zero_row_sum, zero_column_sum, learning_rate, max_iter_asyn, num_nodes, dim, rho, alpha, gamma, eta, neighbors, \\\n",
    "                    cons = False, delay_type=delay_type, min_delay=None, max_delay=None, expScale_delay=expScale, \\\n",
    "                        drop_msg=False, drop_prob=drop_prob)\n",
    "        f_asy_dagp = error_prd.cost_path(np.sum(x_asy_dagp,  axis=1)/num_nodes) \n",
    "        results2[run,:] = cp.deepcopy(f_asy_dagp)\n",
    "    f_asy_dagp_list.append(results2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "\n",
    "if not os.path.exists(folder):\n",
    "    os.makedirs(folder)\n",
    "\n",
    "### find the optimal solution\n",
    "x_dagp, _, _, _  = dopt.DAGP(prd, zero_row_sum, zero_column_sum, 0.01, 120000, np.random.randn(num_nodes,dim), rho , alpha, cons = False)\n",
    "\n",
    "f_dagp = error_prd.cost_path(np.sum(x_dagp,  axis=1)/num_nodes) \n",
    "f_opt  = f_dagp[-1]\n",
    "\n",
    "colors = plt.cm.tab20(np.linspace(0, 1, len(delay_types)+1))\n",
    "delay_types   = ['uniform:1-20','uniform:1-40', 'uniform:1-60', 'uniform_1-40_with_ideal', 'uniform_1-40_with_loss' ]\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "# plt.figure(figsize=(10, 6))\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "legend_list =[]\n",
    "plt.grid(True, alpha=0.4)\n",
    "plt.yscale('log')\n",
    "\n",
    "plt.tick_params(labelsize=18, width=3)\n",
    "\n",
    "\n",
    "for iii in range(len(delay_types)):\n",
    "    mean_values = np.mean(f_asy_dagp_list[iii], axis=0)\n",
    "    std_dev_values = np.std(f_asy_dagp_list[iii], axis=0)\n",
    "    legend_list.append(delay_types[iii])\n",
    "    plt.plot(np.arange(max_iter_asyn), mean_values-f_opt, color=colors[iii], linewidth=2)\n",
    "\n",
    "plt.xlim(-100,6000)\n",
    "plt.ylim(1e-10,1e1)\n",
    "plt.legend(['$U(1,20)$', '$U(1,40)$', '$U(1,60)$', r'$U(1,40)$, with 50\\% ideal', r' $U(1,40)$, with 50\\% missed'], prop={'size': 16})\n",
    "plt.xlabel(r'\\textbf{{Time units}}', fontsize = 18)\n",
    "plt.ylabel(r'\\textbf{{Optimality gap}}', fontsize = 18)\n",
    "path = os.path.join(folder, 'objective_delay_type_new2')\n",
    "\n",
    "\n",
    "# plt.xlim(3200, 4200)\n",
    "# plt.ylim(1e-10, 1e-8)\n",
    "# plt.title(r'\\textbf{zoomed in}', fontsize = 18)\n",
    "# plt.tick_params(labelsize=22, width=3)\n",
    "# path = os.path.join(folder, 'objective_delay_type_zoom_new2')\n",
    "\n",
    "\n",
    "plt.savefig( path + \".pdf\", format = 'pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "OT",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}