Does Money Vote For Money.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Analysis] Does Money Vote For Money?\n",
    "\n",
    "*A billion here, a billion there; pretty soon you're talking about real money.*\n",
    "\n",
    "During one of the discussions about the architecture and distribution of Reputation on the platform, @abh12345 said:\n",
    "\n",
    "> [However, I would be keen on a Vested Steem Power analysis of voting - does money vote for money?](— https://steemit.com/utopian-io/@abh12345/steemit-steem-reputation-voting-analysis#@abh12345/re-lextenebris-re-abh12345-steemit-steem-reputation-voting-analysis-20180306t185234133z)\n",
    "\n",
    "— https://steemit.com/utopian-io/@abh12345/steemit-steem-reputation-voting-analysis#@abh12345/re-lextenebris-re-abh12345-steemit-steem-reputation-voting-analysis-20180306t185234133z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... Which _is_ a really good question, as far as it goes, and I'm thinking its one that deserves a little poking at."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Terms and Conditions\n",
    "\n",
    "We have to start looking into this by defining more of what we're talking about. Is it just the general issue of do accounts with extremely high SP tended to restrict their votes to other accounts of extremely high SP? [I've already done the analysis for something like that,](https://steemit.com/steem/@lextenebris/steem-visualizing-vote-histories-on-the-blockchain) and the answer was, surprisingly, most of the votes occurring from the top 200 were going out of the network, and not into it.\n",
    "\n",
    "But that says nothing about Reputation, which is an entirely orthogonal measure of account value. Accounts with high Reputation must have, for a considerable amount of time and at considerable effort, been outvoted by accounts with even higher Reputation.\n",
    "\n",
    "I don't really understand what Reputation even looks like on the platform, so that's the place to start."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building Your Rep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting up the imports for our basic query tools\n",
    "\n",
    "from pprint import pprint\n",
    "\n",
    "from steemdata import SteemData\n",
    "import datetime\n",
    "from datetime import datetime as dt\n",
    "\n",
    "import math\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "import bokeh\n",
    "import bokeh.plotting as bplt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Init connection to database\n",
    "\n",
    "db = SteemData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just a list of all accounts with Rep over 30\n",
    "\n",
    "query = {'reputation': {'$gte': 30}}\n",
    "\n",
    "proj = {'name': 1,\n",
    "        'reputation': 1,\n",
    "        '_id': 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 103 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "result = list(db.Accounts.find(query,\n",
    "                               projection=proj,\n",
    "                               sort=[],\n",
    "                               limit=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That seems a legitimate kind of number. Let's look inside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'a-acehsteem', 'reputation': 1567944952},\n",
       " {'name': 'a-aka-assassin', 'reputation': 1174954542},\n",
       " {'name': 'a-ayman', 'reputation': 114463809},\n",
       " {'name': 'a-b', 'reputation': 1998284910},\n",
       " {'name': 'a-dars', 'reputation': 17769912}]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reputation is stored as a big, big number. Which may not be what we're looking for. Let's dig around and see if someone else is calculated how to derive the displayed Reputation number rather than the raw value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*How reputation scores are calculated - the details explained with simple math*](https://steemit.com/steemit/@digitalnotvir/how-reputation-scores-are-calculated-the-details-explained-with-simple-math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lucky for us it's simple, I suppose. Effectively you throw it on a log 10 curve, fiddle around so that the bottom end is squashed a bit and moved up to 25, and generally mischief managed.\n",
    "\n",
    "Let's write a function to do that, because that's the sensible thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Complete rewrite of the func because, well, you'll read down below.\n",
    "#   See https://github.com/steemit/condenser/blob/ff705f7a413c64e513ecb7f1f6f66fee793a28c7/src/app/utils/ParsersAndFormatters.js\n",
    "\n",
    "def steemBullshitLog10(Str):\n",
    "    \n",
    "    # Not in the original code, just better.\n",
    "    if Str == '0':\n",
    "        return 0\n",
    "    \n",
    "    leadingDigits = int(Str[:4])\n",
    "    pad = len(Str) - 1\n",
    "    \n",
    "    # This is not a perfect replication; the JS library has a constant for log[10]\n",
    "    \n",
    "    strLog = math.log(leadingDigits) / math.log(10)\n",
    "    \n",
    "    return pad + (strLog - int(strLog))\n",
    "\n",
    "\n",
    "def steemBullshitRep2Rep(RawI):\n",
    "    RepS = str(RawI)\n",
    "    \n",
    "    IsRepNeg = RawI < 0\n",
    "    \n",
    "    if IsRepNeg:\n",
    "        RepS = RepS[1:]\n",
    "        \n",
    "    RepI = steemBullshitLog10(RepS)\n",
    "        \n",
    "    RepI = max(RepI - 9, 0)\n",
    "    \n",
    "    if IsRepNeg:\n",
    "        RepI *= -1\n",
    "    \n",
    "    RepI = (RepI * 9) + 25\n",
    "    \n",
    "    return RepI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And now, let's write it the way it _should_ be written\n",
    "#   given stated intent in the comments\n",
    "\n",
    "def rep2Rep(RawI):\n",
    "    if RawI:\n",
    "        if RawI > 0:\n",
    "            return  int(max((math.log( RawI, 10) - 9), 0) * 9) + 25\n",
    "        else:\n",
    "            return -int(max((math.log(-RawI, 10) - 9), 0) * 9) + 25\n",
    "    else:\n",
    "        # Because we arbitrarily center at 25\n",
    "        return 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep2Rep(result[0]['reputation'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This appears to work well enough for us. It does mean that we can't really query accounts for which ones have a minimum Reputation, not without doing some reverse engineering to find out what number would actually map to 30.\n",
    "\n",
    "Maybe that would be worth doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Imgur](https://i.imgur.com/AfVsNrq.png?1)](https://goo.gl/JfM6vr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you go with what will get you the fastest answer, and when I need to do some sort of weird salt for a missing variable problem – I go to Wolfram Alpha.\n",
    "\n",
    "(I know, I know – there are plenty of tools that I could've used straight in Python but they would've all taken more time to set up than simply going to webpage. (I know, I know – there are plenty of tools that I could've used straight in Python but they would've all taken more time to set up than simply going to webpage. Also, this function as given to Wolfram Alpha isn't strictly correct. There is a weird bit regarding the absolute value of the Reputation as stored when it is a negative number that I didn't put in – but which has retroactively been worked into `rep2Rep`. See all the advantages you get when you read these things when they're done and not while I'm writing them?))\n",
    "\n",
    "Still, this tells us the amount of in-database Reputation that will equate to a minimum level for figuring out who is at least Reputation 30.\n",
    "\n",
    "Let's plug that back in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Init connection to database\n",
    "\n",
    "db = SteemData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "minRep = int(3.593813663804627302188167229038422636504 * 10**9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3593813663"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minRep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just a list of all accounts\n",
    "\n",
    "query = {}\n",
    "\n",
    "proj = {'name': 1,\n",
    "        'reputation': 1,\n",
    "        '_id': 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 12.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "result = list(db.Accounts.find(query,\n",
    "                               projection=proj,\n",
    "                               sort=[]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "788516"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "repCalc = [rep2Rep(int(e['reputation'])) for e in result]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "788516"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(repCalc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "Data = pd.DataFrame({'name': [e['name'] for e in result],\n",
    "                     'rep': [int(e['reputation']) for e in result],\n",
    "                     'calcRep': [e for e in repCalc]\n",
    "                    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>name</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>513965</th>\n",
       "      <td>78</td>\n",
       "      <td>steemsports</td>\n",
       "      <td>913296035791209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>293626</th>\n",
       "      <td>77</td>\n",
       "      <td>knozaki2015</td>\n",
       "      <td>746658070499557</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>410136</th>\n",
       "      <td>77</td>\n",
       "      <td>papa-pepper</td>\n",
       "      <td>682990070870322</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        calcRep         name              rep\n",
       "513965       78  steemsports  913296035791209\n",
       "293626       77  knozaki2015  746658070499557\n",
       "410136       77  papa-pepper  682990070870322"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data.sort_values('rep', ascending=False).head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>name</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>340682</th>\n",
       "      <td>-15</td>\n",
       "      <td>matrixdweller</td>\n",
       "      <td>-29377009310460</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>580751</th>\n",
       "      <td>-16</td>\n",
       "      <td>wang</td>\n",
       "      <td>-37765258368568</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>59937</th>\n",
       "      <td>-17</td>\n",
       "      <td>berniesanders</td>\n",
       "      <td>-53479962528315</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        calcRep           name             rep\n",
       "340682      -15  matrixdweller -29377009310460\n",
       "580751      -16           wang -37765258368568\n",
       "59937       -17  berniesanders -53479962528315"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data.sort_values('rep', ascending=False).tail(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting that list took a lot more gyration than expected – because the values for Reputation as stored in the database are so large, they change type at some point and stop being 64-bit integers and start being strings.\n",
    "\n",
    "@furion , if you're listening, they probably ought to be stored as *all* strings or an even bigger int if necessary. I would settle for strings, but one or the other should definitely happen. This mixed type solution is messy.\n",
    "\n",
    "Anyway, we have a list of all the accounts on the system sorted by reputation, and how we can actually do some stuff with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "cData = Data[Data['calcRep'] >= 40].sort_values('calcRep', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "nData = cData.set_index('name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>steemsports</th>\n",
       "      <td>78</td>\n",
       "      <td>913296035791209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gavvet</th>\n",
       "      <td>77</td>\n",
       "      <td>660761030588799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>knozaki2015</th>\n",
       "      <td>77</td>\n",
       "      <td>746658070499557</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>papa-pepper</th>\n",
       "      <td>77</td>\n",
       "      <td>682990070870322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ozchartart</th>\n",
       "      <td>76</td>\n",
       "      <td>467589219907553</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             calcRep              rep\n",
       "name                                 \n",
       "steemsports       78  913296035791209\n",
       "gavvet            77  660761030588799\n",
       "knozaki2015       77  746658070499557\n",
       "papa-pepper       77  682990070870322\n",
       "ozchartart        76  467589219907553"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>chadwickthecrab</th>\n",
       "      <td>40</td>\n",
       "      <td>58978979429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>yudiananda</th>\n",
       "      <td>40</td>\n",
       "      <td>50125948491</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mahmut</th>\n",
       "      <td>40</td>\n",
       "      <td>47287237996</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mahmoodhassan</th>\n",
       "      <td>40</td>\n",
       "      <td>56958995698</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>yohamartinez</th>\n",
       "      <td>40</td>\n",
       "      <td>48050862479</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 calcRep          rep\n",
       "name                                 \n",
       "chadwickthecrab       40  58978979429\n",
       "yudiananda            40  50125948491\n",
       "mahmut                40  47287237996\n",
       "mahmoodhassan         40  56958995698\n",
       "yohamartinez          40  48050862479"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nData.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55739"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(nData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is a lot lower number than I expected to see. In fact, I'm starting to wonder if poking around in this part of the world doesn't invalidate a lot of the things we've been told about the amount of live accounts on the platform. It's under 55,000 accounts with a reputation of \"you've at least done something to create content\", covering the entire life of the platform. \n",
    "\n",
    "In fact, I'm starting to wonder if poking around in this part of the world doesn't invalidate a lot of the things we've been told about the amount of live accounts on the platform.\n",
    "\n",
    "That is not a great thing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But before we go there, we need to talk about something you've already seen the evidence of up above…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Who th'Hell Wrote This Tripe?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look, I know it's been a long time since I had to maintain enterprise-class code. In the intervening years I may have become more cynical, more bitter, and even better at doing code analysis than I was in the heady years of my youth.\n",
    "\n",
    "Which I despised, for the record. Going through someone else's code is like going through their sewer pipe. It's not even as dignified as going through their garbage. I enjoy going through the garbage.\n",
    "\n",
    "Someone needs to find the people that wrote the connector and the JavaScript code originally for the steem blockchain, cut off their fingers, feed them their own fingers, and then possibly remove their ears and tongue so no one else has to listen to their insanity – because the actual code is actually bad.\n",
    "\n",
    "I invite you to go and look at the article I linked earlier. You'll notice that it lightly outlines the Reputation calculation and then cites a piece of code and shows a piece of code. There is some reference to \"details left out.\"\n",
    "\n",
    "I'm here to tell you that what was left out up there was grade-A stupid.\n",
    "\n",
    "Someone decided that the best way to implement a log base 10 algorithm was not to actually use floats or decent integer approximations, but instead to convert or use a string, snip off the first five characters of that string and convert it to an int, take the natural logarithm of that int and divide it by the natural logarithm of 10 (the only smart part of this algorithm), then crush those things back together, counting on the `parseInt` function in JavaScript to do the right thing and if they are slight offset in log calculation to effectively return the decimal portion of the base 10 logarithm of the overall request, and then pass it back.\n",
    "\n",
    "But the stupid doesn't stop there, because the actual Reputation calculation maintains some of the calculation in an integer state and some in a string state, mashes things together willy-nilly, and hopes to Hell that `parseInt` can save the day again when they go to return the ultimate value.\n",
    "\n",
    "This isn't just wrong. It's beyond wrong. Whoever wrote this code doesn't need to be allowed near keyboard for the safety of the entire application.\n",
    "\n",
    "I can almost, kind of, if I tilt my head to the side 90° and then squint really hard, see what they were trying to do. There is a really clumsy attempt to keep from passing around large integers, which some bright soul decided that at least part of the Reputation fields in the blockchain itself would be stored as strings. Rather than simply read the value and immediately convert it to something useful like a 64-bit integer and doing the calculations sensibly in that domain, they decided to write their own base 10 logarithm code which is effectively just \"tell me how long this string is -1\", pass around a whole pile of strings, build and deconstruct strings, parse strings multiple times, and hit the stack on top of all of that.\n",
    "\n",
    "Out of curiosity, pure curiosity, I decided to do a quick set of time comparisons of my proper version of the Reputation code, a pretty straightforward version of their Reputation code, and the dumbest possible implementation I could imagine which was just literally taking the length of an integer turned into a string and returning that as the base 10 logarithm.\n",
    "\n",
    "Here's what that looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "75 ms ± 681 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit -n 10 [rep2Rep(i) for i in range(1, 100000)][:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "209 ms ± 3.54 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit -n 10 [steemBullshitRep2Rep(i) for i in range(1, 100000)][:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34.6 ms ± 529 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit -n 10 [len(str(i)) - 1 + 25 for i in range(1, 100000)][:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I was impressed; it turns out that they only ran *a third* the speed of properly designed code. Though I could double the speed of my own if I replaced it with a purely naïve implementation. I'm not sure we would actually lose much accuracy in the presentation as a result, and since nothing actually hinges on the short form Reputation presentation, maybe these really ridiculous blocks of code could be replaced with even stupider but at least coherent blocks of code.\n",
    "\n",
    "If you're curious where this stuff lives, be my guest and go gaze upon the horror with thine own eyes.\n",
    "\n",
    "https://github.com/steemit/steem-js/blob/master/src/formatter.js\n",
    "\n",
    "https://github.com/steemit/condenser/blob/ff705f7a413c64e513ecb7f1f6f66fee793a28c7/src/app/utils/ParsersAndFormatters.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that's out of the way, let's check out what the distribution of Reputation looks like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eye on the Prize(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At a certain point you just have to roll up your sleeves, flex your fingers, and get ready to get your hands dirty. I have a sneaking suspicion of what this is going to look like, right up front, but we'll take a look at how things actually shake out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>steemsports</th>\n",
       "      <td>78</td>\n",
       "      <td>913296035791209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gavvet</th>\n",
       "      <td>77</td>\n",
       "      <td>660761030588799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>knozaki2015</th>\n",
       "      <td>77</td>\n",
       "      <td>746658070499557</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>papa-pepper</th>\n",
       "      <td>77</td>\n",
       "      <td>682990070870322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ozchartart</th>\n",
       "      <td>76</td>\n",
       "      <td>467589219907553</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             calcRep              rep\n",
       "name                                 \n",
       "steemsports       78  913296035791209\n",
       "gavvet            77  660761030588799\n",
       "knozaki2015       77  746658070499557\n",
       "papa-pepper       77  682990070870322\n",
       "ozchartart        76  467589219907553"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([<matplotlib.axes._subplots.AxesSubplot object at 0x000001220C3478D0>,\n",
       "       <matplotlib.axes._subplots.AxesSubplot object at 0x000001220C3A1358>],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1584x1296 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nData.plot(subplots=True, \n",
    "           figsize=(22, 18), \n",
    "           title='Reputation Ranks', \n",
    "           grid=True, \n",
    "          )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does this look familiar to you?\n",
    "\n",
    "If you've been reading any of the analysis that I've been doing over the last few weeks, it should. It looks like every other distribution curve on Steemit. Every single one. The difference between the top and bottom is that the top is taking the integer Reputation of all of the accounts with greater than 40 Rep, and the lower curve is those exact same accounts except with their raw reputation plotted.\n",
    "\n",
    "Can you tell the immediate difference between the two?\n",
    "\n",
    "If you've been following the functions I've been writing, you know – the calculated Reputation has an implicit logarithmic curve causing the vast slope of the actual underlying reputation to be somewhat masked. I've used logarithmic slopes before in showing SP distribution on the blockchain, and the results were exactly like this. It just lifted up the knee of the curve.\n",
    "\n",
    "Is Reputation 40 high enough to count as \"money,\" or should we take the limit even higher? Of course, as we raise our cutoff point, the population of people that we're talking about becomes very quickly much smaller. Let's redo this with Reputation 50+ and see where that puts us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "cData = Data[Data['calcRep'] >= 50].sort_values('calcRep', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "nData = cData.set_index('name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19129"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(nData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>steemsports</th>\n",
       "      <td>78</td>\n",
       "      <td>913296035791209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>papa-pepper</th>\n",
       "      <td>77</td>\n",
       "      <td>682990070870322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>knozaki2015</th>\n",
       "      <td>77</td>\n",
       "      <td>746658070499557</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gavvet</th>\n",
       "      <td>77</td>\n",
       "      <td>660761030588799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>krnel</th>\n",
       "      <td>76</td>\n",
       "      <td>528772137201395</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             calcRep              rep\n",
       "name                                 \n",
       "steemsports       78  913296035791209\n",
       "papa-pepper       77  682990070870322\n",
       "knozaki2015       77  746658070499557\n",
       "gavvet            77  660761030588799\n",
       "krnel             76  528772137201395"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>neesje</th>\n",
       "      <td>50</td>\n",
       "      <td>738360211524</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ned-scott-videos</th>\n",
       "      <td>50</td>\n",
       "      <td>629802131081</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tktk1023</th>\n",
       "      <td>50</td>\n",
       "      <td>732930735510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>neclatenekeci</th>\n",
       "      <td>50</td>\n",
       "      <td>653698846700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wefund</th>\n",
       "      <td>50</td>\n",
       "      <td>680810981197</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  calcRep           rep\n",
       "name                                   \n",
       "neesje                 50  738360211524\n",
       "ned-scott-videos       50  629802131081\n",
       "tktk1023               50  732930735510\n",
       "neclatenekeci          50  653698846700\n",
       "wefund                 50  680810981197"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nData.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That takes us down to only 20,000 of the users on the platform and probably puts us in the right place to start wondering if all of the votes for this group stay within the group or fall outside of it?\n",
    "\n",
    "Of course, we need to figure out what the scope of the votes we're interested in actually are. All votes on the platform would be far too much data to crunch and not very interesting. The last week might be acceptable, so let's target that first.\n",
    "\n",
    "Step one is querying the database for all of the votes which were done by any of the people in this list within the last week."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "intL = nData.index.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Init connection to database\n",
    "\n",
    "db = SteemData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's put our account on interest here in a list. One day\n",
    "#   we might want to generalize to more than one.\n",
    "\n",
    "intL = nData.index.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We want only the vote transactions which have happened\n",
    "#   in the last week AND involve only our accounts of interest. \n",
    "\n",
    "query = {\n",
    "    'type' : 'vote',\n",
    "    'timestamp' : {'$gte': dt.now() - datetime.timedelta(days=7)},\n",
    "    '$or': [{'voter': {'$in': intL}}\n",
    "           ]}\n",
    "\n",
    "proj = {'voter': 1, 'author': 1, 'weight': 1, 'permlink': 1,\n",
    "        '_id': 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1min 12s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "result = db.Operations.find(query,\n",
    "                            projection=proj)\n",
    "\n",
    "votes = list(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'author': 'appics',\n",
       "  'permlink': 're-claudiaz-re-appics-announcing-appics-or-the-next-generation-social-app-or-first-smart-media-token-20171018t233054132z',\n",
       "  'voter': 'sinner264',\n",
       "  'weight': 1000},\n",
       " {'author': 'simone88',\n",
       "  'permlink': 'colored-drawing-mayor-mccheese',\n",
       "  'voter': 'biglipsmama',\n",
       "  'weight': 300},\n",
       " {'author': 'novi',\n",
       "  'permlink': 'wanita-tangguh-b2e0e2732f87c',\n",
       "  'voter': 'good-karma',\n",
       "  'weight': 6},\n",
       " {'author': 'edwardbernays',\n",
       "  'permlink': 'basic-needs',\n",
       "  'voter': 'youareyourowngod',\n",
       "  'weight': 10},\n",
       " {'author': 'hninyu',\n",
       "  'permlink': 'grilled-shrimp-a3c0635fbd3cb',\n",
       "  'voter': 'cryptohustler',\n",
       "  'weight': 50}]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votes[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1913625"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(votes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Almost 2 million votes in the last week from the accounts in this pile.\n",
    "\n",
    "That is a lot of voting.\n",
    "\n",
    "Worse, though – it's just too many edges to deal with. Though maybe once we get this data into some sort of table that we can work with, structuring the output with some summaries and counts certainly may cut down on things – especially if there are a lot of commonalities.\n",
    "\n",
    "What the Hell, let's give it a try."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "vData = pd.DataFrame(votes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "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>author</th>\n",
       "      <th>permlink</th>\n",
       "      <th>voter</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>appics</td>\n",
       "      <td>re-claudiaz-re-appics-announcing-appics-or-the...</td>\n",
       "      <td>sinner264</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>simone88</td>\n",
       "      <td>colored-drawing-mayor-mccheese</td>\n",
       "      <td>biglipsmama</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>novi</td>\n",
       "      <td>wanita-tangguh-b2e0e2732f87c</td>\n",
       "      <td>good-karma</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>edwardbernays</td>\n",
       "      <td>basic-needs</td>\n",
       "      <td>youareyourowngod</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>hninyu</td>\n",
       "      <td>grilled-shrimp-a3c0635fbd3cb</td>\n",
       "      <td>cryptohustler</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          author                                           permlink  \\\n",
       "0         appics  re-claudiaz-re-appics-announcing-appics-or-the...   \n",
       "1       simone88                     colored-drawing-mayor-mccheese   \n",
       "2           novi                       wanita-tangguh-b2e0e2732f87c   \n",
       "3  edwardbernays                                        basic-needs   \n",
       "4         hninyu                       grilled-shrimp-a3c0635fbd3cb   \n",
       "\n",
       "              voter  weight  \n",
       "0         sinner264    1000  \n",
       "1       biglipsmama     300  \n",
       "2        good-karma       6  \n",
       "3  youareyourowngod      10  \n",
       "4     cryptohustler      50  "
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "veData = vData[vData['author'].isin(intL)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1147353"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(veData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5995704487556339"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(veData) / len(vData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I suppose that we have an answer, really. Roughly 60% of the votes in the last week cast by accounts with Reputations greater than 50 went to other accounts with Reputations greater than 50.\n",
    "\n",
    "But maybe it's not as bad as it looks, right? I mean, maybe all of the votes going inside the group are tiny votes, and they tend to vote with heavier weight outside of the group. That should be relatively easy to find out. All we need to do is sum up the weights on all the votes inside and in total, and a quick divisor will let us know what the ratio is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7303280912"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vSum = vData['weight'].sum()\n",
    "\n",
    "vSum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5232713161"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "veSum = veData['weight'].sum()\n",
    "\n",
    "veSum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7164880036864177"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "veSum / vSum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh.\n",
    "\n",
    "71% by weight went to authors inside the group as opposed to merely 60% by count.\n",
    "\n",
    "At this point it's getting hard to avoid finding that money does, in fact, vote for money.\n",
    "\n",
    "But soft, what light through yonder window breaks?\n",
    "\n",
    "What percentage of these votes are actually self-votes? Those would count as votes which were cast for someone within the same group, right? What percentage of the total are simply not getting out of the group because they are going to the voter themselves?\n",
    "\n",
    "We can easily work this out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "vsData = vData[vData['author'] == vData['voter']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90695"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(vsData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "vsSum = vsData['weight'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "835090614"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vsSum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.047394343196812336, 0.11434458349094377)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(vsData) / len(vData), vsSum / vSum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not *entirely* expected.\n",
    "\n",
    "Only 4.7% of the total number of votes cast by accounts with a Reputation of greater than 50 were self-votes, which is relatively reassuring, I suppose. However, 11.4% of the total weight in votes cast by accounts with Reputation 50 or more went to self-voting.\n",
    "\n",
    "I want to be clear at this point, I have no problem with people self-voting. I am a firm believer in \"code is law,\" and the steem blockchain goes out of its way to reinforce at every turn that voting your own goods up with your own SP is one of the most efficient and effective ways of increasing your holdings.\n",
    "\n",
    "You don't have to like it, but you do have to accept it.\n",
    "\n",
    "This paints a very strange picture, in that 60% of votes in general go inside of the high reputation group, while 71% of the total vote weight stayed in the group. Only 4.7% of those votes were self votes, but they made up 11.4% of the total weight of votes cast.\n",
    "\n",
    "Apparently, high Reputation accounts keep the SP in the family, with a tendency to vote other high Reputation accounts more aggressively, but of that 71% of vote power, roughly 11% were just voting for themselves.\n",
    "\n",
    "That's really, really interesting. Like most of my findings, I don't know what it actually means – but we found it.\n",
    "\n",
    "Out of curiosity, a truly perverse and probably self-destructive curiosity, what say we turn the breakpoint all the way up to Reputation 70 and see how the numbers fall out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "cData = Data[Data['calcRep'] >= 70].sort_values('calcRep', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "nData = cData.set_index('name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "224"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(nData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only 224 accounts on the entire blockchain have a Reputation of over 70. I'm not sure if that's reassuring or terrifying. It is what it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>steemsports</th>\n",
       "      <td>78</td>\n",
       "      <td>913296035791209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gavvet</th>\n",
       "      <td>77</td>\n",
       "      <td>660761030588799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>papa-pepper</th>\n",
       "      <td>77</td>\n",
       "      <td>682990070870322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>knozaki2015</th>\n",
       "      <td>77</td>\n",
       "      <td>746658070499557</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ozchartart</th>\n",
       "      <td>76</td>\n",
       "      <td>467589219907553</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             calcRep              rep\n",
       "name                                 \n",
       "steemsports       78  913296035791209\n",
       "gavvet            77  660761030588799\n",
       "papa-pepper       77  682990070870322\n",
       "knozaki2015       77  746658070499557\n",
       "ozchartart        76  467589219907553"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "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>calcRep</th>\n",
       "      <th>rep</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>richman</th>\n",
       "      <td>70</td>\n",
       "      <td>114253548771732</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>reddust</th>\n",
       "      <td>70</td>\n",
       "      <td>100083302723374</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rea</th>\n",
       "      <td>70</td>\n",
       "      <td>116140932922857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>razvanelulmarin</th>\n",
       "      <td>70</td>\n",
       "      <td>108790190309091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fishingvideos</th>\n",
       "      <td>70</td>\n",
       "      <td>100154736138756</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 calcRep              rep\n",
       "name                                     \n",
       "richman               70  114253548771732\n",
       "reddust               70  100083302723374\n",
       "rea                   70  116140932922857\n",
       "razvanelulmarin       70  108790190309091\n",
       "fishingvideos         70  100154736138756"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nData.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "intL = nData.index.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Init connection to database\n",
    "\n",
    "db = SteemData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's put our account on interest here in a list. One day\n",
    "#   we might want to generalize to more than one.\n",
    "\n",
    "intL = nData.index.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We want only the vote transactions which have happened\n",
    "#   in the last week AND involve only our accounts of interest. \n",
    "\n",
    "query = {\n",
    "    'type' : 'vote',\n",
    "    'timestamp' : {'$gte': dt.now() - datetime.timedelta(days=7)},\n",
    "    '$or': [{'voter': {'$in': intL}}\n",
    "           ]}\n",
    "\n",
    "proj = {'voter': 1, 'author': 1, 'weight': 1, 'permlink': 1,\n",
    "        '_id': 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 16.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "result = db.Operations.find(query,\n",
    "                            projection=proj)\n",
    "\n",
    "votes = list(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'author': 'walidelhaddad',\n",
       "  'permlink': 'binance-offers-usd250-000-bounty-for-arrest-of-hackers',\n",
       "  'voter': 'cheetah',\n",
       "  'weight': 8},\n",
       " {'author': 'carlitojoshua',\n",
       "  'permlink': 'march-fire-prevention-month',\n",
       "  'voter': 'juvyjabian',\n",
       "  'weight': 1000},\n",
       " {'author': 'smilebot',\n",
       "  'permlink': 'remember-to-smile-a2db16b93296a',\n",
       "  'voter': 'cheetah',\n",
       "  'weight': -8},\n",
       " {'author': 'wefund',\n",
       "  'permlink': 'wefund-ada-1-3',\n",
       "  'voter': 'krexchange',\n",
       "  'weight': 10000},\n",
       " {'author': 'gabbybear',\n",
       "  'permlink': 'international-women-s-day',\n",
       "  'voter': 'juvyjabian',\n",
       "  'weight': 1000}]"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votes[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "91305"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(votes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "91,000 total votes cast by accounts with Reputation 70 or greater. Compared to the number of votes that we been juggling along the way, this is very, very small. We are getting down into the realm of the graphable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "vData = pd.DataFrame(votes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "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>author</th>\n",
       "      <th>permlink</th>\n",
       "      <th>voter</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>walidelhaddad</td>\n",
       "      <td>binance-offers-usd250-000-bounty-for-arrest-of...</td>\n",
       "      <td>cheetah</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>carlitojoshua</td>\n",
       "      <td>march-fire-prevention-month</td>\n",
       "      <td>juvyjabian</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>smilebot</td>\n",
       "      <td>remember-to-smile-a2db16b93296a</td>\n",
       "      <td>cheetah</td>\n",
       "      <td>-8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>wefund</td>\n",
       "      <td>wefund-ada-1-3</td>\n",
       "      <td>krexchange</td>\n",
       "      <td>10000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>gabbybear</td>\n",
       "      <td>international-women-s-day</td>\n",
       "      <td>juvyjabian</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          author                                           permlink  \\\n",
       "0  walidelhaddad  binance-offers-usd250-000-bounty-for-arrest-of...   \n",
       "1  carlitojoshua                        march-fire-prevention-month   \n",
       "2       smilebot                    remember-to-smile-a2db16b93296a   \n",
       "3         wefund                                     wefund-ada-1-3   \n",
       "4      gabbybear                          international-women-s-day   \n",
       "\n",
       "        voter  weight  \n",
       "0     cheetah       8  \n",
       "1  juvyjabian    1000  \n",
       "2     cheetah      -8  \n",
       "3  krexchange   10000  \n",
       "4  juvyjabian    1000  "
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "veData = vData[vData['author'].isin(intL)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12615"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(veData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.13816329883357975"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(veData) / len(vData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "161766147"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vSum = vData['weight'].sum()\n",
    "\n",
    "vSum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54197247"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "veSum = veData['weight'].sum()\n",
    "\n",
    "veSum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3350345421777277"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "veSum / vSum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "vsData = vData[vData['author'] == vData['voter']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2538"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(vsData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "vsSum = vsData['weight'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22746035"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vsSum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.02779694430754066, 0.14061060006578507)"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(vsData) / len(vData), vsSum / vSum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So there we have it.\n",
    "\n",
    "Of accounts with Reputation 70+ who have voted in the last week:\n",
    "\n",
    "- Nearly 14% by count of those votes went to other accounts with Reputation 70+.\n",
    "\n",
    "- 33% by weight of those votes stayed with accounts with Reputation 70+.\n",
    "\n",
    "- Only 2.7% of those votes by count were self-votes.\n",
    "\n",
    "- But nearly 15% by weight of those votes were self-votes.\n",
    "\n",
    "Looking at the list of accounts in the Reputation 70+ category, this is not surprising news."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Epilogue*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So what have we learned here, today?\n",
    "\n",
    "Money does, in fact, vote for money. Quite a lot of the time. Not only does it vote for money, it votes for itself quite often. The class of accounts with high Reputations focus on, whether intentionally or emergently, other accounts with high Reputations.\n",
    "\n",
    "The percentages by count decrease as the Reputation breakpoint increases, but not faster than the number of accounts involved decreases. And when talking about vote weight, which is purely about percentages, there seems to be an active centralization as you go up.\n",
    "\n",
    "Of accounts with Reputation 40+, it's not surprising that the vast bulk of their vote weight goes within the group. That includes moderately successful and established small bloggers with communities who have managed to tough it out and are still around.\n",
    "\n",
    "Once we start talking about 70+, however – it's an entirely different world. Keep in mind, 14% of their total votes for the week went to one of the other 224 accounts of comparable level.\n",
    "\n",
    "We haven't even dealt with the question of how many of these accounts are automated as opposed to manual, which is an entirely orthogonal question that probably deserves some kind of attention. Is it possible to gain an extremely high Reputation via automated means?\n",
    "\n",
    "There are definitely some bots in this group, particularly up voting bots. That means that they have not only been uploaded by new users, but have a long history of being up voted by higher Reputation accounts as well. It's not something that we can blame on uncouth newbies.\n",
    "\n",
    "This is interesting stuff. Hopefully someone else finds it as interesting as I do."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [Python 3.6](https://www.python.org/)\n",
    "* [Jupyter Lab](https://github.com/jupyterlab/jupyterlab)\n",
    "* [SteemData](https://steemdata.com/) created by @furion\n",
    "* [MongoDB](https://www.mongodb.com/)\n",
    "* [Pandas](https://pandas.pydata.org/)\n",
    "\n",
    "**And the letter \"YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY?!\"**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}