pref_voting_testing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": 3,
   "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": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwBElEQVR4nO3deXRV5aH38d8+h4QkZBIZEglDQBkiQYtXBdSEqgwWvUWkdUDgUC/oW2r19fq+V7EUX7Ro26u1t7a9DncRwAv1Ilq5ppahl0EUHEAhkAg0kdEMgEISA5nOfv9IkxIl4czn7L2/n7VcK5xz9t7PyVosfzy//ezHME3TFAAAABAgV7QHAAAAAGsjUAIAACAoBEoAAAAEhUAJAACAoBAoAQAAEBQCJQAAAIJCoAQAAEBQCJQAAAAICoESAAAAQSFQAgAAICgESgAAAASFQAkAAICgECgBAAAQFAIlAAAAgkKgBAAAQFAIlAAAAAgKgRIAAABBIVACAAAgKARKAAAABIVACQAAgKAQKAEAABAUAiUAAACCQqAEAABAUAiUAAAACAqBEgAAAEEhUAIAACAoBEoAAAAEhUAJAACAoBAoAQAAEBQCJQAAAIJCoAQAAEBQukR7ANFyrKZeu4+eUnFFtapPN6qx2VSc21BqYpxyMlI1vE+aeqZ0jfYwAQAAYp6jAmVJebWWbTuotcUVOl7bIElyuwy5DMk0JcOQvKbU7DUlST2S4zU+J0PTR/XXsMzUaA4dAAAgZhmmaZrRHkQ4maapNcWVemFTqT4+fFJul9EWGH3R+vmR/dI1J2+QJuT0lmEYYRwxAACAtdg6UFbVnNG8N3ZrfUmlXH+bfQxU6/E3DuutRbcOV6+UhNANFAAAwMJsGygLi8r1yKpdqmts9mtG8nzcLkNJcW49fdsITcrNDNl5AQAArMqWgfLlLWV6srBEhqRwfLnW886flKN7rs0OwxUAAACsw3aLclrDpPTNMPngDZfowRsHS5IGPFoY8DVaz/tEYbEkESoBAICj2eo5lIVF5W1hMlKeKCxWYVF5RK8JAAAQS2wTKKtqzuiRVbsU6fXXhqRHXt+lYzX1Eb4yAABAbLBFoDRNU/Pe2K26xuaw3DPZ6bUl1TU0a94fi2TD21EBAADOyxaBck1xpdaXVIZ0Nbc/mr2m1hVXak1xZVSuDwAAEE22CJQvbi6VK8rPGncZLeMAAABwGsuv8i4pr9aOQycDOjY1oYvuuTZbNw3PVJ/0RDU2e1VSXqMVHx7S6p2f+3UuryntOHRSn1ZUa2gG2zQCAADnsHygXLbtoN/bKUpS1gWJeuWeqzXgwm7tXh896EKNHnShxuf01gOvfuL3No1Ltx7Uoltz/RoLAACAlVm+8l5bXBHQvZPP3zlSfS9I0ivbDuqul7fplue36P+8tlOlx2olSTePuEjzbhrq1zmbvabWFlf4PRYAAAArs/QM5bGaeh2vbQjo2Mv7puvHf/i4XbVddPSU/lRUrpX3jlbORWnyjMnWqx8d1r7KWp/Pe7y2Qcdr69UjuWtA4wIAALAaS89Q7j56KuBj15dUnvM+ya8amvXoG0WSWirsaVf39/vcRUGMCwAAwGosHSiLK6rlDnB598rtRzp8b+eRU9pbUSNJunZQD7/O63YZKi6vDmhMAAAAVmTpQFl9ujHgxwXtOnKy0/d3/u397B7dFOf2/SIuQ6o50xTYoAAAACzI0oGysdlUoJvTnDjPvZfHa1u2UnS5DKUlxvl17oYmb2CDAgAAsCBLB8o4tyEjwBlKM4ybNMZ3sfSvFQAAwC+WTj6piXEKdLfF863Cbn3f6zV16nSjz+f1mlJKgqUXzwMAAPjF0oEyJyM14P27R2Sln+f9NEnSZye+UmOz79do9prKyWSnHAAA4ByWDpTD+6QFfOzUkX06fG9EVlrb9onv/vW43+fODWJcAAAAVmPpbrZnSlf1SI4P6OHm43IyNCk3U4VF5e1eT4p3a9Hklq0Tm72mln9wyK/zXtgtTp+V7NL7VVU6evRou/+ys7P1m9/8Rm632+/xAgAAxCpLB0pJGp+ToVc/Oux39b3zyEn9+vbLdXV2d729u0I1Zxo1LDNV9+UN0qBeyZKkpdsO6NO/PY/SF26XoYPvrtZV83/b4WeeeuoppaUxgwkAAOzD8oFy+qj+fs8iStLc5Tu0/J9GacboAZoxesA33v9TUbmeLCzx65zNXlP1Res6fD8/P58wCQAAbMfS91BK0rDMVI3sl+73A86PfHlaN//mHT2/4a/aX1mjuoYmVZ9u1PtlJ/TAqx/rh8t3+DXr6TKkkf3StWPDW+revfs5P3P8+HGtWLFCp0+f9m+wAAAAMcwwzUAfDR47/rynQve9sj3aw9C/332FJl6aoaKiIuXl5enkyZPn/FxqaqruuOMOeTwejRo1SkagD9MEAACIAbYIlKZpavay7dqwtyrgxwgFw+0ydP3QXnrx7ivawuF7772ncePGqa6uTpI0ZcoU5ebmasmSJTpw4EDbsYMHD5bH49H06dOVlZUV8bEDAAAEyxaBUpKqas7ohmc2qba+KYx74HyTISk5oYv+56Gx6pnS/mHpa9as0S233KLGxkZt3LhR+fn58nq92rx5swoKCrRy5cq2wGkYhsaNGyePx6PJkycrMTExgt8CAAAgcLYJlJJUWFSuuct3RPy6v71rpCblZp7zvXfffVcHDhzQtGnTvvFeTU2NVq1apYKCAm3atKntdSpxAABgJbYKlJL0H1s+0xOFxRG73vxJObrn2uygz1NWVqalS5dSiQMAAMuxXaCU/h4qDSks9XfreX96c45+cE3wYfJsVOIAAMBqbBkopZb6+5FVu1TX2BzShTpul6GkeLeenjKiw5o7VKjEAQCAFdg2UEotC3XmvbFb60sq5TKkYHJl6/Hjcnpr0eTcbyzACTcqcQAAEKtsHSillkcKrSmu1IubS7Xj0Em5XYZfM5atnx/ZL11z8gZpQk7vqM4IUokDAIBYY/tAebaS8mot23ZQa4srdLy2QVJLYDx7lx2vqbbA2SM5XuNzMjR9VH8Ny0yNxpA7RSUOAABigaMC5dmO19ar6Ogp/XlbkVb995+Ul3+9Bl8ySCkJXZSTmarcPmnqkRzZWjsYVOIAACBaHBsoWw0dOlR79+5VZmamjh49avnZPCpxAAAQaY4OlB9++KGuuuqqtj+vWbNG48ePj+KIQotKHAAARIKjA+XNN9+swsLCtj+PHj1a7777ri0DFpU4AAAIF8cGyq/PTray2yzl11GJAwCAUHNsoPz67GQrO89Sfh2VOAAACAVHBsp9+/ZpyJAhHb6/detWjRo1KoIjij4qcQAAEChHBsrKykrl5+fr6NGjamhoUENDg+Li4tS1a1f17NlT69ev18CBA6M9zKigEgcAAP5yZKA824IFC7Rw4ULNnTtXzz//fLSHE1OoxAEAgC9c0R4AYldKSoo8Ho82btyo0tJSLViwQAMGDFB1dbVefPFFjRkzRkOHDtVTTz2lI0eORHu4AAAgSgiU8MnAgQP1+OOPq7S0VBs2bNDMmTOVlJSkffv2ad68eerXr58mTJigFStW6PTp09EeLgAAiCACJfzicrk0duxYFRQUqKKiQosXL1Z+fr5M09TatWt11113KSMjQ/fee6+2bt0qh99RAQCAIxAoETAqcQAAIBEoESJU4gAAOBeBEiFFJQ4AgPMQKBE2VOIAADgDgRIRQSUOAIB9ESgRUVTiAADYD4ESUUMlDgCAPRAoEROoxAEAsC4CJWIKlTgAANZDoETMOlcl3r9//3aV+JAhQ7Ro0SIdPnw42sMFAMCxCJSwhNZKvKysrF0lvn//fj322GPq37+/xo8fr+XLl1OJAwAQYQRKWEpnlfi6des0bdo0KnEAACKMQAnLohIHACA2EChhC1TiAABED4EStkIlDgBA5BEoYVtU4gAARAaBEo5AJQ4AQPgQKOEoVOIAAIQegRKORSUOAEBoECgBUYkDABAMAiVwFipxAAD8R6AEOkAlDgCAbwiUgA/8qcTr6uqiPVwAACKKQAn4wZdKPDMzU3PmzNF7771HJQ4AcAQCJRCgzirxl156Sddccw2VOADAEQiUQAhQiQMAnIxACYQQlTgAwIkIlECYUIkDAJyCQAlEAJU4AMDOCJRABFGJAwDsiEAJRAmVOADALgiUQAygEgcAWBmBEoghVOIAACsiUAIxikocAGAVBErAAqjEAQCxjEAJWAiVOAAgFhEoAYuiEgcAxAoCJWADVOIAgGgiUAI2QiUOAIgGAiVgU1TiAIBIIVACDkAlDgAIJwIl4CBU4gCAcCBQAg5FJQ4ACBUCJQAqcQBAUAiUANpQiQMAAkGgBHBOVOIAAF8RKAGcF5U4AKAzBEoAPqMSBwCcC4ESQECoxAEArQiUAIJGJQ4AzkagBBAyVOIA4EwESgBhQSUOAM5BoAQQdlTiAGBvBEoAEUMlDgD2RKAEEBVU4gBgHwRKAFFHJQ4A1kagBBAzqMQBwJoIlABiEpU4AFgHgRJAzKMSB4DYRqAEYBlU4gAQmwiUACyJShwAYgeBEoDlUYkDQHQRKAHYBpU4AEQHgRKALVGJA0DkECgB2B6VOACEF4ESgGNQiQNAeBAoATgSlTgAhA6BEoDjUYkDQHAIlADwN1TiABAYAiUAnAOVOAD4jkAJAOdBJQ4AnSNQAoCPqMQB4NwIlAAQACpxAPg7AiUABIlKHIDTESgBIESoxAE4FYESAMKAShyAkxAoASDMqMQB2B2BEgAihEocgF0RKAEgCqjEAdgJgRIAooxKHIDVESgBIEZQiQOwKgIlAMQgKnEAVkKgBIAYRyUOINYRKAHAIqjEAcQqAiUAWBCVOIBYQqAEAIujEgcQbQRKALAJKnEA0UKgBAAbohIHEEkESgCwOSpxAOFGoAQAh6ASBxAuBEoAcCAqcQChRKAEAIejEgcQLAIlAEASlTiAwBEoAQDfQCUOwB8ESgBAp6jEAZwPgRIA4JNoVeLr16/XunXrdODAgZCcD0DoESgBAH6LVCV+4sQJTZw4Ud/97nd15ZVX6tJLL9Wzzz6r+vr6EH4bAMEiUAIAghLOSryxsVEvv/yy7r//fg0YMEAlJSV65plntHPnzjB9GwCBIFACAELCn0r8q6++8qkSz8jIkMfj0c9//nM9/PDDSkhI0NSpU3XxxRdLkkzTbDtPU1NTWL8fgI4RKAEAIddZJb5161Z169ZNhmGc9zytYfHYsWNav369vF6v8vLy1L17d0lqd47Vq1dr4sSJWrRokaqqqsLzxQCcE4ESABBWX6/Ef/GLX/g9m1haWqqNGzdq5MiRuuyyy9q9ZxiGGhsb9fHHH2vt2rX6yU9+ooyMDOXl5enVV18N5VcB0AECJQAgIlor8ZtuukldunTx6ZjWGcj3339fZWVlGj9+vPr06dP2fusMZllZmdauXashQ4boP//zPzV//nzV1dXpzjvvVLdu3TRt2jQeaQSEkW9/owEAiDDTNGUYho4cOaK//OUv6t69u/Lz85WYmNj2mdbA+dFHH+mTTz7Ro48+qjvvvFNer1d33XWXdu7cqdWrV6u2tlbx8fHR+iqA7REoAQAxqTUsFhUVadu2bbr22ms1dOhQSX8Pm5J08uRJbdiwQYZhaOTIkaqpqVFKSoqGDBmiIUOG6KabbtKZM2d8nhUF4D/+dgEAYo7X65XL5VJ9fb3effddnThxQhMmTFCvXr0ktV+Ms3fvXpWVlamhoUHz58/XmDFj9J3vfEfXX3+9unXrppSUFKWkpETrqwCOwD2UAICY43K1/O9p//79Wr9+vQYOHKirrrpKbrf7G5/t1auX7r//fi1ZskS5ublatmyZZsyYoWeeeSZku/UA6BwzlACAmLJt2zZddNFF6tevn/bt26ddu3ZpxowZ6t+//zk/n52drezsbEnS9OnTdeTIEf3zP/+zHn/8cSUnJ+uhhx6K5PABRyJQAgBixtGjRzV79mzFxcXp29/+tvbt2ydJuvnmm3XhhRdKan//5Nl/Nk1TXq9XWVlZmjdvnjZv3qwXXnhBM2fObDsWQHhQeQMAYkZ6erruuOMOlZeX61e/+pUKCwsVFxenDz74QHv27FFjY2OHD0Q3DENut1umaeqyyy7T2LFjtX//fu3ZsyfC3wJwHgIlACBmdOvWTY899pjKy8u1ZcsWzZw5Uw0NDXryySc1YcIE/exnP9OJEyckteyeI/19gU7rNoytfy4rK5PUsn1j6/sAwoNACQCISWPGjNHixYtVW1urgoIC9e/fX/v371dKSorq6+t144036mc/+5mqq6sltQTL1jC5detW7dq1Szk5ORo8eHDb+wDCg3soAQAxze12a8aMGZoxY4bq6uoUHx+vQ4cOKTExUc8++6w+/PBDff/739ell16q4cOHa926dVqwYIHq6+t13333SfrmfZetTNNUU1OT4uLiIv21AFshUAIALCMpKUmS1K9fPy1fvlwvvfSSXnrpJb311lvKzMxUQ0ODjh07Jrfbrdtvv12zZ8+W1PHspNfr1fz587Vjxw55PB5Nnjy57RoAfEegBABY0sCBA/XUU0/pySef1IoVK/T222+rrq5Offv21be+9S15PJ621d+dLeRZtmyZPv/8c61bt06pqam6/fbb5fF4NHr0aGpywEcESgCApbndbt199926++67dfr06XZ7fXcWJqWWB6i/8847Wrp0qZYsWaIDBw60zXpecskl8ng8mj59uvr27RuJrwJYFotyAAC2kZiY2G41ty8zjAMHDtTjjz+u0tJSbdiwQTNnzlRSUpL279+vxx57TP3799f48eO1fPly1dXVhXP4gGURKAEAthJoTe1yuTR27FgVFBSooqJCixcvVn5+vkzT1Lp16zRt2jRlZmZqzpw5eu+993gMEXAWAiUAAF+TkpIij8ejjRs3qrS0VAsWLNCAAQNUXV2tl156Sddcc42GDBmiRYsW6fDhw9EeLhB1BEoAADpBJQ6cH4ESAAAfUIkDHSNQAgDgJypxoD0CJQAAQaASBwiUAACEBJU4nIxACQBAiFGJw2kIlAAAhBGVOJyAQAkAQARQicPOCJQAAEQYlTjshkAJAEAUUYnDDgiUAADEACpxWBmBEgCAGEMlDqshUAIAEMP8qcRPnz4d7eHCoQiUAABYgC+VeEZGhu69915t3bqVShwRRaAEAMBiOqvEX3zxRY0ZM4ZKHBFFoAQAwMKoxBELCJQAANgAlTiiiUAJAIDNUIkj0giUAADYGJU4IoFACQCAA1CJI5wIlAAAOAyVOEKNQAkAgINRiSMUCJQAAIBKHEEhUAIAgHaoxOEvAiUAAOgQlTh8QaAEAADnRSWOzhAoAQCAX3ypxIcOHaqnnnpKR44cifZwEQEESgAAELCOKvF9+/Zp3rx56tevnyZMmKAVK1ZQidsYgRIAAASts0p87dq1uuuuu6jEbYxACQAAQopK3HkM0+H/RFiwYIEWLlyouXPn6vnnn4/2cAAAsCWv16vNmzeroKBAK1euVF1dnSTJMAyNGzdOHo9HkydPVmJiYpRH2rljNfXaffSUiiuqVX26UY3NpuLchlIT45STkarhfdLUM6VrtIcZcV2iPQAAAGB/rZX42LFj9Zvf/EarVq1SQUGBNm3apLVr12rt2rVKTU3VHXfcIY/Ho1GjRskwjGgPW5JUUl6tZdsOam1xhY7XNkiS3C5DLkMyTckwJK8pNXtb5uh6JMdrfE6Gpo/qr2GZqdEcesQwQ8kMJQAAUVNWVqalS5dqyZIlOnDgQNvrgwcPlsfj0fTp05WVlRXxcZmmqTXFlXphU6k+PnxSbpfRFhh90fr5kf3SNSdvkCbk9I6ZgBwO3EMJAACiJhZXiVfVnNHsZdt13yvbtfPISUnyK0ye/flPDp/Ufa9s1+xl21VVcybUQ40ZBEoAABB1sbJKvLCoXDc8s0kb9lZJaqmyg9F6/Ia9VbrhmU0qLCoPcoSxiUAJAABiSrRWib+8pUxzl+9QbX2T3zOS59PsNVVb36S5y3foP7Z8FtJzxwICJQAAiFmRqsRf3lKmJwtLJEnhWlzSet4nCottFyoJlAAAIOaFsxIvLCpvC5OR8kRhsa3qbwIlAACwlFBW4lU1Z/TIql2K9PprQ9Ijr+/SsZr6CF85PAiUAADAsoKpxE3T1Lw3dquusTlsNXdHTEl1Dc2a98ciW2xDSaAEAACWF0glvqa4UutLKkO+AMdXzV5T64ortaa4MirXDyUCJQAAsBVfK/H/9+oWuaL8rHGXIb24uTS6gwgBtl4EAAC21VqJ//SnP223l/hnXzaovtH/fcMH907W+JwMXTWguy7pnazu3eLV1GyqqqZeOw59qVe2HdTHh0/6fD6vKe04dFKfVlRraIZ1t2lkhhIAANje1yvxWx76pQw/75wcld1dax/M18PjhyhvcE9lpiWqaxe3unXtouwe3XTbyCy98cNr9H8nDPHrvG6XoaVbD/p1TKxhhhIAADhKSkqKDjanyVSDX8e5XYa+qm/Shr1Veq/0hEqP1ar2TJMuTI7XJb1TNGvMAGVdkKQfjr1Ynx3/Siu3+/bQ9WavqbXFFVp0a24gXycmECgBAICjHKup1/Fa/8KkJBWXV2v0039R9Zmmb7y3ef9xLd16QP8x80rlXdJTD9xwiVbtOOLz1o3Haxt0vLZePZK7+j2uWEDlDQAAHGX30VMBHfdlXeM5w2SrxmZTT/2p5QHpWRckKSfTv3siiwIcVywgUAIAAEcprqiWOwTLu+PdLl2UlqCLeyVrcO+W/wzj7+cd5kegdLsMFZdXBz2maKHyBgAAjlJ9ulEuQ2oO4NjEOLdmjRmgWy67SJf0SlYXd8dzc927xft8Xpch1XQy+xnrCJQAAMBRGptNBbI5TVZ6opbPHqV+3ZN8+nxCnNuv8zc0ef0fVIwgUAIAAEeJcxsyAmi8n/3+5erXPUler6mV24/ov3d9rr9W1eqLrxrU0NwSBg1D+mzRpJaf/Tx/fBfr3olIoAQAAI6Smhjn8+rrVoN6dtNV2d0lSb/d+Fc9s27fOT+XnhgX0Ji8ppSSYN1YZt0oDAAAEICcjFS/9+++pFdK289v7Srv8HMjstIDGlOz1/R7VXgsIVACAABHGd4nze9jupy1KjwpvuN7I6dd1S+gMUlSbgDjihXWnVsFAADowMaNG3Xw4EH16dNHffr0UVZWllJSWmYZe6Z0VY/keL8ebv7Zia/afp56RdY59+u+++p+Gn9pRkDj7ZEcb9mHmksESgAAYDNffvmlbrjhBnm97VdNJyUlKS4uTgMGDNBNP12q/9p+xOfqe8/n1fq0olpDM1I17er+SkuM0+sfH1VV9RllpiVq8rf6aFJupj488IWuHNDdr/G6XYbG5wQWRGMFgRIAANhKWlqasrKydOjQoXav19XVSZJ27typFy7trhUfHvbrvA/9104t/6erlZ4Ur5tHXKSbR1zU7v2S8mr9cPkOfTjvRr/O2+w1NWN0f7+OiTXcQwkAAGzlq6++0mWXXdbh+08++aSuHpKlkf3S5c+GOcXl1frOv72jV7Yd1JEv69TQ5NWXdQ365PCXerKwWJN/966O1dT7NVaXIY3sl66hGdZdkCMxQwkAAGzA6/Vq06ZNKigo0GuvvdY2G/l1v/71r/XjH/9YkjQnb5Due2W7X9f5/NQZ/eTN3Z1+ZsCjhT6fz2u2jMPqCJQAAMCySktLtXTpUi1ZskQHDx5se33w4MFqaGjQgQMH2l5bsGBBW5iUpAk5vXXjsN7asLfK78cIhYLbZej6ob00Iad3xK8dalTeAADAUmpqarR48WLl5+fr4osv1sKFC3Xw4EGlpqZqzpw5eu+99/Tpp59q/vz5bcfcf//9WrBgQbvzGIahRbcOV1Kc2+9dbYJlqOXxQ4sm58oIZNueGMMMJQAAiHkdVdqGYWjcuHHyeDyaPHmyEhMT2465/fbb9frrr2vIkCH65S9/ec7g1islQU/fNkJzl++I2HeRJFPS01NGqGeKdR8VdDYCJQAAiFmdVdoej0fTp09XVlbWOY/t1q2b3nrrrfNeY1Jupiom5eiJwuKQjft85k/K0aTczIhdL9wIlAAAIKbU1NTotddeU0FBgTZv3tz2empqqu644w55PB6NGjUqpFXxPddmS5KeKCyWoZYZxFBrPe9Pb87RD67JDsMVoodACQAAoi6QSjvU7rk2WxlpCXpk1S7VNTaHdKGO22UoKd6tp6eMsNXMZCsCJQAAiJpgKu1wmJSbqSsHXKB5b+zW+pJKuYyWR/sEqvX464f20qLJuba5Z/LrCJQAACCiolFp+6NXSoJemn6F1hRX6sXNpdpx6KTcLsOvGcvWz1/eN11z8gZpQk5vW6zm7giBEgAAhF0sVNr+MAxDEy/N0MRLM1RSXq1l2w5qbXGFjtc2SGoJjGfvsuM11RY4eyTHa3xOhqaP6q9hmdbeAcdXBEoAABA2sVZpB2JYZqoW3ZqrRbfm6nhtvYqOnlJxebVqzjSpocmr+C4upSR0UU5mqnL7pKlHsj1r7c4QKAEAQEjFeqUdjB7JXfXtIb307SG9oj2UmEKgBAAAQbNapY3QIlACAICA2aHSRvAIlAAAwC92rrQRGAIlAAA4LyptdIZACQAAOkSlDV8QKAEAQDtU2vAXgRIAAFBpIygESgAAHIxKG6FAoAQAwGGotBFqBEoAAByAShvhRKAEAMDGqLQRCQRKAABshkobkUagBADABqi0EU0ESgAALIxKG7GAQAkAgMVQaSPWECgBALAAKm3EMgIlAAAxjEobVkCgBAAgxlBpw2oIlAAAxAAqbVgZgRIAgCii0oYdECgBAIgwKm3YDYESAIAIoNKGnREoAQAIIyptOAGBEgCAEKPShtMQKAEACAEqbTgZgRIAgCBQaQMESgAA/EalDbRHoAQAwAdU2kDHCJQAAHSCShs4PwIlAABfQ6UN+IdACQCAqLSBYBAoAQCORqUNBI9ACQBwHCptILQIlAAAR6DSBsKHQAkAsDUqbSD8CJQAANuh0gYii0AJALAFKm0gegiUAABLo9IGoo9ACQCwHCptILYQKAEAlkClDcQuAiUAIKZRaQOxj0AJAIg5VNqAtRimaZrRHkQ0ffHFF/ryyy+Vmpqqnj17Rns4AOBYVNqAdTk+UAIAootKG7A+Km8AQMRRaQP2QqAEAEQElTZgXwRKAEBYUWkD9kegBACEHJU24CwESgBASFBpA85FoAQABIVKGwCBEgDgNyptAGcjUH5Nc3Ozli9frrffflvHjx9XRkaG/vEf/1FTp06N9tAAIKqotAF0xLEPNl+4cKH+8Ic/6P3331dKSookqbGxURMnTtSGDRva/avaNE1NmTJFK1eu5F/bAByHShvA+Th2hvL1119X375928KkJD399NPauHGj8vLy9Mgjjyg7O1sHDhzQokWL9Prrr+u3v/2tfvSjH0Vx1AAQGVTaAPzh2BnK9PR0eTwePffcc22vDRs2TM3NzSoqKlLXrl3bXq+vr1dubq5SUlK0ffv2KIwWAMKPShtAoBw7Q9nY2KiEhIR2rx04cECzZ89uFyYlqWvXrrrpppv08ssvR3KIABARVNoAguXYQJmdna0PPvig3WtpaWlqbGw85+fr6+vVpYtjf10AbIZKG0AouaI9gGiZOnWqNm7cqNdee63ttSlTpuiPf/yjTpw40e6zX3zxhd58801dfvnlER4lAISO1+vVhg0bNHPmTGVkZOgHP/iBNm/eLMMwNH78eC1fvlwVFRV64YUXNHr0aMIkAJ859h7K2tpajRw5UmVlZZo1a5buvvtuZWVlaerUqTp16pQefPBBZWdn67PPPtOvfvUrHTx4UG+++aZuueWWaA8dAPxCpQ0g3BwbKCXp8OHD+v73v68PPvhAnf0aEhIS9K//+q/64Q9/GMHRAUDgqLQBRJKjA6XU8ozJN954QytWrNBHH32kqqoqeb1epaena/Dgwbr++us1a9Ys9evXL9pDBYBOsUobQLQ4PlACgNVRaQOINpYtA4AFUWkDiCUESgCwCCptALGKQAkAMY5KG0CsI1ACQAyi0gZgJY4PlM3NzWpubpbL5WInHABRRaUNwKocn6B27Nihjz76SMOHD9d1110X7eEAcCAqbQBW5/hA+dZbb2nhwoWaO3cugRJAxFBpA7ATxwdKAIgUKm0AdkWgBIAwo9IGYHcESgAIAyptAE5CoASAEKHSBuBUBEoACBKVNgCnI1ACQACotAHg7wiUAOAjKm0AODcCJQCcB5U2AHSOQAkA50ClDQC+I1ACwN9QaQNAYAiUAByvs0p75syZmjFjBpU2AHSCQAnAkai0ASB0CJQAHINKGwDCg0AJwPZYpQ0A4UWgBGBLVNoAEDkESgC2QaUNANFBoARgeVTaABBdBEoAlkSlDQCxg0AJwDKotAEgNhEoAcQ8Km0AiG0ESgAxiUobAKyDQAkgZlBpA4A1ESgBRB2VNgBYG4ESQFRQaQOAfRAoAUQMlTYA2BOBEkDYUWkDgL0RKAGEBZU2ADgHgRJAyFBpA4AzESgBBI1KGwCcjUAJICBU2gCAVgRKAD6j0gYAnAuBEsB5UWkDADpDoARwTlTaAABfESgBtKHSBgAEgkAJgEobABAUAiXgUFTaAIBQIVACDkKlDQAIBwIl4ABU2gCAcCJQAjZFpQ0AiBQCJWAjVNoAgGggUAIxwDTNoGYKqbQBANFEoASi5IsvvtDvf/97lZaW6uGHH1ZOTo5fx1NpAwBiBYESiLCKigqtXLlSzz77bNts4qRJk/wOlFdeeaX27t0riUobABBdrmgPAHCan//853rwwQd16tQp3XbbbUpISND69et18uRJn8/R1NSk733vexo8eLAWLVqkQ4cOac2aNbrzzjsJkwCAiCNQAhE2fPhwzZo1S4cOHdLvfvc7jRw5UuvXr1dZWZnP53C73frJT36iTz/9VI8++ij3RwIAoopACUTYjBkz9Nxzzyk5OVlJSUnKy8tTWVmZPvjgAzU3N/t0DsMw1LVrV+6PBADEBAIlEGFxcXFKTk6WJHXr1k15eXm68MILtWbNGlVVVUlqWfUNAIBVECiBKPF6vZKk3NxcjRo1Slu2bFFJSYkkMfMIALAUAiUQJS5Xy1+/Pn366IYbbtAXX3yhd955R6dPn47yyAAA8A+BEoii1mr76quv1qBBg7RmzRodOXJEkny+nxIAgGgjUAJh4st9kK3V9tChQ5Wfn6+PP/5Yn3zyiaSWldwAAFgBgRIIIa/Xqw0bNmjmzJl688031djY6NNx6enpys/Pl2EY2rJli2pra3X06FGtXr1aO3fuDPOoAQAIDjvlACFwrr20T5w4ocmTJ/t8juuuu065ubl68803VVtbq507d2r37t2699579etf/zpMIwcAIHgESiBA59tLe9asWTJN87wrtpubm7Vnzx6tW7dOx44d06FDh7R48WL17dtXDz/8sB544IFwfxUAAIJCoAT84PV6tWnTJhUUFOi1115TXV2dpOD20l69erX+5V/+RX/961+VkJAgj8ej2bNna/To0eH6GgAAhBSBEvDBuSptSRo8eLA8Ho+mT58e8PaHAwcOVG5urubNm6fp06ezGAcAYDkESqAD56u0PR6PRo0aFfRDyC+77DKtWrUq2OECABA1BErgLOGotAEAsDsCJaDwVtoAANgdgRKOFalKGwAAuyNQwlGotAEACD0CJRyBShsAgPAhUMK2qLQBAIgMAiVshUobAIDII1DCFqi0AQCIHgIlLItKGwCA2ECghKVQaQMAEHsIlLAEKm0AAGIXgRIxi0obAABrIFAiplBpAwBgPQRKxISysjItWbKEShsAAAsiUCJqqLQBALAHAiUiikobAAD7IVAiIqi0AQCwLwIlwoZKGwAAZyBQIqSotAEAcB4CJUKCShsAAOciUCJgVNoAAEAiUMJPVNoAAODrCJTwCZU2AADoCIESHaLSBgAAviBQoh0qbQAA4C8CJSRRaQMAgMARKB2MShsAAIQCgdJhqLQBAECoESgdgkobAACEC4HSxjqqtNPS0toq7auvvppKGwAABIVAaTNU2gAAINIIlDZBpQ0AAKLFsYHyWE29dh89paLmTKWP9WhP16F66u0SpSbGKScjVcP7pKlnStdoD7NTVNoAACAWGKZpmtEeRKSUlFdr2baDWltcoeO1DZIklyE1NzWpSxe3XC6XvKbU7G35lfRIjtf4nAxNH9VfwzJTozn0NlTaAAAg1tg+UJqmqTXFlXphU6k+PnxSbpfRFhh90fr5kf3SNSdvkCbk9I7KjB+VNgAAiFW2DpRVNWc0743dWl9SKZch+ZEjv6H1+BuH9daiW4erV0pC6AbaASptAABgBbYNlIVF5Xpk1S7VNTb7NSN5Pm6XoaQ4t56+bYQm5WaG7LytqLQBAIDV2DJQvrylTE8WlsiQFI4v13re+ZNydM+12SE5J5U2AACwKtut8m4Nk1J4wuTZ532isFiSAg6VVNoAAMAObDVDWVhUrrnLd0T8ur+9a6TP9TeVNgAAsBvbBMqqmjO64ZlNqq1vCtvM5LkYkpITuuh/Hhrb6XMrqbQBAIBd2SJQmqap2cu2a8PeqpAuwPGV22Xo+qG99OLdV7Srp6m0AQCAE9jiHso1xZVaX1IZtes3e02tK67UmuJKjR/Wi0obAAA4ii1mKKf8/l19cvhkUM+ZDJbLkC5UjY4tf4RKGwAAOIrlZyhLyqu149DJgI69ov8F+t4VWbpyQHf1Sumqrl3cOvFVvYrLq7Vx7zG9+clRVZ9p8ulcXlM6phR9XkelDQAAnMXyM5Tz3ijSqx8d9uveya5dXPrFbSP03cv7dPq559bv03N/2e/7YEyvrrqwSUt+NJFKGwAAOIblZyjXFlf4FSYNQ3ppxj8o75KekqSy47V6ZdtB7TpySqcbm9UrJUFX9L8gsF1wDJfKGpIJkwAAwFEsHSiP1dTreG2DX8fMHD2gLUz+eXeFfvyHj9XQ7G17f4+qtWFvlZ5Zt1e9OnkMUEeO1zboeG29eiT7fywAAIAVuaI9gGDsPnrKr88bhjTnuoGSpM9PntZDKz9pFybPZppSZXV9QOMq8nNcAAAAVmbpQFlcUS23y/cFLzmZqboovaWO/sOHh1TX0BzyMbldhorLq0N+XgAAgFhl6UBZfbpRfuRJXXpRWtvPHx74Mgwjanl8UI2PK8MBAADswNKBsrHZlD9r1LsnxbX9XFVzJgwjatHQdO4aHQAAwI4sHSjj3IZi8RGP8V0s/WsFAADwi6WTT2pinF+743xR19j2c6+UhDCMqOUB5ykJll48DwAA4BdLB8qcjFS/nkG556zV11dldw/HkNTsNZWTmRqWcwMAAMQiSwfK4X3Szv+hsxRXVOvoydOSpNv/oa+S4t3hGJZy/RwXAACAlVk6UPZM6aoeyfE+f940pRc3l0mSLkpP1LPfu1xx7nPfhGkYCujB5j2S43moOQAAcBRLB0pJGp+T4dezKJduO6DN+49JkiYOz9CfH8jTrDEDdEX/C3RpZqrGDu6p/33jJfrLQ/m666p+fo3F7TI0PifDr2MAAACszjBNfx68E3tKyqt107+949cxCXEuPfO9y8+7X/dz6/fpub/s9+vcf37gOg3N4B5KAADgHJYPlJI05ffv6pPDJ/1a8S1JowdeqKlXZOnKAd3VM7mrXK6WvbiLP6/W/3xaqdU7P9dXPu6m4zKky/um6/X/dU0A3wAAAMC6bBEo/7ynQve9sj3aw9C/332FJl5K5Q0AAJzF8vdQStKEnN66cVhvv+6lDCW3y9C4nN6akNM7KtcHAACIJlsESsMwtOjW4UqKcyvSkdKQlBTv1qLJuTJicdseAACAMLNFoJRadr55+rYRinR/b0p6esoI9QzgEUMAAAB2YJtAKUmTcjM1f1JORK85f1LOeVeLAwAA2JmtAqUk3XNtdluoDFcB3Xren96co3uuzQ7TVQAAAKzBFqu8z6WwqFyPrNqlusZmv/b7Ph+3y1BSvFtPTxnBzCQAAIBsHCglqarmjOa9sVvrSyrlMuT3cyrP1nr8uJzeWjQ5l3smAQAA/sbWgVKSTNPUmuJKvbi5VDsOnZTbZfg1Y9n6+ZH90jUnb5Am5PRmNTcAAMBZbB8oz1ZSXq1l2w5qbXGFjtc2SGoJjGc/vtJrqi1w9kiO1/icDE0f1V/DMtlOEQAA4FwcFSjPdry2XkVHT6m4vFo1Z5rU0ORVfBeXUhK6KCczVbl90tQjmVobAADgfBwbKAEAABAatntsEAAAACKLQAkAAICgECgBAAAQFAIlAAAAgkKgBAAAQFAIlAAAAAgKgRIAAABBIVACAAAgKARKAAAABIVACQAAgKAQKAEAABAUAiUAAACCQqAEAABAUAiUAAAACAqBEgAAAEEhUAIAACAoBEoAAAAEhUAJAACAoBAoAQAAEBQCJQAAAIJCoAQAAEBQCJQAAAAICoESAAAAQSFQAgAAICgESgAAAASFQAkAAICgECgBAAAQFAIlAAAAgkKgBAAAQFAIlAAAAAgKgRIAAABB+f/Z42OBqNoW4wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9jklEQVR4nO3deWBU5d328WsmK2RDGUgQEBAiEAQhWAUaEFoFNPpYF9BYwIWlrQGl2rcVXCpVAX3pW0SgimJVkECotbWF4IYiEehTIWwGl7AHEyQRSIKELDPvH2kiSCAzmeXMOfP9/BUzZ8786MMTrtzXOfexuVwulwAAAIBmshs9AAAAAMyNQAkAAACvECgBAADgFQIlAAAAvEKgBAAAgFcIlAAAAPAKgRIAAABeIVACAADAKwRKAAAAeIVACQAAAK8QKAEAAOAVAiUAAAC8QqAEAACAVwiUAAAA8AqBEgAAAF4hUAIAAMArBEoAAAB4hUAJAAAArxAoAQAA4BUCJQAAALxCoAQAAIBXCJQAAADwCoESAAAAXiFQAgAAwCsESgAAAHiFQAkAAACvECgBAADgFQIlAAAAvEKgBAAAgFcIlAAAAPAKgRIAAABeCTd6AAAINkfKT2nnoePKLy5T2clqVde6FBFmU3yLCKUkxeuy9glqExdl9JgAEDQIlAAgaVdRmZZs2q9384tVUlElSQqz22S3SS6XZLNJTpdU63RJkhyxkRqekqSxAzqpZ7t4I0cHAMPZXC6Xy+ghAMAILpdL7+Qf1ovrdivv4DGF2W0NgdEd9cenXtxKk4Z01YiURNlsNj9ODADBiUAJICR9U16p6W/t1Pu7Dsv+39XH5qp//zU9EzXz5svUNi7ad4MCgAkQKAGEnFU7ivTwm9v1XXWtRyuSTQmz29QyIkyzb+2j9N7tfHZeAAh2BEoAIeXl3D16atUu2ST544df/XkfS0/R+LQufvgEAAg+3JQDIGTUh0mp8TA59afJmnrNpZKkztNWNesz6s/75Kp8SSJUAggJ7EMJICSs2lHUECYD5clV+Vq1oyignwkARiBQArC8b8or9fCb2xXo+69tkh7+23YdKT8V4E8GgMAiUAKwNJfLpelv7dR31bV+uWbyvJ8t6buqWk3/+w5xuToAKyNQArC0d/IP6/1dh316N7cnap0uvZd/WO/kHzbk8wEgEAiUACxt0ce7ZTd4r3G7rW4OALAq7vIGYFm7isq05cCxZr8/Pjpc49O66LrL2ql9qxaqrnVqV1G5sv5zQG9v+9rt8zhd0pYDx/R5cZl6JPGYRgDWQ6AEYFlLNu33+HGK9Tpc0EJLx1+lzq1jzvj+wK6tNbBraw1PSdQDK7a6fe4wu02vb9yvmTf39ngWAAh2VN4ALOvd/OJmXzs5PyNVHS9oqaWb9uvOlzfpxvm5+j9/3abdRyokSTf0uUjTr+vh9vlqnS69m1/crFkAINixQgnAko6Un1JJRVWz39+3YyvdvzzvjGp7x6HjWr2jSCt/MVApFyXo7kFdtOLTg/rycIVb5yypqFJJxSk5YqOaPRcABCNWKAFY0s5Dx716//u7Djd6neSJqlpNe2uHpLoa++dXdfLovDu8nAsAghGBEoAl5ReXKcyL27tXbi4852vbCo/ri+JySVJaV4fb5wyz25RfVNbsmQAgWBEoAVhS2clqr7YL2l547Lyvb/vv610cMYoIc++D7DapvLKm+UMBQJAiUAKwpOpal7x5OE1pE9dfllTUPU7RbrcpoUWE2+etqnE2fygACFIESgCWFBFmk82LFUqXnx7UGBnOj10A1sNPNgCWFN8iQt48bbGpO7HrX3c6XTp+stqtczpdUlw0m2sAsB4CJQBLSkmK9+r53X06tGri9QRJ0t7SE6qude9zap0upbTjSTkArIdACcCSLmuf4NX7b0ttf87X+nRIaHiE4icFJR6dt7eXcwFAMCJQArCkNnFRcsRGNvv916YkKb13u7O+3zIyTDN/Vvf4xFqnS8v+94Db53TERrKpOQBL4mIeAJY1PCVJKz492Kzqe1vhMT13e19d1eVC5ewsVnlltXq2i9cvh3RV17axkqTXN+3T5//dj7IpYXabhqckeTwHAJgBgRKAZY0d0MmjFcTTZS7bomUTBmjcwM4aN7DzWa+v3lGkp1btcvt8tU6Xxg307Kk6AGAWBEoAltWzXbxSL26lrQePeXzHd+HRk7rh+fWaNKSrRqQkqv0FLVRT69KuojIt+88B/WPr2Y9lPBe7re7Z4PXXXQKA1dhcLm+2/gWA4Lbms2L9culmo8fQC2P6a2QvKm8A1sRNOQAsbURKoq7pmejVc729EWa36dqURI1ISTTk8wEgEFihBGAZhw8f1rZt27R9+3Zt3bpV7733nkpLS/XHBS/p5aKLVHGqxk/Pv2mcTVKk3am9z9+tC1qE69prr1Xfvn11+eWXq0+fPkpMJGQCsAYCJQDTW7FihR544AEdPny40denT5+uQXdMVuayLQGeTErT53pj9m8afS0pKUlz587V7bffHuCpAMC3qLwBmN6HH354zjDZpk0bPfHEE0rv3U6PpacEdK7H0lP0yowpatOmTaOvFxcX66OPPgroTADgDwRKAKY3Y8YMJSU1fsPLrFmzFBERIUkan9alIVT664rK+vM+fkOKxqd1UWRkpGbOnNnosUlJSXriiSf8NAkABA6BEoDpVVdXy+FwnPX9zp07a9y4cWd8b3xaFy24M1WxUeE+v1EnzG5TbHS4FtyZqnt/3KXh++PGjVPnzp3POt7hcKi6utqnMwCAEQiUAEwtJydHffv21c6dOxUZeeajFh999NGG1cnTpfdupw8eulrDureVVLdPpDfq3/+THm219sGhZz2yMTIyUo888shZ39u5c6f69eunNWvWeDcAABiMQAnAlGpqajRt2jRdf/31Ki0tVb9+/bR9+3b99Kc/ldT46uTp2sZF66Wx/fXCmP7q27GVJHm8Yll/fN+OrfTCmP5aNKa/2sQ1/qzu01cpr7nmGm3fvl39+vVTSUmJrrvuOk2fPl01NTUefT4ABAvu8gZgOoWFhcrIyFBubq4kKTMzU3PmzFF0dLSOHDmiJ598UnfccYcGDRrk9jl3FZVpyab9eje/WCUVVZLqAuPpGdPpUsNzwR2xkRqekqSxAzqpZzv3noCzYcMGLV++XI899pjatGmjyspKPfTQQ1q4cKEkKS0tTVlZWerQoYPbcwNAMCBQAjCVnJwcjR07VqWlpYqLi9PixYs1atQon35GScUp7Th0XPlFZXp9WbZctjDdcvNNiosOV0q7ePVunyBHbOMrkc2RnZ2tCRMmqLy8XA6HQ0uWLNHIkSN9dn4A8DcCJQBTqKmp0WOPPabZs2dLkvr166fs7Gx169bNb5/53nvvafjw4Q1fX3PNNX77rIKCAo0ePVp5eXmSpGnTpukPf/iDwsPD/faZAOArBEoAQe98Fbc/XX311fr4448bvvb3npFU4ADMikAJIKgFouJuzLp16zR06NCzvjdkyBC/fzYVOACz4S5vAEGpsbu4t2zZEpAwKdVtlu7O9/xh9OjR2rJlC3eBAzANVigBBB2jKu56ja1Onv5aIFYpJSpwAObBCiWAoFK/UXlubq7i4uKUnZ2t+fPnByxMStLcuXPP+dqf/vSngM0RHR2tBQsWaMWKFYqLi1Nubi4boQMISgRKAEHB6Ir7dH379lV8fLxiY2MbvhcbG6v4+Hj17ds34PNQgQMIdlTeAAxndMV9LidOnGgIlRUVFYqJiTF0HipwAMGKFUoAhgqGitssqMABBCsCJQBDBFPFbTZU4ACCDYESQMAVFhZq2LBhDU+9yczM1IYNG/z61Bur6datmzZs2KD77rtPkjRr1iwNGzZMhYWFBk8GIBQRKAEEFBW379RX4NnZ2VTgAAxFoAQQEFTc/jNq1CgqcACGIlAC8Dsqbv+jAgdgJAIlAL+i4g4cKnAARiFQAvALKm7jUIEDCDQCJQCfo+I2HhU4gEAiUALwKSru4EEFDiBQCJQAfIKKO3hRgQPwNwIlAK9RcQc/KnAA/kSgBOAVKm7zoAIH4C8ESgDNQsVtXlTgAHyNQAnAY1Tc5kcFDsCXCJQAPELFbR1U4AB8hUAJwC1U3NZFBQ7AWwRKAE2i4rY+KnAA3iBQAjgvKu7QQQUOoLkIlAAaRcUduqjAAXiKQAngLFTcqK/AMzMzJVGBAzg/AiWAM1Bxo150dLTmz59PBQ6gSQRKAJKouHFuVOAAmkKgBEDFjSZRgQM4HwIlEOKouOEuKnAA50KgBEIUFTeaiwocwA8RKIEQRMUNb1GBAzgdgRIIMVTc8BUqcAD1CJRAiKDihr9QgQMgUAIhoLCwUEOHDqXiht9QgQOhjUAJWFx9xf3JJ59QccOvqMCB0EWgBCyKihtGoQIHQg+BErAgKm4YjQocCC0ESsBiqLgRLKjAgdBBoAQsgoobwYoKHLA+AiVgAVTcCHZU4IC1ESgBk6PihllQgQPWRaAETIqKG2ZFBQ5YD4ESMCEqbpgdFThgLQRKwGSouGEVVOCAdRAoAZOg4oZVUYED5kegBEyAihtWRwUOmBuBEghyVNwIFVTggHkRKIEgRcWNUEUFDpgPgRIIQlTcCHVU4IC5ECiBIEPFDdShAgfMg0AJBAkqbqBxVOBA8CNQAkGAihs4PypwILgRKAGDUXED7qECB4IXgRIwCBU30DxU4EDwIVACBqDiBrxDBQ4EFwIlEGBU3IBvUIEDwYNACQQIFTfgH1TggPEIlEAAUHED/kUFDhiLQAn4GRU3EBhU4IBxCJSAn1BxA8agAgcCj0AJ+AEVN2AsKnAgsAiUgI9RcQPBgQocCBwCJeAjVNxAcKICB/yPQAn4ABU3ENyowAH/IlACXqLiBsyBChzwHwIl0ExU3IA5UYEDvkegBJqBihswNypwwLcIlICHqLgBa6ACB3yHQAm4iYobsCYqcMB7BErADVTcgLVRgQPeIVACTaDiBkIDFTjQfARK4ByouIHQRAUOeI5ACTSCihsIbVTggGcIlMAPUHEDkKjAAU8QKIH/ouIG0JjGKvBp06ZRgQOnIVACouIGcH4/rMBnz55NBQ6chkCJkEfFDcAdVODAuREoEbKqq6v18MMPN1TcqampVNwAmkQFDpyNQImQVFhYqGHDhumZZ56RJE2ePJmKG4DbqMCBMxEoEXIaq7iff/55RUVFGT0aABOhAge+R6BEyKDiBuAPVOAAgRIhgoobgD9RgSPUEShheVTcAAKBChyhjEAJy6LiBmAEKnCEIgIlLImKG4CRqMARagiUsBwqbgDBgAocoYRACcug4gYQjKjAEQoIlLAEKm4AwYwKHFZHoITpUXEDMAMqcFgZgRKmRcUNwIyowGFFBEqYEhU3ADOjAofVEChhOlTcAKyAChxWQqCEaVBxA7AiKnBYAYESpkDFDcDKqMBhdgRKBD0qbgChgAocZkagRNCi4gYQiqjAYUYESgQlKm4AoYwKHGZDoETQoeIGACpwmAuBEkGDihsAzkYFDjMgUCIoUHEDwLn5qgI/duyYtm3b5o8REeIIlDAcFTcANK2xCnzevHluv7+mpkYDBw7UrbfeqqlTp2rPnj1+nBahhkAJw1BxA4Dn6ivwjIwMPf30026/r7y8XL/97W8VExOjefPmKSUlRYsWLfLjpAglNpfL5TJ6CISewsJC3XHHHfrkk08k1VXcc+bMYVUSQeXEiROKjY2VJFVUVCgmJsbgiYDvOZ1OuVwuhYWFefzee+65R6+99pqSk5P19ttvq3v37n6YEKEk3OgBEHreeecd/fznP1dpaani4uK0ePFiViUBwEN2u/slo8vlks1mkyTl5eVp7969cjgceuSRR9SpUyd/jYgQQuWNgHI6nTpw4AAVNwAYYP/+/Zo3b57Wr1+viRMnKj09XdHR0UaPBQtghRIBZbfbNXHiREVGRuqOO+6g4gYAP6tfnayoqFBWVpaysrJ000036e6771br1q3POu7kyZNq0aKFgRPDjFihRLOVl5fr2LFjKisr8+h9LpdLd911F2ESAPzs9Ko7JydHCxYsULdu3TR16lQlJyc3etyrr76q9PR07dy505CZYU4ESjTLkiVLdMMNN2jAgAEaOnSoHnzwQX311Vduvbf+hxYAwH+cTmfDz9tNmzbpueeea7jTe8CAAZLqgqT0/c/l9evX64033lBOTo769OmjP//5z8YMD9MhUMJjEydO1F133aUjR44oOTlZR48e1dy5c3XzzTfrpZdeMno8AAhp9SGx/qadffv2adGiRdq4caMyMzOVnp6uyMhISXVBsv74PXv2aOHChdq4caN+85vfaNSoUcrMzFRGRoYxfxCYCtdQwi31P3DmzJmjV155RVOmTNEvfvELpaSkaN++fVq2bJkeffRRTZ48WQkJCRo9erTBEwNAaHr11VdVVlame++9V3FxcVq+fLmWLVt23usmjx8/riVLlujNN99UZmamZs6cqYMHD6pXr16aM2eOunfvruXLl6tfv34G/skQzNiHEm5zuVwNj/rasmWL4uPjG14rLCzU7373O2VlZSk6Olpbt27VpZdeauC0gPfYhxJmc/LkSd12223KycnRXXfdpV69emnevHlKSEjQvHnzNGzYsEbfl5WVpd/97neqqqrSihUrdPXVV0uSjh8/rtWrV+uJJ55QQUGB9u/frw4dOgTyjwSTYIUSbvviiy/073//W1deeWVDmHQ6nbLb7erQoYPatm0rSaqsrNS9996r3NxcI8cFgJDTokULrVq1SmPGjNFrr72m8PBwxcTE6KmnnmoIk/U/t+tVVVUpPj5eQ4YMUVZWlqZNm6apU6fq+uuvV0JCgjIyMnTRRRfp+PHjhEmcE9dQwm2JiYm65JJLdPz4cR05ckTSmTfYtGzZUpdffrm6dOmiDRs28EgvADDI0qVL9corr6i2tlbHjx9XQUFBw44cP9wQPTIyUunp6Xr99de1ceNGFRcXa+rUqfrggw8ajrn66qv1P//zPwH9M8BcCJRwW0JCggYOHKjt27dr4cKFKisrawiUa9as0SuvvKIxY8Zo6dKlkuruKqyqqhJXVQBA4N1999367LPP1KNHDz311FN64IEHVFBQcNZxp9/pfeWVV+qjjz6Sw+HQlClTdOjQoUCPDZMiUMJtdrtdTz/9tLp27ao//OEPGjt2rF544QU98MAD+vWvfy2Xy6WrrrpKl1xyiS6//HJt3LhRkZGRbBMEAAbp0aOH8vPzlZGRoXXr1mnfvn2S6q4Jls7cf9Jms8npdOriiy/W6NGjVVhYqLVr1xo1OkyGQAmPJCYmavny5Ro+fLj++c9/KjMzUwsXLlRsbKw++OADpaWlKTExUa1bt9bRo0dVXl4up9Np9NgAENLeeOMN/e1vf9M111wjScrMzNQHH3zQECbrVynrf14PGjRIUt0Nl4A7uCkHHuvfv7/eeust/etf/1JERIRsNttZ19acOnVK8fHxrFACQJDo27evJGnbtm16++239cUXXyghIUFXXHGFbDabampqFB5eFwvef/99AyeFGbFCiWaJjo7WbbfdpptuuumsMPmXv/xFn376qSZNmqSoqCgCJQAEkcsvv1y///3v9eWXX+rRRx9tqLVPD5Mvv/yybDabbrnlFkniWng0iRVKNOmHW0ycy7fffqu///3vevbZZ9W1a1eNGDEiANMBADw1depUtW7dWhMmTNCXX36pq6++Wmlpadq7d6+ef/55lZeXN2xo7u6/AQhtbGyOc6qurtbMmTM1fvx4JSUlNfz22phFixbpzTff1KZNm9ShQwf97W9/U/fu3QM4LeB7bGwOq8vPz9fkyZP16aef6sSJE3K5XLrwwgs1YcIEzZ492+jxYCKsUKJRBw8eVEZGhj755BOtWrVKGzduPO/xBQUFOnr0qO677z7NmjUrQFMCALyRkpKitWvX6v3331dFRYVKS0uVlpbWsCDA6iTcxQolzrJ69WqNGzdOpaWlio+P1+LFi3Xbbbc1+b5Dhw6pffv2AZgQCAxWKBHKTt9SCGgKv3agQXV1tR5++GGlp6ertLRUqamp2rJli1thUhJhEgAs5Hxh0uVyqba2NoDTINgRKCGpruIeNmyYnnnmGUnS5MmTtWHDBnXt2tXgyQAAwaS6ulofffSRfvKTn7BPJRoQKKHVq1erX79++uSTTxQfH6+VK1fq+eefV1RUlNGjAQCCjNPp1MSJE/Xxxx+rb9++ysnJMXokBAECZQjztuIGAISeqKgorVmzRv369VNpaamuv/56TZs2TTU1NUaPBgMRKEMUFTcAoLm6deumDRs2KDMzU5I0e/ZsDRs2jAo8hBEoQxAVNwDAW9HR0Zo/f76ys7MVFxen3NxcKvAQRqAMIVTcAABfGzVqlLZs2UIFHuIIlCGCihsA4C9U4CBQhgAqbgCAv1GBhzYCpYVRcQMAAo0KPDQRKC2KihsAYBQq8NBDoLQgKm4AgNGowEMLgdJCqLgBAMGGCjw0ECgtgoobABCsqMCtj0BpAVTcAIBgRwVubQRKE6PiBgCYDRW4NREoTYqKGwBgVlTg1kOgNCEqbgCA2VGBWwuB0kSouAEAVkMFbg0ESpOg4gYAWBUVuPkRKE2AihsAYHVU4OZGoAxiVNwAgFBDBW5OBMogRcUNAAhVVODmQ6AMQlTcAIBQRwVuLgTKIELFDQDAmajAzYFAGSSouAEAaBwVePAjUAYBKm4AAM6PCjy4ESgNRMUNAIBnqMCDE4HSIFTcAAA0DxV48CFQGoCKGwAA71CBBxcCZQBRcQMA4FtU4MGBQBkgVNwAAPgHFbjxCJQBQMUNAIB/UYEby+ZyuVxGD2GEI+WntPPQceUXl6nsZLWqa12KCLMpvkWEUpLidVn7BLWJ8y7wVVdX67HHHmtYlUxNTVV2djarkoBJnDhxQrGxsZKkiooKxcTEGDwRAHcUFBRo9OjRysvLkyQ9/PDDevLJJxUeHu71uQORH8wopALlrqIyLdm0X+/mF6ukokqSFGa3yW6TXC7JZpOcLqnWWfc/iSM2UsNTkjR2QCf1bBfv0WcdPHhQGRkZ+uSTTyTVVdxz5sxhVRIwEQIlYF6VlZX6zW9+owULFkiS0tLSlJWVpQ4dOnh8rkDmB7OyfKB0uVx6J/+wXly3W3kHjynMbmv4P7g76o9PvbiVJg3pqhEpibLZbOd9z+rVqzVu3DiVlpYqPj5eixcv5sYbwIQIlID5rVy5UuPHj1d5eblat26tJUuW6LrrrmvyfUbkBzOzdKD8prxS09/aqfd3HZb9v789NFf9+6/pmaiZN1+mtnHRZx1DxQ1YC4ESsAZPK/BA5wcrsGygXLWjSA+/uV3fVdd69BtFU8LsNrWMCNPsW/sovXe7hu9TcQPWQ6AErMPdCjzQ+cEqLBkoX87do6dW7ZJNkj/+cPXnfSw9RePTulBxAxZFoASs53wVeKDzg5VYLlDW/2UIlH6u3fr7Mw9IouIGrIZACVhTYxV4l+vGa2bOFwGbwWqh0lL7UK7aURTQMClJebauatn9x2xUDgCASfxwI/R5b60PaJiUpCdX5WvVjqKAfqY/WWaF8pvySv30j+tUcarGL8vU5+JyOdUizKb1D18bkvtOAVbGCiVgfYuXrdQfNku2yBaqK6UDwyYpNjpcax8caon8YIkVSpfLpelv7dR31bUBDZOSZLPZVS27pv99hyySzQEACAkul0sba7ooPDpGgQyTUt21lN9V1VomP1giUL6Tf1jv7zrs07uxPFHrdOm9/MN6J/+wIZ8PAAA8R37wHUsEykUf75bd4L1C7ba6OQAAgDmQH3zH+4daGmxXUZm2HDjWrPf273SBRvXvoB91vlBt46IUFR6m0hOnlF9Upo++OKJ/bD2kssoat87ldElbDhzT58Vl6pEUGo9ZgvfeeOMNrV+/Xps3b9aOHTtUVVWlV199VePGjTN6NACwtObmh0sTYzU8JUlXdr5QyYmxujAmUjW1Ln1TfkpbDhzV0k37lXfQ/fNaJT+YPlAu2bTf48chRYXb9eytfXRT3/ZnvdYuoYXaJbTQT3skqnVMpOZ+8JXb5w2z2/T6xv2aeXNvt9+D0Pboo4/qwIEDcjgcuuiii7R//36jRwKAkNCc/DCgy4VaPmngWd+PCpe6RIWriyNGt6Z20MKPCvTsO+7fNW6F/GD6QPlufrFHfxlsNumlcVdoSHIbSdKekgot3bRf2wuP62R1rdrGRat/pwuatYt9rdOld/OLTf0XAoG1ePFiJScnq2PHjnrmmWc0ffp0o0cCgJDgaX6Q6oLfiVM1+vCLb7Rhd6l2H6lQRWWNWsdGKjkxTvcM6qwOF7TUfUO7aW/JCa3cXOjWea2QH0wdKI+Un1JJRZVH77lrYOeGMLlmZ7HuX56nqlpnw+ufqUwffvGN/vjeF2rbjNv4SyqqVFJxSo5Y828BAP/7yU9+YvQIAGA5f/7zn/X2228rMzNT6enpstnOvFCyOflBkvKLyjRw9geNXg738Vclen3jPi2+60caktxGD/w0WW9uKXT7OeBmzw+mviln56HjHh1vs0mTBl8iSfr62Ek9uHLrGWHydC6XdLjsVLPm2uHhXAAAwHcWLFigNWvW6MYbb9SPfvQj/etf/zpjax5P80O9o99Vn/feiupal2atrnvASocLWiqlnWfXRJo5P5h6hTK/uMyj6x9S2sXrolYtJEnL/3NA31XV+nymMJu0bX+JruzABsihzt+bYLtcLlVVVammxr0bx+C5EydONPo1gOB2+s/FzZs368Ybb1S/fv30yCOP6JZbbvE4P5xLZJhdjthItYwKb7hb/PTV0J7t4rXz6zK3zhVmtym/qEzDurf1aiajmDpQlp2slt0muRsLe12U0PD1f/Yd9ctMNTXVmjHzWf163Wt+OT/MISoqSpWVlX7/nClTpuill17y++dASkxMNHoEAF7Iy8vTbbfdpiuuuEK3/OF1j/LD6VpEhOmeQZ114+UXKbltrMLDzl32XhgT6fZ57Tap3M2dZYKRqQNlda1Lnmwuf2HLiIavvyn33z/2tvCIpg8CAACG8DQ/1OvQqoWWTRygiy9s6dbx0RFhHp2/qqbxy/DMwNSBMiLMJpvBG5L+UEREpH79wBQ9+I+5Ro+CEPD888/rT3/6k9FjWNaJEycaViYPHz7Ms7wBk+jfv7+++OLMbXtOr7xnr/m8Wfnh/43uq4svbCmn06WVmwv1z+1fq+CbCn17oqrhngybTdo7M73uaw/PHxlu3ltbTB0o41tEuH33lCR9+111w9dt46K1+4jvr4lySbowriX/8MDvbDaboqKiFBVlzjsCzSYmJob/vwZMIjz8+3jTv39/PfHEE2fc7e1pfpCkrm1idGWXCyVJCz4q0B/f+7LR41q1aF5L6XRJcdHmjWXmjcKSUpLiPbqg9rPT7p6q/0vha7VOl8d3dQEAAN/JzMzUyJEj9c9//lP/+c9/dMMNN5xxs4yn+UGSktvGNXz9r+1F5zyuT4dWHs8rmT8/mDpQXtY+oemDTpNfXKZDx05Kkm6/oqNaRnp2bYO7ens4FwAA8J1f/epXysnJOStI1vM0P0hS+GkP/T5ffvj5lRd7fO56Zs4P5l1bldQmLkqO2Ei3Nyd1uaRFH+/RjP/ppYtatdD/G9VXU5ZvUXXt2b+l2GxSm9gofVPu2V6UjthI025KisBbvHixcnNzJUk7duyQy+XSSy+9pA8//FCSlJaWpvHjxxs5IgBYjqf5QZL2ln5/mdxt/Ts0+rzuMVddrOG9kpo1k9nzg6kDpSQNT0nSik8Pur10/fqmffppz7YaktxGIy9L0poHhtQ9evHQcVVW1apNXJT6XdxKN15+kd7e+rXHz/IentK8v0gITbm5uXr99dcb/ttms2nDhg3asGFDw38TKAHA9zzND599XabPi8vUIyleP7+qkxJaROhveYf0TVml2iW00M/6tVd673b6z75v9aPOnl1WZ4X8YHO5mnPjfPDYVVSm6+at9+g90RF2/XFU3yaf1z33/S89CpSStOaBweqRZN5rIAB878SJE4qNjZUkVVRUcFMOYCHNyQ8p7eK1bMJVatWy8f0ldxWVadxf/lf/mX6NJM9yhNnzg+lXKHu2i1fqxa209eAxt+/Yqqx2KnPZFi29pLVu699BP+p8odrERslur3uWZv7XZVr7+WG9ve1rt+ew26S+HVuZ+i8DAAChojn5Ib+oTNfPW6/7hnbT0O5t1DYuWieqarS/9IT+tb1ISzbt1ykP95K0Sn4w/QqlJK35rFi/XLrZ6DH0wpj+GtnMaycABB9WKAFrIz/4jqnv8q43IiVR1/RMVJjdmF3Ow+w2XZuSqBEpPJoNAACzID/4jiUCpc1m08ybL1PLiDCPd6X3+rMl2Wurteu1x7Ro0SJ9+umnOnnyZICnAAAA7jh58qQ+/fRTvfjiixo6dKhid71tWH5oGRmmmT/r3ejWRmZjicq73qodRcpctiXgn/vtP/+vyj9b1/Dfdrtdl156qS6//HINHTpUkyZNkt1uiewOhBQqb8D8nE6nFi1apI8++kjbtm3Tl19+Kafz++scIyIi9Nbm/YbkhwV3pjZ5g7BZWCpQStLi3L16clV+wD7vsfQUfbDwEWVlZZ3zmJ07d6pXr14BmwmAbxAoAfP77LPPdNlll53z9YyMDC1btsyQ/DA+rUvAPs/fLBcope9DpU11z9b2tfrzPn5Diu79cReVlJSoU6dO+u677846dtCgQVq3bt0ZzxUFYA4ESsD8ampqdPXVVzfs73u6mJgY7du3Tw6HQ1Lg84OVWLKHHZ/WRQvuTFVsVLjPL7QNs9sUGx2uBXemNvxlcDgcuv/++88+NixMs2fPJkwCAGCQ8PBwzZo1S2FhZz8u8f77728Ik1Lg84OVWHKFst435ZWa/tZOvb/rsOw2ub3PVGPq339tSqJm/qy32sSd+XikkpISde7cWSdOnDjj+3FxcVq8eLFGjRrV/A8HYAhWKAHzy87O1oQJE1ReXn7G92NjY7V3794zAmW9QOYHq7DkCmW9tnHRemlsf70wpr/6dmwlSR7/xlF/fN+OrfTCmP5aNKZ/o38ZHA6HpkyZ0vDfv/rVr5SWlqby8nKNHj1akydPVmVlZfP/MAAAwG2VlZXKzMzU7bffrvLycg0ePFi//OUvG16fMmVKo2FSCmx+sApLr1D+0K6iMi3ZtF/v5hc3PBA+zG7T6X9HnC41PNfTERup4SlJGjugk3q2a3oH+5KSEqWlpemSSy7RP/7xD9lsNj3++OOaNWuWJKlfv37Kzs5Wt27dfP+HA+BzrFAC5lRQUKDRo0crLy9PkjR9+nTNmDFDLpdLN910k/bs2aPc3NxzBsof8nd+sIKQCpSnK6k4pR2Hjiu/qEzllTWqqnEqMtyuuOhwpbSLV+/2CXLE+uY3iTVr1mjs2LEqKSmhAgdMhEAJmM/pFbfD4dDSpUs1YsQIn50/kPnBTEI2UAZaYWGhMjIylJubK0nKzMzUnDlzFB0dbfBkAM6FQAmYR2VlpR566CEtXLhQkjR48GBlZWWpffv2Bk8WGix9DWUw6dChgz788ENNmzZNkrRgwQINGjRIBQUFBk8GAIC5FRQUaNCgQQ1hcvr06Vq7di1hMoAIlAEUHh6umTNnKicnRw6HQ3l5eUpNTdXKlSuNHg0AAFPKzs5Wamqq8vLy5HA4tGbNGj399NNs2RdgBEoDjBw5Unl5edwFDgBAMzV2F/fWrVt9er0k3EegNAgVOAAAzUPFHXwIlAaiAgcAwDNU3MGJQBkEqMABADg/Ku7gRqAMElTgAAA0joo7+BEogwgVOAAAZ6LiNgcCZRCiAgcAhDoqbnMhUAYpKnAAQKii4jYfAmUQowIHAIQaKm5zIlCaABU4AMDqqLjNjUBpElTgAACrouI2PwKliVCBAwCshorbGgiUJkQFDgAwOypuayFQmhQVOADArKi4rYdAaWJU4AAAs6HitiYCpQVQgQMAgh0Vt7URKC2CChwAEKyouK2PQGkhVOAAgGBDxR0aCJQWRAUOADAaFXdoIVBaFBU4AMAoVNyhh0BpYVTgAIBAo+IOTQTKEEAFDgDwNyru0EagDBFU4AAAf6HiBoEyhFCBAwB8jYobEoEyJFGBAwC8RcWN0xEoQxQVOACguai48UMEyhBGBQ4A8BQVNxpDoAQVOACgSVTcOB8CJSRRgQMAzo2KG00hUKIBFTgA4IeouOEOAiXOQgUOAKDihicIlGgUFTgAhC4qbniKQIlzogIHgNBDxY3mIFCiSVTgAGB9VNzwBoESbmmsAv/xj3+s3bt3GzwZAMBbVNzwFoESbvthBb5lyxYqcAAwuR9W3Dk5OVTc8BiBEh47vQIvKyujAgcAEzpXxT1y5EijR4MJESjRLFTgAGBeVNzwNQIlmo0KHADMh4ob/kCghNeowAEg+FFxw59sLpfLZfQQsIaamho9/vjjmjVrliQpNTVV2dnZ6tq1q8GTAc3jdDq1d+9eSVKXLl1kt/M7OMypoKBAo0ePVl5enqS6invGjBmsSsJnCJTwuTVr1mjs2LEqKSlRfHy8Xn75ZY0aNcrosQAgJGVnZ2vChAkqLy+Xw+HQkiVLWJWEz/HrNnyOChwAjEfFjUAiUMIvuAscAIzDXdwINCpv+B0VOAAEDhU3jMAKJfyOChwA/I+KG0YiUCIgqMABwH+ouGE0Km8EHBU4APgOFTeCASuUCDgqcADwHhU3ggmBEoagAocZ3HPPPVq8eLFbx65du1ZdunTRG2+84eepACpuBB8CJQzDs8AR7F5//XXl5ua6dWxycrIOHDig9evX+3kqhDqexY1gRKCE4ajAYQUdO3aUw+HQ5s2bjR4FFkXFjWDGTTkIGjwLHMEmLCxM/fr1c/umsRdffFFff/01vwzB53gWN4IdgRJBh7vAESzCwsLkcrlks9ncfo/L5ZLT6fTjVAg13MUNMyBQIigVFhYqIyOj4fq1zMxMzZkzR9HR0QZPhlASFhamQYMGaeLEiR69b9y4cX6aCKGksrJSDz30UMONN4MHD1ZWVhY33iAoESgRtKjAYbSwsDCNGzdOf/nLX4weBSGGihtmw005CFrcBQ4gFHEXN8yIQImgx13gMMpdd92ltLQ0o8dAiOAubpgZlTdMgwocgFVRccPsCJQwHe4CB2Al3MUNK6DyhulQgQOwAipuWAmBEqbEs8ABmBnP4obVUHnD9KjAAZgJFTesiBVKmB4VOAAzoOKGlREoYQlU4PAHl8ulqqoqVVVViTIH3qDihtVRecNyqMDhK9XV1Xr55ZclSRMmTFBERITBE8GMqLgRCgiUsCSeBQ5fOHHihGJjYyVJFRUViomJMXgimAnP4kYoofKGJVGBAzASFTdCDYESlsWzwAEYgWdxIxQRKGF53AUOIBC4ixuhjECJkEAFDsCfqLgR6giUCBlU4AD8gYobIFAiBFGBA/AFKm7gewRKhCQqcADeoOIGzkSgRMiiAgfQHFTcwNkIlAh5VOAA3EHFDZwbgRIQFTiA86PiBs6PQAn81+kVeOvWranAAUii4gbcQaAEfmDkyJHaunUrFTgQ4qi4AfcRKIFGUIEDoY2KG/AMgRI4BypwIDRRcQOeI1ACTaACB0IDFTfQfARKwA1U4IC1UXED3iFQAm6iAgesiYob8B6BEvAQFThgDVTcgO8QKIFmoAIHzI2KG/AtAiXQTFTggDlRcQO+R6AEvEQFDpgDFTfgPwRKwAeowIHgRsUN+BeBEvARKnAgOFFxA/5HoAR8jAocCA5U3EDgECgBP6ACB4xFxQ0EFoES8BMqcMAYVNxA4BEoAT+jAgcCg4obMA6BEggAKnDAv6i4AWMRKIEAoQIH/IOKGzAegRIIMCpwwDeouIHgQaAEDEAFDniHihsILgRKwCBU4EDzUHEDwYdACRiMChxwDxU3ELwIlEAQoAIHzo+KGwhuBEogSFCBA42j4gaCH4ESCDJU4EAdKm7APAiUQBCiAkeoo+IGzIVACQQpX1bgx44d07Zt2/wwJeB7VNyA+dhcLpfL6CEAnF9hYaEyMjKUm5uriIgIFRQUqGPHjrLZbE2+t6amRr1791Z1dbVuuOEG3X///brkkksCMLX5nThxQrGxsZKkiooKxcTEGDyRtblcLh04cEDJycmqrq7W4MGDlZWVxaokYAIESsAkampq9Pjjj8vhcGjq1Kmy290rGI4ePaq///3vmjt3rnbs2KHIyEjNmzdPkyZN8vPE5kegDDyn06k//elP+vbbbzVjxgxWJQGTIFACIeSee+7Ra6+9puTkZL399tvq3r270SMFNQIlALiHaygBCzv998W8vDzt3btXDodDjzzyiDp16mTgZAgFxcXFRo8AIEAIlEAI2L9/v+bNm6f169dr4sSJSk9PV3R0tNFjwcLuvPNOTZw4Ufn5+UaPAiAACJSARblcLtlsNlVUVGj58uXKysrSTTfdpLvvvlutW7c2ejxYVFFRka6//notX75cq1ev1ooVK1RaWmr0WAD8jEAJWFB9mJSknJwczZ8/X926ddPUqVOVnJxs8HSwqqKiIs2YMUNr1qzRtddeqyuuuEJz587VqlWrVFVVJenMyzAAWAeBErAYp9PZECY3bdqk5557TuXl5frtb3+rAQMGSOIfdfhHSUmJFi1apDvuuEPvvPOOfv/73ysuLk7PPvusNm3aJElubXUFwHwIlIBF1IfE+u2E9u3bp0WLFmnjxo3KzMxUenq6IiMjJfGPOvyjd+/eevHFFzVnzhxJ0sCBAzVlyhQVFBRo7ty5+uqrrwyeEIC/ECgBi3j11VcbViMlacWKFVq2bBnXTSKgJkyYoIsuukgul0sXXHCB7rjjDt155536xz/+oVdffZXrKQGLYsdYwAJOnjypv/71r8rJydHWrVvVq1cvLViwQMnJyZoyZQrXTSJgfrj63alTJ02aNElffvmlFixYoO7du+uOO+5QZGSkamtrFRYWZtCkAHyJjc0BCxkzZoyWLVum8PBwxcTE6LnnntO4ceMk1V1b6e7TdVCHjc29c/rNYStXrtSDDz6ohIQEzZ8/X0OHDpVU9ySnw4cPq0ePHgZOCsBb/OsCWMjSpUv1yiuvqLa2VsePH1dBQYHKysokiTCJgLPZbA3X9l533XWaPHmyCgoKNH/+fBUWFmrHjh168MEHdd9992nnzp0GTwvAG1TegMXcfffdGjBggG655RY99dRTOnjwoB599FF17drV6NEQgupDZWxsrEaPHq3du3dr8eLFstvt2rt3rzZv3qx7771Xl112mdGjAvACSxaABfXo0UP5+fnKyMjQunXrtHfvXqNHAtSlSxfdeuut6tKli/76179qy5YtWrRokV5++WWjRwPgJVYoAQt74403tHXrVvXt2/ecx1RXV2vPnj3q1KkTj2OERyorK7Vv3z517dpVERER5zyu/jrK7du3a/ny5dqzZ4969eql7Oxs9ezZM1DjAvAjVigBiztfmHQ6nTp69KgGDx6sQYMGqaCgIHCDwdQKCgo0aNAgDRkyREePHpXT6Tzv8Xv27NHDDz+s1157TWPHjtWOHTsIk4CFECiBEFZ/HZvT6VReXp5SU1O1cuVKo8dCkMvOzlZqaqry8vLkcrm0b9++Jm/66tSpkzp27KhXXnlFr732WoAmBRAobBsEQIWFhcrIyFBubq4kKTMzU3PmzAn5Cpxtg85UWVmphx56SAsXLpQkDR48WFlZWWrfvr1b72ffScC6WKEEoA4dOujDDz/UtGnTJEkLFiygAscZ6ivu+jA5ffp0rV271u0wKYkwCVgYgRKAJCk8PFwzZ85UTk6OWrduTQWOBqdX3A6HQzk5OXr66acVHs59nQDqECgBnGHkyJHaunWr0tLSVF5ertGjR2vy5MmqrKw0ejQEWGVlpTIzM3X77bervLxcgwcP1tatWzVy5EijRwMQZAiUAM5CBQ5fVNwAQgeBEkCjqMBDFxU3AE8RKAGcFxV46KDiBtBcBEoATaICtz4qbgDeIFACcAsVuHVRcQPwFoESgEeowK2DihuArxAoAXiMCtz8qLgB+BKBEkCzUIGbFxU3AF8jUALwSmMVeGZmJhV4EKqsrNR9991HxQ3A5wiUALz2wwp84cKFVOBBpqCgQAMHDtSf//xnSVTcAHyLQAnAJ6jAg1d9xb1161YqbgB+QaAE4FNU4MGDihtAoBAoAfgcFbjxqLgBBBKBEoBfUIEbh4obQKARKAH4FRV44FBxAzAKgRKA31GB+x8VNwAjESgBBAQVuP9QcQMwGoESQEBRgfsOFTeAYEGgBBBwVODeo+IGEEwIlAAMQQXefFTcAIINgRKAoajA3UfFDSBYESgBGI4KvGlU3ACCGYESQFCgAj83Km4AwY5ACSCoUIF/j4obgFkQKAEEHSpwKm4A5kKgBBCUQrkCp+IGYDYESgBBLZQqcCpuAGZFoAQQ9EKhAqfiBmBmBEoApmDlCpyKG4DZ2Vwul8voIQDAE4WFhcrIyFBubq4k6b777tMf//hHRUdH++T8R8pPaeeh49p2oEQzZv1f2cLCNfX+KWod31IpSfG6rH2C2sRFef05lZWVevDBBxtWJQcPHqysrCxWJQGYDoESgCnV1NTo8ccf16xZsyRJ/fr1U3Z2trp169as8+0qKtOSTfv1bn6xSiqqJElhdptqa2okSRER4XK6pFpn3Y9MR2ykhqckaeyATurZLt7jzysoKNCoUaO0detWSXUV94wZM1iVBGBKBEoAprZmzRqNGTNGpaWliouL0+LFizVq1Ci33utyufRO/mG9uG638g4eqwuQTvd/JNYfn3pxK00a0lUjUhJls9mafF92drYmTJig8vJyORwOLVmyhBtvAJgagRKA6TWnAv+mvFLT39qp93cdlt0meZAjz1L//mt6JmrmzZepbVzjn0vFDcCqCJQALMGTCnzVjiI9/OZ2fVdd69GKZFPC7Da1jAjT7Fv7KL13uzNeo+IGYGUESgCW0lQF/nLuHj21apdskvzxw6/+vI+lp2h8WhdJVNwArI9ACcByzlWBL/30az21apfX578ttYPmjLpckpT2zFoVHjvZ6HHTRiRrW/ZcKm4Alsc+lAAsp7GN0K+4ZZJPwqQnZr3zlV5bu10SG5UDsDYCJQBLOn0jdEeHS1TW/QY1ff+1b7mcTjnSH9CKf6xmo3IAlkagBGBpI0aM0HW/f13hLWL8cs3k+djsdoVHtdR7x9uIq4sAWBmBEoClvZN/WB/vPubVtkDeqHVJ7+Uf1jv5h40ZAAACgEAJwNIWfbxb9kB33T9gt9XNAQBWxQU9ACxrV1GZthw45vH74qPD9auru2p4SpLaX9BCFadq9HlxuZb9e79W7yz2+HxOl7TlwDF9XlymHkmeP6YRAIIdgRKAZS3ZtN/jxyl2bROrN8ZfpaSE7592Ex0RprRuUUrr5lD2pwf1v3u/9XiWMLtNr2/cr5k39/b4vQAQ7AiUACzr3fxij8JkbFS4Xr/3yoYw+c9tX+vNLYUqqTilS9rEanxaF42+oqMuTYzzeJZap0vv5hcTKAFYEoESgCUdKT+lkooqj94z5Sfd1L5VC0nSs2s+18J131/3uPPrMq3eUaRX7vqRhlzaplkzlVRUqaTilByxUc16PwAEK27KAWBJOw8d9+j4iDCbbr+io6S6ay9PD5P1apwu/fbN7aqqcTZ7rh0ezgUAZkCgBGBJ+cVlCvPg9u7e7RPUqmWkJOmvWwrPeVxxWaXWFxxp1kxhdpvyi8qa9V4ACGYESgCWVHay2qPtgrqfdl3k9sJj5z1228Hzv34udptUXlnTrPcCQDAjUAKwpOpalzx5OE396qQklTZx7aWn12aezpu6HACCFYESgCVFhNlka+aG5v58qE5kOD92AVgPP9kAWFJ8iwiPHrd4/GR1w9eO2MjzHNn06+fidElx0WyuAcB6CJQALCklKd6jPSg/Ly5v+LpPh1bnPbap18+l1ulSSjuelAPAegiUACzpsvYJHh2/89BxHfuu7trIW/q1P+dxifFRGpzsaPZcvT2cCwDMgEAJwJLaxEV5VE1X1Tq1cnPddkG9LkrQL4ZcctYxYXabZt/SR1HhYc2ayREbyabmACyJQAnAsoanJHm0F+W8D77S18dOSpKmXddTz93eV1df2ka9LorXjX3a6c1fDtKw7m21rYlthRoTZrdpeEqSx+8DADOwuVyebKwBAOaxq6hM181b79F7ktvG6o3xV6ltfHSjr6/89KD+vfdbzRl1uSQp7Zm1KvxvCG3KmgcGq0cS11ACsB5WKAFYVs928Uq9uJVHG5x/9U2Frp37sV5Yt1t7Sip0qrpWpRWntGF3ie5fnqf/8+Z2j+ew26TUi1sRJgFYFiuUACxtzWfF+uXSzUaPoRfG9NfIXlTeAKyJFUoAljYiJVHX9Ez06FpKXwqz23RtSqJGpCQa8vkAEAgESgCWZrPZNPPmy9QyIkyBjpQ2SS0jwzTzZ71la+5jewDABAiUACyvbVy0Zt/ax6+PVGyMS9LsW/qoTRxbBQGwNgIlgJCQ3rudHktPCehnPpaeovTe7QL6mQBgBAIlgJAxPq1LQ6j0VwFdf97Hb0jR+LQufvoUAAgu3OUNIOSs2lGkh9/cru+qaz163ndTwuw2tYwM0+xb+rAyCSCkECgBhKRvyis1/a2den/XYdltkje5sv7916YkaubPenPNJICQQ6AEELJcLpfeyT+sRR/v1pYDxxRmt3m0Yll/fOrFrTRpSFeNSEnkbm4AIYlACQCqe0zjkk379W5+sUoqqiTVBcbTt690utQQOB2xkRqekqSxAzqpZzuegAMgtBEoAeAHSipOaceh48ovKlN5ZY2qapyKDLcrLjpcKe3i1bt9ghyx1NoAUI9ACQAAAK+wbRAAAAC8QqAEAACAVwiUAAAA8AqBEgAAAF4hUAIAAMArBEoAAAB4hUAJAAAArxAoAQAA4BUCJQAAALxCoAQAAIBXCJQAAADwCoESAAAAXiFQAgAAwCsESgAAAHiFQAkAAACvECgBAADgFQIlAAAAvEKgBAAAgFcIlAAAAPAKgRIAAABeIVACAADAKwRKAAAAeIVACQAAAK8QKAEAAOAVAiUAAAC8QqAEAACAVwiUAAAA8AqBEgAAAF4hUAIAAMArBEoAAAB4hUAJAAAAr/x/qnFyNP+/6KYAAAAASUVORK5CYII=",
      "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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<networkx.classes.digraph.DiGraph object at 0x29d345b90>, <networkx.classes.digraph.DiGraph object at 0x29d1e55d0>]\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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(3, 0, 2, 1), (2, 3, 0, 1), (1, 0, 3, 2), (0, 2, 3, 1), (1, 0, 2, 3), (0, 3, 2, 1)]\n",
      "+---+---+---+---+---+---+\n",
      "| 1 | 2 | 1 | 1 | 2 | 1 |\n",
      "+---+---+---+---+---+---+\n",
      "| 1 | 1 | 2 | 0 | 3 | 0 |\n",
      "| 0 | 0 | 3 | 2 | 0 | 3 |\n",
      "| 3 | 2 | 0 | 3 | 2 | 2 |\n",
      "| 2 | 3 | 1 | 1 | 1 | 1 |\n",
      "+---+---+---+---+---+---+\n",
      "\\begin{tabular}{cccccc}\n",
      "$1$ & $2$ & $1$ & $1$ & $2$ & $1$\\\\\\hline \n",
      "$b$ & $b$ & $c$ & $a$ & $d$ & $a$\\\\ \n",
      "$a$ & $a$ & $d$ & $c$ & $a$ & $d$\\\\ \n",
      "$d$ & $c$ & $a$ & $d$ & $c$ & $c$\\\\ \n",
      "$c$ & $d$ & $b$ & $b$ & $b$ & $b$\n",
      "\\end{tabular}\n",
      "[0] [1] [3] [0]\n",
      "([3], [[2], [0]])\n",
      "([0], [[1]])\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": null,
   "metadata": {},
   "outputs": [],
   "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": 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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}