chris.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RI_t762VjERb"
      },
      "source": [
        "# Simulating voting rules (Python 3.10.10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hsMO2DrGjERf"
      },
      "source": [
        "## Introduction\n",
        "\n",
        "Voting rules can be confusing. To illustrate the possible voting rules as discussed in the lectures, we simulate the voting rules and the effects they can have. In this demo, \"agent\" and \"voter\" is used interchangably."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wLJJzjQkjERh"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import string\n",
        "from collections import Counter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PoSwiP6FjERj"
      },
      "source": [
        "## Model definition"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vh1ONgSCjERk"
      },
      "source": [
        "### Defining functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tKiQdcejERk"
      },
      "source": [
        "We first define the functions `create_voters` and `create_alternatives` to create specific sets $N$ and $A$, respectively."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GG5C1WTXjERl",
        "outputId": "5d673e7c-ee59-4cd8-d03d-54c89f9f6a53"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "create_voters(5)=[0, 1, 2, 3, 4]\n",
            "create_alternatives(5)=['a', 'b', 'c', 'd', 'e']\n"
          ]
        }
      ],
      "source": [
        "def create_voters(n_voters: int = 0) -> list[int]:\n",
        "    \"\"\"\n",
        "    Create a list of voters of size `n_voters`.\n",
        "    If `n_voters` is equal to 0, a random number of voters in the range\n",
        "    [3, 10] will be created.\n",
        "    \"\"\"\n",
        "\n",
        "    assert isinstance(n_voters, int), 'Number of voters must be an integer'\n",
        "    assert n_voters >= 0, 'Number of voters must be zero or positive'\n",
        "\n",
        "    if n_voters == 0:\n",
        "        n_voters = random.randint(3, 10)\n",
        "\n",
        "    return [i for i in range(n_voters)]\n",
        "\n",
        "\n",
        "def create_alternatives(n_alternatives: int = 0) -> list[str]:\n",
        "    \"\"\"\n",
        "    Create a list of alternatives of size `n_alternatives`.\n",
        "    If `n_alternatives` is equal to 0, a random number of alternatives in the range\n",
        "    [3, 10] will be created.\n",
        "    \"\"\"\n",
        "\n",
        "    assert isinstance(n_alternatives, int), 'Number of alternatives must be an integer'\n",
        "    assert n_alternatives >= 0, 'Number of alternatives must be zero or positive'\n",
        "    assert n_alternatives <= 26, 'Number of alternatives must be less than or equal to 26'\n",
        "\n",
        "    if n_alternatives == 0:\n",
        "        n_alternatives = random.randint(3, 10)\n",
        "\n",
        "    return list(string.ascii_lowercase[:n_alternatives])\n",
        "\n",
        "\n",
        "print(f'{create_voters(5)=}')\n",
        "print(f'{create_alternatives(5)=}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L_n7VPWPjERn"
      },
      "source": [
        "We define a function `create_preference_profile` for creating preference profiles. For each agent $i \\in N$ it creates a preference $\\succ_i$ containing alternatives from the set $A$:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1JpoabgpjERo"
      },
      "outputs": [],
      "source": [
        "def create_profile(voters: list[int], alternatives: list[str]) -> dict:\n",
        "    \"\"\"\n",
        "    Create a preference profile for a given number of voters and alternatives.\n",
        "    Randomized on each call.\n",
        "    \"\"\"\n",
        "\n",
        "    profile = dict()\n",
        "\n",
        "    for voter in voters:\n",
        "        profile[voter] = ''.join(random.sample(alternatives, k=len(alternatives)))\n",
        "\n",
        "    return profile"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l-MhTru0jERp"
      },
      "source": [
        "Functions for getting the top choice of a voter $i$ and the bottom choice: $top(\\succ_i) = a_{i_1}$ and $bot(\\succ_i) = a_{i_{|A|}}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S_ninCbzjERq"
      },
      "outputs": [],
      "source": [
        "def top_choice(profile: dict, voter: int) -> str:\n",
        "    \"\"\"\n",
        "    Returns the top choice of a voter.\n",
        "    \"\"\"\n",
        "\n",
        "    return profile[voter][0]\n",
        "\n",
        "def bottom_choice(profile: dict, voter: int) -> str:\n",
        "    \"\"\"\n",
        "    Returns the bottom choice of a voter.\n",
        "    \"\"\"\n",
        "\n",
        "    return profile[voter][-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0XgEYB0VjERs"
      },
      "source": [
        "## Description of a sample preference profile"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SV1JSHfxjERs",
        "outputId": "9fdf4142-b073-4c13-8f1d-23343d157a99"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sample profile:\n",
            "profile={0: 'bca', 1: 'acb', 2: 'cab', 3: 'abc'}\n",
            "\n",
            "Preferences by voter:\n",
            "Voter 0: bca\n",
            "Voter 1: acb\n",
            "Voter 2: cab\n",
            "Voter 3: abc\n",
            "\n",
            "Preferences by frequency:\n",
            "bca: 1\n",
            "acb: 1\n",
            "cab: 1\n",
            "abc: 1\n"
          ]
        }
      ],
      "source": [
        "# sample preference profile for 4 voters and 3 alternatives\n",
        "n_voters = 4\n",
        "n_alternatives = 3\n",
        "voters = create_voters(n_voters)\n",
        "alternatives = create_alternatives(n_alternatives)\n",
        "profile = create_profile(voters, alternatives)\n",
        "print('Sample profile:')\n",
        "print(f'{profile=}')\n",
        "\n",
        "\n",
        "print('\\nPreferences by voter:')\n",
        "\n",
        "for voter in voters:\n",
        "    print(f'Voter {voter}: {profile[voter]}')\n",
        "\n",
        "\n",
        "# count the number of each preference\n",
        "preference_count = Counter(profile.values())\n",
        "\n",
        "print('\\nPreferences by frequency:')\n",
        "\n",
        "for preference, count in preference_count.most_common():\n",
        "    print(f'{preference}: {count}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GKQIgn35jERt"
      },
      "source": [
        "## The dictatorship rule $F_{DCT}$\n",
        "\n",
        "For any profile $R$: $F_{DCT}(R) = top(\\succ_i)$, with voter $i \\in N$ being the \"dictator\"."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y7zufVVijERt"
      },
      "outputs": [],
      "source": [
        "def dictatorship_rule(profile: dict, dictator: int) -> str:\n",
        "    \"\"\"\n",
        "    This rule returns the top choice of the dictator specified.\n",
        "    \"\"\"\n",
        "\n",
        "    return top_choice(profile, dictator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MKpvAE2NjERt",
        "outputId": "bcc03796-45da-4004-8869-5811e773d820"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_voters=4\n",
            "n_alternatives=3\n",
            "profile={0: 'abc', 1: 'abc', 2: 'acb', 3: 'cab'}\n",
            "--------------------------------------------------------------------------------\n",
            "\n",
            "Dictatorship rule:\n",
            "Dictator: 0\n",
            "Winner: a\n"
          ]
        }
      ],
      "source": [
        "print(f'{n_voters=}')\n",
        "print(f'{n_alternatives=}')\n",
        "print(f'{profile=}')\n",
        "print('-' * 80)\n",
        "\n",
        "dictator = random.choice(voters)\n",
        "\n",
        "print('\\nDictatorship rule:')\n",
        "print(f'Dictator: {dictator}')\n",
        "\n",
        "winner = dictatorship_rule(profile, dictator)\n",
        "print(f'Winner: {winner}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JIB1tX4_jERu"
      },
      "source": [
        "## The majority rule $F_{MAJ}$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NtmdHdSgjERu"
      },
      "source": [
        "The majority rule states that for any profile $R$: $F_{MAJ}(R) = x$, such that $top(\\succ_i) = x$ for a strict majority of voters in $N$. A strict majority is the the half of the voters plus one.\n",
        "\n",
        "The majority rule does not always have an outcome. In that case, the function `majority_rule` returns `None`. This can happen when `n_voters` is even and/or `n_alternatives` is greater than 2."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hyRx9aVcjERv"
      },
      "outputs": [],
      "source": [
        "def majority_rule(profile: dict) -> str | None:\n",
        "    \"\"\"\n",
        "    This rule returns the majority top choice.\n",
        "    If there is no majority, it returns None.\n",
        "    \"\"\"\n",
        "\n",
        "    majority = len(profile) // 2 + 1\n",
        "\n",
        "    top_choices = [top_choice(profile, voter) for voter in profile]\n",
        "    top_choice_count = Counter(top_choices)\n",
        "\n",
        "    for top, count in top_choice_count.items():\n",
        "        if count >= majority:\n",
        "            return top\n",
        "\n",
        "    return None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tnzeEp9-jERv",
        "outputId": "f64d9571-dd66-4f5b-f7a1-48be44d1043f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_voters=4\n",
            "n_alternatives=3\n",
            "profile={0: 'abc', 1: 'abc', 2: 'acb', 3: 'cab'}\n",
            "--------------------------------------------------------------------------------\n",
            "\n",
            "Majority rule:\n",
            "Winner: a\n"
          ]
        }
      ],
      "source": [
        "print(f'{n_voters=}')\n",
        "print(f'{n_alternatives=}')\n",
        "print(f'{profile=}')\n",
        "print('-' * 80)\n",
        "\n",
        "print('\\nMajority rule:')\n",
        "\n",
        "winner = majority_rule(profile)\n",
        "print(f'Winner: {winner}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DyXW1ArAjERv"
      },
      "source": [
        "## The plurality rule $F_{PLU}$\n",
        "\n",
        "The plurality rule states that for any profile $R$: $F_{PLU}(R) = \\text{argmax}_{x \\in A}p_R(x)$, where $p_R(x) = | \\{ i \\in N | top(\\succ_i) = x \\} |$. That is, the plurality rule extracts the alternatives that are the most at the top of the voters' preferences.\n",
        "\n",
        "This implementation of `plurality_rule` returns a random winner in case of a tie. This results in the fact that this rule always has a winner."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PUfZfa0kjERv"
      },
      "outputs": [],
      "source": [
        "def plurality_rule(profile: dict) -> str:\n",
        "    \"\"\"\n",
        "    This rule returns the plurality top choice.\n",
        "    If there are ties, return a random winner.\n",
        "    \"\"\"\n",
        "\n",
        "    # construct a list of all the top choices, and count them\n",
        "    top_choices = [top_choice(profile, voter) for voter in profile]\n",
        "    choice_votes = Counter(top_choices)\n",
        "\n",
        "    # find the maximum number of votes\n",
        "    max_votes = max(choice_votes.values())\n",
        "\n",
        "    # get winners\n",
        "    winners = [c for c, v in choice_votes.items() if v == max_votes]\n",
        "\n",
        "    return random.choice(winners)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B7GOZnUdjERw",
        "outputId": "f7120777-a739-48ed-ff07-e2dfc7841ca4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_voters=4\n",
            "n_alternatives=3\n",
            "profile={0: 'abc', 1: 'abc', 2: 'acb', 3: 'cab'}\n",
            "--------------------------------------------------------------------------------\n",
            "\n",
            "Plurality rule:\n",
            "Winner: a\n"
          ]
        }
      ],
      "source": [
        "print(f'{n_voters=}')\n",
        "print(f'{n_alternatives=}')\n",
        "print(f'{profile=}')\n",
        "print('-' * 80)\n",
        "\n",
        "print('\\nPlurality rule:')\n",
        "\n",
        "winner = plurality_rule(profile)\n",
        "print(f'Winner: {winner}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9WZWyU8TjERw"
      },
      "source": [
        "### Duverger's law\n",
        "\n",
        "The two-party system in the United States is a result of the single-ballot plurality-rule voting system that is in place there. The president is chosen with this voting rule. To illustrate how unfavorable this voting system is, we will simulate a country with 100 citizens and varying between 5, 4, 3 and 2 alternatives."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LFQ6tBVBjERw"
      },
      "source": [
        "#### 5 alternatives"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7SY65SFyjERx",
        "outputId": "f687419b-492d-4935-8344-015c2ef1098e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Preferences by frequency:\n",
            "cadeb:  6   bcdea:  3   cbdae:  3   debac:  3   eadbc:  3   edcab:  3   \n",
            "acdbe:  2   daceb:  2   dacbe:  2   adbec:  2   dceab:  2   bdcae:  2   \n",
            "eadcb:  2   cedab:  2   daebc:  2   ebadc:  2   cdabe:  2   bdcea:  2   \n",
            "bcead:  2   acedb:  2   bdaec:  2   edbac:  2   bcaed:  2   bdeca:  2   \n",
            "cdeba:  2   baced:  2   bdace:  2   edcba:  2   eacbd:  2   decab:  2   \n",
            "dcbae:  1   cdaeb:  1   ebcad:  1   cdbea:  1   caedb:  1   cabed:  1   \n",
            "eabdc:  1   badec:  1   bcdae:  1   edbca:  1   dbace:  1   becda:  1   \n",
            "dcaeb:  1   eacdb:  1   abdce:  1   cedba:  1   dbcae:  1   aedbc:  1   \n",
            "aecdb:  1   ecbda:  1   acdeb:  1   bceda:  1   debca:  1   deacb:  1   \n",
            "cbade:  1   edabc:  1   edacb:  1   adcbe:  1   aebcd:  1   bedac:  1   \n",
            "daecb:  1   \n",
            "\n",
            "Plurality rule winner: b\n",
            "Top vote: 24 times\n",
            "Bottom vote: 30 times\n",
            "In bottom 2 votes: 51 times\n"
          ]
        }
      ],
      "source": [
        "random.seed(27)\n",
        "\n",
        "n_voters = 100\n",
        "n_alternatives = 5\n",
        "voters = create_voters(n_voters)\n",
        "alternatives = create_alternatives(n_alternatives)\n",
        "profile = create_profile(voters, alternatives)\n",
        "\n",
        "print('\\nPreferences by frequency:')\n",
        "\n",
        "preference_count = Counter(profile.values())\n",
        "\n",
        "for i, (preference, count) in enumerate(preference_count.most_common()):\n",
        "    # print in table form\n",
        "    print(f'{preference}: {count:>2}', end='   ')\n",
        "    if i % 6 == 5 and i != len(preference_count) - 1:\n",
        "        print()\n",
        "\n",
        "print()\n",
        "\n",
        "winner = plurality_rule(profile)\n",
        "winner_on_top = sum([1 for voter in profile if top_choice(profile, voter) == winner])\n",
        "winner_on_bottom = sum([1 for voter in profile if bottom_choice(profile, voter) == winner])\n",
        "winner_on_bottom_2 = sum([1 for voter in profile if winner in profile[voter][-2:]])\n",
        "\n",
        "print(f'\\nPlurality rule winner: {winner}')\n",
        "print(f'Top vote: {winner_on_top} times')\n",
        "print(f'Bottom vote: {winner_on_bottom} times')\n",
        "print(f'In bottom 2 votes: {winner_on_bottom_2} times')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6HGxJilIjERx"
      },
      "source": [
        "As we can see, the plurality rule winner for this profile is alternative $b$. However, even though $b$ reached the top of the voter's preference 24 times, they were at the bottom of the preference of 30 voters. This shows that the plurality rule can provide terrible winners that do not align with many people's preferences. Even worse, however, is that in 51 out of 100 voters, the winner $b$ was either one of the bottom two alternatives in their preference."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5H-bm9OSjERx"
      },
      "source": [
        "#### 4 alternatives"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DbJQGncdjERy",
        "outputId": "ef60c581-9a3c-453e-ad09-76b58561a0d1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Preferences by frequency:\n",
            "dabc:  8   cdba:  7   cadb:  7   abcd:  6   badc:  6   dacb:  5   \n",
            "cabd:  5   dbca:  5   cdab:  5   dcba:  5   adbc:  4   bcda:  4   \n",
            "bcad:  4   bacd:  4   abdc:  4   bdca:  4   cbad:  4   acbd:  3   \n",
            "dcab:  3   dbac:  3   cbda:  2   adcb:  1   bdac:  1   \n",
            "\n",
            "Plurality rule winner: c\n",
            "Top vote: 30 times\n",
            "Bottom vote: 26 times\n",
            "In bottom 2 votes: 51 times\n"
          ]
        }
      ],
      "source": [
        "random.seed(706)\n",
        "\n",
        "n_voters = 100\n",
        "n_alternatives = 4\n",
        "voters = create_voters(n_voters)\n",
        "alternatives = create_alternatives(n_alternatives)\n",
        "profile = create_profile(voters, alternatives)\n",
        "\n",
        "print('\\nPreferences by frequency:')\n",
        "\n",
        "preference_count = Counter(profile.values())\n",
        "\n",
        "for i, (preference, count) in enumerate(preference_count.most_common()):\n",
        "    # print in table form\n",
        "    print(f'{preference}: {count:>2}', end='   ')\n",
        "    if i % 6 == 5 and i != len(preference_count) - 1:\n",
        "        print()\n",
        "\n",
        "print()\n",
        "\n",
        "winner = plurality_rule(profile)\n",
        "winner_on_top = sum([1 for voter in profile if top_choice(profile, voter) == winner])\n",
        "winner_on_bottom = sum([1 for voter in profile if bottom_choice(profile, voter) == winner])\n",
        "winner_on_bottom_2 = sum([1 for voter in profile if winner in profile[voter][-2:]])\n",
        "\n",
        "print(f'\\nPlurality rule winner: {winner}')\n",
        "print(f'Top vote: {winner_on_top} times')\n",
        "print(f'Bottom vote: {winner_on_bottom} times')\n",
        "print(f'In bottom 2 votes: {winner_on_bottom_2} times')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vCqoPobujERy"
      },
      "source": [
        "In the above voting simulation, we can again see that the majority of voters have written down the winner ($c$) to be in the bottom half of their preference. This time, the amount of times that alternative $c$ is at the top of preferences is more than the amount of times $c$ is at the bottom of preferences."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pO-y7RSGjERz"
      },
      "source": [
        "## The plurarity with runoff rule $F_{RUN}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0f1NSVLdjERz",
        "outputId": "6d1b2c61-0cb0-4efd-dafc-f0e70d67774e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Ellipsis"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBpPp_b0jER0"
      },
      "source": [
        "## The Condorcet rule $F_{CON}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v379EZ4TjER0"
      },
      "outputs": [],
      "source": [
        "def condorcet_matchups(profile: dict) -> np.ndarray:\n",
        "    alternatives = list(list(profile.values())[0])\n",
        "    alternatives.sort()\n",
        "\n",
        "    matchups = np.identity(len(alternatives))\n",
        "\n",
        "    for preference in profile.values():\n",
        "        idxs = np.array([preference.index(a) for a in alternatives])\n",
        "\n",
        "        for i in range(len(alternatives)):\n",
        "            wins = np.where(idxs[i] < idxs, 1, 0)\n",
        "            losses = np.where(idxs[i] > idxs, -1, 0)\n",
        "\n",
        "            matchups[i] += wins + losses\n",
        "\n",
        "    winners = np.where(matchups > 0, 1, 0)\n",
        "    return matchups, winners\n",
        "\n",
        "def condorcet_rule(profile: dict) -> tuple:\n",
        "    alternatives = list(list(profile.values())[0])\n",
        "    alternatives.sort()\n",
        "\n",
        "    matchups, winners = condorcet_matchups(profile)\n",
        "    winner = np.nonzero(np.all(winners > 0, 1))[0]\n",
        "\n",
        "    if len(winner) == 0:\n",
        "        winner = None\n",
        "    else:\n",
        "        winner = alternatives[winner]\n",
        "\n",
        "    return winner, (matchups, winners)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f'{n_voters=}')\n",
        "print(f'{n_alternatives=}')\n",
        "print(f'{profile=}')\n",
        "print('-' * 80)\n",
        "\n",
        "print('\\n Condorcet rule:')\n",
        "\n",
        "winner, results = condorcet_rule(profile)\n",
        "print(f'Winner: {winner}')\n",
        "\n",
        "print('Head-to-head victories: ')\n",
        "print(results[1])\n",
        "print(results[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S1WiPZFvwd_b",
        "outputId": "5575050f-5032-4ee4-df46-866b134edc7a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_voters=4\n",
            "n_alternatives=3\n",
            "profile={0: 'bca', 1: 'acb', 2: 'cab', 3: 'abc'}\n",
            "--------------------------------------------------------------------------------\n",
            "\n",
            " Condorcet rule:\n",
            "Winner: None\n",
            "Head-to-head victories: \n",
            "[[1 1 0]\n",
            " [0 1 0]\n",
            " [0 0 1]]\n",
            "[[ 1.  2.  0.]\n",
            " [-2.  1.  0.]\n",
            " [ 0.  0.  1.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YTW_J-RljER0"
      },
      "source": [
        "## The Borda rule $F_{BOR}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2ZGSI1tYjER1"
      },
      "outputs": [],
      "source": [
        "def borda_score(profile: dict) -> dict:\n",
        "    br = dict()\n",
        "    example_preference = list(list(profile.values())[0])\n",
        "    example_preference.sort()\n",
        "\n",
        "    n_alternatives = len(example_preference)\n",
        "\n",
        "    for a in example_preference:\n",
        "        br[a] = 0\n",
        "\n",
        "    for preference in profile.values():\n",
        "        for k, a in enumerate(preference):\n",
        "            br[a] += n_alternatives - k - 1\n",
        "\n",
        "    return br\n",
        "\n",
        "\n",
        "def borda_rule(profile: dict) -> tuple:\n",
        "    scores = borda_score(profile)\n",
        "    winner = max(scores, key=scores.get)\n",
        "\n",
        "    return winner, scores"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f'{n_voters=}')\n",
        "print(f'{n_alternatives=}')\n",
        "print(f'{profile=}')\n",
        "print('-' * 80)\n",
        "\n",
        "print('\\n Borda rule:')\n",
        "\n",
        "winner, scores = borda_rule(profile)\n",
        "print(f'Winner: {winner}')\n",
        "\n",
        "print('\\n Borda scores: ')\n",
        "for n, a in scores.items():\n",
        "    print(f'Alternative {n}: {a}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0o_1CKHAtmER",
        "outputId": "c138fff1-7d5a-4ac7-9a02-729f612aefff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_voters=100\n",
            "n_alternatives=4\n",
            "profile={0: 'cdba', 1: 'dabc', 2: 'cadb', 3: 'adbc', 4: 'abcd', 5: 'bcda', 6: 'bcad', 7: 'cdba', 8: 'bacd', 9: 'acbd', 10: 'cdba', 11: 'dacb', 12: 'abdc', 13: 'cabd', 14: 'dcab', 15: 'bacd', 16: 'acbd', 17: 'cabd', 18: 'cdba', 19: 'dacb', 20: 'cabd', 21: 'dbca', 22: 'badc', 23: 'cdba', 24: 'cadb', 25: 'dabc', 26: 'cdab', 27: 'cdab', 28: 'bcad', 29: 'dcba', 30: 'dcab', 31: 'dcba', 32: 'dabc', 33: 'dabc', 34: 'adcb', 35: 'dcba', 36: 'badc', 37: 'dabc', 38: 'abcd', 39: 'abdc', 40: 'dabc', 41: 'dabc', 42: 'abdc', 43: 'bcda', 44: 'adbc', 45: 'bdca', 46: 'abcd', 47: 'badc', 48: 'cadb', 49: 'cbda', 50: 'cbad', 51: 'adbc', 52: 'bcad', 53: 'dabc', 54: 'bdca', 55: 'dacb', 56: 'bcda', 57: 'badc', 58: 'cbad', 59: 'bdca', 60: 'cdab', 61: 'bdac', 62: 'dbca', 63: 'dbac', 64: 'bcda', 65: 'bdca', 66: 'dcba', 67: 'dacb', 68: 'dbca', 69: 'cadb', 70: 'dacb', 71: 'dbca', 72: 'dcba', 73: 'cdab', 74: 'abcd', 75: 'dbac', 76: 'badc', 77: 'badc', 78: 'dcab', 79: 'cdba', 80: 'abcd', 81: 'cadb', 82: 'dbca', 83: 'adbc', 84: 'bacd', 85: 'abcd', 86: 'cadb', 87: 'cadb', 88: 'acbd', 89: 'cbad', 90: 'cabd', 91: 'cbad', 92: 'dbac', 93: 'cdab', 94: 'bacd', 95: 'cabd', 96: 'abdc', 97: 'cdba', 98: 'cbda', 99: 'bcad'}\n",
            "--------------------------------------------------------------------------------\n",
            "\n",
            " Borda rule:\n",
            "Winner: d\n",
            "\n",
            " Borda scores: \n",
            "Alternative a: 144\n",
            "Alternative b: 149\n",
            "Alternative c: 153\n",
            "Alternative d: 154\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xo3hTJs9jER1"
      },
      "source": [
        "## Various scoring rules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BpRs31WdjER1"
      },
      "outputs": [],
      "source": [
        "def score_points(profile: dict, scores: list) -> dict:\n",
        "    s = dict()\n",
        "    alt = list(list(profile.values())[0])\n",
        "    alt.sort()\n",
        "\n",
        "    n_alt = len(alt)\n",
        "\n",
        "    for a in alt:\n",
        "        s[a] = 0\n",
        "\n",
        "    for pref in profile.values():\n",
        "        for p, a in zip(scores, pref):\n",
        "            s[a] += p\n",
        "\n",
        "    return s\n",
        "\n",
        "def scoring_rule(profile, scores) -> tuple:\n",
        "    s = score_points(profile, scores)\n",
        "    winner = max(s, key=s.get)\n",
        "\n",
        "    return winner, s"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "score = [1, 1, 0, 0]\n",
        "print(f'{n_voters=}')\n",
        "print(f'{n_alternatives=}')\n",
        "print(f'{profile=}')\n",
        "print('-' * 80)\n",
        "\n",
        "print('\\n Scoring rule:')\n",
        "\n",
        "winner, scores = scoring_rule(profile, score)\n",
        "print(f'Winner: {winner}')\n",
        "\n",
        "print('\\n Scores: ')\n",
        "for n, a in scores.items():\n",
        "    print(f'Alternative {n}: {a}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cw0HeLCgOrsg",
        "outputId": "0d0ac3ba-e8d3-4829-839c-ff484dfa861a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_voters=100\n",
            "n_alternatives=4\n",
            "profile={0: 'cdba', 1: 'dabc', 2: 'cadb', 3: 'adbc', 4: 'abcd', 5: 'bcda', 6: 'bcad', 7: 'cdba', 8: 'bacd', 9: 'acbd', 10: 'cdba', 11: 'dacb', 12: 'abdc', 13: 'cabd', 14: 'dcab', 15: 'bacd', 16: 'acbd', 17: 'cabd', 18: 'cdba', 19: 'dacb', 20: 'cabd', 21: 'dbca', 22: 'badc', 23: 'cdba', 24: 'cadb', 25: 'dabc', 26: 'cdab', 27: 'cdab', 28: 'bcad', 29: 'dcba', 30: 'dcab', 31: 'dcba', 32: 'dabc', 33: 'dabc', 34: 'adcb', 35: 'dcba', 36: 'badc', 37: 'dabc', 38: 'abcd', 39: 'abdc', 40: 'dabc', 41: 'dabc', 42: 'abdc', 43: 'bcda', 44: 'adbc', 45: 'bdca', 46: 'abcd', 47: 'badc', 48: 'cadb', 49: 'cbda', 50: 'cbad', 51: 'adbc', 52: 'bcad', 53: 'dabc', 54: 'bdca', 55: 'dacb', 56: 'bcda', 57: 'badc', 58: 'cbad', 59: 'bdca', 60: 'cdab', 61: 'bdac', 62: 'dbca', 63: 'dbac', 64: 'bcda', 65: 'bdca', 66: 'dcba', 67: 'dacb', 68: 'dbca', 69: 'cadb', 70: 'dacb', 71: 'dbca', 72: 'dcba', 73: 'cdab', 74: 'abcd', 75: 'dbac', 76: 'badc', 77: 'badc', 78: 'dcab', 79: 'cdba', 80: 'abcd', 81: 'cadb', 82: 'dbca', 83: 'adbc', 84: 'bacd', 85: 'abcd', 86: 'cadb', 87: 'cadb', 88: 'acbd', 89: 'cbad', 90: 'cabd', 91: 'cbad', 92: 'dbac', 93: 'cdab', 94: 'bacd', 95: 'cabd', 96: 'abdc', 97: 'cdba', 98: 'cbda', 99: 'bcad'}\n",
            "--------------------------------------------------------------------------------\n",
            "\n",
            " Scoring rule:\n",
            "Winner: a\n",
            "\n",
            " Scores: \n",
            "Alternative a: 53\n",
            "Alternative b: 47\n",
            "Alternative c: 49\n",
            "Alternative d: 51\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NQD9-4r2O2eY"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "base",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.12"
    },
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "9WZWyU8TjERw",
        "LFQ6tBVBjERw",
        "5H-bm9OSjERx"
      ]
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}