01_MD_reputation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import json \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "import json \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "from collections import defaultdict\n",
    "import sys\n",
    "\n",
    "sys.path.insert(0, '../')\n",
    "\n",
    "\n",
    "from trust.pagerank import PersonalizedPageRank, PersonalizedPageRankNx\n",
    "from trust.hitting_time import PersonalizedHittingTime\n",
    "from trust.maxflow_based import MaxFlow, BarterCast\n",
    "\n",
    "from trust.seed_choice import get_seed_rep_max\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# MakerDAO reputation evolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from networkx.readwrite import json_graph\n",
    "import json\n",
    "\n",
    "l = 153\n",
    "G_t  = []\n",
    "\n",
    "for i in range(l):\n",
    "    with open('../datasets/sourcecred/makerDao_work/wg'+str(i)+'.json', 'r') as f:\n",
    "        d = json.loads(f.read())\n",
    "        G = json_graph.node_link_graph(d)\n",
    "        # Normalize the weights to [1, inf]\n",
    "        for e in list(G.edges()):\n",
    "            G[e[0]][e[1]]['weight'] *= 4\n",
    "        G_t.append(G)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "id_to_user = {}\n",
    "with open('../datasets/sourcecred/md_users.txt', 'r') as outfile1:\n",
    "    vals = outfile1.read()\n",
    "    for v in vals.split('\\n'):\n",
    "        vals_s = v.split(',')\n",
    "        if len(vals_s) == 2:\n",
    "            id_to_user[vals_s[0]] = vals_s[1]    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Reputation calculation \n",
    "\n",
    "1. We assume initial period of bootstrap: T weeks. In the boostrap weeks the seeds are chosen randomly in the network. \n",
    "2. Reputation is calculated as a random walk-based metric run from the seed node. \n",
    " - We take into account the weight of the edges. \n",
    " - Random walks probability are calculated based on the weights. \n",
    "\n",
    "3. On the next rounds the seed is chosed based on previous rounds. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def normalize(rep_vals):\n",
    "    \"\"\"Normalize reputation values to [0, 1].\"\"\"\n",
    "    max_rep = sum(rep_vals.values())\n",
    "    new_vals = {}\n",
    "    for v in rep_vals:\n",
    "        new_vals[v] = rep_vals[v] / max_rep\n",
    "    return new_vals\n",
    "\n",
    "def build_aux_graph(G, seed_node):\n",
    "    H = G.copy()\n",
    "    for e in G.edges():\n",
    "        if e[0] != seed_node:\n",
    "            H[e[0]][e[1]]['weight'] = G[e[0]][e[1]]['weight'] / G.out_degree(e[0], weight='weight')\n",
    "    return H\n",
    "\n",
    "def decay_aux_graph(G, seed_node, p=0.85):\n",
    "    lvl = 0\n",
    "    cur_s = {seed_node}\n",
    "    next_s = set()\n",
    "\n",
    "    for f,t,_ in nx.edge_bfs(G, seed_node, orientation='original'):\n",
    "        if f in cur_s:\n",
    "            next_s.add(t)\n",
    "            G[f][t]['weight'] *= p**lvl\n",
    "        else:\n",
    "            # Start of new level \n",
    "            lvl += 1\n",
    "            cur_s = next_s.copy()\n",
    "            next_s = {t}\n",
    "            G[f][t]['weight'] *= p**lvl\n",
    "    return G\n",
    "\n",
    "def seed_flow_graph(G, seed_node, flow_node):\n",
    "    H = G.copy()\n",
    "    for e2 in G[seed_node]:\n",
    "        if e2 != flow_node:\n",
    "            H.remove_edge(seed_node, e2)\n",
    "    return H\n",
    "\n",
    "\n",
    "def aux_max_flow(G, seed_node, decay_p = 0.85):\n",
    "    T = build_aux_graph(G, seed_node)\n",
    "    T = decay_aux_graph(T, seed_node, decay_p)\n",
    "    new_vals = {}\n",
    "\n",
    "    for i in T.nodes():\n",
    "        if i != seed_node:\n",
    "            new_vals[i] = nx.maximum_flow_value(T, seed_node, i, capacity='weight')\n",
    "    return new_vals\n",
    "\n",
    "    #for e in T[seed_node]:\n",
    "    #    H = seed_flow_graph(T, seed_node, e)\n",
    "    #    f_w = H[seed_node][e]['weight']\n",
    "    #    rep_vals[e] += f_w \n",
    "    \n",
    "\n",
    "def simple_maxflow(G, seed_node, rep_vals):\n",
    "    for i in G.nodes():\n",
    "        if i != seed_node:\n",
    "            rep_vals[i] += nx.maximum_flow_value(G, seed_node, i, capacity='weight')\n",
    "\n",
    "\n",
    "def simple_pht(G, seed_node, rep_vals, decay_p: float, use_weight: bool = True):\n",
    "    pht = PersonalizedHittingTime(G, seed_node, reset_probability=1-decay_p)\n",
    "    weight_mult = G.out_degree(seed_node, weight='weight') if use_weight else 1.0\n",
    "    for i in G.nodes():\n",
    "        if i != seed_node:\n",
    "            rep_vals[i] += weight_mult * pht.compute(seed_node, i)\n",
    "\n",
    "\n",
    "def simple_ppr(G, seed_node, rep_vals, decay_p: float, use_weight: bool = True):\n",
    "    pht = PersonalizedPageRank(G, seed_node, reset_probability=1-decay_p)\n",
    "    weight_mult = G.out_degree(seed_node, weight='weight') if use_weight else 1.0\n",
    "    for i in G.nodes():\n",
    "        if i != seed_node:\n",
    "            rep_vals[i] += weight_mult *  pht.compute(seed_node, i)\n",
    "\n",
    "\n",
    "# Personalized PageRank \n",
    "# Personalized Hitting Time \n",
    "# Personalized MaxFlow\n",
    "# MeritRank\n",
    "\n",
    "\n",
    "def pick_seeds(new_seeds, num_seeds):\n",
    "    cur_seeds = []\n",
    "    selected_seeds = 0\n",
    "    while selected_seeds < num_seeds:\n",
    "        for s in new_seeds:\n",
    "            if s in G and G.out_degree(s) > 0:\n",
    "                cur_seeds.append(s)\n",
    "                selected_seeds += 1\n",
    "                if selected_seeds == num_seeds:\n",
    "                    return cur_seeds\n",
    "        if selected_seeds != num_seeds:\n",
    "            print('Cannot find enough seeds!')\n",
    "            print(new_seeds)\n",
    "            return None\n",
    "    \n",
    "def agg_rep_update(G: nx.Graph, seed_node: int, rep_alg, **rep_params):\n",
    "    \"\"\"Update reputation values based on the accumulated reputation.\"\"\"\n",
    "    new_rep = {}\n",
    "    rep = rep_alg(G, seed_node, **rep_params)\n",
    "    for v_node in G.nodes():\n",
    "        if v_node != seed_node:\n",
    "            new_rep[v_node] = rep.compute(seed_node, v_node)\n",
    "    return new_rep\n",
    "\n",
    "def aux_rep(G, s, decay_p = 0.85, rep_func = 'ppr'):\n",
    "    new_rep = defaultdict(float)\n",
    "    for k in G[s]:\n",
    "        f_w = G[s][k]['weight'] / G.out_degree(s, weight='weight')\n",
    "        H = seed_flow_graph(G, s, k)\n",
    "        if rep_func == 'ppr':\n",
    "            R = PersonalizedPageRank(H, s, number_random_walks = 1000, reset_probability =  1- decay_p)\n",
    "        for i in H.nodes():\n",
    "            if i != s:\n",
    "                new_rep[i] += f_w * R.compute(s, i)\n",
    "    return new_rep\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "G = G_t[10].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 460,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "H = build_aux_graph(G, 0)\n",
    "H = decay_aux_graph(H, s, 0.85)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{140401: 0.748,\n",
       " 142117: 0.7959336219336218,\n",
       " 140514: 0.6994864127100968,\n",
       " 140539: 0,\n",
       " 140752: 0,\n",
       " 140557: 0,\n",
       " 141798: 0.8974358974358974,\n",
       " 141586: 0.8974358974358974,\n",
       " 141747: 0,\n",
       " 140904: 0.10793650793650793,\n",
       " 141429: 0.12041666666666664,\n",
       " 141701: 0.2564102564102564,\n",
       " 142079: 0,\n",
       " 141735: 0,\n",
       " 141389: 0.7645517640254481,\n",
       " 141086: 0.28151147098515517,\n",
       " 140957: 0.2229807692307692,\n",
       " 141821: 0,\n",
       " 141993: 0.05128205128205128,\n",
       " 142181: 0,\n",
       " 142271: 0,\n",
       " 142378: 0,\n",
       " 141911: 0,\n",
       " 141824: 0.09444444444444444,\n",
       " 141957: 0.18888888888888888,\n",
       " 141995: 0.040138888888888884,\n",
       " 140452: 0.05128205128205128,\n",
       " 141377: 0.06568181818181817}"
      ]
     },
     "execution_count": 462,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aux_max_flow(G, s, 0.85)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.748\n",
      "0.7959336219336218\n",
      "0.6994864127100968\n",
      "0\n",
      "0\n",
      "0\n",
      "0.8974358974358974\n",
      "0.8974358974358974\n",
      "0\n",
      "0.10793650793650793\n",
      "0.12041666666666664\n",
      "0.2564102564102564\n",
      "0\n",
      "0\n",
      "0.7645517640254481\n",
      "0.28151147098515517\n",
      "0.2229807692307692\n",
      "0\n",
      "0.05128205128205128\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0.09444444444444444\n",
      "0.18888888888888888\n",
      "0.040138888888888884\n",
      "0.05128205128205128\n",
      "0.06568181818181817\n"
     ]
    }
   ],
   "source": [
    "for i in H.nodes():\n",
    "    if i != s:\n",
    "        print(nx.maximum_flow_value(H, s, i, capacity='weight'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 458,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.06451612903225806\n",
      "0.13970348647768002\n",
      "0.12903225806451613\n",
      "0.1935483870967742\n",
      "0.467741935483871\n",
      "0.01717171717171717\n",
      "0.16129032258064516\n",
      "0\n",
      "0.3064516129032258\n",
      "0.16129032258064516\n",
      "0.11603128054740958\n",
      "0.03434343434343434\n",
      "0\n",
      "0\n",
      "0.01717171717171717\n"
     ]
    }
   ],
   "source": [
    "for i in H.nodes():\n",
    "    if i != s:\n",
    "        print(nx.maximum_flow_value(H, s, i, capacity='weight'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 453,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "InDegreeView({140557: 0.06451612903225806, 140799: 5.421095571095571, 140860: 1.0328796651377297, 141821: 0.12903225806451613, 141701: 0.1935483870967742, 141798: 0.596653633105246, 141362: 0.01717171717171717, 142117: 3.4259408602150536, 141747: 0, 141957: 1.3447214076246334, 142271: 0.44689393939393934, 141429: 0.11603128054740958, 141520: 0.03434343434343434, 142258: 0, 140591: 0, 142176: 0.01717171717171717})"
      ]
     },
     "execution_count": 453,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.in_degree(weight='weight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 454,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.06451612903225806\n",
      "0.13970348647768002\n",
      "0.12903225806451613\n",
      "0.1935483870967742\n",
      "0.467741935483871\n",
      "0.01717171717171717\n",
      "0.16129032258064516\n",
      "0\n",
      "0.3064516129032258\n",
      "0.16129032258064516\n",
      "0.11603128054740958\n",
      "0.03434343434343434\n",
      "0\n",
      "0\n",
      "0.01717171717171717\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.467741935483871"
      ]
     },
     "execution_count": 437,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(141798, 0.21531322505800465),\n",
       " (141701, 0.1665893271461717),\n",
       " (141957, 0.1308584686774942),\n",
       " (142117, 0.12529002320185614),\n",
       " (141821, 0.108584686774942),\n",
       " (140860, 0.0765661252900232),\n",
       " (140557, 0.06682134570765662),\n",
       " (141429, 0.06450116009280743),\n",
       " (142271, 0.032018561484918794),\n",
       " (141520, 0.005568445475638051)]"
      ]
     },
     "execution_count": 386,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = G_t[0]\n",
    "s = 140799\n",
    "reps = dict()\n",
    "R = PersonalizedHittingTime(G, s)\n",
    "\n",
    "for t in G.nodes():\n",
    "    if t != s:\n",
    "        reps[t] = R.compute(s, t)\n",
    "sorted(reps.items(), key=lambda x: x[1], reverse=True)[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "G = G_t[100]\n",
    "vals = aux_max_flow(G, s, 0.85)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "H = build_aux_graph(G, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "normalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AtlasView({141573: {'weight': 20.5}, 141221: {'weight': 8}, 140655: {'weight': 4}, 140751: {'weight': 8}, 140402: {'weight': 4}, 140557: {'weight': 12}, 142258: {'weight': 8}, 142194: {'weight': 4}, 140397: {'weight': 18.0}, 141563: {'weight': 4}, 142378: {'weight': 4}, 141031: {'weight': 16}, 140506: {'weight': 4}, 142079: {'weight': 4}, 141389: {'weight': 8}, 140926: {'weight': 4}, 140571: {'weight': 8}, 141270: {'weight': 8}, 141924: {'weight': 4}, 142077: {'weight': 9.0}, 140452: {'weight': 8.0}, 141806: {'weight': 11.0}, 142292: {'weight': 4}, 140968: {'weight': 8.0}, 141297: {'weight': 1.0}, 141447: {'weight': 1.0}, 141824: {'weight': 2.0}, 141957: {'weight': 1.0}, 142188: {'weight': 1.0}, 142231: {'weight': 1.0}})"
      ]
     },
     "execution_count": 428,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(141031, 0.02531248264343893),\n",
       " (140587, 0.02531248264343893),\n",
       " (141945, 0.02531248264343893),\n",
       " (140571, 0.02531248264343893),\n",
       " (140888, 0.02531248264343893),\n",
       " (140397, 0.025312482643438928),\n",
       " (140926, 0.025312482643438928),\n",
       " (142077, 0.025312482643438928),\n",
       " (140557, 0.025312482643438924),\n",
       " (140904, 0.025312482643438924)]"
      ]
     },
     "execution_count": 430,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 423,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AtlasView({141573: {'weight': 0.10379746835443038}, 141221: {'weight': 0.04050632911392405}, 140655: {'weight': 0.020253164556962026}, 140751: {'weight': 0.04050632911392405}, 140402: {'weight': 0.020253164556962026}, 140557: {'weight': 0.060759493670886074}, 142258: {'weight': 0.04050632911392405}, 142194: {'weight': 0.020253164556962026}, 140397: {'weight': 0.09113924050632911}, 141563: {'weight': 0.020253164556962026}, 142378: {'weight': 0.020253164556962026}, 141031: {'weight': 0.0810126582278481}, 140506: {'weight': 0.020253164556962026}, 142079: {'weight': 0.020253164556962026}, 141389: {'weight': 0.04050632911392405}, 140926: {'weight': 0.020253164556962026}, 140571: {'weight': 0.04050632911392405}, 141270: {'weight': 0.04050632911392405}, 141924: {'weight': 0.020253164556962026}, 142077: {'weight': 0.04556962025316456}, 140452: {'weight': 0.04050632911392405}, 141806: {'weight': 0.05569620253164557}, 142292: {'weight': 0.020253164556962026}, 140968: {'weight': 0.04050632911392405}, 141297: {'weight': 0.005063291139240506}, 141447: {'weight': 0.005063291139240506}, 141824: {'weight': 0.010126582278481013}, 141957: {'weight': 0.005063291139240506}, 142188: {'weight': 0.005063291139240506}, 142231: {'weight': 0.005063291139240506}})"
      ]
     },
     "execution_count": 423,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H2[s]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 422,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9746835443037974"
      ]
     },
     "execution_count": 422,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nx.maximum_flow_value(H2, s, 140397, capacity='weight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.07066974595842956"
      ]
     },
     "execution_count": 381,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = PersonalizedHittingTime(G_t[0], s)\n",
    "R.compute(s, 141429)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "H.remove_edge(140799, 141429)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "S = build_aux_graph(H, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1\n",
      "0.06060606060606061\n",
      "-\n"
     ]
    }
   ],
   "source": [
    "for e in nx.all_simple_edge_paths(H, s, 141429):\n",
    "    for f,t in e:\n",
    "        print(S[f][t]['weight'])\n",
    "    print(\"-\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0071794871794871795"
      ]
     },
     "execution_count": 359,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = PersonalizedHittingTime(H, s)\n",
    "R.compute(s, 141429)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AtlasView({141821: {'weight': 0.125}, 141701: {'weight': 0.1875}, 141798: {'weight': 0.296875}, 141429: {'weight': 0.0625}, 140557: {'weight': 0.0625}, 140860: {'weight': 0.03125}, 141957: {'weight': 0.109375}, 142117: {'weight': 0.09375}, 0: {'weight': 0.03125}})"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S[140799]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "R = PersonalizedHittingTime(H, s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1010194624652456"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R.compute(s, 141821)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.11617100371747212"
      ]
     },
     "execution_count": 327,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R.compute(s, 141821)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "s = 140799\n",
    "old_reps = defaultdict(float)\n",
    "\n",
    "G = G_t[10]\n",
    "R = PersonalizedPageRank(G, s, number_random_walks = 1000, reset_probability = 0.15 )\n",
    "for i in G.nodes():\n",
    "    if i != s:\n",
    "        old_reps[i] += R.compute(s, i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Choose the inital seeds \n",
    "G = G_t[0]\n",
    "num_seeds = 3 \n",
    "\n",
    "score  = {i: G.in_degree(i)*G.out_degree(i) for i in G.nodes()}\n",
    "sorted_score = sorted(score.items(), key=lambda x: x[1], reverse=True)\n",
    "initial_seeds = [k for k,_ in sorted_score[:num_seeds]]\n",
    "\n",
    "\n",
    "seed_decay = True\n",
    "seed_decay_p = 0.05\n",
    "decay_p = 0.85\n",
    "\n",
    "\n",
    "# Attack specification \n",
    "start_attack_w = 10\n",
    "end_attack_w = 25\n",
    "max_l = 50\n",
    "\n",
    "num_attack_edges = 3\n",
    "weight_attack_edges = 20\n",
    "attacker_node = 140799\n",
    "\n",
    "reward_per_w = 1000\n",
    "\n",
    "# rep_algs = {'ppr': PersonalizedPageRank}\n",
    "rep_algs = {'ppr': PersonalizedPageRank, 'pht': PersonalizedHittingTime, 'pmf': MaxFlow}\n",
    "rep_args = {'ppr': {'number_random_walks': 1000, 'reset_probability': 1 - decay_p}, \n",
    "            'pht': {'number_random_walks': 1000, 'reset_probability': 1 - decay_p}, \n",
    "            'pmf': {},\n",
    "            'aux_ppr': {'number_random_walks': 1000, 'reset_probability': 1 - decay_p}}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "rep_vals = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "new_seeds = {'ppr': initial_seeds.copy(), 'pht': initial_seeds.copy(), 'pmf': initial_seeds.copy()}\n",
    "cur_seeds = {}\n",
    "\n",
    "H_t = [G_t[i].copy() for i in range(max_l)]\n",
    "\n",
    "rewards = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "used_rep = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "\n",
    "syb_count = 0\n",
    "\n",
    "for w in range(max_l):\n",
    "    G = H_t[w]\n",
    "    # # 1. Pick seeds for reputation calculation \n",
    "    for r_n in rep_algs.keys():\n",
    "        cur_seeds[r_n] = pick_seeds(new_seeds[r_n], num_seeds)\n",
    "    # 2. Insert Attack edges \n",
    "    # We mimic the attack edges as a real user - attacker_node\n",
    "    if w == start_attack_w:\n",
    "        for i in range(num_attack_edges):\n",
    "            G.add_edge(attacker_node, attacker_node + i)\n",
    "    # 3. Insert Sybil edges\n",
    "    # 4. Update reputation\n",
    "    for r_n in rep_algs.keys():\n",
    "        for seed_node in cur_seeds[r_n]:    \n",
    "            new_rep = agg_rep_update(G, seed_node, rep_algs[r_n], **rep_args[r_n])\n",
    "            for k,v in new_rep.items():\n",
    "                rep_vals[r_n][k] += v\n",
    "            # 5. Optional seed punish\n",
    "            if seed_decay:\n",
    "                rep_vals[r_n][seed_node] *= seed_decay_p\n",
    "        # 6. Choose new seeds: maximum reputation \n",
    "        new_seeds[r_n] = [k for k,_ in sorted(rep_vals[r_n].items(), key=lambda x: x[1], reverse=True)]\n",
    "    # 7. Distribute the rewards \n",
    "    for r_n in rep_algs.keys():\n",
    "        rep_sum = sum(rep_vals[r_n].values())\n",
    "        for k,v in rep_vals[r_n].items():\n",
    "            # rewards[r_n][k] += (v - used_rep[r_n][k]) * reward_per_w / num_seeds\n",
    "            rewards[r_n][k] += (v / rep_sum) * reward_per_w \n",
    "            used_rep[r_n][k] = rep_vals[r_n][k]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "@equivrel 141519 278.46857668969506\n",
      "@charlesstlouis 141362 264.04369184491486\n",
      "@cyrus 141429 260.2216625786077\n",
      "@monet-supply 141945 259.0170898990639\n",
      "@MakerMan 140820 248.44388957587046\n",
      "@LongForWisdom 140799 242.0987523853942\n",
      "@rune 142141 231.22284262084898\n",
      "@befitsandpiper 141280 224.82829238234388\n",
      "@hexonaut 141627 223.0645502392742\n",
      "@Jiecut 140714 214.67707788349355\n",
      "@NikKunkel 140904 185.19765601607543\n",
      "@Andy_McCall 140433 179.25429922875588\n",
      "@Jtathmann 140738 177.46134333518057\n",
      "@s_ben 142150 172.22139199975078\n",
      "@cmooney 141389 167.04566945237724\n",
      "@FourthStreet 140621 148.75027550285557\n",
      "@hongbiao_li 141638 147.52744218686473\n",
      "@Kurt_Barry 140773 138.0095615171009\n",
      "@andytudhope 141231 132.17204047113324\n",
      "@Spidomo 141054 125.94887234725405\n"
     ]
    }
   ],
   "source": [
    "for k,v in sorted([(k,v) for k,v in rep_vals.items() if v > 0], key=lambda x: x[1], reverse=True)[:20]:\n",
    "    print(id_to_user.get(str(k)), k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "attack_w = 10\n",
    "num_syb = 5\n",
    "\n",
    "attack_w = 20\n",
    "max_l = 80\n",
    "\n",
    "def add_sybil_path_region(G, attacker_node, total_syb, num_syb):\n",
    "    G.add_edge(attacker_node, attacker_node*2 + total_syb, weight=attack_w)\n",
    "    a = attacker_node*2 + total_syb\n",
    "    for i in range(num_syb):\n",
    "        G.add_edge(a + i, a + i + 1, weight=attack_w)\n",
    "    return num_syb + 1\n",
    "\n",
    "def add_sybil_cycle_region(G, attacker_node, total_syb, num_syb):\n",
    "    for i in range(num_syb):\n",
    "        a = attacker_node*2 + total_syb + i\n",
    "        G.add_edge(attacker_node, a, weight=attack_w)\n",
    "        G.add_edge(a, attacker_node, weight=attack_w)\n",
    "    return num_syb\n",
    "\n",
    "def add_sybil_parallel_region(G, attacker_node, total_syb, num_syb):\n",
    "    a = attacker_node*2 + total_syb\n",
    "    for i in range(num_syb):\n",
    "        G.add_edge(attacker_node, a + i, weight=attack_w)\n",
    "    return num_syb + 1\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Pre-run the reputation \n",
    "\n",
    "rep_vals = defaultdict(float)\n",
    "seed_punish = False\n",
    "\n",
    "G = G_t[0]\n",
    "num_seeds = 3 \n",
    "\n",
    "score  = {i: G.in_degree(i)*G.out_degree(i) for i in G.nodes()}\n",
    "sorted_score = sorted(score.items(), key=lambda x: x[1], reverse=True)\n",
    "initial_seeds = [k for k,_ in sorted_score[:num_seeds]]\n",
    "new_seeds = initial_seeds.copy()\n",
    "\n",
    "for w in range(40):\n",
    "    cur_seeds = []\n",
    "    selected_seeds = 0\n",
    "    G = G_t[w].copy()\n",
    "    # 1. Select seeds based on gained reputation \n",
    "    while selected_seeds < num_seeds:\n",
    "        for s in new_seeds:\n",
    "            if s in G:\n",
    "                cur_seeds.append(s)\n",
    "                selected_seeds += 1\n",
    "                if selected_seeds == num_seeds:\n",
    "                    break\n",
    "        if selected_seeds != num_seeds:\n",
    "            print('Cannot find enough seeds!')\n",
    "            break\n",
    "    # 2. Build auxiliary graph. Weights for indirect edges are change to proportional. \n",
    "    for seed_node in cur_seeds:\n",
    "        # simple_maxflow(G, seed_node, rep_vals,)\n",
    "        # simple_ppr(G, seed_node, rep_vals, decay_p = decay_p, use_weight= False)\n",
    "        simple_pht(G, seed_node, rep_vals, decay_p = decay_p, use_weight=False)\n",
    "        # aux_max_flow(G, seed_node, rep_vals, decay_p = decay_p)\n",
    "        # 3. Seed punish\n",
    "        if seed_punish:\n",
    "            intro_rep = G.out_degree(seed_node, weight='weight')\n",
    "            rep_vals[seed_node] -= intro_rep * seed_decay\n",
    "            rep_vals[seed_node] = max(rep_vals[seed_node], 0)\n",
    "\n",
    "    new_seeds = sorted(rep_vals.items(), key=lambda x: x[1], reverse=True)\n",
    "    new_seeds = [k for k,_ in new_seeds]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "seeds =  new_seeds[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame(columns=['active', 'passive', 'num_syb', 'weeks', 'decay_p'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 465,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "--- Finished 0.4 ---\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "--- Finished 0.6 ---\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "--- Finished 0.8 ---\n"
     ]
    }
   ],
   "source": [
    "rep_vals = defaultdict(float)\n",
    "old_rep_vals = []\n",
    "\n",
    "num_seeds = 3\n",
    "\n",
    "attacker_node = new_seeds[0]\n",
    "\n",
    "seed_decay = 0.1\n",
    "seed_punish = False\n",
    "attack_w = 20\n",
    "syb_rep_gain = {}\n",
    "\n",
    "contrib_decay_w = 8 # 2 mounts \n",
    "contrib_decay_val = 0\n",
    "N = 30\n",
    "\n",
    "for decay_p in [0.4, 0.6, 0.8]:\n",
    "    for num_syb in [30, 20, 15, 10, 5, 4, 3, 2, 1, 0]:\n",
    "        for total_weeks in range(1, 10):\n",
    "            total_syb = 0\n",
    "            rep_vals = defaultdict(float)\n",
    "            new_seeds = seeds[:num_seeds]\n",
    "            for w in range(40, 40 + total_weeks):\n",
    "                G = G_t[w].copy()\n",
    "                cur_seeds = []\n",
    "                selected_seeds = 0\n",
    "                # 1. Select seeds based on gained reputation \n",
    "                while selected_seeds < num_seeds:\n",
    "                    for s in new_seeds:\n",
    "                        if s in G:\n",
    "                            cur_seeds.append(s)\n",
    "                            selected_seeds += 1\n",
    "                            if selected_seeds == num_seeds:\n",
    "                                break\n",
    "                    if selected_seeds != num_seeds:\n",
    "                        print('Cannot find enough seeds!')\n",
    "                        break\n",
    "                if w >= attack_w and num_syb > 0:\n",
    "                    total_syb += add_sybil_parallel_region(G, attacker_node, total_syb, num_syb)\n",
    "                \n",
    "                # 2. Build auxiliary graph. Weights for indirect edges are change to proportional. \n",
    "                for seed_node in cur_seeds:\n",
    "                    # simple_maxflow(G, seed_node, rep_vals,)\n",
    "                    simple_ppr(G, seed_node, rep_vals, decay_p = decay_p, use_weight= False)\n",
    "                    # simple_pht(G, seed_node, rep_vals, decay_p = decay_p, use_weight=False)\n",
    "                    # aux_max_flow(G, seed_node, rep_vals, decay_p = decay_p)\n",
    "                    # 3. Seed punish\n",
    "                    if seed_punish:\n",
    "                        intro_rep = G.out_degree(seed_node, weight='weight')\n",
    "                        rep_vals[seed_node] -= intro_rep * seed_decay\n",
    "                        rep_vals[seed_node] = max(rep_vals[seed_node], 0)\n",
    "                \n",
    "                #old_rep_vals.append(rep_vals.copy())\n",
    "                #if len(old_rep_vals) == contrib_decay_w:\n",
    "                #    old_reps = old_rep_vals.pop(0)\n",
    "                #    for k,v in old_reps.items():\n",
    "                #        rep_vals[k] -= v * contrib_decay_val\n",
    "                \n",
    "                # Choose new seeds\n",
    "                new_seeds = sorted(rep_vals.items(), key=lambda x: x[1], reverse=True)\n",
    "                new_seeds = [k for k,_ in new_seeds]\n",
    "            df = df.append({'active': sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]), 'passive':  rep_vals[attacker_node], 'num_syb': num_syb, 'weeks': total_weeks, 'decay_p': decay_p}, ignore_index=True)\n",
    "            if num_syb % 5 == 0:\n",
    "                print(\"Processed {} our of {}\".format(num_syb, N))\n",
    "    print('--- Finished {} ---'.format(decay_p))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 466,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df['gain'] = (df['active']) / df['passive']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('syb_rep_mf_seed.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('sybil_rep_maxflow.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2 = df[df['weeks'] == 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "g = sns.lineplot(x='num_syb', y='gain', data=df2, estimator='mean', ci=40, hue='decay_p', )\n",
    "# g.set(yscale='log')\n",
    "# g_results.set(xticks=sample_count)\n",
    "#g_results.set(xticklabels=sample_count)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('sybil_rep_pht.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='num_syb', ylabel='gain'>"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "\n",
    "sns.lineplot(x='num_syb', y='gain', data=df, estimator='mean', ci=90, hue='decay_p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('syb_rep_gain.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "aux_maxflow_syil_gain = syb_rep_gain.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "aux_maxflow_syil_gain = {k // 2: v for k,v in aux_maxflow_syil_gain.items() if k > 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>active</th>\n",
       "      <th>passive</th>\n",
       "      <th>num_syb</th>\n",
       "      <th>weeks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>130.197319</td>\n",
       "      <td>96.045241</td>\n",
       "      <td>20.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>128.877114</td>\n",
       "      <td>96.045241</td>\n",
       "      <td>10.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>113.124122</td>\n",
       "      <td>96.045241</td>\n",
       "      <td>5.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>102.190226</td>\n",
       "      <td>96.045241</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>89.603670</td>\n",
       "      <td>96.045241</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>74.262682</td>\n",
       "      <td>96.045241</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>55.375122</td>\n",
       "      <td>96.045241</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       active    passive  num_syb  weeks\n",
       "0  130.197319  96.045241     20.0    2.0\n",
       "1  128.877114  96.045241     10.0    2.0\n",
       "2  113.124122  96.045241      5.0    2.0\n",
       "3  102.190226  96.045241      4.0    2.0\n",
       "4   89.603670  96.045241      3.0    2.0\n",
       "5   74.262682  96.045241      2.0    2.0\n",
       "6   55.375122  96.045241      1.0    2.0"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df['weeks'] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{20: {'active': 66.11141080870743, 'passive': 6.770764067291448},\n",
       " 10: {'active': 65.82400993004147, 'passive': 6.770764067291448},\n",
       " 5: {'active': 62.394675983673466, 'passive': 6.770764067291448},\n",
       " 4: {'active': 59.91568718367347, 'passive': 6.770764067291448},\n",
       " 3: {'active': 55.78403918367347, 'passive': 6.770764067291448},\n",
       " 2: {'active': 48.89795918367347, 'passive': 6.770764067291448},\n",
       " 1: {'active': 38.46530612244898, 'passive': 6.770764067291448},\n",
       " 0: {'active': 0, 'passive': 8.770764067291449}}"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "syb_rep_gain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "@cyrus 141429 677.8381204404394\n",
      "@MakerMan 140820 626.6017055538786\n",
      "@LongForWisdom 140799 624.8525189450362\n",
      "@psychonaut 142079 604.3843367125074\n",
      "@rich.brown 142117 555.7543889274599\n",
      "@Andy_McCall 140433 515.0330088528558\n",
      "@hexonaut 141627 456.54731652306924\n",
      "@monet-supply 141945 452.4988394004422\n",
      "@jernejml 141701 450.87176886635757\n",
      "@Mitote 140869 439.4233167089363\n",
      "@Aaron_Bartsch 140397 405.1323140067299\n",
      "@Planet_X 140957 389.576891467803\n",
      "@Derek 140571 346.7002168662156\n",
      "@charlesstlouis 141362 326.81607101214405\n",
      "@swakya 142258 310.3290980640907\n",
      "@NikKunkel 140904 304.90850543058804\n",
      "@Kurt_Barry 140773 294.4290862187448\n",
      "@rune 142141 294.11989937866036\n",
      "@spin 142238 275.8673011922343\n",
      "@latetot 141801 263.77512634017097\n"
     ]
    }
   ],
   "source": [
    "for k,v in sorted([(k,v) for k,v in rep_vals.items() if v > 0], key=lambda x: x[1], reverse=True)[:20]:\n",
    "    print(id_to_user.get(str(k)), k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8461650498807798"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / rep_vals[attacker_node]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Make an attack \n",
    "\n",
    "a = 200000\n",
    "x = np.random.choice([k for k,v in rep_vals.items() if v > 20], size=1)[0]\n",
    "x = 142117\n",
    "\n",
    "seed_decay = 0.1 # 30 % of introduced reputation is taken from seed reputation\n",
    "\n",
    "AG_t = [G_t[w].copy() for w in range(l)]\n",
    "\n",
    "# One attack edge \n",
    "AG_t[10].add_edge(x, a, weight=4)\n",
    "\n",
    "num_syb = 0\n",
    "# Sybil edges - arbitrary number of edges\n",
    "for i in range(1, 1000):\n",
    "    AG_t[10].add_edge(a, a+i, weight=40)\n",
    "    num_syb += 1\n",
    "\n",
    "\n",
    "for w in range(10, 20):\n",
    "    G = AG_t[w]\n",
    "    cur_seeds = []\n",
    "    selected_seeds = 0\n",
    "    # 1. Select seeds based on gained reputation \n",
    "    while selected_seeds < num_seeds:\n",
    "        for s in new_seeds:\n",
    "            if s in G:\n",
    "                cur_seeds.append(s)\n",
    "                selected_seeds += 1\n",
    "                if selected_seeds == num_seeds:\n",
    "                    break\n",
    "        if selected_seeds != num_seeds:\n",
    "            print('Cannot find enough seeds!')\n",
    "            break\n",
    "        \n",
    "    for seed_node in cur_seeds:\n",
    "        # 2. Build auxiliary graph. Weights for indirect edges are change to proportional. \n",
    "        aux_max_flow(G, seed_node, rep_vals, decay_p = 0.6)\n",
    "        # Seed punish\n",
    "        intro_rep = G.out_degree(seed_node, weight='weight')\n",
    "        rep_vals[seed_node] -= intro_rep * seed_decay\n",
    "        \n",
    "    # Choose new seeds\n",
    "    new_seeds = sorted(rep_vals.items(), key=lambda x: x[1], reverse=True)\n",
    "    new_seeds = [k for k,_ in new_seeds]\n",
    "\n",
    "    # Insert more Sybils \n",
    "    # Sybil edges - arbitrary number of edges\n",
    "    for i in range(num_syb, num_syb+5):\n",
    "        AG_t[w+1].add_edge(a, a+i, weight=40)\n",
    "        num_syb += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34.012363636364256"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(rep_vals[a+k] for k in range(num_syb)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.11363636363636"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "@cyrus 141429 340.6319968705102\n",
      "@ginworkflow 141586 293.70073371547255\n",
      "@LongForWisdom 140799 293.37674239172503\n",
      "@jernejml 141701 276.1740297416319\n",
      "@rich.brown 142117 275.13133118822606\n",
      "@kwadrax 141798 258.6268484954899\n",
      "@swakya 142258 240.57074524973547\n",
      "@rune 142141 206.4096833569106\n",
      "@Mitote 140869 195.85812254726426\n",
      "@Adam_Skrodzki 140401 190.17167384574154\n",
      "@Davidutro 140557 174.44913205082338\n",
      "@Planet_X 140957 174.17657989205654\n",
      "@ChrisBlec 140514 163.5106711901757\n",
      "@NikKunkel 140904 150.54022818500184\n",
      "@psychonaut 142079 133.3230621525939\n",
      "@lix 141821 130.09576079733455\n",
      "@iammeeoh 141648 123.31033704231137\n",
      "@MicahZoltu 140860 111.3973094027242\n",
      "@mmoossttaaffaa 141940 107.41048345732462\n",
      "@tbone 142271 104.66126606959794\n"
     ]
    }
   ],
   "source": [
    "for k,v in sorted([(k,v) for k,v in rep_vals.items() if v > 0], key=lambda x: x[1], reverse=True)[:20]:\n",
    "    print(id_to_user.get(str(k)), k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Attack scenario\n",
    "# a) If top contributor decides to go rogue, and creates Sybils. \n",
    "# b) When you received feedback from the reputable nodes and exploit it.\n",
    "\n",
    "# Passive attack - create links from Sybils to the attacker. \n",
    "# Active attack - receive cummulative reward due to transitivity of the reputation function. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "simple_maxflow_rep_vals = rep_vals.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1825"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([1 for k,v in rep_vals.items() if v > 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1960"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "@Planet_X 140957 2037.3787872708908\n",
      "@twblack88 142317 2077.799772961968\n",
      "@g_dip 141573 2103.060565973572\n",
      "@NikKunkel 140904 2259.879547985243\n",
      "@Derek 140571 2405.1808366698756\n",
      "@Davidutro 140557 2478.3287952736314\n",
      "@MakerMan 140820 2588.1384988800824\n",
      "@Primoz 140968 2589.6205530525476\n",
      "@juan 141754 2616.678489317537\n",
      "@prose11 142077 2693.1246195289964\n",
      "@psychonaut 142079 2735.3760933790286\n",
      "@hexonaut 141627 2746.890190175418\n",
      "@ElProgreso 140587 2788.5531612718905\n",
      "@LongForWisdom 140799 2838.3929084499837\n",
      "@ultraschuppi 142325 2845.150047063644\n",
      "@SebVentures 141031 2861.2833242416664\n",
      "@monet-supply 141945 2870.138716669133\n"
     ]
    }
   ],
   "source": [
    "for k,v in sorted([(k,v) for k,v in rep_vals.items() if v > 2000], key=lambda x: x[1], reverse=False)[:20]:\n",
    "    print(id_to_user.get(str(k)), k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Adding Sybil agents at some time\n",
    "\n",
    "- Attacker performs some work to receive positive feedback: \n",
    "  + Feedback from reputable nodes: like, reply, or references\n",
    "- After receiveing some feedback: execute traitor attack  \n",
    "  + Approve activity of Sybil bots\n",
    "  + To increase the probability to receive more rewards during the distribution. \n",
    "- Two types of attacks: passive Sybil attack (manipulate to increase the reputation of attacker) and active Sybil attack (manipulate to increase reputation of Sybil bots). \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding edge to  140799\n",
      "55.79999999999997\n"
     ]
    }
   ],
   "source": [
    "a = 200_000\n",
    "num_syb = 0\n",
    "\n",
    "rep_val = defaultdict(float)\n",
    "norm_rep = {}\n",
    "bootstrap_w = 8\n",
    "H_t = [G_t[i].copy() for i in range(l)]\n",
    "\n",
    "rep_val, norm_rep = rep(H_t, rep_val, norm_rep_val, 0, bootstrap_w, 10, seed_choice='random')\n",
    "x = 140799\n",
    "# np.random.choice(list(norm_rep.keys()), p=list(norm_rep.values()), replace=False)\n",
    "\n",
    "print(\"Adding edge to \", x)\n",
    "H_t[bootstrap_w].add_edge(x, a, weight=1)\n",
    "rep_val[a] = 0\n",
    "norm_rep[a] = 0\n",
    "\n",
    "num_syb = 0\n",
    "cur_w = bootstrap_w\n",
    "while cur_w < l:\n",
    "    # Insert Sybil edges:\n",
    "    for k in range(10):\n",
    "        num_syb += 1\n",
    "        H_t[cur_w].add_edge(a, a+num_syb, weight=20)\n",
    "        rep_val[a+num_syb] = 0\n",
    "        norm_rep[a+num_syb] = 0\n",
    "    # Further distribution seed_choice='random'\n",
    "    rep_val, norm_rep = rep(H_t, rep_val, norm_rep, cur_w, cur_w + 1, 3)\n",
    "    cur_w += 1\n",
    "    \n",
    "gain = 0\n",
    "if norm_rep[a] != 0:\n",
    "    gain = sum([norm_rep[a+i] for i in range(num_syb + 1)]) / norm_rep[a] \n",
    "print(gain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(201017, 0.00022707099064880656),\n",
       " (201019, 0.00022707099064880656),\n",
       " (200007, 0.0002064281733170969),\n",
       " (200001, 0.0001857853559853872),\n",
       " (200004, 0.0001857853559853872),\n",
       " (200010, 0.0001857853559853872),\n",
       " (200005, 0.0001651425386536775),\n",
       " (200008, 0.0001651425386536775),\n",
       " (201013, 0.0001651425386536775),\n",
       " (200009, 0.00014449972132196784),\n",
       " (201018, 0.00014449972132196784),\n",
       " (200002, 0.00012385690399025813),\n",
       " (200003, 0.00012385690399025813),\n",
       " (201011, 0.00012385690399025813),\n",
       " (201015, 0.00012385690399025813)]"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val = {i:norm_rep[i] for i in range(a, a+num_syb)}\n",
    "sorted(val.items(), key=lambda x: x[1], reverse=True)[:15]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Reputation robustness \n",
    "\n",
    "The PHT reputation is vulnerable to active Sybil attack. \n",
    "As a result of creating one attack edge early with the most reputable node. \n",
    "The edge might be just a result of like from the most reputable node.\n",
    "\n",
    "There are two countermeasures for this attack: \n",
    "1. Reputation decay -> The oppositve of the contribution graph. \n",
    "2. Seed selection: How many seeds and the selection (random, or Based on previous reputation).   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def update_rep(G_t, r, rep_vals, norm_vals, neg_rep):\n",
    "    G = G_t[r]\n",
    "    for s in G.nodes:\n",
    "        rep_vals[s] -= neg_rep[s]\n",
    "        if rep_vals[s] < 0:\n",
    "            rep_vals[s] = 0 \n",
    "    norm_vals = normalize(rep_vals)\n",
    "    return rep_vals, norm_vals\n",
    "\n",
    "def negative_rep(H_t, w, rep_val, norm_rep):\n",
    "    neg_rep = defaultdict(float)\n",
    "    neg_rep, _ = rep(H_t, neg_rep, {}, w, w+1, 10, seed_choice='random')\n",
    "    return update_rep(H_t, w, rep_val, norm_rep, neg_rep)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def boostrap_week(H_t, start_week, end_week, number_of_seeds):\n",
    "    \"\"\"During bootstrap weeks all participants are equal.\n",
    "    For reputation calculation - any seed can be used. \n",
    "    Return reputation values that contributed during this period. \n",
    "    \"\"\"\n",
    "    # Bootstrap weeks distribution\n",
    "    rep_val = defaultdict(float)\n",
    "    norm_rep = {}\n",
    "    rep_val, norm_rep = rep(H_t, rep_val, norm_rep, \n",
    "        start_week, end_week, number_of_seeds, seed_choice='random')\n",
    "    return rep_val, norm_rep\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def experiment(with_decay=False):\n",
    "    a = 200_000\n",
    "    num_syb = 0\n",
    "\n",
    "    rep_val = defaultdict(float)\n",
    "    norm_rep = {}\n",
    "    rewards_per_week = 1000 # USD per week for distribution \n",
    "    rewards = defaultdict(float)\n",
    "    \n",
    "    bootstrap_w = 8\n",
    "    attack_w = 8\n",
    "    syb_attack_num = 2\n",
    "\n",
    "    # Reputation round distributions \n",
    "    num_seeds = 3\n",
    "\n",
    "    H_t = [G_t[i].copy() for i in range(l)]\n",
    "    RH_t = [H_t[i].reverse() for i in range(l)]\n",
    "\n",
    "    \n",
    "    \n",
    "    # Insert Attack edges: \n",
    "    x = 140799\n",
    "    H_t[bootstrap_w].add_edge(x, a, weight=1)\n",
    "    rep_val[a] = 0\n",
    "    norm_rep[a] = 0\n",
    "\n",
    "    num_syb = 0\n",
    "    cur_w = bootstrap_w\n",
    "    while cur_w < l:\n",
    "        # Insert Sybil edges:\n",
    "        for k in range(1):\n",
    "            num_syb += 1\n",
    "            H_t[cur_w].add_edge(a, a+num_syb, weight=20)\n",
    "            rep_val[a+num_syb] = 0\n",
    "            norm_rep[a+num_syb] = 0\n",
    "\n",
    "        # Distribute the rewards \n",
    "        if with_decay:\n",
    "            # Run punishing walks\n",
    "             \n",
    "            # Decay on previous reputations\n",
    "            r_w = cur_w - 2\n",
    "            # 1. Reverse contribution graph \n",
    "            nrep_val = defaultdict(float)\n",
    "            nnorm_rep = defaultdict(float)\n",
    "            # nrep_val, nnorm_rep = rep(H_t, nrep_val, nnorm_rep, r_w, r_w + 1, 5, seed_choice='random', given_seeds=[140799])\n",
    "            # 2. Update reputation\n",
    "            for k in list(rep_val.keys()):\n",
    "                rep_val[k] = max(rep_val[k] - nrep_val[k], 0) \n",
    "            norm_rep = normalize(rep_val)\n",
    "        rep_val, norm_rep = rep(H_t, rep_val, norm_rep, cur_w, cur_w + 1, 3, given_seeds=[140799])\n",
    "        \n",
    "        # Distribute rewards using norm_rep\n",
    "        for k, v in norm_rep.items():\n",
    "            rewards[k] += rewards_per_week * v\n",
    "            \n",
    "        cur_w += 1\n",
    "        \n",
    "    gain = 0\n",
    "    if rewards[a] != 0:\n",
    "        gain = sum([rewards[a+i] for i in range(num_syb + 1)]) / rewards[a] \n",
    "    return gain\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'@LongForWisdom'"
      ]
     },
     "execution_count": 309,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id_to_user['140799']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "no_decay_vals = [experiment() for _ in range(10)]\n",
    "decay_vals = [experiment(with_decay=True) for _ in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.5833333333333335, 1.6473809523809522)"
      ]
     },
     "execution_count": 311,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(decay_vals), np.mean(no_decay_vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "74cbd192829565fa346022b3141b0fd27063780b621ec0011e4ed21cf4d7d415"
  },
  "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}