RCV simulations Public Choice.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bf4511b7-9c9f-4481-ae6b-18e68b305f75",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Num of candidates\n",
    "import random\n",
    "import pandas as pd\n",
    "import math\n",
    "import operator\n",
    "import numpy as np\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c68d429f-2440-4223-9a5b-d5aa1bf3b4f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Takes as input a dataframe with two columns: a 'ballot' column\n",
    "#and a 'Count' column. The Count column gives the number of ballots of\n",
    "#each type that were cast. Returns the IRV winner(s).\n",
    "def IRV(frame):\n",
    "    num_cands_remaining=len(frame.iloc[0]['ballot'])\n",
    "    n=num_cands_remaining\n",
    "    cand_dict={ }\n",
    "    keys=range(n)\n",
    "    values=[]\n",
    "    \n",
    "    for k in range(len(frame.iloc[0]['ballot'])):\n",
    "        values.append(frame.iloc[0]['ballot'][k])\n",
    "    \n",
    "    for i in keys:\n",
    "        cand_dict[i]=values[i]\n",
    "    while num_cands_remaining>1:\n",
    "        scores=[0 for i in range(n)]\n",
    "        for k in range(len(frame)):\n",
    "            for l in range(n):\n",
    "                if frame.iloc[k]['ballot'][0]==cand_dict[l]:\n",
    "                    scores[l]+=frame.iloc[k]['Count']\n",
    "        for k in range(len(scores)):\n",
    "            if scores[k]>sum(frame['Count'])/2:\n",
    "                return [str(cand_dict[k])]\n",
    "\n",
    "        min_score=min(i for i in scores if i>0)\n",
    "        positions_of_lowest_score=[i for i,v in enumerate(scores) if v==min_score]\n",
    "        #print(positions_of_lowest_score)\n",
    "        \n",
    "        #Tie at the top, record the multiple winners\n",
    "        if num_cands_remaining==len(positions_of_lowest_score):\n",
    "            return [cand_dict[i] for i in positions_of_lowest_score]\n",
    "            break\n",
    "        num_cands_remaining-=len(positions_of_lowest_score)\n",
    "\n",
    "        for k in range(len(frame)):\n",
    "            for l in positions_of_lowest_score:\n",
    "                frame.at[k,'ballot']=frame.at[k,'ballot'].replace(cand_dict[l],'')\n",
    "        #print(data)\n",
    "        frame=pd.DataFrame(frame.groupby(['ballot'],as_index=False)['Count'].sum())\n",
    "        #print(data)\n",
    "\n",
    "    IRV_winner=frame['ballot'][0]\n",
    "    return [IRV_winner]\n",
    "\n",
    "#Takes as input a dataframe with an election. Returns the CL if there is one,\n",
    "#otherwise returns False\n",
    "def Cond_loser(frame):\n",
    "    num_cands_remaining=len(frame.iloc[0]['ballot'])\n",
    "    n=num_cands_remaining\n",
    "    cands_dict={ }\n",
    "    \n",
    "    keys=range(n)\n",
    "    values=[]\n",
    "    \n",
    "    for k in range(len(frame.iloc[0]['ballot'])):\n",
    "        values.append(frame.iloc[0]['ballot'][k])\n",
    "    \n",
    "    for i in keys:\n",
    "        cands_dict[i]=values[i]\n",
    "    Cond_scores=[0 for i in range(len(cands_dict))]\n",
    "    #Get all pairings\n",
    "    possible_pairings=[]\n",
    "    for i in range(len(cands_dict)):\n",
    "        for j in range(len(cands_dict)):\n",
    "            if i<j:\n",
    "                possible_pairings.append([i,j])\n",
    "\n",
    "    for pairing in possible_pairings:\n",
    "        #print(pairing)\n",
    "        pairing_scores=[0,0]\n",
    "        Cand1=pairing[0]\n",
    "        Cand2=pairing[1]\n",
    "        for k in range(len(frame)):\n",
    "            for l in range(len(cands_dict)):\n",
    "                if frame.iloc[k]['ballot'][l]==cands_dict[Cand1]:\n",
    "                    pairing_scores[0]+=frame.iloc[k]['Count']\n",
    "                    #print(Cand1, cands.index(Cand1),pairing_scores)\n",
    "                    break\n",
    "                if frame.iloc[k]['ballot'][l]==cands_dict[Cand2]:\n",
    "                    pairing_scores[1]+=frame.iloc[k]['Count']\n",
    "                    #print(Cand2, cands.index(Cand2),pairing_scores)\n",
    "                    break\n",
    "        #print(pairing_scores)\n",
    "        if pairing_scores[0]>pairing_scores[1]:\n",
    "            Cond_scores[Cand1]+=1\n",
    "        if pairing_scores[0]<pairing_scores[1]:\n",
    "            Cond_scores[Cand2]+=1\n",
    "        \n",
    "    \n",
    "    if 0 not in Cond_scores:\n",
    "        return False\n",
    "    else:\n",
    "        return cands_dict[Cond_scores.index(0)]\n",
    "    \n",
    "   \n",
    "\n",
    "#Takes as input a dataframe with two columns: a 'ballot' column\n",
    "#and a 'Count' column. The Count column gives the number of ballots of\n",
    "#each type that were cast. Returns the plurality winner(s).\n",
    "def plurality(frame):\n",
    "    n=len(frame.iloc[0]['ballot'])\n",
    "    cand_dict={ }\n",
    "    keys=range(n)\n",
    "    values=[]\n",
    "    \n",
    "    for k in range(len(frame.iloc[0]['ballot'])):\n",
    "        values.append(frame.iloc[0]['ballot'][k])\n",
    "    \n",
    "    for i in keys:\n",
    "        cand_dict[i]=values[i]\n",
    "    \n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(frame)):\n",
    "        for l in range(n):\n",
    "            if frame.iloc[k]['ballot'][0]==cand_dict[l]:\n",
    "                scores[l]+=frame.iloc[k]['Count']\n",
    "    \n",
    "    max_score=max(scores)\n",
    "    positions_of_highest_score=[i for i,v in enumerate(scores) if v==max_score]\n",
    "    winning_cands=[cand_dict[i] for i in positions_of_highest_score]\n",
    "    return winning_cands\n",
    "\n",
    "def powerset(seq):\n",
    "    \"\"\"\n",
    "    Returns all the subsets of this set. This is a generator.\n",
    "    \"\"\"\n",
    "    if len(seq) <= 1:\n",
    "        yield seq\n",
    "        yield []\n",
    "    else:\n",
    "        for item in powerset(seq[1:]):\n",
    "            yield [seq[0]]+item\n",
    "            yield item\n",
    "\n",
    "            #Checks if all of the elements of a list are distinct.\n",
    "def all_different(mylist):\n",
    "    for i in range(len(mylist)):\n",
    "        for j in range(len(mylist)):\n",
    "            if i!=j:\n",
    "                if mylist[i]==mylist[j]:\n",
    "                    return False\n",
    "    return True\n",
    "\n",
    "#Given a ranking of candidates, checks if the ranking is single-peaked\n",
    "def is_SP_ranking(ranking):\n",
    "    top_ranking=ranking[0]\n",
    "    left_rankings=[i for i in range(top_ranking)]\n",
    "    right_rankings=[]\n",
    "    for k in range(len(ranking)-len(left_rankings)-1):\n",
    "        right_rankings.append(ranking[0]+1+k)\n",
    "    for i in left_rankings:\n",
    "        for j in left_rankings:\n",
    "            if i<j and ranking.index(i)<ranking.index(j):\n",
    "                return False\n",
    "    \n",
    "    for i in right_rankings:\n",
    "        for j in right_rankings:\n",
    "            if i<j and ranking.index(i)>ranking.index(j):\n",
    "                return False\n",
    "    return True\n",
    "    \n",
    "\n",
    "\n",
    "def clones(frame,l):\n",
    "    cand_set=list(frame.iloc[0]['ballot'])\n",
    "    cand_set.remove(str(l))\n",
    "    clone_set=[]\n",
    "    n=len(frame.iloc[0]['ballot'])\n",
    "    \n",
    "    for cand in cand_set:\n",
    "        clone=True\n",
    "        \n",
    "        for k in range(len(frame)):\n",
    "            if abs(frame.iloc[k]['ballot'].index(cand)-frame.iloc[k]['ballot'].index(str(l)))>1:\n",
    "                clone=False\n",
    "                break\n",
    "        if clone:\n",
    "            clone_set.append(cand)\n",
    "    return clone_set\n",
    "\n",
    "def almost_clones(frame, l, p):\n",
    "    cand_set=list(frame.iloc[0]['ballot'])\n",
    "    cand_set.remove(str(l))\n",
    "    clone_set=[]\n",
    "    n=len(frame.iloc[0]['ballot'])\n",
    "    for cand in cand_set:\n",
    "        clone=True\n",
    "        count=0\n",
    "        for k in range(len(frame)):\n",
    "            if abs(frame.iloc[k]['ballot'].index(cand)-frame.iloc[k]['ballot'].index(str(l)))==1:\n",
    "                count+=frame.iloc[k]['Count']\n",
    "        if count/sum(frame['Count'])>p:\n",
    "            clone_set.append(cand)\n",
    "    return clone_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "349c9bc1-78fb-4818-818e-a685bab92d35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n",
      "0\n",
      "1599\n"
     ]
    }
   ],
   "source": [
    "#impartial culture. \n",
    "#n is number of candidates, electorate_size is the number of voters.\n",
    "n=3\n",
    "electorate_size=1001\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if i!=j and k!=i and k!=j:\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if i!=j and k!=i and k!=j and l!=i and l!=j and l!=k:\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "count=0\n",
    "count1=0\n",
    "count2=0\n",
    "\n",
    "for a in range(10000):\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    if data.at[0,'Count']+data.at[1,'Count']<electorate_size/2:\n",
    "        count1+=1\n",
    "    \n",
    "    if data.at[0,'Count']+data.at[1,'Count']<electorate_size/2 and data.at[0,'Count']+data.at[1,'Count']>data.at[2,'Count']+data.at[3,'Count'] and data.at[2,'Count']+data.at[3,'Count']>data.at[4,'Count']+data.at[5,'Count']:\n",
    "        count+=1\n",
    "\n",
    "print(count1)\n",
    "print(count2)\n",
    "print(count)\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e668090e-5841-456a-ab63-606be5b8135b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3249\n",
      "4862\n",
      "376\n"
     ]
    }
   ],
   "source": [
    "#impartial culture. \n",
    "#n is number of candidates, electorate_size is the number of voters.\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if i!=j and k!=i and k!=j:\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if i!=j and k!=i and k!=j and l!=i and l!=j and l!=k:\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "count=0\n",
    "count1=0\n",
    "count2=0\n",
    "\n",
    "for a in range(10000):\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    data_copy=data.copy(deep=True) \n",
    "    \n",
    "    plurality_winners=plurality(data_copy)\n",
    "   \n",
    "    A_plurality_winner=False\n",
    "    if plurality_winners==['0']:\n",
    "        A_plurality_winner=True\n",
    "        count1+=1\n",
    "    when_B_drops_C_wins=False\n",
    "    if data.at[0,'Count']+data.at[1,'Count']+data.at[2,'Count']<data.at[3,'Count']+data.at[4,'Count']+data.at[5,'Count']:\n",
    "        when_B_drops_C_wins=True\n",
    "        count2+=1\n",
    "    when_C_drops_A_wins=False\n",
    "    if data.at[0,'Count']+data.at[1,'Count']+data.at[4,'Count']>data.at[3,'Count']+data.at[2,'Count']+data.at[5,'Count']:\n",
    "        when_C_drops_A_wins=True\n",
    "    if A_plurality_winner and when_B_drops_C_wins and when_C_drops_A_wins:\n",
    "        count+=1\n",
    "\n",
    "print(count1)\n",
    "print(count2)\n",
    "print(count)\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bc3dfecc-2458-4b26-ba67-8578eb3a57f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model=  IAC  n= 3  V= 601\n",
      "Number of elections in which CL is a plurality spoiler  15022\n",
      "Number of elections in which CL is a plurality winner  5169\n",
      "Number of elections in which CL is an IRV spoiler  5363\n",
      "Number of elections in which CL is an IRV winner  29\n"
     ]
    }
   ],
   "source": [
    "#IAC simulations for CL\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "def soc_inac(ranksmaps, rankmapcount, ncand):\n",
    "    soc_inac_ensemble = []\n",
    "    condi_position = pd.DataFrame(\n",
    "        ranksmaps, columns=[i for i in range(1, ncand+1)])\n",
    "    for i in range(1, ncand+1):\n",
    "        sum_nsup = 0\n",
    "        sum_ninf = 0\n",
    "        nsup = condi_position[condi_position[i] <= int(ncand/2)].index.values\n",
    "        ninf = condi_position[condi_position[i] > np.ceil(ncand/2)].index.values\n",
    "        for j in range(len(nsup)):\n",
    "            sum_nsup = sum_nsup + rankmapcount[nsup[j]]\n",
    "        for j in range(len(ninf)):\n",
    "            sum_ninf = sum_ninf + rankmapcount[ninf[j]]\n",
    "        if sum_ninf > sum_nsup:\n",
    "            soc_inac_ensemble.append(str(i))\n",
    "\n",
    "    return soc_inac_ensemble\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "n=3\n",
    "electorate_size=601\n",
    "model='IAC'\n",
    "possible_ballots=[]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "CL_IRV_winner=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    \n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    #Check for majority candidate and CL\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)<=electorate_size/2 and Cond_loser(data)!=False:\n",
    "    \n",
    "        CL=Cond_loser(data)\n",
    "\n",
    "        data_copy=data.copy(deep=True)    \n",
    "        IRV_winners=IRV(data_copy)\n",
    "        data_copy=data.copy(deep=True)  \n",
    "        plurality_winners=plurality(data_copy)\n",
    "\n",
    "        #First check for spoiler candidates\n",
    "\n",
    "\n",
    "        if CL in plurality_winners:\n",
    "            #print(\"CL is a plurality winner \",CL)\n",
    "            #print(data)\n",
    "            CL_plurality_winner+=1\n",
    "\n",
    "        if CL not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                #print(\"CL is a plurality spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_plurality_spoiler+=1\n",
    "        if CL in IRV_winners:\n",
    "            CL_IRV_winner+=1\n",
    "            #print(\"CL is an IRV winner \",CL)\n",
    "            #print(data)\n",
    "\n",
    "        if CL not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                #print(\"CL is an IRV spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_IRV_spoiler+=1\n",
    "        a-=1\n",
    "\n",
    "print(\"Model= \",model, \" n=\",n, \" V=\",electorate_size)           \n",
    "print(\"Number of elections in which CL is a plurality spoiler \", CL_plurality_spoiler)\n",
    "print(\"Number of elections in which CL is a plurality winner \", CL_plurality_winner)\n",
    "print(\"Number of elections in which CL is an IRV spoiler \", CL_IRV_spoiler)\n",
    "print(\"Number of elections in which CL is an IRV winner \", CL_IRV_winner)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1d0b2c76-8797-47f1-afc3-affa8100d614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model=  IAC  n= 3  V= 600\n",
      "Number of elections in which CL is a plurality spoiler  15212\n",
      "Number of elections in which CL is a plurality winner  5055\n",
      "Number of elections in which CL is an IRV spoiler  5340\n",
      "Number of elections in which CL is an IRV winner  312\n"
     ]
    }
   ],
   "source": [
    "#IAC simulations for CL\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "def soc_inac(ranksmaps, rankmapcount, ncand):\n",
    "    soc_inac_ensemble = []\n",
    "    condi_position = pd.DataFrame(\n",
    "        ranksmaps, columns=[i for i in range(1, ncand+1)])\n",
    "    for i in range(1, ncand+1):\n",
    "        sum_nsup = 0\n",
    "        sum_ninf = 0\n",
    "        nsup = condi_position[condi_position[i] <= int(ncand/2)].index.values\n",
    "        ninf = condi_position[condi_position[i] > np.ceil(ncand/2)].index.values\n",
    "        for j in range(len(nsup)):\n",
    "            sum_nsup = sum_nsup + rankmapcount[nsup[j]]\n",
    "        for j in range(len(ninf)):\n",
    "            sum_ninf = sum_ninf + rankmapcount[ninf[j]]\n",
    "        if sum_ninf > sum_nsup:\n",
    "            soc_inac_ensemble.append(str(i))\n",
    "\n",
    "    return soc_inac_ensemble\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "n=3\n",
    "electorate_size=600\n",
    "model='IAC'\n",
    "possible_ballots=[]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "CL_IRV_winner=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    \n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate and CL\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)<=electorate_size/2 and Cond_loser(data)!=False:\n",
    "    \n",
    "        CL=Cond_loser(data)\n",
    "\n",
    "        data_copy=data.copy(deep=True)    \n",
    "        IRV_winners=IRV(data_copy)\n",
    "        data_copy=data.copy(deep=True)  \n",
    "        plurality_winners=plurality(data_copy)\n",
    "\n",
    "        #First check for spoiler candidates\n",
    "\n",
    "\n",
    "        if CL in plurality_winners:\n",
    "            #print(\"CL is a plurality winner \",CL)\n",
    "            #print(data)\n",
    "            CL_plurality_winner+=1\n",
    "\n",
    "        if CL not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                #print(\"CL is a plurality spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_plurality_spoiler+=1\n",
    "        if CL in IRV_winners:\n",
    "            CL_IRV_winner+=1\n",
    "            #print(\"CL is an IRV winner \",CL)\n",
    "            #print(data)\n",
    "\n",
    "        if CL not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                #print(\"CL is an IRV spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_IRV_spoiler+=1\n",
    "        a-=1\n",
    "\n",
    "print(\"Model= \",model, \" n=\",n, \" V=\",electorate_size)     \n",
    "print(\"Number of elections in which CL is a plurality spoiler \", CL_plurality_spoiler)\n",
    "print(\"Number of elections in which CL is a plurality winner \", CL_plurality_winner)\n",
    "print(\"Number of elections in which CL is an IRV spoiler \", CL_IRV_spoiler)\n",
    "print(\"Number of elections in which CL is an IRV winner \", CL_IRV_winner)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f1f61d5c-a181-4539-955b-12e08860c8f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  20309\n",
      "Num elections with a plurality spoiler set:  20309\n",
      "Num elections with an IRV spoiler cand:  9976\n",
      "Num elections with an IRV spoiler set:  9976\n",
      "Num elections with a plurality clone spoiler  4\n",
      "Num elections with a plurality clone spoiler who spoiled the election for their clone 4\n",
      "Num elections with a plurality almost clone spoiler  1169\n",
      "Num elections with a plurality almost clone spoiler who spoiled the election for their clone 1156\n",
      "Num elections with an IRV clone spoiler  0\n",
      "Num elections with an IRV clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV almost clone spoiler  102\n",
      "Num elections with an IRV almost clone spoiler who spoiled the election for their clone 102\n"
     ]
    }
   ],
   "source": [
    "#IAC simulations\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "def soc_inac(ranksmaps, rankmapcount, ncand):\n",
    "    soc_inac_ensemble = []\n",
    "    condi_position = pd.DataFrame(\n",
    "        ranksmaps, columns=[i for i in range(1, ncand+1)])\n",
    "    for i in range(1, ncand+1):\n",
    "        sum_nsup = 0\n",
    "        sum_ninf = 0\n",
    "        nsup = condi_position[condi_position[i] <= int(ncand/2)].index.values\n",
    "        ninf = condi_position[condi_position[i] > np.ceil(ncand/2)].index.values\n",
    "        for j in range(len(nsup)):\n",
    "            sum_nsup = sum_nsup + rankmapcount[nsup[j]]\n",
    "        for j in range(len(ninf)):\n",
    "            sum_ninf = sum_ninf + rankmapcount[ninf[j]]\n",
    "        if sum_ninf > sum_nsup:\n",
    "            soc_inac_ensemble.append(str(i))\n",
    "\n",
    "    return soc_inac_ensemble\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "n=3\n",
    "electorate_size=501\n",
    "possible_ballots=[]\n",
    "candmap = gen_cand_map(n)\n",
    "election=gen_votemap_iac(electorate_size,candmap)\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l+1): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            \n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                \n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "          \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "676a213e-dd2c-4254-9918-c3ae5a0499a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  40242\n",
      "Num elections with a plurality spoiler set:  40242\n",
      "Num elections with an IRV spoiler cand:  21187\n",
      "Num elections with an IRV spoiler set:  21187\n",
      "Num elections with a plurality clone spoiler  6\n",
      "Num elections with a plurality clone spoiler who spoiled the election for their clone 6\n",
      "Num elections with a plurality almost clone spoiler  1931\n",
      "Num elections with a plurality almost clone spoiler who spoiled the election for their clone 1893\n",
      "Num elections with an IRV clone spoiler  0\n",
      "Num elections with an IRV clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV almost clone spoiler  208\n",
      "Num elections with an IRV almost clone spoiler who spoiled the election for their clone 208\n"
     ]
    }
   ],
   "source": [
    "#IAC simulations FOR REAL\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "candmap = gen_cand_map(n)\n",
    "election=gen_votemap_iac(electorate_size,candmap)\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(0,n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l+1): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(1,n+1)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(1,n+1):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            \n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                \n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "          \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(1,n+1):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "id": "d915aa64-7ae6-4f87-ab23-6633553169a2",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-289-b5975c863f64>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    125\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mb\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    126\u001b[0m                     \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msubset\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 127\u001b[0;31m                         \u001b[0mdata_copy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'ballot'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'ballot'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreplace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    128\u001b[0m                 \u001b[0mnew_IRV_winners\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mIRV\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    129\u001b[0m                 \u001b[0;31m#print(new_plur_winners)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m__setitem__\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m   2165\u001b[0m             \u001b[0;32mreturn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2166\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2167\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__setitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2168\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2169\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m__setitem__\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m   2116\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Not enough indexers for scalar access (setting)!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2118\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_set_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtakeable\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_takeable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2120\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m_set_value\u001b[0;34m(self, index, col, value, takeable)\u001b[0m\n\u001b[1;32m   3269\u001b[0m             \u001b[0mengine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3270\u001b[0m             \u001b[0mloc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mengine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3271\u001b[0;31m             \u001b[0mvalidate_numeric_casting\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3272\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3273\u001b[0m             \u001b[0mseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_values\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/series.py\u001b[0m in \u001b[0;36mdtype\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    476\u001b[0m         \u001b[0mReturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0mobject\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0munderlying\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    477\u001b[0m         \"\"\"\n\u001b[0;32m--> 478\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mgr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    479\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    480\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/internals/managers.py\u001b[0m in \u001b[0;36mdtype\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1615\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mDtypeObj\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_block\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/internals/blocks.py\u001b[0m in \u001b[0;36mdtype\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    345\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    346\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 347\u001b[0;31m     \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    348\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    349\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#impartial culture. \n",
    "#n is number of candidates, electorate_size is the number of voters.\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if i!=j and k!=i and k!=j:\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if i!=j and k!=i and k!=j and l!=i and l!=j and l!=k:\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "for a in range(50000):\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "    \n",
    "    if plurality_spoiler ==False and n!=3:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "                \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    \n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False and n!=3:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ce249cc7-a362-4dbe-a8be-f0e31207db1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "99\n",
      "98\n",
      "97\n",
      "96\n",
      "95\n",
      "94\n",
      "93\n",
      "old plurality winner ['2']\n",
      "new plurality winner ['3']\n",
      "  ballot  Count\n",
      "0    321     51\n",
      "1    213    144\n",
      "2    132    100\n",
      "3    312    122\n",
      "4    123      4\n",
      "5    231     80\n",
      "plurality spoiler  1\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-ea498423753b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    164\u001b[0m                 \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m                 \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"plurality spoiler \"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m                 \u001b[0mclone_set\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m                 \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Clones\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mclone_set\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-7ac9905a7b32>\u001b[0m in \u001b[0;36mclones\u001b[0;34m(frame, l)\u001b[0m\n\u001b[1;32m    117\u001b[0m     \u001b[0mn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'ballot'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    118\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mcand\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcand_set\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0mcand\u001b[0m\u001b[0;34m!=\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    120\u001b[0m             \u001b[0mcand_set\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcand\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    121\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mcand\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcand_set\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#IAC simulations\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "def soc_inac(ranksmaps, rankmapcount, ncand):\n",
    "    soc_inac_ensemble = []\n",
    "    condi_position = pd.DataFrame(\n",
    "        ranksmaps, columns=[i for i in range(1, ncand+1)])\n",
    "    for i in range(1, ncand+1):\n",
    "        sum_nsup = 0\n",
    "        sum_ninf = 0\n",
    "        nsup = condi_position[condi_position[i] <= int(ncand/2)].index.values\n",
    "        ninf = condi_position[condi_position[i] > np.ceil(ncand/2)].index.values\n",
    "        for j in range(len(nsup)):\n",
    "            sum_nsup = sum_nsup + rankmapcount[nsup[j]]\n",
    "        for j in range(len(ninf)):\n",
    "            sum_ninf = sum_ninf + rankmapcount[ninf[j]]\n",
    "        if sum_ninf > sum_nsup:\n",
    "            soc_inac_ensemble.append(str(i))\n",
    "\n",
    "    return soc_inac_ensemble\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "n=3\n",
    "electorate_size=501\n",
    "possible_ballots=[]\n",
    "candmap = gen_cand_map(n)\n",
    "election=gen_votemap_iac(electorate_size,candmap)\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=100\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    print(a)\n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            \n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                print(\"old plurality winner\", plurality_winners)\n",
    "                print(\"new plurality winner\", new_plur_winners)\n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                print(data_copy)\n",
    "                print(\"plurality spoiler \",l)\n",
    "                clone_set=clones(data_copy, l)\n",
    "                print(\"Clones\",clone_set)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "          \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71ed2626-4d76-4e34-935e-08751002295b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#IAC-SP simulations\n",
    "\n",
    "\n",
    "n=3\n",
    "electorate_size=501\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "6e2cc6ad-7f06-4260-a28a-28f839b089e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  58906\n",
      "Num elections with a plurality spoiler set:  90403\n",
      "Num elections with an IRV spoiler cand:  43959\n",
      "Num elections with an IRV spoiler set:  57805\n",
      "132473\n"
     ]
    }
   ],
   "source": [
    "#Linear-SP simulations\n",
    "\n",
    "\n",
    "n=4\n",
    "electorate_size=400\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    cand_positions=[]\n",
    "    \n",
    "    for k in range(n):\n",
    "        pos=random.randint(0,electorate_size-1)\n",
    "        while pos in cand_positions:\n",
    "            pos=random.randint(0,electorate_size-1)\n",
    "        cand_positions.append(pos)\n",
    "\n",
    "    cand_positions.sort()\n",
    "    cand_dict={cand_positions[i]:str(i) for i in range(n)}\n",
    "    \n",
    "    \n",
    "    #Get each voter's choice and add to the dataframe\n",
    "    for k in range(electorate_size):\n",
    "        choice=''\n",
    "        \n",
    "        dict1=cand_dict.copy()\n",
    "        \n",
    "        while len(choice)<n:\n",
    "            distances=[abs(k-i) for i in dict1]\n",
    "            distances.sort()\n",
    "            if distances[0]==0:\n",
    "                choice+=str(cand_dict[k])\n",
    "    \n",
    "            else:\n",
    "                if k-distances[0] in cand_positions and k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                    dict1.pop(k+distances[0])\n",
    "                elif k-distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                elif k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k+distances[0])\n",
    "        \n",
    "        for l in range(len(data)):\n",
    "            if data.at[l,'ballot']==choice:\n",
    "                index=l\n",
    "                break\n",
    "        data.at[index,'Count']+=1\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                \n",
    "    \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "                \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    \n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(count)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d7a566e-be21-44bf-aafa-1fb3ec36950e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#impartial culture, where we also check for clones\n",
    "#n is number of candidates, electorate_size is the number of voters.\n",
    "n=4\n",
    "electorate_size=400\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if i!=j and k!=i and k!=j:\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if i!=j and k!=i and k!=j and l!=i and l!=j and l!=k:\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "\n",
    "for a in range(100):\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "824f917c-ef44-4336-90fb-eec9a0e627f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ballot  Count\n",
      "0   0123    201\n",
      "1   1023    183\n",
      "2   1203      7\n",
      "3   1230      0\n",
      "4   2103      5\n",
      "5   2130      7\n",
      "6   2310    183\n",
      "7   3210     14\n",
      "spoiler  2\n",
      "Num elections with a plurality spoiler cand:  58312\n",
      "Num elections with a plurality spoiler set:  90380\n",
      "Num elections with an IRV spoiler cand:  43651\n",
      "Num elections with an IRV spoiler set:  57814\n",
      "Num elections with a plurality clone spoiler  0\n",
      "Num elections with a plurality clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with a plurality almost clone spoiler  12159\n",
      "Num elections with a plurality almost clone spoiler who spoiled the election for their clone 11339\n",
      "Num elections with an IRV clone spoiler  0\n",
      "Num elections with an IRV clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV almost clone spoiler  2290\n",
      "Num elections with an IRV almost clone spoiler who spoiled the election for their clone 1635\n"
     ]
    }
   ],
   "source": [
    "#Linear-SP simulations, where we also check for clones\n",
    "\n",
    "\n",
    "n=4\n",
    "electorate_size=600\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "\n",
    "counter=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    cand_positions=[]\n",
    "    \n",
    "    for k in range(n):\n",
    "        pos=random.randint(0,electorate_size-1)\n",
    "        while pos in cand_positions:\n",
    "            pos=random.randint(0,electorate_size-1)\n",
    "        cand_positions.append(pos)\n",
    "\n",
    "    cand_positions.sort()\n",
    "    cand_dict={cand_positions[i]:str(i) for i in range(n)}\n",
    "    \n",
    "    \n",
    "    #Get each voter's choice and add to the dataframe\n",
    "    for k in range(electorate_size):\n",
    "        choice=''\n",
    "        \n",
    "        dict1=cand_dict.copy()\n",
    "        \n",
    "        while len(choice)<n:\n",
    "            distances=[abs(k-i) for i in dict1]\n",
    "            distances.sort()\n",
    "            if distances[0]==0:\n",
    "                choice+=str(cand_dict[k])\n",
    "    \n",
    "            else:\n",
    "                if k-distances[0] in cand_positions and k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                    dict1.pop(k+distances[0])\n",
    "                elif k-distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                elif k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k+distances[0])\n",
    "        \n",
    "        for l in range(len(data)):\n",
    "            if data.at[l,'ballot']==choice:\n",
    "                index=l\n",
    "                break\n",
    "        data.at[index,'Count']+=1\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "                        else:\n",
    "                            if counter<1:\n",
    "                                print(data)\n",
    "                                print(\"spoiler \",l)\n",
    "                                counter+=1\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ca9a597e-bb6c-42c7-b7d4-8651cd4cad9a",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'all_different' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-a8cbe51be7e0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m                 \u001b[0;32mif\u001b[0m \u001b[0mall_different\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m                     \u001b[0;32mif\u001b[0m \u001b[0mis_SP_ranking\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m                         \u001b[0mpossible_ballots\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'all_different' is not defined"
     ]
    }
   ],
   "source": [
    "#Linear-SP simulations, where we also check for clones\n",
    "\n",
    "\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "\n",
    "counter=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    cand_positions=[]\n",
    "    \n",
    "    for k in range(n):\n",
    "        pos=random.randint(0,electorate_size-1)\n",
    "        while pos in cand_positions:\n",
    "            pos=random.randint(0,electorate_size-1)\n",
    "        cand_positions.append(pos)\n",
    "\n",
    "    cand_positions.sort()\n",
    "    cand_dict={cand_positions[i]:str(i) for i in range(n)}\n",
    "    \n",
    "    \n",
    "    #Get each voter's choice and add to the dataframe\n",
    "    for k in range(electorate_size):\n",
    "        choice=''\n",
    "        \n",
    "        dict1=cand_dict.copy()\n",
    "        \n",
    "        while len(choice)<n:\n",
    "            distances=[abs(k-i) for i in dict1]\n",
    "            distances.sort()\n",
    "            if distances[0]==0:\n",
    "                choice+=str(cand_dict[k])\n",
    "    \n",
    "            else:\n",
    "                if k-distances[0] in cand_positions and k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                    dict1.pop(k+distances[0])\n",
    "                elif k-distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                elif k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k+distances[0])\n",
    "        \n",
    "        for l in range(len(data)):\n",
    "            if data.at[l,'ballot']==choice:\n",
    "                index=l\n",
    "                break\n",
    "        data.at[index,'Count']+=1\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                print(data_copy)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "                        else:\n",
    "                            if counter<1:\n",
    "                                print(data)\n",
    "                                print(\"spoiler \",l)\n",
    "                                counter+=1\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "267dfce0-5340-4cd6-a94d-e65ca58e9704",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  6296\n",
      "Num elections with a plurality spoiler set:  6296\n",
      "Num elections with a plurality spoiler cand and there's a tie issue:  570\n",
      "Num elections with an IRV spoiler cand:  2467\n",
      "Num elections with an IRV spoiler set:  2467\n"
     ]
    }
   ],
   "source": [
    "#impartial culture. \n",
    "#n is number of candidates, electorate_size is the number of voters.\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if i!=j and k!=i and k!=j:\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if i!=j and k!=i and k!=j and l!=i and l!=j and l!=k:\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "tie_issue=0\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "a=20000\n",
    "\n",
    "while a>0:\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    if max(scores)<=electorate_size/2:\n",
    "        cands=[str(i) for i in range(n)]\n",
    "        r=[x for x in powerset(cands)]\n",
    "\n",
    "        #Check for plurality spoiler candidates and sets\n",
    "\n",
    "        #First check for spoiler candidates\n",
    "        plurality_spoiler=False\n",
    "        plurality_spoiler_set=False\n",
    "\n",
    "        for l in range(n):\n",
    "            if str(l) not in plurality_winners:\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                #print(data_copy)\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    if len(plurality_winners)>1 or len(new_plur_winners)>1:\n",
    "                        tie_issue+=1\n",
    "                    plurality_spoiler=True\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "        if plurality_spoiler==False:\n",
    "            for subset in r:\n",
    "                if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                    #print(l)\n",
    "                    data_copy=data.copy(deep=True)\n",
    "                    for b in range(len(data_copy)):\n",
    "                        for l in subset:\n",
    "                            data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                    new_plur_winners=plurality(data_copy)\n",
    "                    #print(new_plur_winners)\n",
    "                    if plurality_winners!=new_plur_winners:\n",
    "                        plurality_spoiler_set=True\n",
    "\n",
    "\n",
    "        if plurality_spoiler:\n",
    "            plur_spoiler+=1\n",
    "        if plurality_spoiler_set:\n",
    "            plur_spoiler_set+=1\n",
    "\n",
    "        IRV_spoiler_exists=False\n",
    "        IRV_spoiler_set_exists=False\n",
    "        #Check for IRV spoiler candidates and sets\n",
    "        #First, check for spoiler cands\n",
    "        for l in range(n):\n",
    "            if str(l) not in IRV_winners:\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "\n",
    "        if IRV_spoiler_exists==False:\n",
    "            for subset in r:\n",
    "                if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                    #print(l)\n",
    "                    data_copy=data.copy(deep=True)\n",
    "                    for b in range(len(data_copy)):\n",
    "                        for l in subset:\n",
    "                            data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                    new_IRV_winners=IRV(data_copy)\n",
    "                    #print(new_plur_winners)\n",
    "                    if IRV_winners!=new_IRV_winners:\n",
    "                        if len(subset)==1:\n",
    "                            IRV_spoiler_exists=True\n",
    "                        IRV_spoiler_set_exists=True\n",
    "\n",
    "        if IRV_spoiler_exists:\n",
    "            IRV_spoiler+=1\n",
    "        if IRV_spoiler_set_exists:\n",
    "            IRV_spoiler_set+=1\n",
    "        a-=1\n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with a plurality spoiler cand and there's a tie issue: \",tie_issue)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "id": "7362bd2d-706d-46ae-bd1b-422951589836",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  49537\n",
      "Num elections with a plurality spoiler set:  59776\n",
      "Num elections with an IRV spoiler cand:  22981\n",
      "Num elections with an IRV spoiler set:  25812\n",
      "Num elections with a plurality clone spoiler  0\n",
      "Num elections with a plurality clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with a plurality almost clone spoiler  0\n",
      "Num elections with a plurality almost clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV clone spoiler  0\n",
      "Num elections with an IRV clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV almost clone spoiler  0\n",
      "Num elections with an IRV almost clone spoiler who spoiled the election for their clone 0\n"
     ]
    }
   ],
   "source": [
    "#impartial culture, where we also check for clones\n",
    "\n",
    "\n",
    "n=4\n",
    "electorate_size=401\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if i!=j and k!=i and k!=j:\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if i!=j and k!=i and k!=j and l!=i and l!=j and l!=k:\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "\n",
    "\n",
    "\n",
    "for a in range(100000):\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "04584a00-afc3-4b95-aa0d-f959acaefb04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  40502\n",
      "Num elections with a plurality spoiler set:  40502\n",
      "Num elections with an IRV spoiler cand:  21688\n",
      "Num elections with an IRV spoiler set:  21688\n",
      "Num elections with a plurality clone spoiler  7\n",
      "Num elections with a plurality clone spoiler who spoiled the election for their clone 7\n",
      "Num elections with a plurality almost clone spoiler  1897\n",
      "Num elections with a plurality almost clone spoiler who spoiled the election for their clone 1842\n",
      "Num elections with an IRV clone spoiler  0\n",
      "Num elections with an IRV clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV almost clone spoiler  206\n",
      "Num elections with an IRV almost clone spoiler who spoiled the election for their clone 206\n"
     ]
    }
   ],
   "source": [
    "#IAC simulations\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "n=3\n",
    "electorate_size=401\n",
    "possible_ballots=[]\n",
    "candmap = gen_cand_map(n)\n",
    "election=gen_votemap_iac(electorate_size,candmap)\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(0,n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l+1): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(1,n+1)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(1,n+1):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            \n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                \n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "          \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(1,n+1):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "147e5d6b-a2ad-4ac0-a35a-4ce8d21a5e34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  38004\n",
      "Num elections with a plurality spoiler set:  48769\n",
      "Num elections with an IRV spoiler cand:  21612\n",
      "Num elections with an IRV spoiler set:  24374\n",
      "Num elections with a plurality clone spoiler  0\n",
      "Num elections with a plurality clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with a plurality almost clone spoiler  0\n",
      "Num elections with a plurality almost clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV clone spoiler  0\n",
      "Num elections with an IRV clone spoiler who spoiled the election for their clone 0\n",
      "Num elections with an IRV almost clone spoiler  0\n",
      "Num elections with an IRV almost clone spoiler who spoiled the election for their clone 0\n"
     ]
    }
   ],
   "source": [
    "#IAC simulations\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "n=4\n",
    "electorate_size=400\n",
    "possible_ballots=[]\n",
    "candmap = gen_cand_map(n)\n",
    "election=gen_votemap_iac(electorate_size,candmap)\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(0,n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l+1): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(1,n+1)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(1,n+1):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            \n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                \n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "          \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(1,n+1):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bcf04b5e-1e9b-422a-8cdf-d4c514036620",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ballot  Count\n",
      "0    210     75\n",
      "1    102    234\n",
      "2    012    290\n",
      "3    120      2\n",
      "  ballot  Count\n",
      "0    120    178\n",
      "1    102     31\n",
      "2    210    237\n",
      "3    012    155\n",
      "  ballot  Count\n",
      "0    012    285\n",
      "1    210    124\n",
      "2    102    129\n",
      "3    120     63\n",
      "  ballot  Count\n",
      "0    102    138\n",
      "1    012    118\n",
      "2    210    259\n",
      "3    120     86\n",
      "  ballot  Count\n",
      "0    012    209\n",
      "1    210    254\n",
      "2    120     10\n",
      "3    102    128\n",
      "  ballot  Count\n",
      "0    012    209\n",
      "1    210    254\n",
      "2    120     10\n",
      "3    102    128\n",
      "  ballot  Count\n",
      "0    120    133\n",
      "1    102    102\n",
      "2    012    131\n",
      "3    210    235\n",
      "  ballot  Count\n",
      "0    120    201\n",
      "1    012    298\n",
      "2    102     82\n",
      "3    210     20\n",
      "  ballot  Count\n",
      "0    210    261\n",
      "1    012    260\n",
      "2    120     65\n",
      "3    102     15\n",
      "  ballot  Count\n",
      "0    012    253\n",
      "1    120     68\n",
      "2    210    263\n",
      "3    102     17\n",
      "  ballot  Count\n",
      "0    012    117\n",
      "1    210    295\n",
      "2    102    189\n",
      "  ballot  Count\n",
      "0    012    117\n",
      "1    210    295\n",
      "2    102    189\n",
      "  ballot  Count\n",
      "0    012    277\n",
      "1    210     94\n",
      "2    102    210\n",
      "3    120     20\n",
      "  ballot  Count\n",
      "0    102    124\n",
      "1    210    294\n",
      "2    012    160\n",
      "3    120     23\n",
      "  ballot  Count\n",
      "0    012    285\n",
      "1    120     30\n",
      "2    210    147\n",
      "3    102    139\n",
      "  ballot  Count\n",
      "0    102      9\n",
      "1    120    151\n",
      "2    012    230\n",
      "3    210    211\n",
      "  ballot  Count\n",
      "0    102      9\n",
      "1    120    151\n",
      "2    012    230\n",
      "3    210    211\n",
      "  ballot  Count\n",
      "0    102     69\n",
      "1    012    186\n",
      "2    210    294\n",
      "3    120     52\n",
      "  ballot  Count\n",
      "0    210    277\n",
      "1    120    139\n",
      "2    102    136\n",
      "3    012     49\n",
      "  ballot  Count\n",
      "0    102    158\n",
      "1    210    291\n",
      "2    120     71\n",
      "3    012     81\n",
      "  ballot  Count\n",
      "0    210    208\n",
      "1    012    248\n",
      "2    102     82\n",
      "3    120     63\n",
      "  ballot  Count\n",
      "0    012    259\n",
      "1    210    132\n",
      "2    120    182\n",
      "3    102     28\n",
      "  ballot  Count\n",
      "0    012    259\n",
      "1    210    132\n",
      "2    120    182\n",
      "3    102     28\n",
      "  ballot  Count\n",
      "0    012    237\n",
      "1    210    176\n",
      "2    102     58\n",
      "3    120    130\n",
      "  ballot  Count\n",
      "0    012    237\n",
      "1    210    176\n",
      "2    102     58\n",
      "3    120    130\n",
      "  ballot  Count\n",
      "0    012     85\n",
      "1    210    260\n",
      "2    120    163\n",
      "3    102     93\n",
      "  ballot  Count\n",
      "0    210    279\n",
      "1    012    220\n",
      "2    102     81\n",
      "3    120     21\n",
      "  ballot  Count\n",
      "0    210    279\n",
      "1    012    220\n",
      "2    102     81\n",
      "3    120     21\n",
      "  ballot  Count\n",
      "0    012    177\n",
      "1    120    116\n",
      "2    210    253\n",
      "3    102     55\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-db2a8354ba76>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    263\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mb\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    264\u001b[0m                 \u001b[0mdata_copy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'ballot'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'ballot'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreplace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 265\u001b[0;31m             \u001b[0mnew_IRV_winners\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mIRV\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_copy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    266\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mIRV_winners\u001b[0m\u001b[0;34m!=\u001b[0m\u001b[0mnew_IRV_winners\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    267\u001b[0m                 \u001b[0mIRV_spoiler_exists\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-3-a54f9be7ff0b>\u001b[0m in \u001b[0;36mIRV\u001b[0;34m(frame)\u001b[0m\n\u001b[1;32m     19\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'ballot'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0mcand_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m                     \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+=\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Count'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Count'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m    893\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    894\u001b[0m             \u001b[0mmaybe_callable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_if_callable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 895\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_axis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmaybe_callable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    896\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    897\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_is_scalar_access\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_getitem_axis\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m   1489\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1490\u001b[0m         \u001b[0;31m# a list of integers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1491\u001b[0;31m         \u001b[0;32melif\u001b[0m \u001b[0mis_list_like_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1492\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_list_axis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1493\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/indexers.py\u001b[0m in \u001b[0;36mis_list_like_indexer\u001b[0;34m(key)\u001b[0m\n\u001b[1;32m     63\u001b[0m     \"\"\"\n\u001b[1;32m     64\u001b[0m     \u001b[0;31m# allow a list_like, but exclude NamedTuples which can be indexers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mis_list_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32mpandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.is_list_like\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32mpandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.c_is_list_like\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/abc.py\u001b[0m in \u001b[0;36m__instancecheck__\u001b[0;34m(cls, instance)\u001b[0m\n\u001b[1;32m     94\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0m_abc_register\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msubclass\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 96\u001b[0;31m         \u001b[0;32mdef\u001b[0m \u001b[0m__instancecheck__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     97\u001b[0m             \u001b[0;34m\"\"\"Override for isinstance(instance, cls).\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     98\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0m_abc_instancecheck\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#IAC-SP simulations, where we check for clones\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "model='IAC-SP'\n",
    "    \n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "    \n",
    "    ReplaceSize = 0\n",
    "    \n",
    "    ICsize=len(possible_ballots)\n",
    "    ballot_dict={i:possible_ballots[i] for i in range(len(possible_ballots))}\n",
    "    for x in range(numvotes):\n",
    "        \n",
    "        \n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        \n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            \n",
    "            #tvote = gen_ic_vote(alts, rng)\n",
    "            x=random.randint(0,len(ballot_dict)-1)\n",
    "            tvote=ballot_dict[x]\n",
    "            \n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    \n",
    "    return voteMap\n",
    "\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(0,n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    clone_spoiler_found_plur=False\n",
    "    clone_spoiler_change_winner_found_plur=False\n",
    "    almost_clone_spoiler_found_plur=False\n",
    "    almost_clone_spoiler_change_winner_found_plur=False\n",
    "    \n",
    "    for l in range(0,n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            \n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                \n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                print(data_copy)\n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_plur=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            clone_spoiler_change_winner_found_plur=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_plur=True\n",
    "\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_plur_winners and clone not in plurality_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_plur=True\n",
    "                \n",
    "    if plurality_spoiler==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(plurality_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    plurality_spoiler_set=True\n",
    "\n",
    "            \n",
    "          \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    if plurality_spoiler_set:\n",
    "        plur_spoiler_set+=1\n",
    "    if clone_spoiler_found_plur:\n",
    "        plur_clone+=1\n",
    "    if clone_spoiler_change_winner_found_plur:\n",
    "        plur_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_plur:\n",
    "        plur_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_plur:\n",
    "        plur_almost_clone_spoiler+=1\n",
    "    \n",
    "    clone_spoiler_found_IRV=False\n",
    "    clone_spoiler_change_winner_found_IRV=False\n",
    "    almost_clone_spoiler_found_IRV=False\n",
    "    almost_clone_spoiler_change_winner_found_IRV=False\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                \n",
    "                #Check if l is a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                \n",
    "                clone_set=clones(data_copy, l)\n",
    "                \n",
    "                almost_clone_set=almost_clones(data_copy, l,p)\n",
    "                \n",
    "                if clone_set!=[]:\n",
    "                    #If l is a clone, see if l spoiled the election for their clone\n",
    "                    clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            clone_spoiler_change_winner_found_IRV=True\n",
    "                    \n",
    "                #Check if l is almost a clone\n",
    "                data_copy=data.copy(deep=True)\n",
    "                clone_set=almost_clones(data_copy, l,p)\n",
    "                if clone_set!=[]:\n",
    "                    #If l is an almost clone, see if l spoiled the election for their clone\n",
    "                    almost_clone_spoiler_found_IRV=True\n",
    "                    for clone in clone_set:\n",
    "                        if clone in new_IRV_winners and clone not in IRV_winners:\n",
    "                            almost_clone_spoiler_change_winner_found_IRV=True\n",
    "    \n",
    "    if IRV_spoiler_exists==False:\n",
    "        for subset in r:\n",
    "            if len(subset)>=2 and set(IRV_winners).isdisjoint(set(subset)):\n",
    "                #print(l)\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    for l in subset:\n",
    "                        data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                #print(new_plur_winners)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    if len(subset)==1:\n",
    "                        IRV_spoiler_exists=True\n",
    "                    IRV_spoiler_set_exists=True\n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    if clone_spoiler_found_IRV:\n",
    "        IRV_clone+=1\n",
    "    if clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_clone_spoiler+=1\n",
    "    if almost_clone_spoiler_found_IRV:\n",
    "        IRV_almost_clone+=1\n",
    "    if almost_clone_spoiler_change_winner_found_IRV:\n",
    "        IRV_almost_clone_spoiler+=1\n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with a plurality spoiler set: \" ,plur_spoiler_set)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections with an IRV spoiler set: \", IRV_spoiler_set)\n",
    "print(\"Num elections with a plurality clone spoiler \",plur_clone)\n",
    "print(\"Num elections with a plurality clone spoiler who spoiled the election for their clone\",plur_clone_spoiler)\n",
    "print(\"Num elections with a plurality almost clone spoiler \",plur_almost_clone)\n",
    "print(\"Num elections with a plurality almost clone spoiler who spoiled the election for their clone\",plur_almost_clone_spoiler)\n",
    "print(\"Num elections with an IRV clone spoiler \",IRV_clone)\n",
    "print(\"Num elections with an IRV clone spoiler who spoiled the election for their clone\",IRV_clone_spoiler)\n",
    "print(\"Num elections with an IRV almost clone spoiler \",IRV_almost_clone)\n",
    "print(\"Num elections with an IRV almost clone spoiler who spoiled the election for their clone\",IRV_almost_clone_spoiler)\n",
    "print(\"Model=\",model,\" n=\",n,\" V=\",electorate_size) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c6a13aae-637a-4233-abf7-727013905b22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model= Linear-SP\n",
      "n=  5\n",
      "V=  400\n",
      "Number of elections in which CL is a plurality spoiler  29980\n",
      "Number of elections in which CL is a plurality winner  8518\n",
      "Number of elections in which CL is an IRV spoiler  17436\n",
      "Number of elections in which CL is an IRV winner  230\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#Linear-SP simulations for CL\n",
    "\n",
    "\n",
    "n=5\n",
    "electorate_size=400\n",
    "possible_ballots=[]\n",
    "model='Linear-SP'\n",
    "\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "CL_IRV_winner=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    \n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    cand_positions=[]\n",
    "    \n",
    "    for k in range(n):\n",
    "        pos=random.randint(0,electorate_size-1)\n",
    "        while pos in cand_positions:\n",
    "            pos=random.randint(0,electorate_size-1)\n",
    "        cand_positions.append(pos)\n",
    "\n",
    "    cand_positions.sort()\n",
    "    cand_dict={cand_positions[i]:str(i) for i in range(n)}\n",
    "    \n",
    "    \n",
    "    #Get each voter's choice and add to the dataframe\n",
    "    for k in range(electorate_size):\n",
    "        choice=''\n",
    "        \n",
    "        dict1=cand_dict.copy()\n",
    "        \n",
    "        while len(choice)<n:\n",
    "            distances=[abs(k-i) for i in dict1]\n",
    "            distances.sort()\n",
    "            if distances[0]==0:\n",
    "                choice+=str(cand_dict[k])\n",
    "    \n",
    "            else:\n",
    "                if k-distances[0] in cand_positions and k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                    dict1.pop(k+distances[0])\n",
    "                elif k-distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                elif k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k+distances[0])\n",
    "        \n",
    "        for l in range(len(data)):\n",
    "            if data.at[l,'ballot']==choice:\n",
    "                index=l\n",
    "                break\n",
    "        data.at[index,'Count']+=1\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate and CL\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)<=electorate_size/2 and Cond_loser(data)!=False:\n",
    "    \n",
    "        CL=Cond_loser(data)\n",
    "\n",
    "        data_copy=data.copy(deep=True)    \n",
    "        IRV_winners=IRV(data_copy)\n",
    "        data_copy=data.copy(deep=True)  \n",
    "        plurality_winners=plurality(data_copy)\n",
    "\n",
    "        #First check for spoiler candidates\n",
    "\n",
    "\n",
    "        if CL in plurality_winners:\n",
    "            #print(\"CL is a plurality winner \",CL)\n",
    "            #print(data)\n",
    "            CL_plurality_winner+=1\n",
    "\n",
    "        if CL not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                #print(\"CL is a plurality spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_plurality_spoiler+=1\n",
    "        if CL in IRV_winners:\n",
    "            CL_IRV_winner+=1\n",
    "            #print(\"CL is an IRV winner \",CL)\n",
    "            #print(data)\n",
    "\n",
    "        if CL not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                #print(\"CL is an IRV spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_IRV_spoiler+=1\n",
    "        a-=1\n",
    "print(\"model=\", model)\n",
    "print(\"n= \",n)\n",
    "print(\"V= \",electorate_size)          \n",
    "print(\"Number of elections in which CL is a plurality spoiler \", CL_plurality_spoiler)\n",
    "print(\"Number of elections in which CL is a plurality winner \", CL_plurality_winner)\n",
    "print(\"Number of elections in which CL is an IRV spoiler \", CL_IRV_spoiler)\n",
    "print(\"Number of elections in which CL is an IRV winner \", CL_IRV_winner)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "78262827-2e7e-4f8b-983d-093be8899766",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model= IAC-SP\n",
      "n=  5\n",
      "V=  600\n",
      "Number of elections in which CL is a plurality spoiler  9821\n",
      "Number of elections in which CL is a plurality winner  79\n",
      "Number of elections in which CL is an IRV spoiler  815\n",
      "Number of elections in which CL is an IRV winner  3\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#IAC-SP for CL\n",
    "n=5\n",
    "electorate_size=600\n",
    "possible_ballots=[]\n",
    "model='IAC-SP'\n",
    "    \n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "    \n",
    "    ReplaceSize = 0\n",
    "    \n",
    "    ICsize=len(possible_ballots)\n",
    "    ballot_dict={i:possible_ballots[i] for i in range(len(possible_ballots))}\n",
    "    for x in range(numvotes):\n",
    "        \n",
    "        \n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        \n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            \n",
    "            #tvote = gen_ic_vote(alts, rng)\n",
    "            x=random.randint(0,len(ballot_dict)-1)\n",
    "            tvote=ballot_dict[x]\n",
    "            \n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    \n",
    "    return voteMap\n",
    "\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "CL_IRV_winner=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    \n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate and CL\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)<=electorate_size/2 and Cond_loser(data)!=False:\n",
    "    \n",
    "        CL=Cond_loser(data)\n",
    "\n",
    "        data_copy=data.copy(deep=True)    \n",
    "        IRV_winners=IRV(data_copy)\n",
    "        data_copy=data.copy(deep=True)  \n",
    "        plurality_winners=plurality(data_copy)\n",
    "\n",
    "        #First check for spoiler candidates\n",
    "\n",
    "\n",
    "        if CL in plurality_winners:\n",
    "            #print(\"CL is a plurality winner \",CL)\n",
    "            #print(data)\n",
    "            CL_plurality_winner+=1\n",
    "\n",
    "        if CL not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                #print(\"CL is a plurality spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_plurality_spoiler+=1\n",
    "        if CL in IRV_winners:\n",
    "            CL_IRV_winner+=1\n",
    "            #print(\"CL is an IRV winner \",CL)\n",
    "            #print(data)\n",
    "\n",
    "        if CL not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                #print(\"CL is an IRV spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_IRV_spoiler+=1\n",
    "        a-=1\n",
    "print(\"model=\", model)\n",
    "print(\"n= \",n)\n",
    "print(\"V= \",electorate_size)          \n",
    "print(\"Number of elections in which CL is a plurality spoiler \", CL_plurality_spoiler)\n",
    "print(\"Number of elections in which CL is a plurality winner \", CL_plurality_winner)\n",
    "print(\"Number of elections in which CL is an IRV spoiler \", CL_IRV_spoiler)\n",
    "print(\"Number of elections in which CL is an IRV winner \", CL_IRV_winner)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b50f7e7-2788-44fe-bef4-7d2e20cb55bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "#IAC for CL\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "model='IAC-SP'\n",
    "    \n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "\n",
    "    ICsize = math.factorial(len(alts))\n",
    "    ReplaceSize = 0\n",
    "\n",
    "    for x in range(numvotes):\n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            tvote = gen_ic_vote(alts, rng)\n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    return voteMap\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "def soc_inac(ranksmaps, rankmapcount, ncand):\n",
    "    soc_inac_ensemble = []\n",
    "    condi_position = pd.DataFrame(\n",
    "        ranksmaps, columns=[i for i in range(1, ncand+1)])\n",
    "    for i in range(1, ncand+1):\n",
    "        sum_nsup = 0\n",
    "        sum_ninf = 0\n",
    "        nsup = condi_position[condi_position[i] <= int(ncand/2)].index.values\n",
    "        ninf = condi_position[condi_position[i] > np.ceil(ncand/2)].index.values\n",
    "        for j in range(len(nsup)):\n",
    "            sum_nsup = sum_nsup + rankmapcount[nsup[j]]\n",
    "        for j in range(len(ninf)):\n",
    "            sum_ninf = sum_ninf + rankmapcount[ninf[j]]\n",
    "        if sum_ninf > sum_nsup:\n",
    "            soc_inac_ensemble.append(str(i))\n",
    "\n",
    "    return soc_inac_ensemble\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "CL_IRV_winner=0\n",
    "\n",
    "a=10\n",
    "count=0\n",
    "while a>0:\n",
    "    \n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate and CL\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l+1): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    print(\"\\n\")\n",
    "    print(data)\n",
    "    print(\"scores\",scores)\n",
    "    \n",
    "    if max(scores)<=electorate_size/2 and Cond_loser(data)!=False:\n",
    "        print(\"inside if\")\n",
    "        CL=Cond_loser(data)\n",
    "        print(\"CL is \",CL)\n",
    "        data_copy=data.copy(deep=True)    \n",
    "        IRV_winners=IRV(data_copy)\n",
    "        data_copy=data.copy(deep=True)  \n",
    "        plurality_winners=plurality(data_copy)\n",
    "\n",
    "        #First check for spoiler candidates\n",
    "\n",
    "\n",
    "        if CL in plurality_winners:\n",
    "            print(\"CL is a plurality winner \",CL)\n",
    "            print(data)\n",
    "            CL_plurality_winner+=1\n",
    "\n",
    "        if CL not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                print(\"CL is a plurality spoiler \",CL)\n",
    "                print(data)\n",
    "                CL_plurality_spoiler+=1\n",
    "        if CL in IRV_winners:\n",
    "            CL_IRV_winner+=1\n",
    "            print(\"CL is an IRV winner \",CL)\n",
    "            print(data)\n",
    "\n",
    "        if CL not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                print(\"CL is an IRV spoiler \",CL)\n",
    "                print(data)\n",
    "                CL_IRV_spoiler+=1\n",
    "        a-=1\n",
    "print(\"model=\", model)\n",
    "print(\"n= \",n)\n",
    "print(\"V= \",electorate_size)          \n",
    "print(\"Number of elections in which CL is a plurality spoiler \", CL_plurality_spoiler)\n",
    "print(\"Number of elections in which CL is a plurality winner \", CL_plurality_winner)\n",
    "print(\"Number of elections in which CL is an IRV spoiler \", CL_IRV_spoiler)\n",
    "print(\"Number of elections in which CL is an IRV winner \", CL_IRV_winner)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3bd9cb94-bcfa-4d85-8087-f65bd7ead258",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90000\n",
      "80000\n",
      "70000\n",
      "60000\n",
      "50000\n",
      "40000\n",
      "30000\n",
      "20000\n",
      "10000\n",
      "0\n",
      "model= IC\n",
      "n=  3\n",
      "V=  601\n",
      "Number of elections in which CL is a plurality spoiler  20833\n",
      "Number of elections in which CL is a plurality winner  4054\n",
      "Number of elections in which CL is an IRV spoiler  3752\n",
      "Number of elections in which CL is an IRV winner  238\n",
      "90000\n",
      "80000\n",
      "70000\n",
      "60000\n",
      "50000\n",
      "40000\n",
      "30000\n",
      "20000\n",
      "10000\n",
      "0\n",
      "model= IC\n",
      "n=  4\n",
      "V=  601\n",
      "Number of elections in which CL is a plurality spoiler  26677\n",
      "Number of elections in which CL is a plurality winner  2722\n",
      "Number of elections in which CL is an IRV spoiler  4388\n",
      "Number of elections in which CL is an IRV winner  125\n",
      "90000\n",
      "80000\n",
      "70000\n",
      "60000\n",
      "50000\n",
      "40000\n",
      "30000\n",
      "20000\n",
      "10000\n",
      "0\n",
      "model= IC\n",
      "n=  5\n",
      "V=  601\n",
      "Number of elections in which CL is a plurality spoiler  28383\n",
      "Number of elections in which CL is a plurality winner  2191\n",
      "Number of elections in which CL is an IRV spoiler  4575\n",
      "Number of elections in which CL is an IRV winner  57\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#impartial culture for CL\n",
    "\n",
    "model='IC'\n",
    "#n=5\n",
    "electorate_size=601\n",
    "\n",
    "n_values=[3,4,5]     \n",
    "for n in n_values:\n",
    "    possible_ballots=[]\n",
    "\n",
    "    if n==3:\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                for k in range(n):\n",
    "                    if all_different([i,j,k]):\n",
    "                        \n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "    if n==4:\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                for k in range(n):\n",
    "                    for l in range(n):\n",
    "                        if all_different([i,j,k,l]):\n",
    "                            \n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "    if n==5:\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                for k in range(n):\n",
    "                    for l in range(n):\n",
    "                        for p in range(n):\n",
    "                            if all_different([i,j,k,l,p]):\n",
    "                                \n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "    if n==6:\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                for k in range(n):\n",
    "                    for l in range(n):\n",
    "                        for p in range(n):\n",
    "                            for q in range(n):\n",
    "                                if all_different([i,j,k,l,p,q]):\n",
    "                                    \n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "    CL_plurality_spoiler=0\n",
    "    CL_plurality_winner=0\n",
    "    CL_IRV_spoiler=0\n",
    "    CL_IRV_winner=0\n",
    "\n",
    "    a=100000\n",
    "    count=0\n",
    "    while a>0:\n",
    "\n",
    "        count+=1\n",
    "        data['ballot']=possible_ballots\n",
    "        data['Count']=[0 for item in possible_ballots]\n",
    "        for k in range(electorate_size):\n",
    "            vote=random.randint(0,len(possible_ballots)-1)\n",
    "            data.at[vote,'Count']+=1\n",
    "        #print(data)\n",
    "        data_copy=data.copy(deep=True)    \n",
    "        IRV_winners=IRV(data_copy)\n",
    "        #print(IRV_winners)\n",
    "        data_copy=data.copy(deep=True)  \n",
    "        plurality_winners=plurality(data_copy)\n",
    "        #print(plurality_winners)\n",
    "        #print(\"CL\",type(Cond_loser(data)))\n",
    "        #Check for majority candidate and CL\n",
    "        scores=[0 for i in range(n)]\n",
    "        for k in range(len(data)):\n",
    "            for l in range(n):\n",
    "                if data.iloc[k]['ballot'][0]==str(l): \n",
    "                    scores[l]+=data.iloc[k]['Count']\n",
    "\n",
    "\n",
    "\n",
    "        if max(scores)<=electorate_size/2 and Cond_loser(data)!=False:\n",
    "\n",
    "            CL=Cond_loser(data)\n",
    "\n",
    "            data_copy=data.copy(deep=True)    \n",
    "            IRV_winners=IRV(data_copy)\n",
    "            data_copy=data.copy(deep=True)  \n",
    "            plurality_winners=plurality(data_copy)\n",
    "\n",
    "            #First check for spoiler candidates\n",
    "\n",
    "\n",
    "            if CL in plurality_winners:\n",
    "                #print(\"CL is a plurality winner \",CL)\n",
    "                #print(data)\n",
    "                CL_plurality_winner+=1\n",
    "\n",
    "            if CL not in plurality_winners:\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "                #print(data_copy)\n",
    "                new_plur_winners=plurality(data_copy)\n",
    "                if plurality_winners!=new_plur_winners:\n",
    "                    #print(\"CL is a plurality spoiler \",CL)\n",
    "                    #print(data)\n",
    "                    CL_plurality_spoiler+=1\n",
    "            if CL in IRV_winners:\n",
    "                CL_IRV_winner+=1\n",
    "                #print(\"CL is an IRV winner \",CL)\n",
    "                #print(data)\n",
    "\n",
    "            if CL not in IRV_winners:\n",
    "                data_copy=data.copy(deep=True)\n",
    "                for b in range(len(data_copy)):\n",
    "                    data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "                #print(data_copy)\n",
    "                new_IRV_winners=IRV(data_copy)\n",
    "                if IRV_winners!=new_IRV_winners:\n",
    "                    #print(\"CL is an IRV spoiler \",CL)\n",
    "                    #print(data)\n",
    "                    CL_IRV_spoiler+=1\n",
    "            a-=1\n",
    "            if a%10000==0:\n",
    "                print(a)\n",
    "    print(\"model=\", model)\n",
    "    print(\"n= \",n)\n",
    "    print(\"V= \",electorate_size)          \n",
    "    print(\"Number of elections in which CL is a plurality spoiler \", CL_plurality_spoiler)\n",
    "    print(\"Number of elections in which CL is a plurality winner \", CL_plurality_winner)\n",
    "    print(\"Number of elections in which CL is an IRV spoiler \", CL_IRV_spoiler)\n",
    "    print(\"Number of elections in which CL is an IRV winner \", CL_IRV_winner)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e96a5340-26ca-42b6-af12-8fe6ad85b568",
   "metadata": {},
   "outputs": [],
   "source": [
    "File=open('Desktop/ward1.xlsx','r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "59155bd5-ea7b-478b-9693-90054356589b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<_io.TextIOWrapper name='Desktop/ward1.xlsx' mode='r' encoding='UTF-8'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "82cfbcf0-e3ca-480e-beb9-9e701e612afa",
   "metadata": {},
   "outputs": [
    {
     "ename": "UnicodeDecodeError",
     "evalue": "'utf-8' codec can't decode bytes in position 15-16: invalid continuation byte",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m                        Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-2433ec515f88>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlines\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mFile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadlines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mlines\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/codecs.py\u001b[0m in \u001b[0;36mdecode\u001b[0;34m(self, input, final)\u001b[0m\n\u001b[1;32m    320\u001b[0m         \u001b[0;31m# decode input (taking the buffer into account)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    321\u001b[0m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuffer\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 322\u001b[0;31m         \u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsumed\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_buffer_decode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfinal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    323\u001b[0m         \u001b[0;31m# keep undecoded input until the next call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    324\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuffer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconsumed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m: 'utf-8' codec can't decode bytes in position 15-16: invalid continuation byte"
     ]
    }
   ],
   "source": [
    "lines=File.readlines()\n",
    "lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "48d6990c-3e91-4eac-9857-2e9453d2e7a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  38692\n",
      "Num elections with an IRV spoiler cand:  19462\n",
      "Num elections A wins plurality  38692\n",
      "Num elections A wins IRV  19462\n",
      "Num elections A wins pluarlity, B spiols,  10903\n",
      "Num elections A wins pluarlity, C spiols,  38692\n",
      "Num elections A wins IRV, B spiols,  52\n",
      "Num elections A wins IRV, C spiols,  19462\n",
      "199384\n"
     ]
    }
   ],
   "source": [
    "#Linear-SP simulations\n",
    "\n",
    "\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "A_wins=0\n",
    "A_wins_IRV=0\n",
    "A_wins_C_spoils=0\n",
    "A_wins_B_spoils=0\n",
    "A_wins_C_spoils_IRV=0\n",
    "A_wins_B_spoils_IRV=0\n",
    "while a>0:\n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    cand_positions=[]\n",
    "    \n",
    "    for k in range(n):\n",
    "        pos=random.randint(0,electorate_size-1)\n",
    "        while pos in cand_positions:\n",
    "            pos=random.randint(0,electorate_size-1)\n",
    "        cand_positions.append(pos)\n",
    "\n",
    "    cand_positions.sort()\n",
    "    cand_dict={cand_positions[i]:str(i) for i in range(n)}\n",
    "    \n",
    "    \n",
    "    #Get each voter's choice and add to the dataframe\n",
    "    for k in range(electorate_size):\n",
    "        choice=''\n",
    "        \n",
    "        dict1=cand_dict.copy()\n",
    "        \n",
    "        while len(choice)<n:\n",
    "            distances=[abs(k-i) for i in dict1]\n",
    "            distances.sort()\n",
    "            if distances[0]==0:\n",
    "                choice+=str(cand_dict[k])\n",
    "    \n",
    "            else:\n",
    "                if k-distances[0] in cand_positions and k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                    dict1.pop(k+distances[0])\n",
    "                elif k-distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                elif k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k+distances[0])\n",
    "        \n",
    "        for l in range(len(data)):\n",
    "            if data.at[l,'ballot']==choice:\n",
    "                index=l\n",
    "                break\n",
    "        data.at[index,'Count']+=1\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    if plurality_winners==['0']:\n",
    "        A_wins+=1\n",
    "    if IRV_winners==['0']:\n",
    "        A_wins_IRV+=1\n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    \n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners and plurality_winners==['0']:\n",
    "                \n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                if str(l)=='1':\n",
    "                    A_wins_B_spoils+=1\n",
    "                if str(l)=='2':\n",
    "                    A_wins_C_spoils+=1\n",
    "                \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    \n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners and IRV_winners==['0']:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                if str(l)=='1':\n",
    "                    A_wins_B_spoils_IRV+=1\n",
    "                if str(l)=='2':\n",
    "                    A_wins_C_spoils_IRV+=1\n",
    "    \n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    \n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections A wins plurality \",A_wins)\n",
    "print(\"Num elections A wins IRV \",A_wins_IRV)\n",
    "print(\"Num elections A wins pluarlity, B spiols, \",A_wins_B_spoils)\n",
    "print(\"Num elections A wins pluarlity, C spiols, \",A_wins_C_spoils)\n",
    "print(\"Num elections A wins IRV, B spiols, \",A_wins_B_spoils_IRV)\n",
    "print(\"Num elections A wins IRV, C spiols, \",A_wins_C_spoils_IRV)\n",
    "print(count)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "37ca08ab-7a7d-400a-ac89-2ac0ceb55dff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num elections with a plurality spoiler cand:  19235\n",
      "Num elections with an IRV spoiler cand:  11068\n",
      "Num elections A wins plurality  34940\n",
      "Num elections A wins IRV  18174\n",
      "Num elections A wins pluarlity, B spiols,  2676\n",
      "Num elections A wins pluarlity, C spiols,  12311\n",
      "Num elections A wins pluarlity, D spiols,  17268\n",
      "Num elections A wins IRV, B spiols,  811\n",
      "Num elections A wins IRV, C spiols,  3878\n",
      "Num elections A wins IRV, D spiols,  7838\n",
      "132672\n"
     ]
    }
   ],
   "source": [
    "#Linear-SP simulations, figuring out who wins and who spoils\n",
    "\n",
    "\n",
    "n=4\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "A_wins=0\n",
    "A_wins_IRV=0\n",
    "A_wins_B_spoils=0\n",
    "A_wins_C_spoils=0\n",
    "A_wins_D_spoils=0\n",
    "A_wins_B_spoils_IRV=0\n",
    "A_wins_C_spoils_IRV=0\n",
    "A_wins_D_spoils_IRV=0\n",
    "\n",
    "0\n",
    "A_wins_D_spoils_IRV=0\n",
    "while a>0:\n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    cand_positions=[]\n",
    "    \n",
    "    for k in range(n):\n",
    "        pos=random.randint(0,electorate_size-1)\n",
    "        while pos in cand_positions:\n",
    "            pos=random.randint(0,electorate_size-1)\n",
    "        cand_positions.append(pos)\n",
    "\n",
    "    cand_positions.sort()\n",
    "    cand_dict={cand_positions[i]:str(i) for i in range(n)}\n",
    "    \n",
    "    \n",
    "    #Get each voter's choice and add to the dataframe\n",
    "    for k in range(electorate_size):\n",
    "        choice=''\n",
    "        \n",
    "        dict1=cand_dict.copy()\n",
    "        \n",
    "        while len(choice)<n:\n",
    "            distances=[abs(k-i) for i in dict1]\n",
    "            distances.sort()\n",
    "            if distances[0]==0:\n",
    "                choice+=str(cand_dict[k])\n",
    "    \n",
    "            else:\n",
    "                if k-distances[0] in cand_positions and k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                    dict1.pop(k+distances[0])\n",
    "                elif k-distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                elif k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k+distances[0])\n",
    "        \n",
    "        for l in range(len(data)):\n",
    "            if data.at[l,'ballot']==choice:\n",
    "                index=l\n",
    "                break\n",
    "        data.at[index,'Count']+=1\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    if plurality_winners==['0']:\n",
    "        A_wins+=1\n",
    "    if IRV_winners==['0']:\n",
    "        A_wins_IRV+=1\n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    \n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    plurality_spoiler=False\n",
    "    plurality_spoiler_set=False\n",
    "    \n",
    "    for l in range(n):\n",
    "        if str(l) not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            #print(new_plur_winners)\n",
    "            if plurality_winners!=new_plur_winners and plurality_winners==['0']:\n",
    "                \n",
    "                plurality_spoiler=True\n",
    "                plurality_spoiler_set=True\n",
    "                if str(l)=='1':\n",
    "                    A_wins_B_spoils+=1\n",
    "                if str(l)=='2':\n",
    "                    A_wins_C_spoils+=1\n",
    "                if str(l)=='3':\n",
    "                    A_wins_D_spoils+=1\n",
    "                \n",
    "                \n",
    "                \n",
    "    if plurality_spoiler:\n",
    "        plur_spoiler+=1\n",
    "    \n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    #Check for IRV spoiler candidates and sets\n",
    "    #First, check for spoiler cands\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners and IRV_winners==['0']:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                if str(l)=='1':\n",
    "                    A_wins_B_spoils_IRV+=1\n",
    "                if str(l)=='2':\n",
    "                    A_wins_C_spoils_IRV+=1\n",
    "                if str(l)=='3':\n",
    "                    A_wins_D_spoils_IRV+=1\n",
    "                \n",
    "    \n",
    "                \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    \n",
    "    a-=1\n",
    "                \n",
    "print(\"Num elections with a plurality spoiler cand: \" ,plur_spoiler)\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections A wins plurality \",A_wins)\n",
    "print(\"Num elections A wins IRV \",A_wins_IRV)\n",
    "print(\"Num elections A wins pluarlity, B spiols, \",A_wins_B_spoils)\n",
    "print(\"Num elections A wins pluarlity, C spiols, \",A_wins_C_spoils)\n",
    "print(\"Num elections A wins pluarlity, D spiols, \",A_wins_D_spoils)\n",
    "print(\"Num elections A wins IRV, B spiols, \",A_wins_B_spoils_IRV)\n",
    "print(\"Num elections A wins IRV, C spiols, \",A_wins_C_spoils_IRV)\n",
    "print(\"Num elections A wins IRV, D spiols, \",A_wins_D_spoils_IRV)\n",
    "\n",
    "print(count)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "979910c8-8915-4140-89ef-de6da2574d42",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "#Linear-SP simulations for CL\n",
    "\n",
    "\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "model='Linear-SP'\n",
    "\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "                \n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "                                \n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "CL_IRV_winner=0\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "    \n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    cand_positions=[]\n",
    "    \n",
    "    for k in range(n):\n",
    "        pos=random.randint(0,electorate_size-1)\n",
    "        while pos in cand_positions:\n",
    "            pos=random.randint(0,electorate_size-1)\n",
    "        cand_positions.append(pos)\n",
    "\n",
    "    cand_positions.sort()\n",
    "    cand_dict={cand_positions[i]:str(i) for i in range(n)}\n",
    "    \n",
    "    \n",
    "    #Get each voter's choice and add to the dataframe\n",
    "    for k in range(electorate_size):\n",
    "        choice=''\n",
    "        \n",
    "        dict1=cand_dict.copy()\n",
    "        \n",
    "        while len(choice)<n:\n",
    "            distances=[abs(k-i) for i in dict1]\n",
    "            distances.sort()\n",
    "            if distances[0]==0:\n",
    "                choice+=str(cand_dict[k])\n",
    "    \n",
    "            else:\n",
    "                if k-distances[0] in cand_positions and k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                    dict1.pop(k+distances[0])\n",
    "                elif k-distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k-distances[0]])\n",
    "                    dict1.pop(k-distances[0])\n",
    "                elif k+distances[0] in cand_positions:\n",
    "                    choice+=str(cand_dict[k+distances[0]])\n",
    "                    dict1.pop(k+distances[0])\n",
    "        \n",
    "        for l in range(len(data)):\n",
    "            if data.at[l,'ballot']==choice:\n",
    "                index=l\n",
    "                break\n",
    "        data.at[index,'Count']+=1\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate and CL\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)<=electorate_size/2 and Cond_loser(data)!=False:\n",
    "    \n",
    "        CL=Cond_loser(data)\n",
    "        \n",
    "\n",
    "        data_copy=data.copy(deep=True)    \n",
    "        IRV_winners=IRV(data_copy)\n",
    "        data_copy=data.copy(deep=True)  \n",
    "        plurality_winners=plurality(data_copy)\n",
    "\n",
    "        #First check for spoiler candidates\n",
    "\n",
    "\n",
    "        if CL in plurality_winners:\n",
    "            #print(\"CL is a plurality winner \",CL)\n",
    "            #print(data)\n",
    "            CL_plurality_winner+=1\n",
    "\n",
    "        if CL not in plurality_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_plur_winners=plurality(data_copy)\n",
    "            if plurality_winners!=new_plur_winners:\n",
    "                #print(\"CL is a plurality spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_plurality_spoiler+=1\n",
    "        if CL in IRV_winners:\n",
    "            CL_IRV_winner+=1\n",
    "            #print(\"CL is an IRV winner \",CL)\n",
    "            #print(data)\n",
    "\n",
    "        if CL not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(CL,'')\n",
    "            #print(data_copy)\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                #print(\"CL is an IRV spoiler \",CL)\n",
    "                #print(data)\n",
    "                CL_IRV_spoiler+=1\n",
    "        a-=1\n",
    "print(\"model=\", model)\n",
    "print(\"n= \",n)\n",
    "print(\"V= \",electorate_size)          \n",
    "print(\"Number of elections in which CL is a plurality spoiler \", CL_plurality_spoiler)\n",
    "print(\"Number of elections in which CL is a plurality winner \", CL_plurality_winner)\n",
    "print(\"Number of elections in which CL is an IRV spoiler \", CL_IRV_spoiler)\n",
    "print(\"Number of elections in which CL is an IRV winner \", CL_IRV_winner)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9eb86b4d-207b-4b9c-8f99-7dd77a3b940f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33566\n",
      "189.66376690698922\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#impartial culture for CL, just messing around to see why graphs are the way they are\n",
    "\n",
    "model='IC'\n",
    "#n=5\n",
    "electorate_size=601\n",
    "\n",
    "n=3\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "\n",
    "num_times_A_CL=0\n",
    "num_times_B_CL=0\n",
    "num_times_C_CL=0\n",
    "num_votes_for_A=0\n",
    "A_scores=[]\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "\n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    #print(data)\n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    #print(IRV_winners)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    #print(plurality_winners)\n",
    "    #print(\"CL\",type(Cond_loser(data)))\n",
    "    \n",
    "\n",
    "    \n",
    "\n",
    "    if Cond_loser(data)!=False:\n",
    "        CL=Cond_loser(data)\n",
    "        if CL=='0':\n",
    "            num_times_A_CL+=1\n",
    "            A_score=0\n",
    "            for k in range(len(data)):\n",
    "                \n",
    "                if data.iloc[k]['ballot'][0]=='0':\n",
    "                    A_score+=data.iloc[k]['Count']\n",
    "            num_votes_for_A+=A_score\n",
    "            A_scores.append(A_score)\n",
    "        \n",
    "        \n",
    "        a-=1\n",
    "        \n",
    "        \n",
    "print(num_times_A_CL)\n",
    "print(num_votes_for_A/num_times_A_CL)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "feeba6ab-5107-4cda-a1d2-08d4a97584bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "142\n",
      "220\n",
      "8.18535277187245\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "print(min(A_scores))\n",
    "print(max(A_scores))\n",
    "print(statistics.pstdev(A_scores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "dc5218b6-3b9e-44d4-b7f3-52b36602f883",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20107\n",
      "110.65509524046352\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#impartial culture for CL, just messing around to see why graphs are the way they are\n",
    "\n",
    "model='IC'\n",
    "#n=5\n",
    "electorate_size=601\n",
    "\n",
    "n=5\n",
    "possible_ballots=[]\n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "\n",
    "                    possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "column_names=['ballot','Count']\n",
    "data=pd.DataFrame(columns = column_names)\n",
    "data['ballot']=possible_ballots\n",
    "data['Count']=[0 for item in possible_ballots]\n",
    "\n",
    "CL_plurality_spoiler=0\n",
    "CL_plurality_winner=0\n",
    "CL_IRV_spoiler=0\n",
    "\n",
    "num_times_A_CL=0\n",
    "num_votes_for_A=0\n",
    "A_scores=[]\n",
    "\n",
    "a=100000\n",
    "count=0\n",
    "while a>0:\n",
    "\n",
    "    count+=1\n",
    "    data['ballot']=possible_ballots\n",
    "    data['Count']=[0 for item in possible_ballots]\n",
    "    for k in range(electorate_size):\n",
    "        vote=random.randint(0,len(possible_ballots)-1)\n",
    "        data.at[vote,'Count']+=1\n",
    "    #print(data)\n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    #print(IRV_winners)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    #print(plurality_winners)\n",
    "    #print(\"CL\",type(Cond_loser(data)))\n",
    "    #Check for majority candidate and CL\n",
    "    \n",
    "\n",
    "    \n",
    "\n",
    "    if Cond_loser(data)!=False:\n",
    "        CL=Cond_loser(data)\n",
    "        if CL=='0':\n",
    "            num_times_A_CL+=1\n",
    "            A_score=0\n",
    "            for k in range(len(data)):\n",
    "                \n",
    "                if data.iloc[k]['ballot'][0]=='0':\n",
    "                    A_score+=data.iloc[k]['Count']\n",
    "            num_votes_for_A+=A_score\n",
    "            A_scores.append(A_score)\n",
    "        \n",
    "        a-=1\n",
    "        \n",
    "        \n",
    "print(num_times_A_CL)\n",
    "print(num_votes_for_A/num_times_A_CL)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f4384789-1a9f-44b6-bdce-45a6c285d1ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C wins and there's a spoiler  4\n",
      "   ballot  Count\n",
      "0   32140     18\n",
      "1   21304     34\n",
      "2   23140     49\n",
      "3   43210    130\n",
      "4   12340     54\n",
      "5   34210     24\n",
      "6   10234     11\n",
      "7   23104     33\n",
      "8   32410     61\n",
      "9   01234     68\n",
      "10  12304     40\n",
      "11  21340     22\n",
      "12  32104     10\n",
      "13  12034     12\n",
      "14  21034     29\n",
      "15  23410      6\n",
      "C wins and there's a spoiler  0\n",
      "   ballot  Count\n",
      "0   21304     31\n",
      "1   32104     42\n",
      "2   43210     91\n",
      "3   12034     20\n",
      "4   12304     55\n",
      "5   01234     92\n",
      "6   34210     29\n",
      "7   32140     64\n",
      "8   21340     67\n",
      "9   23410     16\n",
      "10  23140     19\n",
      "11  32410     17\n",
      "12  23104     15\n",
      "13  12340     14\n",
      "14  21034     29\n",
      "C wins and there's a spoiler  0\n",
      "   ballot  Count\n",
      "0   43210    170\n",
      "1   01234     96\n",
      "2   21304      7\n",
      "3   21034     29\n",
      "4   12340     31\n",
      "5   23104     12\n",
      "6   23140     30\n",
      "7   32104     56\n",
      "8   21340     29\n",
      "9   32140     44\n",
      "10  10234     12\n",
      "11  32410     18\n",
      "12  12034     28\n",
      "13  34210     21\n",
      "14  23410     11\n",
      "15  12304      7\n",
      "C wins and there's a spoiler  4\n",
      "   ballot  Count\n",
      "0   43210    170\n",
      "1   01234     96\n",
      "2   21304      7\n",
      "3   21034     29\n",
      "4   12340     31\n",
      "5   23104     12\n",
      "6   23140     30\n",
      "7   32104     56\n",
      "8   21340     29\n",
      "9   32140     44\n",
      "10  10234     12\n",
      "11  32410     18\n",
      "12  12034     28\n",
      "13  34210     21\n",
      "14  23410     11\n",
      "15  12304      7\n",
      "C wins and there's a spoiler  4\n",
      "   ballot  Count\n",
      "0   12034    111\n",
      "1   23410     23\n",
      "2   21034     38\n",
      "3   23140     31\n",
      "4   43210    129\n",
      "5   12304     13\n",
      "6   23104     44\n",
      "7   21304     12\n",
      "8   21340      8\n",
      "9   10234     37\n",
      "10  34210     17\n",
      "11  32140     39\n",
      "12  01234     26\n",
      "13  32104     48\n",
      "14  12340     13\n",
      "15  32410     12\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-55-45e8c3683770>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    146\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    147\u001b[0m     \u001b[0mcandmap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgen_cand_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 148\u001b[0;31m     \u001b[0melection\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgen_votemap_iac\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0melectorate_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcandmap\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    149\u001b[0m     \u001b[0mkeys\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0melection\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    150\u001b[0m     \u001b[0mvalues\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0melection\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-55-45e8c3683770>\u001b[0m in \u001b[0;36mgen_votemap_iac\u001b[0;34m(nvoters, candmap)\u001b[0m\n\u001b[1;32m    116\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgen_votemap_iac\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnvoters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcandmap\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 118\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mgen_urn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnvoters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcandmap\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    120\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-55-45e8c3683770>\u001b[0m in \u001b[0;36mgen_urn\u001b[0;34m(numvotes, replace, alts)\u001b[0m\n\u001b[1;32m     84\u001b[0m             \u001b[0mflip\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflip\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mICsize\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     85\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mvote\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mReplaceVotes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 86\u001b[0;31m                 \u001b[0mflip\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflip\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mReplaceVotes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvote\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     87\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mflip\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     88\u001b[0m                     \u001b[0mvoteMap\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvote\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mvoteMap\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvote\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#IAC-SP simulations, where we check for clones\n",
    "n=5\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "model='IAC-SP'\n",
    "    \n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "    \n",
    "    ReplaceSize = 0\n",
    "    \n",
    "    ICsize=len(possible_ballots)\n",
    "    ballot_dict={i:possible_ballots[i] for i in range(len(possible_ballots))}\n",
    "    for x in range(numvotes):\n",
    "        \n",
    "        \n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        \n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            \n",
    "            #tvote = gen_ic_vote(alts, rng)\n",
    "            x=random.randint(0,len(ballot_dict)-1)\n",
    "            tvote=ballot_dict[x]\n",
    "            \n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    \n",
    "    return voteMap\n",
    "\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "   \n",
    "    \n",
    "C_wins_and_spoiler_exists=0\n",
    "D_wins_and_B_spoiler=0\n",
    "D_wins_and_C_spoiler=0\n",
    "D_wins_and_no_spoiler=0\n",
    "a=20000\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(0,n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    \n",
    "    \n",
    "    \n",
    "    cands=[str(i) for i in range(n)]\n",
    "    r=[x for x in powerset(cands)]\n",
    "    \n",
    "    #Check for plurality spoiler candidates and sets\n",
    "    \n",
    "    #First check for spoiler candidates\n",
    "    IRV_spoiler_exists=False\n",
    "    IRV_spoiler_set_exists=False\n",
    "    \n",
    "\n",
    "    for l in range(n):\n",
    "        if str(l) not in IRV_winners:\n",
    "            data_copy=data.copy(deep=True)\n",
    "            for b in range(len(data_copy)):\n",
    "                data_copy.at[b,'ballot']=data_copy.at[b,'ballot'].replace(str(l),'')\n",
    "            new_IRV_winners=IRV(data_copy)\n",
    "            \n",
    "            if IRV_winners!=new_IRV_winners:\n",
    "                IRV_spoiler_exists=True\n",
    "                IRV_spoiler_set_exists=True\n",
    "                if IRV_winners==['2']:\n",
    "                    C_wins_and_spoiler_exists+=1\n",
    "                    print(\"C wins and there's a spoiler \", l)\n",
    "                    print(data)\n",
    "                if IRV_winners==['3'] and str(l)=='1':\n",
    "                    D_wins_and_B_spoiler+=1\n",
    "                    #print(\"D wins and B is a spoiler\")\n",
    "                    #print(data)\n",
    "                if IRV_winners==['3'] and str(l)=='2':\n",
    "                    D_wins_and_C_spoiler+=1\n",
    "    if IRV_spoiler_exists==False and IRV_winners==['3']:\n",
    "        D_wins_and_no_spoiler+=1       \n",
    "    if IRV_spoiler_exists:\n",
    "        IRV_spoiler+=1\n",
    "    if IRV_spoiler_set_exists:\n",
    "        IRV_spoiler_set+=1\n",
    "    \n",
    "    a-=1\n",
    "                \n",
    "\n",
    "print(\"Num elections with an IRV spoiler cand: \", IRV_spoiler)\n",
    "print(\"Num elections where C wins and a spoiler exists \",C_wins_and_spoiler_exists)\n",
    "print(\"Num elections where D wins and B is spoiler \",D_wins_and_B_spoiler)\n",
    "print(\"Num elections where D wins and C is spoiler \",D_wins_and_C_spoiler)\n",
    "print(\"Num elections where D wins and no spoiler \",D_wins_and_no_spoiler)\n",
    "\n",
    "\n",
    "\n",
    " \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "88a4128d-61fe-46dc-b237-ef06f15a2ac1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1872\n",
      "16090\n",
      "2038\n",
      "5417\n",
      "8837\n",
      "5625\n"
     ]
    }
   ],
   "source": [
    "#IAC-SP simulations, where we check for clones\n",
    "n=3\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "model='IAC-SP'\n",
    "    \n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "    \n",
    "    ReplaceSize = 0\n",
    "    \n",
    "    ICsize=len(possible_ballots)\n",
    "    ballot_dict={i:possible_ballots[i] for i in range(len(possible_ballots))}\n",
    "    for x in range(numvotes):\n",
    "        \n",
    "        \n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        \n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            \n",
    "            #tvote = gen_ic_vote(alts, rng)\n",
    "            x=random.randint(0,len(ballot_dict)-1)\n",
    "            tvote=ballot_dict[x]\n",
    "            \n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    \n",
    "    return voteMap\n",
    "\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=20000\n",
    "A_wins_IRV=0\n",
    "B_wins_IRV=0\n",
    "C_wins_IRV=0\n",
    "\n",
    "A_wins_plurality=0\n",
    "B_wins_plurality=0\n",
    "C_wins_plurality=0\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(0,n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    if IRV_winners==['0']:\n",
    "        A_wins_IRV+=1\n",
    "    if IRV_winners==['1']:\n",
    "        B_wins_IRV+=1\n",
    "    if IRV_winners==['2']:\n",
    "        C_wins_IRV+=1\n",
    "    if plurality_winners==['0']:\n",
    "        A_wins_plurality+=1\n",
    "    if plurality_winners==['1']:\n",
    "        B_wins_plurality+=1\n",
    "    if plurality_winners==['2']:\n",
    "        C_wins_plurality+=1\n",
    "    \n",
    "    a-=1\n",
    "                \n",
    "print(A_wins_IRV)\n",
    "print(B_wins_IRV)\n",
    "print(C_wins_IRV)\n",
    "\n",
    "print(A_wins_plurality)\n",
    "print(B_wins_plurality)\n",
    "print(C_wins_plurality)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ffc26b13-37a1-421a-9711-b39b96a27c94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "2954\n",
      "14149\n",
      "2883\n",
      "7\n",
      "131\n",
      "4187\n",
      "11161\n",
      "4310\n",
      "115\n"
     ]
    }
   ],
   "source": [
    "#IAC-SP simulations, where we check for clones\n",
    "n=5\n",
    "electorate_size=601\n",
    "possible_ballots=[]\n",
    "model='IAC-SP'\n",
    "    \n",
    "\n",
    "if n==3:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                if all_different([i,j,k]):\n",
    "                    if is_SP_ranking([i,j,k]):\n",
    "                        possible_ballots.append(str(i)+str(j)+str(k))\n",
    "if n==4:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    if all_different([i,j,k,l]):\n",
    "                        if is_SP_ranking([i,j,k,l]):\n",
    "                            possible_ballots.append(str(i)+str(j)+str(k)+str(l))\n",
    "\n",
    "if n==5:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        if all_different([i,j,k,l,p]):\n",
    "                            if is_SP_ranking([i,j,k,l,p]):\n",
    "                                possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p))\n",
    "\n",
    "if n==6:\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            for k in range(n):\n",
    "                for l in range(n):\n",
    "                    for p in range(n):\n",
    "                        for q in range(n):\n",
    "                            if all_different([i,j,k,l,p,q]):\n",
    "                                if is_SP_ranking([i,j,k,l,p,q]):\n",
    "                                    possible_ballots.append(str(i)+str(j)+str(k)+str(l)+str(p)+str(q))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "def gen_ic_vote(alts, seed=None):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    alts=[str(alt) for alt in alts]\n",
    "    options = list(alts)\n",
    "    rng.shuffle(options)\n",
    "    return tuple(options)\n",
    "\n",
    "def gen_urn(numvotes, replace, alts):\n",
    "    rng = np.random.default_rng()\n",
    "    voteMap = {}\n",
    "    ReplaceVotes = {}\n",
    "    \n",
    "    ReplaceSize = 0\n",
    "    \n",
    "    ICsize=len(possible_ballots)\n",
    "    ballot_dict={i:possible_ballots[i] for i in range(len(possible_ballots))}\n",
    "    for x in range(numvotes):\n",
    "        \n",
    "        \n",
    "        # flip = random.randint(1, ICsize+ReplaceSize)\n",
    "        flip = rng.integers(1, ICsize+ReplaceSize, endpoint=True)\n",
    "        \n",
    "        if flip <= ICsize:\n",
    "            #generate an IC vote and make a suitable number of replacements...\n",
    "            # tvote = gen_ic_vote(alts)\n",
    "            \n",
    "            #tvote = gen_ic_vote(alts, rng)\n",
    "            x=random.randint(0,len(ballot_dict)-1)\n",
    "            tvote=ballot_dict[x]\n",
    "            \n",
    "            voteMap[tvote] = (voteMap.get(tvote, 0) + 1)\n",
    "            ReplaceVotes[tvote] = (ReplaceVotes.get(tvote, 0) + replace)\n",
    "            ReplaceSize += replace\n",
    "        else:\n",
    "            #iterate over replacement hash and select proper vote.\n",
    "            flip = flip - ICsize\n",
    "            for vote in ReplaceVotes.keys():\n",
    "                flip = flip - ReplaceVotes[vote]\n",
    "                if flip <= 0:\n",
    "                    voteMap[vote] = (voteMap.get(vote, 0) + 1)\n",
    "                    ReplaceVotes[vote] = (ReplaceVotes.get(vote, 0) + replace)\n",
    "                    ReplaceSize += replace\n",
    "                    break\n",
    "            else:\n",
    "                print(\"We Have a problem... replace fell through....\")\n",
    "                exit()\n",
    "                # return None\n",
    "    \n",
    "    return voteMap\n",
    "\n",
    "\n",
    "def voteset_to_rankmap(votemap, candmap):\n",
    "    rmapcount = []\n",
    "    rmap = []\n",
    "    #Votemaps are tuple --> count, so it's strict and easy...\n",
    "    for order in votemap.keys():\n",
    "        rmapcount.append(votemap[order])\n",
    "        cmap = {}\n",
    "        for crank in range(1, len(order)+1):\n",
    "            cmap[order[crank-1]] = crank\n",
    "        rmap.append(cmap)\n",
    "    return rmap, rmapcount\n",
    "\n",
    "def gen_cand_map(nalts):\n",
    "    candmap = {i:\"Candidate \" + str(i) for i in range(1, nalts+1)}\n",
    "    return candmap\n",
    "\n",
    "\n",
    "def gen_votemap_iac(nvoters, candmap):\n",
    "    return gen_urn(nvoters, 1, candmap)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plur_spoiler=0\n",
    "IRV_spoiler=0\n",
    "plur_spoiler_set=0\n",
    "IRV_spoiler_set=0\n",
    "\n",
    "p=0.95\n",
    "plur_clone=0\n",
    "plur_clone_spoiler=0\n",
    "plur_almost_clone=0\n",
    "plur_almost_clone_spoiler=0\n",
    "\n",
    "IRV_clone=0\n",
    "IRV_clone_spoiler=0\n",
    "IRV_almost_clone=0\n",
    "IRV_almost_clone_spoiler=0\n",
    "    \n",
    "a=20000\n",
    "A_wins_IRV=0\n",
    "B_wins_IRV=0\n",
    "C_wins_IRV=0\n",
    "D_wins_IRV=0\n",
    "E_wins_IRV=0\n",
    "\n",
    "A_wins_plurality=0\n",
    "B_wins_plurality=0\n",
    "C_wins_plurality=0\n",
    "D_wins_plurality=0\n",
    "E_wins_plurality=0\n",
    "count=0\n",
    "while a>0:\n",
    "    candmap = gen_cand_map(n)\n",
    "    election=gen_votemap_iac(electorate_size,candmap)\n",
    "    keys=list(election.keys())\n",
    "    values=list(election.values())\n",
    "    values_string=[''.join(key) for key in keys]\n",
    "    column_names=['ballot','Count']\n",
    "    data=pd.DataFrame(columns = column_names)\n",
    "    data['ballot']=values_string\n",
    "    data['Count']=values\n",
    "    \n",
    "    \n",
    "    #Check for majority candidate\n",
    "    scores=[0 for i in range(n)]\n",
    "    for k in range(len(data)):\n",
    "        for l in range(0,n):\n",
    "            if data.iloc[k]['ballot'][0]==str(l): \n",
    "                scores[l]+=data.iloc[k]['Count']\n",
    "    \n",
    "    \n",
    "    \n",
    "    if max(scores)>electorate_size/2:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "    data_copy=data.copy(deep=True)    \n",
    "    IRV_winners=IRV(data_copy)\n",
    "    data_copy=data.copy(deep=True)  \n",
    "    plurality_winners=plurality(data_copy)\n",
    "    if IRV_winners==['0']:\n",
    "        A_wins_IRV+=1\n",
    "    if IRV_winners==['1']:\n",
    "        B_wins_IRV+=1\n",
    "    if IRV_winners==['2']:\n",
    "        C_wins_IRV+=1\n",
    "    if IRV_winners==['3']:\n",
    "        D_wins_IRV+=1\n",
    "    if IRV_winners==['4']:\n",
    "        E_wins_IRV+=1\n",
    "    if plurality_winners==['0']:\n",
    "        A_wins_plurality+=1\n",
    "    if plurality_winners==['1']:\n",
    "        B_wins_plurality+=1\n",
    "    if plurality_winners==['2']:\n",
    "        C_wins_plurality+=1\n",
    "    if plurality_winners==['3']:\n",
    "        D_wins_plurality+=1\n",
    "    if plurality_winners==['4']:\n",
    "        E_wins_plurality+=1\n",
    "    \n",
    "    a-=1\n",
    "                \n",
    "print(A_wins_IRV)\n",
    "print(B_wins_IRV)\n",
    "print(C_wins_IRV)\n",
    "print(D_wins_IRV)\n",
    "print(E_wins_IRV)\n",
    "print(A_wins_plurality)\n",
    "print(B_wins_plurality)\n",
    "print(C_wins_plurality)\n",
    "print(D_wins_plurality)\n",
    "print(E_wins_plurality)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e70012d-7c99-4e30-a473-25baffac7ca0",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}