NNS.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "HSsEL5vvbgXT",
        "hA9JaczmxGMp",
        "OsDpcECj3iKQ"
      ],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "*first mount drive if you are using google colab and go to a project folder*\n",
        "```\n",
        "cd /content/drive/MyDrive/NNS\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "bty6-ul3nC7R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cd /content/drive/MyDrive/NNS"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "32y6d_3moLEz",
        "outputId": "d225136c-8903-4dc9-a2e7-28592662f10a"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/MyDrive/NNS\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Part 0: Setup"
      ],
      "metadata": {
        "id": "2mgjDyEZfxBt"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "64LrCp97akeZ"
      },
      "outputs": [],
      "source": [
        "pip install matplotlib numpy\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "g-T227iNWvOp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Part I Voting Power Multipliers"
      ],
      "metadata": {
        "id": "GvqFVjgUbNGT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notes: The voting power is calculated when the proposal is made, not when the ballot is cast."
      ],
      "metadata": {
        "id": "Nm9ZYGVB4Ftf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 1.1 Voting Power Multiplier $a$ of Dissolve Delay (Or Lock-up Duration)"
      ],
      "metadata": {
        "id": "F4TAIp1xfsbr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title NNS Voting Power Multiplier $a$ of dissolve delay (month)\n",
        "dissolve_delay_month = 60 # @param {type:\"number\"}\n",
        "\n",
        "def calculate_slope_intercept(f):\n",
        "    # Define the points\n",
        "    x1, y1 = 6, 1.06\n",
        "    x2, y2 = 96, 2\n",
        "\n",
        "    # Calculate the slope and intercept for the line segment between the points\n",
        "    m = (y2 - y1) / (x2 - x1)\n",
        "    b = y1 - m * x1\n",
        "\n",
        "    def wrapper(x):\n",
        "        return f(x, m, b)\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "@calculate_slope_intercept\n",
        "def multiplier_duration(x, m, b):\n",
        "    # If x is a single number\n",
        "    if np.isscalar(x):\n",
        "        if x < 6:\n",
        "            return \"the dissolve delay must be at least 6 months\"\n",
        "        elif x == 6:\n",
        "            return 1.06\n",
        "        elif x > 96:\n",
        "            return 2\n",
        "        else:\n",
        "            return m * x + b\n",
        "    else:  # If x is an array\n",
        "        y = np.where(x < 6, \"the dissolve delay must be at least 6 months\", m * x + b)\n",
        "        y = np.where(x > 96, 2, y)\n",
        "        return y\n",
        "\n",
        "y=multiplier_duration(dissolve_delay_month)\n",
        "print(y)"
      ],
      "metadata": {
        "id": "S7S6H96-c7TQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 16  # Width of the figure\n",
        "height = 9  # Height of the figure\n",
        "dpi = 300  # Dots per inch, for high resolution\n",
        "\n",
        "# Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig = plt.figure(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "def calculate_slope_intercept(f):\n",
        "    # Define the points\n",
        "    x1, y1 = 6, 1.06\n",
        "    x2, y2 = 96, 2\n",
        "\n",
        "    # Calculate the slope and intercept for the line segment between the points\n",
        "    m = (y2 - y1) / (x2 - x1)\n",
        "    b = y1 - m * x1\n",
        "\n",
        "    def wrapper(x):\n",
        "        return f(x, m, b)\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "@calculate_slope_intercept\n",
        "def multiplier_duration(x, m, b):\n",
        "    # If x is a single number\n",
        "    if np.isscalar(x):\n",
        "        if x < 6:\n",
        "            return None  # Return None for x < 6\n",
        "        elif x == 6:\n",
        "            return 1.06\n",
        "        elif x > 96:\n",
        "            return 2\n",
        "        else:\n",
        "            return m * x + b\n",
        "    else:  # If x is an array\n",
        "        y = np.where(x < 6, None, m * x + b)  # Replace values for x < 6 with None\n",
        "        y = np.where(x > 96, 2, y)\n",
        "        return y\n",
        "\n",
        "# Generate x values from 0 to 100 for the plot\n",
        "x_values = np.linspace(0, 100, 400)\n",
        "\n",
        "# Calculate the corresponding y values using the multiplier_duration function\n",
        "y_values = multiplier_duration(x_values)\n",
        "\n",
        "# Create a plot, skipping points where x < 6\n",
        "plt.plot(x_values[x_values >= 6], y_values[x_values >= 6], label=\"Multiplier Duration Function\", color='b')\n",
        "\n",
        "# Plot the points\n",
        "x1, y1 = 6, 1.06\n",
        "x2, y2 = 96, 2\n",
        "plt.scatter([x1, x2], [y1, y2], color='red', label=\"Given Points\")\n",
        "\n",
        "# Add a dashed vertical line at x == 6, reaching y == 2\n",
        "plt.axvline(x=6, ymin=0, ymax=2/2.5, color='blue', linestyle='--', label='Dissolve Delay = 6 months')\n",
        "\n",
        "\n",
        "# Annotate the point (6, 1.06)\n",
        "plt.annotate('$6$ months grants a $1.06\\\\times$ per ICP voting power' ,\n",
        "             xy=(6, 1.06),\n",
        "             xytext=(8, 1.8),\n",
        "             arrowprops=dict(facecolor='black', arrowstyle='->'),\n",
        "             fontsize=12)\n",
        "\n",
        "# Annotate the point (6, 1.06) with a dashed line\n",
        "plt.annotate('The dissolve delay must be at least 6 months to vote',\n",
        "             xy=(6, 0.9),\n",
        "             xytext=(8, 0.9),\n",
        "             arrowprops=dict(facecolor='black', arrowstyle='->'),\n",
        "             fontsize=12)\n",
        "\n",
        "# Annotate the point (16, 2)\n",
        "plt.annotate('$8$ years grants $2 \\\\times$ per ICP voting power',\n",
        "             xy=(96, 2),\n",
        "             xytext=(50, 2),\n",
        "             arrowprops=dict(facecolor='black', arrowstyle='->'),\n",
        "             fontsize=12)\n",
        "\n",
        "\n",
        "plt.xlabel(\"Dissolve Delay (month)\")\n",
        "plt.ylabel(\"Voting Power Multiplier (times)\")\n",
        "plt.title(\"NNS Voting Power Multiplier $a$ Based on Dissolve Delay\")\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "\n",
        "\n",
        "plt.ylim(0.8, 2.5)  # Setting y-axis limits for better visualization\n",
        "plt.xlim(0, 100)  # Setting x-axis limits for better visualization\n",
        "\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"multiplier_duration.png\", dpi=dpi)\n",
        "# Display the plot\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "D3bQUlD6diG3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 1.2 Voting Power Multiplier $b$ of Age (length of time spent locked up without dissolving)"
      ],
      "metadata": {
        "id": "9138jXotf0Aq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Voting Power Multiplier $b$ of Age (month)\n",
        "age_month = 0 # @param {type:\"number\"}\n",
        "\n",
        "def Multiplier_Age(x):\n",
        "    if x < 0:\n",
        "        return \"the age is out of range\"\n",
        "    elif x > 48:\n",
        "        return 1.25\n",
        "    else:\n",
        "        m = 0.25 / 48\n",
        "        b = 1\n",
        "        return m * x + b\n",
        "\n",
        "y=Multiplier_Age(age_month)\n",
        "print(y)"
      ],
      "metadata": {
        "id": "RUGMZIx_MwFe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 16  # Width of the figure\n",
        "height = 9  # Height of the figure\n",
        "dpi = 300  # Dots per inch, for high resolution\n",
        "\n",
        "#Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig = plt.figure(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Define the function\n",
        "def Multiplier_Age(x):\n",
        "    if x < 0:\n",
        "        return \"the age is out of range\"\n",
        "    elif x > 48:\n",
        "        return 1.25\n",
        "    else:\n",
        "        m = 0.25 / 48\n",
        "        b = 1\n",
        "        return m * x + b\n",
        "\n",
        "# Generate x values from a bit below 0 to a bit beyond 48\n",
        "x_values = np.linspace(0, 53, 400)\n",
        "\n",
        "# Calculate the y-values using the function\n",
        "y_values = [Multiplier_Age(x) for x in x_values]\n",
        "\n",
        "# Plot the function\n",
        "plt.plot(x_values, y_values, '-b', label=f'$y = {0.25/48:.5f}x + 1$')\n",
        "\n",
        "# Annotate the point (0,0)\n",
        "plt.annotate('1 ICP = the power of 1 vote',\n",
        "             xy=(0, 1),\n",
        "             xytext=(0.5, 1.05),\n",
        "             arrowprops=dict(facecolor='black', arrowstyle='->'),\n",
        "             fontsize=12)\n",
        "\n",
        "# Annotate the point (48, 1.25)\n",
        "plt.annotate('4 years grants a 1.25 times voting power per ICP',\n",
        "             xy=(48, 1.25),\n",
        "             xytext=(20, 1.2),\n",
        "             arrowprops=dict(facecolor='black', arrowstyle='->'),\n",
        "             fontsize=12)\n",
        "\n",
        "# Formatting\n",
        "plt.title(\"NNS Voting Power Multiplier $b$ Based on Age (or length of time spent locked up without dissolving)\")\n",
        "plt.xlabel(\"Age (months)\")\n",
        "plt.ylabel(\"Voting Power Multiplier (times)\")\n",
        "plt.legend(loc=\"upper left\")\n",
        "plt.grid(True)\n",
        "plt.ylim(0.95, 1.3)  # Setting y-axis limits for better visualization\n",
        "plt.xlim(-5, 53)  # Setting x-axis limits for better visualization\n",
        "\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"multiplier_age.png\", dpi=dpi)\n",
        "# Display the plot\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "z_D8yArCO2Hb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_slope_intercept(f):\n",
        "    # Define the points\n",
        "    x1, y1 = 6, 1.06\n",
        "    x2, y2 = 96, 2\n",
        "\n",
        "    # Calculate the slope and intercept for the line segment between the points\n",
        "    m = (y2 - y1) / (x2 - x1)\n",
        "    b = y1 - m * x1\n",
        "\n",
        "    def wrapper(x):\n",
        "        return f(x, m, b)\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "@calculate_slope_intercept\n",
        "def multiplier_duration(x, m, b):\n",
        "    # If x is a single number\n",
        "    if np.isscalar(x):\n",
        "        if x < 6:\n",
        "            return \"the dissolve delay must be at least 6 months\"\n",
        "        elif x == 6:\n",
        "            return 1.06\n",
        "        elif x > 96:\n",
        "            return 2\n",
        "        else:\n",
        "            return m * x + b\n",
        "    else:  # If x is an array\n",
        "        y = np.where(x < 6, \"the dissolve delay must be at least 6 months\", m * x + b)\n",
        "        y = np.where(x > 96, 2, y)\n",
        "        return y\n"
      ],
      "metadata": {
        "id": "At5d8Hk2R_Eu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def log_call(func):\n",
        "    def wrapper(x):\n",
        "        print(f\"{func.__name__} called with argument: {x}\")\n",
        "        return func(x)\n",
        "    return wrapper\n",
        "\n",
        "@log_call\n",
        "def Multiplier_Age(x):\n",
        "    if x < 0:\n",
        "        return \"the age is out of range\"\n",
        "    elif x > 48:\n",
        "        return 1.25\n",
        "    else:\n",
        "        m = 0.25 / 48\n",
        "        b = 1\n",
        "        return m * x + b"
      ],
      "metadata": {
        "id": "UdCm2PYgSm5i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 1.3. Voting Power Multiplier Combined"
      ],
      "metadata": {
        "id": "hX73CpBpbYk1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def combined_multiplier(x_age, x_duration):\n",
        "    # Ensure age is always less than duration\n",
        "    if x_age > x_duration:\n",
        "        return \"Error: age shall be smaller than the dissolve delay\"\n",
        "\n",
        "    age_multiplier = Multiplier_Age(x_age)\n",
        "    duration_multiplier = multiplier_duration(x_duration)\n",
        "\n",
        "    if isinstance(age_multiplier, str) or isinstance(duration_multiplier, str):\n",
        "        # Handle cases where one or both multipliers are out of range or other non-numeric values\n",
        "        return \"Input out of range\"\n",
        "    else:\n",
        "        return age_multiplier * duration_multiplier"
      ],
      "metadata": {
        "id": "QsVKo-dW5dCz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Voting Power Multiplier Combined\n",
        "dissolve_delay_month = 96 # @param {type:\"number\"}\n",
        "age = 48 # @param {type:\"number\"}\n",
        "\n",
        "m_duration = multiplier_duration(dissolve_delay_month)\n",
        "m_age = Multiplier_Age(age)\n",
        "m =combined_multiplier(age, dissolve_delay_month)\n",
        "print(f'The voting power multiplier of dissolve delay {dissolve_delay_month} month is {m_duration}')\n",
        "print(f'The voting power multiplier of age {age} month is {m_age}')\n",
        "print(f'The voting power multiplier of combined multiplier of {dissolve_delay_month} and {age} month is {m}')\n"
      ],
      "metadata": {
        "id": "nhlv06_3ROjY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 16  # Width of the figure\n",
        "height = 9  # Height of the figure\n",
        "dpi = 300  # Dots per inch, for high resolution\n",
        "\n",
        "#Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig = plt.figure(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "\n",
        "# Define the functions if not already defined\n",
        "# ... your previously defined Multiplier_Age and multiplier_duration ...\n",
        "\n",
        "\n",
        "def combined_multiplier(x_age, x_duration):\n",
        "    age_multiplier = Multiplier_Age(x_age)\n",
        "    duration_multiplier = multiplier_duration(x_duration)\n",
        "\n",
        "    if isinstance(age_multiplier, str) or isinstance(duration_multiplier, str):\n",
        "        return np.nan  # Return NaN for out of range values\n",
        "    else:\n",
        "        return age_multiplier * duration_multiplier\n",
        "\n",
        "# Create grid of values\n",
        "x_age = np.linspace(0, 100, 50)  # e.g., 0 to 100 months for age\n",
        "x_duration = np.linspace(6, 100, 50)  # e.g., 6 to 100 months for duration\n",
        "X_age, X_duration = np.meshgrid(x_age, x_duration)\n",
        "Z = np.array([combined_multiplier(a, d) for a, d in zip(np.ravel(X_age), np.ravel(X_duration))])\n",
        "Z = Z.reshape(X_age.shape)\n",
        "\n",
        "# Plotting\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "# Plot the surface\n",
        "ax.plot_surface(X_age, X_duration, Z, cmap='viridis', edgecolor='none', alpha=0.6)\n",
        "\n",
        "# Annotate points\n",
        "ax.scatter(0, 0, 1, color='red', s=100)\n",
        "ax.text(0, 0, 1.1, \"(0,0,1)\", color='red')\n",
        "ax.scatter(96, 48, 2.5, color='blue', s=100)\n",
        "ax.text(96, 48, 2.6, \"(96,48,2.5)\", color='blue')\n",
        "\n",
        "ax.set_xlabel('Age (months)')\n",
        "ax.set_ylabel('Duration (months)')\n",
        "ax.set_zlabel('Combined Multiplier')\n",
        "ax.set_title('3D Visualization of combined_multiplier')\n",
        "\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"multiplier_combined.png\", dpi=dpi)\n",
        "# Display the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "e2mDnvT8SlRY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 16\n",
        "height = 9\n",
        "dpi = 300\n",
        "\n",
        "# Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig = plt.figure(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "# ... your previously defined Multiplier_Age and multiplier_duration ...\n",
        "\n",
        "# Plotting\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "# Create grid of values\n",
        "x_age = np.linspace(0, 100, 50)\n",
        "x_duration = np.linspace(0, 100, 50)\n",
        "X_age, X_duration = np.meshgrid(x_age, x_duration)\n",
        "Z = np.array([combined_multiplier(a, d) for a, d in zip(np.ravel(X_age), np.ravel(X_duration))])\n",
        "Z = Z.reshape(X_age.shape)\n",
        "\n",
        "# Plot the surface\n",
        "surf = ax.plot_surface(X_age, X_duration, Z, cmap='viridis', edgecolor='none', alpha=0.6, rstride=1, cstride=1)\n",
        "\n",
        "# Add contour plots\n",
        "cset = ax.contourf(X_age, X_duration, Z, zdir='z', offset=np.min(Z), cmap='viridis', alpha=0.5)\n",
        "cset = ax.contourf(X_age, X_duration, Z, zdir='x', offset=np.min(X_age), cmap='viridis', alpha=0.5)\n",
        "cset = ax.contourf(X_age, X_duration, Z, zdir='y', offset=np.max(X_duration), cmap='viridis', alpha=0.5)\n",
        "\n",
        "# Annotate points\n",
        "ax.scatter(0, 0, 1, color='red', s=100)\n",
        "ax.text(0, 0, 1.1, \"(0,0,1)\", color='red')\n",
        "ax.scatter(96, 48, 2.5, color='blue', s=100)\n",
        "ax.text(96, 48, 2.6, \"(96,48,2.5)\", color='blue')\n",
        "\n",
        "# Labels and Title\n",
        "ax.set_xlabel('Age (months)')\n",
        "ax.set_ylabel('Duration (months)')\n",
        "ax.set_zlabel('Combined Multiplier')\n",
        "ax.set_title('3D Visualization of combined_multiplier')\n",
        "\n",
        "# Setting axis limits for better visualization\n",
        "ax.set_xlim(2, 100)\n",
        "ax.set_ylim(0, 100)\n",
        "ax.set_zlim(0.5, 3)\n",
        "\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"multiplier_combined.png\", dpi=dpi)\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "cW57LZqQXeyH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 10  # Width of the figure\n",
        "height = 6  # Height of the figure\n",
        "dpi = 300  # Dots per inch, for standard resolution\n",
        "\n",
        "# Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig, ax = plt.subplots(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "# Values for x_age from 0 to 96\n",
        "x_age_values = np.linspace(0, 95, 400)  # excluding 96 to ensure x_age < x_duration\n",
        "\n",
        "# Compute combined multipliers\n",
        "y_values = [combined_multiplier(x, 96) for x in x_age_values]\n",
        "\n",
        "# Plot the curve\n",
        "ax.plot(x_age_values, y_values, '-b', label='Combined Multiplier for $x_{duration} = 96$')\n",
        "\n",
        "# Formatting\n",
        "ax.set_title(\"Combined Multiplier vs Age with Dissolve Delay fixed at 96 months\")\n",
        "ax.set_xlabel(\"$x_{age}$ (months)\")\n",
        "ax.set_ylabel(\"Combined Multiplier (times)\")\n",
        "ax.legend()\n",
        "ax.grid(True)\n",
        "\n",
        "# Display the plot\n",
        "plt.tight_layout()\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"multiplier_age_duration96.png\", dpi=dpi)\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n"
      ],
      "metadata": {
        "id": "nU4rTjP5YjLU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title The Voting Power Multiplier Changes with Age Given A Choosen Dissolve Delay (month)\n",
        "dissolve_delay_month = 48 # @param {type:\"number\"}\n",
        "month = dissolve_delay_month\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 10  # Width of the figure\n",
        "height = 6  # Height of the figure\n",
        "dpi = 300  # Dots per inch, for standard resolution\n",
        "\n",
        "# Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig, ax = plt.subplots(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "# Values for x_age from 0 to the duration of dissolve delay\n",
        "x_age_values = np.linspace(0, month, 400)  # ensure x_age < x_duration\n",
        "\n",
        "# Compute combined multipliers\n",
        "y_values = [combined_multiplier(x, month) for x in x_age_values]\n",
        "\n",
        "# Plot the curve\n",
        "ax.plot(x_age_values, y_values, '-b', label=f\"Combined Multiplier for $x_{{duration}} = {month}$\")\n",
        "\n",
        "# Formatting\n",
        "ax.set_title(f\"Combined Multiplier vs Age with Dissolve Delay fixed at {month} months\")\n",
        "ax.set_xlabel(\"$x_{age}$ (months)\")\n",
        "ax.set_ylabel(\"Combined Multiplier (times)\")\n",
        "ax.legend()\n",
        "ax.grid(True)\n",
        "\n",
        "# Display the plot\n",
        "plt.tight_layout()\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"multiplier_age.png\", dpi=dpi)\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n"
      ],
      "metadata": {
        "id": "xw1mbN2qZFKo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Part II Voting Rewards"
      ],
      "metadata": {
        "id": "HSsEL5vvbgXT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 2.1. Total Rewards"
      ],
      "metadata": {
        "id": "hA9JaczmxGMp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from datetime import datetime\n",
        "\n",
        "def years_difference(G, T):\n",
        "    # Calculate the difference in years\n",
        "    t = T.year - G.year\n",
        "\n",
        "    # If the month and day of T is before that of G, subtract 1 from the difference\n",
        "    if (T.month, T.day) < (G.month, G.day):\n",
        "        t -= 1\n",
        "\n",
        "    return t\n",
        "\n",
        "# Example usage:\n",
        "G = datetime(2020, 12, 18)\n",
        "T = datetime.now()  # Current datetime\n",
        "print(years_difference(G, T))"
      ],
      "metadata": {
        "id": "tpWBg0fWy1Tx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title The year since genesis\n",
        "year = 2023 # @param {type:\"integer\"}\n",
        "month = 9 # @param {type:\"integer\"}\n",
        "date = 16 # @param {type:\"integer\"}\n",
        "\n",
        "from datetime import datetime\n",
        "\n",
        "def years_difference(G, T):\n",
        "    # Calculate the difference in years\n",
        "    t = T.year - G.year\n",
        "\n",
        "    # If the month and day of T is before that of G, subtract 1 from the difference\n",
        "    if (T.month, T.day) < (G.month, G.day):\n",
        "        t -= 1\n",
        "\n",
        "    return t\n",
        "\n",
        "# Example usage:\n",
        "G = datetime(2020, 12, 18) # G is the Genesis of the Internet Computer\n",
        "T = datetime(year,month,date)  # Current datetime\n",
        "t=years_difference(G, T)\n",
        "print(f\"the year difference since the Internet Computer Gensis is {t}\")\n"
      ],
      "metadata": {
        "id": "ZJHrubnExLdI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Yearly Total Reward in Inflation Rate\n",
        "year_since_genesis = 2 # @param {type:\"number\"}\n",
        "\n",
        "def R(t):\n",
        "    # Check if the input is an integer and at least 1\n",
        "    if not isinstance(t, int) or t < 0:\n",
        "        return \"Error: the input must be an integer at least as large as 1\"\n",
        "\n",
        "    # If t is larger than 8, return 0.05\n",
        "    if t > 8:\n",
        "        return 0.05\n",
        "\n",
        "    # Otherwise, compute the function value\n",
        "    return 0.05 + 0.05 * ((8 - t) / 8) ** 2\n",
        "\n",
        "# Example usage:\n",
        "print(R(year_since_genesis))  # This will print the value of R(t) when t=4\n"
      ],
      "metadata": {
        "id": "teYgrwfNzkp1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from matplotlib.ticker import PercentFormatter\n",
        "\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 16  # Width of the figure\n",
        "height = 9  # Height of the figure\n",
        "dpi = 300  # Dots per inch, for high resolution\n",
        "\n",
        "# Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig = plt.figure(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "def R(t):\n",
        "    # Check if the input is an integer and at least 1\n",
        "    if not isinstance(t, int) or t < 0:\n",
        "        return \"Error: the input must be an integer at least as large as 1\"\n",
        "\n",
        "    # If t is larger than 8, return 0.05\n",
        "    if t > 8:\n",
        "        return 0.05\n",
        "\n",
        "    # Otherwise, compute the function value\n",
        "    return 0.05 + 0.05 * ((8 - t) / 8) ** 2\n",
        "\n",
        "# Generate values for t from 0 to 10 to demonstrate the function behavior\n",
        "t_values = np.linspace(0, 10, 400)\n",
        "R_values = [R(int(t)) if isinstance(R(int(t)), float) else np.nan for t in t_values]\n",
        "\n",
        "# Plotting the function\n",
        "plt.plot(t_values, R_values, label='R(t) = 5% + 5% * ((8 - t) / 8) ** 2 for t ≤ 8, R(t) = 5% for t > 8', color='blue')\n",
        "plt.xlabel('Year since genesis')\n",
        "plt.ylabel('Total Reward (percentage of total supply)')\n",
        "plt.title('The timeseries of total rewards in yearly inflation rates by')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "\n",
        "# Set x-ticks for each integer value\n",
        "plt.xticks(np.arange(0, 11, 1))\n",
        "\n",
        "\n",
        "# Format y-axis as percentage\n",
        "plt.gca().yaxis.set_major_formatter(PercentFormatter(1))\n",
        "\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"total_reward_yearly.png\", dpi=dpi)\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "aEgUk6CVz2lg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from matplotlib.ticker import PercentFormatter\n",
        "\n",
        "# Set the style to 'seaborn'\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "# Define the aspect ratio and resolution\n",
        "width = 16  # Width of the figure\n",
        "height = 9  # Height of the figure\n",
        "dpi = 300  # Dots per inch, for high resolution\n",
        "\n",
        "# Set the font to 'Computer Modern'\n",
        "plt.rcParams['font.family'] = 'serif'\n",
        "plt.rcParams['font.serif'] = ['Computer Modern'] + plt.rcParams['font.serif']\n",
        "\n",
        "# Create a new figure with the specified size\n",
        "fig = plt.figure(figsize=(width, height), dpi=dpi)\n",
        "\n",
        "def R(t):\n",
        "    # Check if the input is an integer and at least 1\n",
        "    if not isinstance(t, int) or t < 0:\n",
        "        return \"Error: the input must be an integer at least as large as 1\"\n",
        "\n",
        "    # If t is larger than 8, return 0.05\n",
        "    if t > 8:\n",
        "        return 0.05\n",
        "\n",
        "    # Otherwise, compute the function value\n",
        "    return 0.05 + 0.05 * ((8 - t) / 8) ** 2\n",
        "\n",
        "# Generate values for t from 0 to 10 to demonstrate the function behavior\n",
        "t_values = np.linspace(0, 10, 400)\n",
        "R_values = [(R(int(t))/365.25) if isinstance(R(int(t)), float) else np.nan for t in t_values]\n",
        "\n",
        "# Plotting the function\n",
        "plt.plot(t_values, R_values, label='Daily Reward R(t)/365.25', color='blue')\n",
        "plt.xlabel('Year since genesis')\n",
        "plt.ylabel('Daily Reward (percentage of total supply)')\n",
        "plt.title('The timeseries of daily rewards in inflation rates')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "\n",
        "# Set x-ticks for each integer value\n",
        "plt.xticks(np.arange(0, 11, 1))\n",
        "\n",
        "\n",
        "# Format y-axis as percentage\n",
        "plt.gca().yaxis.set_major_formatter(PercentFormatter(1))\n",
        "\n",
        "# Save the figure in high resolution\n",
        "fig.savefig(\"total_reward_daily.png\", dpi=dpi)\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "nA7djMJK8Gq6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "REFERENCES:\n",
        "\n",
        "https://internetcomputer.org/docs/current/tokenomics/nns/nns-staking-voting-rewards\n",
        "\n",
        "https://dashboard.internetcomputer.org/circulation\n"
      ],
      "metadata": {
        "id": "RJnGMlU0w0Wu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 2.2. Voting Reward Share by Each Neuron"
      ],
      "metadata": {
        "id": "OsDpcECj3iKQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Neuron Stake\n",
        "staked_ICP = 60 # @param {type:\"number\"}\n",
        "staked_maturity = 40 # @param {type:\"number\"}\n",
        "\n",
        "neuron_stake = staked_ICP + staked_maturity #neuron stake\n",
        "\n",
        "print(f\"The neuron stake is {neuron_stake} ICP as the total of {staked_ICP} staked ICP and {staked_maturity} maturity staked\")\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Z5aXid733lX2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def print_multipliers_decorator(func):\n",
        "    def wrapper(x_age, x_duration):\n",
        "        m_duration = multiplier_duration(x_duration)\n",
        "        m_age = Multiplier_Age(x_age)\n",
        "        m = func(x_age, x_duration)\n",
        "\n",
        "        print(f'The voting power multiplier of dissolve delay {x_duration} month is {m_duration}')\n",
        "        print(f'The voting power multiplier of age {x_age} month is {m_age}')\n",
        "        print(f'The voting power multiplier of combined multiplier of {x_duration} and {x_age} month is {m}')\n",
        "        return m\n",
        "    return wrapper\n",
        "\n",
        "# Assuming the definitions of Multiplier_Age and multiplier_duration are provided elsewhere\n",
        "\n",
        "@print_multipliers_decorator\n",
        "def combined_multiplier(x_age, x_duration):\n",
        "    # Ensure age is always less than duration\n",
        "    if x_age > x_duration:\n",
        "        return \"Error: age shall be smaller than the dissolve delay\"\n",
        "\n",
        "    age_multiplier = Multiplier_Age(x_age)\n",
        "    duration_multiplier = multiplier_duration(x_duration)\n",
        "\n",
        "    if isinstance(age_multiplier, str) or isinstance(duration_multiplier, str):\n",
        "        # Handle cases where one or both multipliers are out of range or other non-numeric values\n",
        "        return \"Input out of range\"\n",
        "    else:\n",
        "        return age_multiplier * duration_multiplier\n",
        "\n",
        "# Example usage:\n",
        "combined_multiplier(96, 48)\n"
      ],
      "metadata": {
        "id": "lSIUOWkT6J8N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Neuron Voting Power\n",
        "dissolve_delay_month = 96 # @param {type:\"number\"}\n",
        "age_month = 48 # @param {type:\"number\"}\n",
        "neuron_stake = 100 # @param {type:\"number\"}\n",
        "m=combined_multiplier(age_month, dissolve_delay_month)\n",
        "voting_power = m * neuron_stake\n",
        "print(f'The voting power of the neuron is {voting_power}')\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "vOw9q3UW4_3C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Neuron Rewards Per Proposal Share as Voting Weights\n",
        "neuron_voting_power = 250 # @param {type:\"number\"}\n",
        "total_voting_power = 500 # @param {type:\"number\"}\n",
        "\n",
        "voting_weight = neuron_voting_power / total_voting_power\n",
        "voting_weight_percentage = neuron_voting_power / total_voting_power * 100  # Convert to percentage\n",
        "print(f'The voting weight of the neuron is {voting_weight_percentage:.2f}%')\n"
      ],
      "metadata": {
        "id": "37nFLQst8k8t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Current Daily Reward\n",
        "year_since_genesis = 2 # @param {type:\"number\"}\n",
        "\n",
        "def daily_decorator(func):\n",
        "    def wrapper(t):\n",
        "        result = func(t)\n",
        "        if isinstance(result, float):  # Ensure the result is numeric before dividing\n",
        "            return result / 365.25\n",
        "        return result  # Return the original result (like error messages) if not numeric\n",
        "    return wrapper\n",
        "\n",
        "def R(t):\n",
        "    # Check if the input is an integer and at least 1\n",
        "    if not isinstance(t, int) or t < 0:\n",
        "        return \"Error: the input must be an integer at least as large as 1\"\n",
        "\n",
        "    # If t is larger than 8, return 0.05\n",
        "    if t > 8:\n",
        "        return 0.05\n",
        "\n",
        "    # Otherwise, compute the function value\n",
        "    return 0.05 + 0.05 * ((8 - t) / 8) ** 2\n",
        "\n",
        "@daily_decorator\n",
        "def D(t):\n",
        "    return R(t)\n",
        "\n",
        "# Example usage:\n",
        "print(f\"the current daily reward in inflation rate is {D(2)}\")  # This will print the value of D(t) when t=2\n"
      ],
      "metadata": {
        "id": "URSKyGAq_P9R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Neuron Rewards per Voted Proposal\n",
        "voting_weight= 1 # @param {type:\"number\"}\n",
        "proposal_reward_weight_daily = 0.5 # @param {type:\"number\"}\n",
        "current_daily_reward_rate = 0.0002138945927446954 # @param {type:\"number\"}\n",
        "current_total_supply = 1000 # @param {type:\"number\"}\n",
        "neuron_reward_per_voted_proposal = voting_weight * proposal_reward_weight_daily * current_daily_reward_rate* current_total_supply\n",
        "print(f'The neuron reward per voted proposal is {neuron_reward_per_voted_proposal} ICP' )\n"
      ],
      "metadata": {
        "id": "HMk8qi0u-kg9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Inflationary and deflationary mechanisms**\n",
        "- Deflationary mechanisms:\n",
        "  - Minting cycles to pay for compute and storage burns ICP to create cycles\n",
        "  - Burning of transaction fees.\n",
        "  - Burning of the fee for failed proposals of neurons; note that this only happens at disbursement or merging of neurons, so accumulated fees can persist for a while before finally contributing to deflation.\n",
        "- Inflationary mechanisms:\n",
        "  - Node providers are paid by minting ICP.\n",
        "  - Voting rewards, once spawned and converted to ICP."
      ],
      "metadata": {
        "id": "Ha5oMQJhCU8R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# References\n",
        "\n",
        "## Documentations\n",
        "- https://internetcomputer.org/docs/current/tokenomics/nns/nns-intro\n",
        "\n",
        "## Dashboard\n",
        "\n",
        "- https://www.icpexplorer.org/#/about\n",
        "- https://dashboard.internetcomputer.org/\n",
        "\n",
        "## API\n",
        "- https://ic-api.internetcomputer.org/api\n",
        "- https://ic-api.internetcomputer.org/api/v3/swagger\n",
        "- https://ic-api.internetcomputer.org/api/v3/redoc\n",
        "- https://internetcomputer.org/docs/current/developer-docs/integrations/rosetta/\n",
        "\n",
        "## forum\n",
        "- https://forum.dfinity.org/\n",
        "\n"
      ],
      "metadata": {
        "id": "UteNacTUGU2C"
      }
    }
  ]
}