pref_voting_testing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pref_voting.dominance_axioms import condorcet_winner, condorcet_loser, pareto_dominance\n",
    "from pref_voting.profiles import _find_updated_profile\n",
    "from pref_voting.pairwise_profiles import *\n",
    "from pref_voting.voting_methods import *\n",
    "from pref_voting.generate_profiles import *\n",
    "from pref_voting.voting_methods_registry import voting_methods\n",
    "from pref_voting.generate_weighted_majority_graphs import *\n",
    "from pref_voting.helper import *\n",
    "from pref_voting.mappings import *  \n",
    "from tqdm.notebook import tqdm\n",
    "from itertools import permutations\n",
    "from pref_voting.axioms import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+---+\n",
      "| 4 | 1 |\n",
      "+---+---+\n",
      "| 0 | 1 |\n",
      "| 1 | 2 |\n",
      "| 2 | 0 |\n",
      "+---+---+\n",
      "(np.int64(0), np.int64(1), np.int64(2))\n",
      "(np.int64(0), np.int64(1), np.int64(2))\n",
      "(np.int64(1), np.int64(2), np.int64(0))\n",
      "(np.int64(0), np.int64(1), np.int64(2))\n",
      "(np.int64(0), np.int64(1), np.int64(2))\n"
     ]
    }
   ],
   "source": [
    "prof = Profile(\n",
    "    [[0, 1, 2],\n",
    "     [0, 1, 2],\n",
    "     [1, 2, 0],\n",
    "     [0, 1, 2],\n",
    "     [0, 1, 2],],\n",
    "    \n",
    "    #rcounts=[10, 5]\n",
    ")\n",
    "\n",
    "voters = range(prof.num_voters)\n",
    "\n",
    "prof.anonymize().display()\n",
    "for voter in range(len(prof.rankings)): \n",
    "    print(prof.rankings[voter])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+---+---+---+---+\n",
      "| 4 | 1 | 9 | 8 | 5 |\n",
      "+---+---+---+---+---+\n",
      "| a | b | c | a | c |\n",
      "| c | a | a | b | b |\n",
      "| b | c | b | c | a |\n",
      "+---+---+---+---+---+\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+---+---+---+---+\n",
      "| 4 | 1 | 9 | 8 | 5 |\n",
      "+---+---+---+---+---+\n",
      "| b | a | c | b | c |\n",
      "| c | b | b | a | a |\n",
      "| a | c | a | c | b |\n",
      "+---+---+---+---+---+\n"
     ]
    }
   ],
   "source": [
    "a=0\n",
    "b=1\n",
    "c=2\n",
    "d=3\n",
    "prof = Profile([\n",
    "    [a, c, b],\n",
    "    [b, a, c],\n",
    "    [c, a, b], \n",
    "    [a, b, c], \n",
    "    [c, b, a]\n",
    "], \n",
    "rcounts=[4, 1, 9, 8, 5],\n",
    "cmap = {a: 'a', b: 'b', c: 'c'})\n",
    "\n",
    "prof.display()\n",
    "\n",
    "prof.display_margin_graph()\n",
    "\n",
    "new_prof = prof.apply_cand_permutation({a:b, b:a, c:c})\n",
    "new_prof.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+---+---+---+---+\n",
      "| 4 | 1 | 9 | 8 | 5 |\n",
      "+---+---+---+---+---+\n",
      "| a | b | c | a | d |\n",
      "| c | a | d | b | c |\n",
      "| b | d | a | d | b |\n",
      "| d | c | b | c | a |\n",
      "+---+---+---+---+---+\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prof = Profile([\n",
    "    [a, c, b, d],\n",
    "    [b, a, d, c],\n",
    "    [c, d, a, b], \n",
    "    [a, b, d, c], \n",
    "    [d, c, b, a]\n",
    "], \n",
    "rcounts=[4, 1, 9, 8, 5],\n",
    "cmap = {a: 'a', b: 'b', c: 'c', d: 'd'})\n",
    "\n",
    "prof.display()\n",
    "\n",
    "prof.display_margin_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<networkx.classes.digraph.DiGraph object at 0x2c1460470>, <networkx.classes.digraph.DiGraph object at 0x2c144c0b0>]\n"
     ]
    }
   ],
   "source": [
    "mg = MarginGraph(\n",
    "    [0, 1, 2, 3], \n",
    "    [\n",
    "        (0, 1, 10), \n",
    "        (0, 2, 2), \n",
    "        (1, 3, 4), \n",
    "        (2, 1, 6), \n",
    "        (2, 3, 8), \n",
    "        (3, 0, 4)]\n",
    "        )\n",
    "\n",
    "rp_defeats = ranked_pairs_defeats(mg)\n",
    "\n",
    "print(rp_defeats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(np.int64(0), np.int64(2), np.int64(1), np.int64(3)), (np.int64(2), np.int64(0), np.int64(3), np.int64(1)), (np.int64(1), np.int64(3), np.int64(0), np.int64(2)), (np.int64(0), np.int64(2), np.int64(3), np.int64(1)), (np.int64(1), np.int64(0), np.int64(2), np.int64(3)), (np.int64(3), np.int64(2), np.int64(0), np.int64(1)), (np.int64(2), np.int64(1), np.int64(3), np.int64(0))]\n",
      "+---+---+---+---+---+---+---+\n",
      "| 1 | 1 | 2 | 1 | 1 | 1 | 1 |\n",
      "+---+---+---+---+---+---+---+\n",
      "| 2 | 2 | 1 | 1 | 0 | 3 | 0 |\n",
      "| 1 | 0 | 3 | 0 | 2 | 2 | 2 |\n",
      "| 3 | 3 | 0 | 2 | 3 | 0 | 1 |\n",
      "| 0 | 1 | 2 | 3 | 1 | 1 | 3 |\n",
      "+---+---+---+---+---+---+---+\n",
      "\\begin{tabular}{ccccccc}\n",
      "$1$ & $1$ & $2$ & $1$ & $1$ & $1$ & $1$\\\\\\hline \n",
      "$c$ & $c$ & $b$ & $b$ & $a$ & $d$ & $a$\\\\ \n",
      "$b$ & $a$ & $d$ & $a$ & $c$ & $c$ & $c$\\\\ \n",
      "$d$ & $d$ & $a$ & $c$ & $d$ & $a$ & $b$\\\\ \n",
      "$a$ & $b$ & $c$ & $d$ & $b$ & $b$ & $d$\n",
      "\\end{tabular}\n",
      "[0, 2] [1] [2] [0]\n",
      "([2], [[np.int64(3)], [np.int64(0)]])\n",
      "([0], [[np.int64(1)], [np.int64(3)]])\n"
     ]
    }
   ],
   "source": [
    "num_cands = 4 \n",
    "num_voters = 8\n",
    "\n",
    "for t in range(100000): \n",
    "    prof = generate_profile(num_cands, num_voters).anonymize()\n",
    "\n",
    "    if True or len(prof.ranking_types) < 10:\n",
    "\n",
    "        borda_ws = borda(prof)\n",
    "        pl_ws = plurality(prof)\n",
    "        irv_ws = instant_runoff(prof)\n",
    "        coombs_ws = coombs(prof)\n",
    "        _, irv_exp = instant_runoff_with_explanation(prof)\n",
    "        _, coombs_exp = coombs_with_explanation(prof)\n",
    "        if all([len(e)==1 for e in irv_exp + coombs_exp]) and len(irv_ws) == 1 and len(coombs_ws) == 1 and len(pl_ws) == 1 and irv_ws != coombs_ws and irv_ws != pl_ws and coombs_ws != pl_ws:\n",
    "            print(prof.ranking_types)\n",
    "            prof.display()\n",
    "            print(prof.to_latex(cmap={0: 'a', 1: 'b', 2: 'c', 3: 'd'}))\n",
    "            print(borda_ws, pl_ws, irv_ws, coombs_ws)\n",
    "            print(instant_runoff_with_explanation(prof))\n",
    "            print(coombs_with_explanation(prof))\n",
    "            break\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+\n",
      "| 100 |\n",
      "+-----+\n",
      "+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "prof = ProfileWithTies([\n",
    "    {0: 1, 2: 1, 1: 2, 3: 2}, \n",
    "    {3: 1, 0: 2, 1: 3, 2: 4}, \n",
    "    {2: 1, 1: 1, 3: 1}, \n",
    "    {3: 1, 0: 2, 1: 3, 2: 4}, \n",
    "    {1: 1, 2: 2}, \n",
    "    {}, \n",
    "    {3: 2, 1: 3, 2: 4}], \n",
    "    rcounts=[1, 1, 1, 1, 1, 1, 1], \n",
    "    cmap={0: 'a', 1: 'b', 2: 'c', 3: 'd'})\n",
    "\n",
    "prof = ProfileWithTies([{}], rcounts=[100], cmap={0: 'a', 1: 'b', 2: 'c', 3: 'd'})\n",
    "prof.display()\n",
    "\n",
    "print(prof.to_latex())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_quarto(prof, cmap = None, curr_cands = None):\n",
    "\n",
    "    cmap = cmap if cmap is not None else prof.cmap\n",
    "    rankings = prof._rankings if curr_cands is None else _find_updated_profile(prof._rankings, np.array([c for c in prof.candidates if c not in curr_cands]), len(prof.candidates))\n",
    "    \n",
    "    cs = 'c' * len(prof._rcounts)\n",
    "    \n",
    "    latex_str = \"\\\\begin{array}{\" + str(cs) + \"}\\n\"\n",
    "    latex_str += \" & \".join([f\"{rc}\" for rc in prof._rcounts]) + \"\\\\\\\\\\hline \\n\"\n",
    "    latex_str +=  \"\\\\\\\\ \\n\".join([\" & \".join([f\"{cmap[c]}\" for c in cs])  for cs in rankings.transpose()])\n",
    "    latex_str += \"\\n\\\\end{array}\"\n",
    "    \n",
    "    return latex_str\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "\n",
    "for t in range(10): \n",
    "\n",
    "    num_cands = random.choice([3, 4, 4, 4])\n",
    "\n",
    "    prof = generate_profile(num_cands, 50)\n",
    "\n",
    "    cmap = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}\n",
    "\n",
    "    num_rankings = random.choice([3, 4, 5, 6])\n",
    "    prof_smaller = Profile(prof.anonymize().ranking_types[0:num_rankings], list(prof.anonymize()._rcounts)[0:num_rankings], cmap=cmap)\n",
    "\n",
    "    prof_smaller.display()\n",
    "\n",
    "    prof_smaller.display_margin_graph()\n",
    "    print(to_quarto(prof_smaller, cmap=cmap))\n",
    "\n",
    "    for c1, c2 in combinations(prof_smaller.candidates, 2):\n",
    "        print(f\"* The margin of ${cmap[c1]}$ over ${cmap[c2]}$ is ${prof_smaller.support(c1, c2)} - {prof_smaller.support(c2, c1)} = {prof_smaller.margin(c1, c2)}$\")\n",
    "        print(f\"* The margin of ${cmap[c2]}$ over ${cmap[c1]}$ is ${prof_smaller.support(c2, c1)} - {prof_smaller.support(c1, c2)} = {prof_smaller.margin(c2, c1)}$\")\n",
    "\n",
    "    print(\"\\nThe margin graph is:\")\n",
    "    print(prof_smaller.margin_graph().to_latex(cmap=cmap))\n",
    "\n",
    "print(\"\\n\\n--------\\n\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mg = generate_margin_graph(5)\n",
    "mg.display()\n",
    "mg.debord_profile().display()\n",
    "mg.minimal_profile().display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cands = 4\n",
    "num_voters = 5\n",
    "a=0\n",
    "b=1\n",
    "c=2\n",
    "d=3\n",
    "e=4\n",
    "cmap = {a: 'a', b: 'b', c: 'c', d: 'd', e: 'e'}\n",
    "\n",
    "num_trials = 1000000\n",
    "\n",
    "for t in range(num_trials): \n",
    "    prof = generate_profile(num_cands, num_voters)\n",
    "    rankings = prof.rankings\n",
    "\n",
    "    if len(rankings) == 5:\n",
    "        v1_ranking = rankings[0]\n",
    "        borda_ws = borda(prof)\n",
    "        if len(borda_ws) == 2 and  v1_ranking[0] in borda_ws and v1_ranking[3] in borda_ws:\n",
    "\n",
    "            margins = list(set([prof.margin(c1, c2) for c1 in prof.candidates for c2 in prof.candidates if prof.majority_prefers(c1, c2)]))\n",
    "\n",
    "            if len(margins) >= 3: \n",
    "                for new_ranking in permutations(prof.candidates):\n",
    "                    new_prof = Profile([new_ranking] + rankings[1:])\n",
    "                    new_borda_ws = borda(new_prof)\n",
    "                    if (len(new_borda_ws)==2 and v1_ranking[1] in new_borda_ws and v1_ranking[2] in new_borda_ws) or (len(new_borda_ws)==1 and v1_ranking[1] in new_borda_ws):\n",
    "                        print(margins)\n",
    "                        print(prof)\n",
    "                        print(prof.to_latex(cmap=cmap))\n",
    "                        print(new_ranking)\n",
    "                        print(new_prof.to_latex(cmap=cmap))\n",
    "                        break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "condorcet_cycle = Profile([\n",
    "        [0, 1, 2], \n",
    "        [1, 2, 0], \n",
    "        [2, 0, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Profile([[0, 1, 2], [1, 2, 0], [2, 0, 1]], rcounts=[1, 1, 1], cmap={0: '0', 1: '1', 2: '2'})\n"
     ]
    }
   ],
   "source": [
    "print(condorcet_cycle.description())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condorcet_cycle.description() == \"Profile([[0, 1, 2], [1, 2, 0], [2, 0, 1]], rcounts=[1, 1, 1], cmap={0: '0', 1: '1', 2: '2'})\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cands = 5\n",
    "num_voters = 4\n",
    "\n",
    "a=0\n",
    "b=1\n",
    "c=2\n",
    "d=3\n",
    "e=4\n",
    "cmap = {a: 'a', b: 'b', c: 'c', d: 'd', e: 'e'}\n",
    "\n",
    "\n",
    "for _prof in enumerate_anon_profile(num_cands, num_voters):\n",
    "    prof = _prof.anonymize()\n",
    "    rankings = prof.rankings\n",
    "\n",
    "    if True or len(rankings) == 5:\n",
    "        v1_ranking = rankings[0]\n",
    "        borda_ws = borda(prof)\n",
    "        if len(borda_ws) == 2 and  v1_ranking[0] in borda_ws and v1_ranking[4] in borda_ws:\n",
    "        # if len(borda_ws) == 1 and  v1_ranking[1] in borda_ws:\n",
    "\n",
    "            margins = list(set([prof.margin(c1, c2) for c1 in prof.candidates for c2 in prof.candidates if prof.majority_prefers(c1, c2)]))\n",
    "\n",
    "            if len(margins) >= 2: \n",
    "                found_it = False\n",
    "                for new_ranking in permutations(prof.candidates):\n",
    "                    new_prof = Profile([new_ranking] + rankings[1:])\n",
    "                    new_borda_ws = borda(new_prof)\n",
    "                    # if (len(new_borda_ws)==2 and v1_ranking[1] in new_borda_ws and v1_ranking[2] in new_borda_ws):\n",
    "                    if (len(new_borda_ws)==2 and v1_ranking[1] in new_borda_ws and v1_ranking[2] in new_borda_ws) or (len(new_borda_ws)==2 and v1_ranking[2] in new_borda_ws and v1_ranking[3] in new_borda_ws):\n",
    "                    # if (len(new_borda_ws)==2 and v1_ranking[0] in new_borda_ws and v1_ranking[2] in new_borda_ws) or (len(new_borda_ws)==2 and v1_ranking[0] in new_borda_ws and v1_ranking[3] in new_borda_ws):\n",
    "                        print(margins)\n",
    "                        print(prof)\n",
    "                        print(borda_ws)\n",
    "                        print(prof.to_latex(cmap=cmap))\n",
    "                        print(new_ranking)\n",
    "                        print(new_borda_ws)\n",
    "                        print(new_prof.to_latex(cmap=cmap))\n",
    "                        found_it = False\n",
    "                        break\n",
    "            if found_it:\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=0\n",
    "b=1\n",
    "c=2\n",
    "d=3\n",
    "cmap = {a: 'a', b: 'b', c: 'c', d: 'd'}\n",
    "orig_prof = Profile([\n",
    "    [c, b, a, d], \n",
    "    [c, b, d, a], \n",
    "    [c, b, d, a], \n",
    "    [d, b, a, c],\n",
    "    [d, b, a, c],\n",
    "], cmap=cmap)\n",
    "orig_prof.display()\n",
    "    \n",
    "mg = orig_prof.margin_graph()\n",
    "mg.display()\n",
    "print(mg.to_latex())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=0\n",
    "b=1\n",
    "c=2\n",
    "d=3\n",
    "cmap = {a: 'a', b: 'b', c: 'c', d: 'd'}\n",
    "orig_prof = Profile([\n",
    "    [c, b, a, d], \n",
    "    [c, b, d, a], \n",
    "    [c, b, d, a], \n",
    "    [d, b, a, c],\n",
    "    [d, b, a, c],\n",
    "], cmap=cmap)\n",
    "orig_prof.display()\n",
    "\n",
    "borda_ws = borda(orig_prof)\n",
    "print(borda_ws)\n",
    "\n",
    "for t in range(20): \n",
    "    _prof = generate_profile(4, 5)\n",
    "    rankings = list(_prof.rankings)  \n",
    "    if len(rankings) == 5: \n",
    "        prof = Profile([\n",
    "            [c, b, a, d]\n",
    "        ] + rankings[1:], cmap=cmap)\n",
    "        new_borda_ws = borda(prof)\n",
    "        if borda_ws == new_borda_ws:\n",
    "            print('Match')\n",
    "            print(prof)\n",
    "            print(prof.to_latex())  \n",
    "\n",
    "            print(\"\\n--------\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in range(100): \n",
    "    _prof = generate_profile(4, 5)\n",
    "    rankings = list(_prof.rankings)  \n",
    "    if len(rankings) == 5: \n",
    "        prof = Profile([\n",
    "            [c, b, a, d]\n",
    "        ] + rankings[1:], cmap=cmap)\n",
    "        maj_g = prof.majority_graph()\n",
    "        orig_maj_g = orig_prof.majority_graph()\n",
    "        if maj_g == orig_maj_g:\n",
    "            print('Match')\n",
    "            maj_g.display()\n",
    "            print(prof.to_latex())  \n",
    "            print(\"\\n-------\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=0\n",
    "b=1\n",
    "c=2\n",
    "d=3\n",
    "cmap = {a: 'a', b: 'b', c: 'c', d: 'd'}\n",
    "orig_prof = Profile([\n",
    "    [c, b, a, d], \n",
    "    [d, b, a, c], \n",
    "    [b, c, a, d],\n",
    "    [b, d, a, c],\n",
    "    [b, c, a, d]\n",
    "], cmap=cmap)\n",
    "\n",
    "print(orig_prof.to_latex())\n",
    "orig_prof.display()\n",
    "    \n",
    "mg = orig_prof.margin_graph()\n",
    "mg.display()\n",
    "print(mg.to_latex())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in range(100000): \n",
    "    _prof = generate_profile(4, 5)\n",
    "    rankings = list(_prof.rankings)  \n",
    "    if True or len(rankings) == 5: \n",
    "        prof = Profile([\n",
    "            [c, b, a, d]\n",
    "        ] + rankings[1:], cmap=cmap)\n",
    "        mg = prof.margin_graph()\n",
    "        orig_maj_g = orig_prof.margin_graph()\n",
    "        if mg == orig_maj_g:\n",
    "            print('Match')\n",
    "            mg.display()\n",
    "            print(prof.to_latex())  \n",
    "\n",
    "            print(\"\\n----------\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _revealed_weak_preference(c1, c2, menu, choice): \n",
    "    \"\"\"Returns the revealed weak preference of a menu of choices. \n",
    "    \"\"\"\n",
    "\n",
    "    return c1 in menu and c2 in menu and c1 in choice\n",
    "\n",
    "def _revealed_strict_preference(c1, c2, menu, choice): \n",
    "    \"\"\"Returns the revealed strict preference of a menu of choices. \n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    return _revealed_weak_preference(c1, c2, menu, choice) and not _revealed_weak_preference(c2, c1, menu, choice)\n",
    "\n",
    "def _revealed_indifference(c1, c2, menu, choice): \n",
    "    \"\"\"Returns the revealed indifference of a menu of choices. \n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    return _revealed_weak_preference(c1, c2, menu, choice) and  _revealed_weak_preference(c2, c1, menu, choice)\n",
    "\n",
    "print( {1, 2}, {1, 2})\n",
    "print(_revealed_weak_preference(1, 2, {1, 2}, {1, 2}))\n",
    "print(_revealed_weak_preference(2, 1, {1, 2}, {1, 2}))\n",
    "\n",
    "print(_revealed_strict_preference(1, 2, {1, 2}, {1, 2}))\n",
    "print(_revealed_strict_preference(2, 1, {1, 2}, {1, 2}))\n",
    "print(_revealed_indifference(1, 2, {1, 2}, {1, 2}))\n",
    "print(_revealed_indifference(2, 1, {1, 2}, {1, 2}))\n",
    "\n",
    "print( {1, 2}, {1})\n",
    "print(_revealed_weak_preference(1, 2, {1, 2}, {1}))\n",
    "print(_revealed_weak_preference(2, 1, {1, 2}, {1}))\n",
    "print(_revealed_strict_preference(1, 2, {1, 2}, {1}))\n",
    "print(_revealed_strict_preference(2, 1, {1, 2}, {1}))\n",
    "print(_revealed_indifference(1, 2, {1, 2}, {1}))\n",
    "print(_revealed_indifference(2, 1, {1, 2}, {1}))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "comparisons1 = [({\"A\", \"B\"}, {\"A\"}), ({\"A\", \"C\"}, {\"C\"}), ({\"B\", \"C\"}, {\"B\"})]\n",
    "comparisons2 = [({\"A\", \"B\"}, {\"B\"}), ({\"A\", \"C\"}, {\"A\"}), ({\"B\", \"C\"}, {\"C\"})]\n",
    "pprof = PairwiseProfile([PairwiseComparisons(comparisons1), PairwiseComparisons(comparisons2)], rcounts=[3,2])\n",
    "\n",
    "pprof.display()\n",
    "\n",
    "pprof.margin_graph().display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_pcomps = [(0, 1), (2, 1), ({0, 2}, {0, 2})]\n",
    "pcomps = PairwiseComparisons(_pcomps)\n",
    "print(pcomps.is_coherent())\n",
    "pcomps.display()\n",
    "print(pcomps)\n",
    "print(\"pcomps.weak_preference(0, 1)\", pcomps.weak_preference(0, 1))\n",
    "print(\"pcomps.weak_preference(1, 0)\", pcomps.weak_preference(1, 0))\n",
    "print(\"pcomps.strict_preference(0, 1)\", pcomps.strict_preference(0, 1))\n",
    "print(\"pcomps.strict_preference(1, 0)\", pcomps.strict_preference(1, 0))\n",
    "print(\"pcomps.indifference(0, 1)\", pcomps.indifference(0, 1))   \n",
    "print(\"pcomps.indifference(1, 0)\", pcomps.indifference(1, 0))\n",
    "\n",
    "print(\"pcomps.weak_preference(0, 2)\", pcomps.weak_preference(0, 2))\n",
    "print(\"pcomps.weak_preference(2, 0)\", pcomps.weak_preference(2, 0))\n",
    "print(\"pcomps.strict_preference(0, 2)\", pcomps.strict_preference(0, 2))\n",
    "print(\"pcomps.strict_preference(2, 0)\", pcomps.strict_preference(2, 0))\n",
    "print(\"pcomps.indifference(0, 2)\", pcomps.indifference(0, 2))   \n",
    "print(\"pcomps.indifference(2, 0)\", pcomps.indifference(2, 0))\n",
    "\n",
    "\n",
    "print(\"pcomps.weak_preference(3, 4)\", pcomps.weak_preference(3, 4))\n",
    "print(\"pcomps.strict_preference(3, 4)\", pcomps.strict_preference(3, 4))\n",
    "print(\"pcomps.indifference(3, 4)\", pcomps.indifference(3, 4))   \n",
    "\n",
    "print(\"pcomps.has_comparison(0, 1)\", pcomps.has_comparison(0, 1))\n",
    "print(\"pcomps.has_comparison(1, 0)\", pcomps.has_comparison(1, 0))\n",
    "print(\"pcomps.has_comparison(0, 2)\", pcomps.has_comparison(0, 2))\n",
    "print(\"pcomps.has_comparison(2, 0)\", pcomps.has_comparison(2, 0))\n",
    "print(\"pcomps.has_comparison(3, 4)\", pcomps.has_comparison(3, 4))\n",
    "print(\"pcomps.has_comparison(2, 4)\", pcomps.has_comparison(2, 4))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pprof = PairwiseProfile([\n",
    "    [[{0, 1}, {1}], (3, 2)], \n",
    "    [[{0, 2}, {2, 0}], [{0, 1}, {1}]]], \n",
    "    rcounts=[3, 2])\n",
    "\n",
    "print(pprof)\n",
    "\n",
    "pprof.display()\n",
    "print(pprof.candidates)\n",
    "print(pprof._pairwise_comparisons)\n",
    "print(pprof._tally)\n",
    "for c in pprof.candidates:\n",
    "    for d in pprof.candidates:\n",
    "        print(f'margin({c}, {d}) = {pprof.margin(c,d)}') \n",
    "\n",
    "print(pprof.condorcet_winner())\n",
    "\n",
    "print(pprof.condorcet_loser())  \n",
    "pprof.margin_graph().display()\n",
    "\n",
    "split_cycle.display(pprof.margin_graph())\n",
    "\n",
    "bradley_terry.display(pprof)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "violations = superior_voting.get_violation_witness(\"condorcet_winner\")\n",
    "\n",
    "for prof_type, prof in violations.items():\n",
    "    if prof is not None:\n",
    "        print(prof_type)\n",
    "        print(prof)\n",
    "        condorcet_winner.has_violation(prof, superior_voting, verbose=True)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vm in voting_methods.filter(violates=[\"condorcet_winner\"], election_types=[ElectionTypes.PROFILE]):\n",
    "    print(vm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vm in voting_methods: \n",
    "    print(vm)\n",
    "    elections = vm.get_violation_witness(\"condorcet_winner\")\n",
    "    for prof_type, prof in elections.items():\n",
    "        if prof is not None:\n",
    "            print(prof_type)\n",
    "            condorcet_winner.has_violation(prof, vm, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vm in voting_methods:\n",
    "    print(vm.__name__)\n",
    "    print(vm.name)\n",
    "    print(vm.properties.items())\n",
    "    print(vm.get_properties())\n",
    "    print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(axioms_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prof = generate_profile(5, 10)\n",
    "prof.display()\n",
    "\n",
    "print(prof.margin(0, 4))\n",
    "\n",
    "pickle.dump(prof, open(\"profile.pkl\", \"wb\"))\n",
    "prof = pickle.load(open(\"profile.pkl\", \"rb\"))\n",
    "prof.display()\n",
    "\n",
    "print(prof.margin(0, 4))\n",
    "\n",
    "\n",
    "for vm in voting_methods:\n",
    "    print(vm.name)\n",
    "    if ElectionTypes.PROFILE in vm.input_types:\n",
    "        print(vm(prof))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = [2, 0, 5, 4, 3, 1]\n",
    "u = Utility.from_linear_ranking(r, seed=42)\n",
    "print(u)\n",
    "u.ranking().to_linear()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prof = generate_profile(3, 2, seed=42)\n",
    "\n",
    "prof.display()\n",
    "\n",
    "uprof = prof.to_utility_profile()\n",
    "\n",
    "uprof.display()\n",
    "\n",
    "uprof.to_ranking_profile().to_linear_profile().display()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng(42)\n",
    "        \n",
    "utilities = sorted(rng.random(size=6), reverse=True)\n",
    "print(utilities)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prof = ProfileWithTies([\n",
    "    {'a': 1, 'b': 2, 'c': 3},\n",
    "    {'a': 2, 'b': 1, 'c': 3},\n",
    "    {'a': 3, 'b': 2, 'c': 1},\n",
    "    {'a': 3},\n",
    "    {'a': 2, 'b': 3, 'c': 1},\n",
    "    {'a': 1, 'b': 3},\n",
    "])\n",
    "\n",
    "prof.display()\n",
    "\n",
    "split_cycle.display(prof)\n",
    "split_cycle.display(prof, algorithm='basic_parallel')\n",
    "\n",
    "split_cycle.display(prof, curr_cands = ['b', 'c'])\n",
    "\n",
    "split_cycle.display(prof, algorithm='basic_parallel', curr_cands = ['b', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "for t in tqdm(range(1000)): \n",
    "\n",
    "    prof = generate_profile(random.choice([4, 5, 10, 15]),random.choice([5, 10, 100, 1001]))\n",
    "    sc_ws = split_cycle(prof)\n",
    "    sc_ws_parallel = split_cycle(prof, algorithm='basic_parallel')\n",
    "\n",
    "    if sc_ws != sc_ws_parallel:\n",
    "        print(prof)\n",
    "        print(sc_ws)\n",
    "        print(sc_ws_parallel)\n",
    "        print(\"Error\")\n",
    "        break\n",
    "\n",
    "    sc_ws = split_cycle(prof, curr_cands = [1, 2, 3])\n",
    "    sc_ws_parallel = split_cycle(prof, curr_cands = [1, 2, 3], algorithm='basic_parallel')\n",
    "\n",
    "    if sc_ws != sc_ws_parallel:\n",
    "        print(prof)\n",
    "        print(sc_ws)\n",
    "        print(sc_ws_parallel)\n",
    "        print(\"Error\")\n",
    "        break\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "profs = [generate_edge_ordered_tournament(500) for _ in range(5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "print(len([split_cycle(mg) for mg in profs]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "print(len([split_cycle(mg, algorithm='basic_parallel', num_cpus=8) for mg in profs]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%time\n",
    "\n",
    "print(len([split_cycle(prof, algorithm='floyd_warshall') for prof in profs]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_cycle.set_algorithm(\"floyd_warshall\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Total number of voting methods \", len(list(voting_methods)))\n",
    "\n",
    "print(\"Total number of voting methods accepting Profile \", len(voting_methods.filter(election_types=[ElectionTypes.PROFILE])))\n",
    "\n",
    "print(\"Total number of Condorcet Consistent voting methods \", len(voting_methods.filter(satisfies=[\"condorcet_winner\"])))\n",
    "\n",
    "print(\"Total number of voting methods satisfying condorcet_winner and condorcet_loser\", len(voting_methods.filter(satisfies=[\"condorcet_winner\", \"condorcet_loser\"])))\n",
    "\n",
    "print(\"Total number of voting methods satisfying pareto_dominance\", len(voting_methods.filter(satisfies=[\"pareto_dominance\"])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the function name of the voting method\n",
    "#print(voting_methods.get(\"borda\").name)\n",
    "# not the name parameter but rather the name of the function\n",
    "print(borda.vm.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vm in voting_methods: \n",
    "    print(vm.name)\n",
    "    print(voting_methods.method_type(vm.name))    \n",
    "    print(voting_methods.file_location(vm.name))\n",
    "\n",
    "    filename = voting_methods.file_location(vm.name).split(\".\")[0]\n",
    "    print(f\"https://pref-voting.readthedocs.io/en/latest/{filename}.html#pref_voting.{filename}.{vm.vm.__name__}\")\n",
    "    #scoring_methods.html#pref_voting.scoring_methods.scoring_rule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Total number of voting methods \", len(voting_methods))\n",
    "\n",
    "print(\"Total number of voting methods accepting TruncatedLinearOrders \", len(voting_methods.filter(election_types=[ElectionTypes.TRUNCATED_LINEAR_PROFILE])))\n",
    "\n",
    "print(\"Total number of voting methods accepting MarginGraph \", len(voting_methods.filter(election_types=[ElectionTypes.MARGIN_GRAPH])))\n",
    "\n",
    "print(\"Total number of voting methods accepting MajorityGraph \", len(voting_methods.filter(election_types=[ElectionTypes.MAJORITY_GRAPH])))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "voting_methods.display_methods()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prof = generate_profile(4, 5)\n",
    "for vm in voting_methods:\n",
    "    print(vm)\n",
    "    if ElectionTypes.PROFILE in vm.input_types:\n",
    "        vm.display(prof)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vmidx,vm in enumerate(voting_methods): \n",
    "    print(f\"{vmidx+1}. {vm}\")\n",
    "    vm.save_properties()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "for t in range(10000): \n",
    "    prof = generate_profile(10, 100)\n",
    "    if pareto_dominance.has_violation(prof,superior_voting, verbose=True): \n",
    "        print(prof)\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pref_voting.swf_axioms import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R=0\n",
    "D=1\n",
    "P=2\n",
    "prof = Profile([\n",
    "    [R, D, P],\n",
    "    [P, D, R],\n",
    "    [D, P, R]\n",
    "], \n",
    "[40, 35, 25],\n",
    ")\n",
    "\n",
    "prof.display()\n",
    "\n",
    "plurality.display(prof)\n",
    "instant_runoff.display(prof)\n",
    "split_cycle.display(prof)\n",
    "\n",
    "sc_ranking = swf_from_vm(split_cycle)\n",
    "\n",
    "@swf(\"DPR\")\n",
    "def dpr(profile, curr_cands=None):\n",
    "    return Ranking({D: 1, P: 2, R: 3})\n",
    "@swf(\"DRP\")\n",
    "def drp(profile, curr_cands=None):\n",
    "    return Ranking({D: 1, P: 3, R: 2})\n",
    "@swf(\"RPD\")\n",
    "def rpd(profile, curr_cands=None):\n",
    "    return Ranking({D: 3, P: 2, R: 1})\n",
    "@swf(\"RDP\")\n",
    "def rdp(profile, curr_cands=None):\n",
    "    return Ranking({D: 2, P: 3, R: 1})\n",
    "@swf(\"PDR\")\n",
    "def pdr(profile, curr_cands=None):\n",
    "    return Ranking({D: 2, P: 1, R: 3})\n",
    "@swf(\"PRD\")\n",
    "def prd(profile, curr_cands=None):\n",
    "    return Ranking({D: 3, P: 1, R: 2})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "instant_runoff_ranking.display(prof)\n",
    "\n",
    "irv_swf2 = swf_from_vm(instant_runoff)\n",
    "irv_swf2.display(prof)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "core_support.find_all_violations(prof.anonymize(),pdr, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "core_support.has_violation(prof.anonymize(),drp, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "borda.get_properties()\n",
    "\n",
    "borda.add_property(\"condorcet_winner\", False)\n",
    "borda.save_properties()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}